Polygon Knowledge Layer
Heimdallv2 rpc
Initializing search
Polygon Knowledge Layer
Home
Agglayer
CDK
zkEVM
PoS
Developer tools
Innovation & design
Learn
Polygon Knowledge Layer
Polygon Knowledge Layer
Home
Agglayer
CDK
zkEVM
zkEVM
Overview
Releases
Releases
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
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
Setting Up Telemetry
Default ports for nodes
Network upgrade process
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
Heimdall v2
Heimdall v2
Introduction
Changes from v1
Authentication
Balance transfers
Staking
Checkpoints
Topup
Chain management
Governance
Clerk
Heimdall Bor module
Milestones
Reference
Reference
Heimdall v2 RPC Endpoints
Cosmos SDK RPC Endpoints
Concepts
Concepts
Tokens
Tokens
POL
MATIC
Transactions
Transactions
EIP-1559
EIP-4337
Meta transactions
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
The Graph
Storage
Storage
IPFS
Filecoin
Crust network
Oracles
Oracles
Getting started
Chainlink
Chronicle
Wallets
Wallets
Getting started
WalletConnect
Reown
Reown
Intro
AppKit
WalletKit
Block explorers
Block explorers
OKX explorer
Polygon
zkEVM
zkEVM testnet
Innovation & design
Innovation & design
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
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
Introduction to Plonky3 & Fibonacci Example
Constraint Degree, Intermediate Variables & Range Check Example
zkEVM
zkEVM
Overview
Heimdallv2 rpc
Back to top