Avenlabs.

Roadmap

Initializing search

Home
CDK
zkEVM
L1
Private Chain
Developer tools
Learn

Avenlabs.

Home
CDK
CDK
- Overview
- Get started
  Get started
  - Connect testnet
  - Quickstart
    Quickstart
    
    Validium
    
    Rollup
  - Deploy
    Deploy
    
    Validium
    
    Rollup
    Rollup
    
    Introduction
    
    Install dependencies
    
    Create wallets
    
    Deploy node
    
    Configure prover
    
    Activate forced transactions
    
    Set up Goerli node
- How to
  How to
  - Manage policies
- Architecture
  Architecture
  - DAC
- Specification
  Specification
  - Validium vs rollup
- Concepts
  Concepts
- Additional resources
  Additional resources
  - CDK repos
zkEVM
zkEVM
- Overview
- Get started
  Get started
  - Quick start
    Quick start
    
    Connecting to zkEVM
    
    Using Polygon faucet
    
    Bridging assets to zkEVM
  - Gas station
  - Setup nodes
    Setup nodes
    
    Setup local zkNode
    
    Setup production zkNode
  - Deploy zkEVM
    
    Deploy zkEVM
    
    Install dependencies
    
    Create wallets
    
    Deploy zkNode
    
    Configure Prover
    
    Activate forced transactions
    
    Setup a Goërli node
  - Sync state with snapshots
  - Historical data
- How to
  How to
- Architecture
  Architecture
  - 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
  - zkNode
  - 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
- 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
L1
L1
- Overview
- Get started
  Get started
  - Building on Polygon
- How to
  How to
  - Restore from snapshots
  - Operate a node
    
    Operate a node
    
    Full node
    
    Full node
    
    Manual install
    
    Ansible
    
    Docker
    
    Google cloud
    
    Validator node
    
    Validator node
    
    Rewards and staking incentives
    
    Manual install
    
    Ansible
    
    Staking
    
    Access node
    
    Archive node
    
    Erigon node
  - 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
  - Work with smart contracts
    
    Work with smart contracts
    
    Alchemy
    
    ChainIDE
    
    ChainStack
    
    GetBlock
    
    QuickNode
    
    SmartPress
    
    thirdweb
  - Polygon DID
- 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
- Operating various nodes
  Operating various nodes
  - System requirements
  - Operators
    Operators
    
    Full node binaries
    
    Full node docker
    
    Full node ansible
    
    Full node packages
    
    Full node gcp
    
    Erigon client
  - Validators
    Validators
    
    Prerequisites
    
    Validator binaries
    
    Validator ansible
    
    Validator packages
    
    Staking operations
    
    Commission operations
  - Validator actions
    Validator actions
    
    Becoming a validator
    
    Validator Responsibilities
    
    Topup Heimdall fee
    
    Change your signer address
    
    Move stake
  - Troubleshooting
    Troubleshooting
    
    Validator performance
    
    Technical FAQs
    
    Known issues and errors
    
    Reporting issues
- Reference
  Reference
  - Contracts
    Contracts
    
    Genesis contracts
    
    Delegation via validator shares
    
    Staking manager
  - Heimdall and Bor snapshots
  - Default ports for nodes
  - Common commands
  - Node errors
  - RPC endpoints
  - l1 mainnet multi-signatures
  - Mapped tokens
- Concepts
  Concepts
  - Tokens
    
    Tokens
    
    POL
    
    MATIC
  - Transactions
    
    Transactions
    
    EIP-1559
    
    EIP-4337
    
    Meta-transactions
Private Chain
Private Chain
- Overview
- Roadmap
- Miden rollup docs
  Miden rollup docs
  - Introduction
    
    Introduction
  - Architecture
    
    Architecture
    
    Accounts
    
    Notes
    
    Assets
    
    Transactions
    
    State
    
    Execution
  - Concepts
    Concepts
    
    Crypto primitives
    Crypto primitives
    
    Tiered sparce Merkle tree (TSMT)
- Miden VM
  Miden VM
  - Introduction
    
    Introduction
    
    Overview
    
    Usage
    
    Performance
    
    Background material
  - Architecture
    Architecture
    
    Design
    
    Programs
    
    Decoder
    
    Decoder
    
    Constraints
    
    Operand stack
    
    Operand stack
    
    Operation constraints
    
    System operations
    
    Field operations
    
    u32 operations
    
    Stack manipulation
    
    Input/output operations
    
    Cryptographic operations
    
    Range checker
    
    Chiplets
    
    Chiplets
    
    Hash chiplet
    
    Bitwise chiplet
    
    Memory chiplet
    
    Kernel ROM chiplet
    
    Lookups
    
    Lookups
    
    Multiset checks
    
    LogUp
  - Specification
    Specification
    
    AirScript
    AirScript
    
    Introduction
    
    Language description
    Language description
    
    Syntax overview
    
    Code organization
    
    Type declarations
    
    Constraints
    
    Variables
    
    Evaluators
    
    Convenience
    
    Example AIR definition
    
    Keywords
    
    Appendix
    
    Backends
    
    Development tooling
    
    Development tooling
    
    Debugger
    
    REPL
  - API
    
    API
    
    Assembly
    
    Assembly
    
    Code organization
    
    Execution contexts
    
    Flow control
    
    Field operations
    
    u32 operations
    
    Stack manipulation
    
    IO operations
    
    Cryptographic operations
    
    Debugging
    
    Standard library
    
    Standard library
    
    Collections
    
    Crypto
    Crypto
    
    Digital signatures
    
    FRI verification procedures
    
    Cryptographic hashes
    
    Math
    Math
    
    Unsigned 64-bit integer operations
    
    Memory procedures
    
    System procedures
Developer tools
Developer tools
- Smart contract development
  Smart contract development
  - Hardhat
  - Truffle
  - Remix
  - Replit
  - Crossmint
- Gas
  Gas
  - Polygon MATIC faucet
  - Polygon gas station
- Third-party tutorials
  Third-party tutorials
  - Alchemy subgraphs
- Data
  Data
  - The Graph
    The Graph
    
    Overview
    
    Data
    
    Entities
    
    Queries
  - Covalent
  - Flair
  - PARSIQ
- 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
    
    Common methods
- Storage
  Storage
  - IPFS
  - Filecoin
  - Crust network
  - Mint NFTs
- Oracles
  Oracles
  - Getting started
  - API3
  - Bandchain
  - Band standard dataset
  - Chainlink
  - DIA
  - UMA optimistic oracle
  - Razor
  - Supra
  - Tellor
  - Umbrella
- Wallets
  Wallets
  - Getting started
  - Metamask
    
    Metamask
    
    Create MetaMask wallet
    
    Add Polygon network
    
    Configure custom tokens
    
    Create and import accounts
  - Venly
    
    Venly
    
    Create wallet
    
    Add network
    
    Add custom token
  - Wallet link
  - Fortmatic
  - Portis
  - Torus
  - WalletConnect
  - SlashAuth
  - Plaid wallet onboard
  - Particle network
  - Web3Modal
- Block explorers
  Block explorers
  - Polygon
  - zkEVM
  - zkEVM testnet
  - OKLink
Learn
Learn

Roadmap

Last update: January 17, 2024

Authors: avenbreaks

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