Polygon Knowledge Layer
Home
Initializing search
Polygon Knowledge Layer
Home
CDK
zkEVM
PoS
Miden
Developer tools
Learn
Polygon Knowledge Layer
Polygon Knowledge Layer
Home
CDK
CDK
Overview
Version compatibility matrix
Get started
Get started
Deploy and manage a CDK stack
Deploy and manage a CDK stack
Deploy the CDK stack
Set up a permissionless node
Observability
Breakdown the deployment
How to
How to
Migrate
Migrate
Fork id 7 to 9
General guide for partners
Mint, bridge, and use tokens
Integrate a DAC
Manage allowlists with policies
Quickly test a running stack
Connect to CDK testnets
Architecture
Architecture
CDK rollup
CDK validium
Unified bridge - STB
Specification
Specification
Validium vs rollup
Glossary
Glossary
Additional resources
Additional resources
Third-party guides
CDK repos
zkEVM
zkEVM
Overview
Get started
Get started
Quick start
Setup nodes
Setup nodes
Setup local zkNode
Setup production zkNode
Deploy zkEVM
Deploy zkEVM
Introduction
Environment overview
Prerequisites
Install dependencies
Create wallets
Configure node deployment
Configure prover
Start node
Start services
Sync state with snapshots
Historical data
How to
How to
Write a contract
Deploy a contract with Foundry
Deploy a contract with Hardhat
Verify a contract
Architecture high-level
Architecture high-level
Overview
Architecture low-level
Architecture low-level
Upgrades
Upgrades
Etrog upgrade
Effective gas price
Effective gas price
Effective gas price strategy
User transaction flow
User transaction flow
RPC transaction flow
Sequencer transaction flow
Implementing EGP strategy
Transaction prioritization
zkEVM protocol
zkEVM protocol
State management
Transaction life cycle
Transaction life cycle
Submit transactions
Transaction execution
Transaction batching
Batch sequencing
Batch aggregation
Sequencing batches
Incentive mechanism
Protocol upgradability
Admin role and governance
Upgrade process
Security council
Malfunction resistance
Malfunction resistance
Force batches
Force verification
Emergency state
zkEVM Bridge
zkEVM Bridge
Exit trees
Smart contracts
Flow of assets
LxLy bridge
Unified bridge
Unified bridge
The rollup manager
Sequencing and verification flows
Updating rollups
Global exit trees
Cross-chain exchanges
zkNode
Data streamer
Data streamer
Overall design
Data streamer protocols
Bookmarks
Protocol messages
Stream file
How rollbacks work
The proving system
The proving system
Introduction
Executor
Polynomial identity language
Execution trace design
Selector columns
zkEVM and execution traces
Using lookup tables
Recapitulation
zkProver
zkProver
Main state machine
Main state machine
As a processor
STARK recursion
STARK recursion
Proving tools and techniques
Composition, Recursion and Aggregation
Recursion sub-process
Proving architecture
CIRCOM in zkProver
Proving setup phase
Intermediate steps
Final recursion step
Proof generation phase
Storage state machine
Storage state machine
Creating keys and paths
Storage SM mechanism
Executor and PIL
Arithmetic state machine
Binary state machine
Memory state machine
Memory-Align state machine
Hashing state machines
Hashing state machines
Keccak framework
Padding-kk state machine
Padding-kk-bit state machine
Bits2Field state machine
Keccak-f state machine
Poseidon state machine
Specification
Specification
Polynomial Identity Language
Polynomial Identity Language
Simple example
Modular programs
Connection arguments
Cyclicity in PIL
Filling polynomials
Generating proofs
Permutation arguments
Inclusion arguments
Compiling using PILCOM
Configuration files
PLONK in PIL
Public values
zkASM
zkASM
Basic Syntax
Examples
EVM vs. zkEVM
API
API
JSON RPC endpoints
Concepts
Concepts
EVM basics
Sparse merkle trees
Sparse merkle trees
Merkle trees
Constructing simple SMTs
SMT concepts
Operations on SMTs
mFibonnaci state machine
mFibonnaci state machine
Design approach
An example
Commitment scheme
Verification scheme
PIL-STARK process
PIL-STARK demo
Generic state machine
Generic state machine
Generic SM introduction
Execution trace
Ending programs
Program counter
Plookup
CIRCOM
Troubleshooting
Troubleshooting
Disclosures
PoS
PoS
Overview
Get started
Get started
Building on Polygon
Becoming a validator
Builder how-tos
Builder how-tos
Bridge layers
Bridge layers
Ethereum-Polygon
Ethereum-Polygon
Ethereum to MATIC
MATIC to Ethereum
Submit mapping request
L1-L2 communication
L1-L2 communication
State transfer
Integrate Polygon DID
Node how-tos
Node how-tos
Delegate tokens
Sync node using snapshots
Run a validator node
Run a validator node
System requirements
Prerequisites
Using binaries
Using Ansible
Using packages
Operate validator nodes
Operate validator nodes
Validator best practices
Stake tokens
Set commission rate
Move stake
Change signer address
Top up Heimdall fee
Validator performance requirements
Run a full node
Run a full node
System requirements
Using binaries
Using Docker
Using Ansible
Using packages
Using GCP
Run an access node
Run an Erigon archive node
Troubleshoot nodes
Troubleshoot nodes
Technical FAQs
Known issues and errors
Reporting issues
Governance
Governance
Governance fundamentals
Architecture
Architecture
Bor
Bor
State sync
Network configuration
Commands
Heimdall
Heimdall
Heimdall and Bor
Authentication
Key management
Validation
Balance transfers
Staking
Checkpoints
Topup
Chain management
Governance
Reference
Reference
Contracts
Contracts
Genesis contracts
Delegation via validator shares
Staking manager
Rewards and staking incentives
Default ports for nodes
Common commands
Node errors
RPC endpoints
PoS mainnet multi-signatures
Mapped tokens
Concepts
Concepts
Tokens
Tokens
POL
MATIC
Transactions
Transactions
EIP-1559
EIP-4337
Meta-transactions
Miden
Miden
Miden base
Miden base
Get started
Get started
Prerequisite steps
Create account and use the faucet
Private peer-to-peer off-chain txs
Public peer-to-peer note transactions
Roadmap
Miden architecture
Miden architecture
Overview
Accounts
Notes
Assets
Transactions
Transactions
Transactions overview
Transaction execution
Transaction kernel
Transaction contexts
Transaction procedures
State
Execution
Network
Miden client
Miden client
Overview
Overview
Features
Get started
Get started
Design
Install and run
Miden CLI
Miden CLI
Configuration
Reference
Using the client library
Examples
Developer tools
Developer tools
dApp development
dApp development
dApp Launchpad
dApp Launchpad
Introduction
Quickstart
Frontend
Smart contracts
Commands
Contributing
Common pitfalls
Common tools
Common tools
Hardhat
Remix
Replit
Smart contract development
Chain indexer framework
Chain indexer framework
Overview
Usage
Third-party tutorials
Third-party tutorials
Venly's NFT-API
Venly's Zapier integration
Gas
Gas
Polygon MATIC faucet
Polygon gas station
Data
Data
Alchemy subgraphs
Covalent
Envio
Flair
Moralis
PARSIQ
SubQuery
Matic.js
Matic.js
Installation
Get started
POS
POS
POS client
API overview
Setup
Setup
Ethers
Web3js
Set proof API
Advanced
Advanced
ABI manager
Exit util
Plugin
ERC20
ERC20
approveMax
approve
deposit
getAllowance
getBalance
isWithdrawExited
transfer
withdrawExitFaster
withdrawExit
withdrawStart
ERC721
ERC721
approveAll
approve
depositMany
deposit
getAllTokens
getTokenIdAtIndexForUser
getTokensCount
isApprovedAll
isApproved
isWithdrawExitedMany
isWithdrawExited
transfer
withdrawExitFasterMany
withdrawExitFaster
withdrawExitMany
withdrawExit
withdrawStartMany
withdrawStartWithMetaData
withdrawStart
ERC1155
ERC1155
approveAllForMintable
approveAll
depositMany
deposit
getBalance
isApprovedAll
isWithdrawExitedMany
isWithdrawExited
transfer
withdrawExitFasterMany
withdrawExitFaster
withdrawExitMany
withdrawExit
withdrawStartMany
withdrawStart
Common methods
Common methods
Deposit ETH
isCheckPointed
isDeposited
zkEVM
zkEVM
zkEVM client
ERC20
Message passing
Common methods
Storage
Storage
IPFS
Filecoin
Crust network
Oracles
Oracles
Getting started
API3
Bandchain
Band standard dataset
Chainlink
DIA
Pyth
Razor
Supra
Tellor
UMA optimistic oracle
Umbrella
Wallets
Wallets
Getting started
Polygon Portal
Metamask
Metamask
Create MetaMask wallet
Add Polygon network
Configure custom tokens
Create and import accounts
Venly
Venly
Create Venly wallet
Venly wallet API
Venly widget
Fortmatic
Openfort
Particle network
Portis
SlashAuth
Torus
WalletKit
Wallet link
WalletConnect
Web3Modal
Block explorers
Block explorers
Polygon
zkEVM
zkEVM testnet
OKLink
Learn
Learn
Welcome
Polygon type 1 prover
Polygon type 1 prover
Introduction and definitions
How to
How to
Run prover quickly
Deploy prover on devnet
Architecture
Architecture
Overview
Type 1 design challenges
Tests and proving costs
Specification
Specification
CPU component
CTL protocol