Polygon Knowledge Layer

Roadmap

Initializing search

Home
CDK
zkEVM
PoS
Miden
Developer tools
Learn

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
- 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
    Quick start
    
    zkEVM testnet & mainnet
    
    Using Polygon faucet
    
    Bridging assets to zkEVM
  - Gas station
  - 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
- Architecture
  Architecture
  - 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
    
    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
  - User fees
    
    User fees
    
    Gas price suggestion
    
    L1-L2 cost discrepancies
    
    Breakeven gas price
    
    Prioritizing transactions
    
    User fees flow
    
    User fees flow
    
    RPC flow
    
    Sequencer flow
  - 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
  - Smart contract development on PoS
    Smart contract development on PoS
    
    Alchemy
    
    ChainIDE
    
    ChainStack
    
    Crossmint
    
    GetBlock
    
    QuickNode
    
    SmartPress
    
    Thirdweb
  - Common tools
    Common tools
    
    Hardhat
    
    Remix
    
    Replit
- Chain indexer framework
  Chain indexer framework
  - Overview
  - Usage
- Third-party tutorials
  Third-party tutorials
- Gas
  Gas
  - Polygon MATIC faucet
  - Polygon gas station
- Data
  Data
  - The Graph
    The Graph
    
    Overview
    
    Data
    
    Entities
    
    Queries
  - Moralis
  - Covalent
  - Envio
  - Flair
  - 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
- Oracles
  Oracles
  - Getting started
  - API3
  - Bandchain
  - Band standard dataset
  - Chainlink
  - DIA
  - 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
    
    Range checks
- Plonky 2 & 3
- Polygon protocols
- Demystifying reorgs

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