Skip to content
Polygon Knowledge Layer
Overview
Initializing search
Polygon Knowledge Layer
Home
CDK
zkEVM
PoS
Miden
Developer tools
Innovation & design
Learn
Polygon Knowledge Layer
Polygon Knowledge Layer
Home
CDK
CDK
Overview
Releases
Releases
Version compatibility matrix
Get started
Get started
Local deployment guide
Concepts
Concepts
Layer 2s
L2 architecture overview
L2 transaction lifecycle
Rollups vs. validiums
ZK vs. optimistic rollups
Batches, blocks, transactions
Transaction finality
Gas fees
Bridging & interoperability
Admin upgradeability
How to
How to
Migrate
Migrate
Fork id 7 to 9
General guide for partners
Create custom native token
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
Releases
Releases
CDK Erigon
CDK Erigon
Releases
Deploy a node
How to
How to
Configure chains dynamically
Recover the network
Resources
Etrog upgrade
Build
Build
Connect to zkEVM
Deployment guides
Deployment guides
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
Risk disclosures
Historical data
JSON RPC endpoints
Check transaction status
Architecture
Architecture
zkEVM protocol
zkEVM protocol
zkNode
State management
State management
State management
Transaction life cycle
Transaction life cycle
Submit transactions
Transaction execution
Transaction batching
Batch sequencing
Batch aggregation
Sequencing batches
Data streamer
Data streamer
Overall design
Data streamer protocols
Bookmarks
Protocol messages
Server-source library
Stream file
How rollbacks work
About reorgs
Admin role and governance
Upgrades
Upgrades
Protocol upgradability
Upgrade process
Security council
Malfunction resistance
Malfunction resistance
Force batches
Force verification
Emergency state
zkProver
zkProver
zkProver design
zkProver design
Introduction
Executor
Proving system inputs
Order and prove
Aggregator
JSON-RPC
Polynomial identity language
Execution trace design
Selector columns
zkEVM and execution traces
Using lookup tables
L2 state tree concept
Keys and values
Processing L2 blocks
Recapitulation
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
Unified bridge
Unified bridge
The rollup manager
Sequencing and verification flows
Updating rollups
Global exit trees
Cross-chain exchanges
Bridging
Smart contracts
Smart contracts
Main contracts
Consensus contracts - sequencing
Exit roots
Consensus contracts - verification
API
API
PolygonRollupManager.sol
PolygonZkEVMBridgeV2.sol
PolygonZkEVMGlobalExitRootV2.sol
Consensus
Consensus
Data committee
Data committee
CDKDataCommittee.sol
PolygonDataComittee.sol
Validium
Validium
PolygonDataCommittee.sol
PolygonValidiumEtrog.sol
Migration
Migration
PolygonRollupBaseEtrogNoGap.sol
PolygonValidiumStorageMigration.sol
ZkEVM
ZkEVM
PolygonZkEVMEtrog.sol
PolygonZkEVMExistentEtrog.sol
PolygonZkEVMV2.sol
PolygonZkEVMV2Existent.sol
Lib
Lib
DepositContractBase.sol
DepositContractLib.sol
DepositContractV2.sol
PolygonAccessControlUpgradeable.sol
PolygonRollupBaseEtrog.sol
PolygonTransparentProxy.sol
PolygonZkEVMGlobalExitRootBaseStorage.sol
Utils
Utils
ClaimCompressor.sol
Addresses
Tokenomics
Tokenomics
Incentive mechanism
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
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
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
PoS
PoS
Overview
Get started
Get started
Migrate to POL
Building on PoS
Becoming a validator
Builder how-tos
Builder how-tos
Token bridging
Token bridging
Polygon Portal
Ethereum to PoS
PoS to Ethereum
Submit mapping request
State transfer
Node how-tos
Node how-tos
Prerequisites
Sync node using snapshots
Run a full node
Run a full node
Using binaries
Using Docker
Using Ansible
Using packages
Using GCP
Run a validator node
Run a validator node
Validator best practices
Using binaries
Using Ansible
Using packages
Operate validator nodes
Operate validator nodes
Next steps
Change owner and signer address
Top up Heimdall fee
Validator performance requirements
Run an Erigon archive node
Troubleshoot nodes
Troubleshoot nodes
Technical FAQs
Known issues and errors
Reporting issues
Reference
Reference
Contracts
Contracts
Genesis contracts
Delegation via validator shares
Staking manager
Rewards and staking incentives
Default ports for nodes
Common commands
Seed and bootnodes
RPC endpoints
PoS mainnet multi-signatures
Mapped tokens
Governance
Governance
Governance fundamentals
Delegate tokens
Architecture
Architecture
Overview
Bor
Bor
Introduction
State sync
Network configuration
Heimdall
Heimdall
Introduction
Heimdall and Bor
Authentication
Key management
Validation
Balance transfers
Staking
Checkpoints
Topup
Chain management
Governance
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
Miden compiler
Miden compiler
Usage
Usage
midenc
cargo miden
Guides
Guides
Rust To WebAssembly
WebAssembly To Miden Assembly
Developing Miden programs In Rust
Developing Miden rollup accounts and note scripts In Rust
Debugging programs
Compiler architecture
Compiler architecture
Overview
Supported front ends
Appendices
Appendices
Known limitations
Calling conventions
Canonical ABI vs Miden ABI
Developer tools
Developer tools
Start building
Start building
Test token faucets
Polygon Portal
MetaMask operations
MetaMask operations
Overview
Create MetaMask wallet
Add Polygon network
Configure custom tokens
Import accounts
dApp building essentials
dApp building essentials
Interact with a node RPC
Build smart contracts
Build smart contracts
On PoS
On PoS
Hardhat
Remix
Replit
On zkEVM
On zkEVM
Write a contract
Deploy a contract with Foundry
Deploy a contract with Hardhat
Verify a contract
Verify smart contracts
Verify smart contracts
OKX explorer
OKX explorer
Verify contract with API
Verify contract with external plugins
Estimate gas fees
dApp Launchpad
dApp Launchpad
Introduction
Quickstart
Frontend
Smart contracts
Commands
Contributing
Common pitfalls
Chain indexer framework
Chain indexer framework
Overview
Usage
Mint NFTs
Mint NFTs
Venly NFT API
Venly Zapier integration
Matic.js
Matic.js
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
Third-party tools
Third-party tools
Tutorials
Data
Data
Alchemy subgraphs
Covalent
DipDup
Envio
Flair
Moralis
PARSIQ
SQD (Subsquid)
SubQuery
Storage
Storage
IPFS
Filecoin
Crust network
Oracles
Oracles
Getting started
API3
Bandchain
Band standard dataset
Chainlink
Chronicle
DIA
ORA
Pyth
Razor
Supra
Tellor
UMA optimistic oracle
Umbrella
Wallets
Wallets
Getting started
Venly
Venly
Create Venly wallet
Venly wallet API
Venly widget
Fortmatic
Openfort
Particle network
Portis
Torus
WalletConnect
WalletKit
Web3Modal
Block explorers
Block explorers
OKX explorer
Polygon
zkEVM
zkEVM testnet
Innovation & design
Innovation & design
Welcome
AggLayer
AggLayer
Overview
AggLayer | Unified bridge
AggLayer | Go
AggLayer | Rust
AggLayer | Token flows
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
Range checks
Plonky 2 & 3
Polygon protocols
Demystifying reorgs
Security
Security
Overview
Security areas
Security areas
Governance & management
Risk management
Human resources
Infrastructure
Software development
Smart contracts
Vulnerability management
Security operations
Security reports
Bug bounty programs
Responsable disclosure
Contact us
Learn
Learn
General
General
Stack Choice
Learning ZK
Learning ZK
Overview
Polynomial Time
NP Completeness
Cyclic Groups and Generators
Learning Resources
AggLayer
AggLayer
Overview
Trust
Exit and Balance Trees
A Day in the Life of an AggLayer Transaction
Pessimistic Proof
Unified Liquidity
CDK
CDK
Overview
Miden
Miden
Overview
Notes and Their Features
Note Types
PoS
PoS
Overview
Tutorials
Tutorials
Understanding and Implementing Milestones
Plonky3
Plonky3
Overview
Examples
Examples
Fibonacci
zkEVM
zkEVM
Overview
Polygon Plonky3 Overview
¶
TBD (will be updated with One Pager Content)
Back to top