Polygon Knowledge Layer

Roadmap

Initializing search

Home
CDK
zkEVM
PoS
Miden
Developer tools
Innovation & design
Learn

Polygon Knowledge Layer

Home
CDK
CDK
- Overview
- Releases
  Releases
  - Version compatibility matrix
- Get started
  Get started
  - Local deployment guide
- Concepts
  Concepts
- 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
- 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
- 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
- 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
- AggLayer
  AggLayer
- CDK
  CDK
  - Overview
- Miden
  Miden
- PoS
  PoS
  - Overview
  - Tutorials
    Tutorials
    
    Understanding and Implementing Milestones
- Plonky3
  Plonky3
  - Overview
  - Examples
    Examples
    
    Fibonacci
- zkEVM
  zkEVM
  - Overview

Roadmap

Comments

Cookie consent

We use cookies to recognize your repeated visits and preferences, as well as to measure the effectiveness of our documentation and whether users find what they're searching for. With your consent, you're helping us to make our documentation better.

Google Analytics
GitHub

Manage settings