DOCSEARCHbyAlgolia
Submit Docs

Monad Documentation

website·Indexed 37 days ago

https://docs.monad.xyz

Technical documentation for the Monad network, covering architecture, consensus, and execution. Includes developer guides for building and deploying applications, JSON-RPC references, node operations, and the execution event SDK for C and Rust.

Tokens
161.4K
Snippets
660
Records
1.3K
Agent score
71%

What's inside Monad

  1. Overview of Embedded Wallet Providers for Monad

    Embedded wallets allow developers to integrate wallet functionality directly into their applications, enabling users to sign in via email or social methods and perform actions without signing every transaction manually. These services typically use cryptographic sharding (MPC, SSS, TSS) or Trusted Execution Environments (TEE) to manage keys across the user, developer, and provider servers.

  2. Overview of Monad's JIT Compilation and Execution Model

    Monad achieves high-performance execution of EVM bytecode by combining a highly optimized interpreter with a bespoke native-code compiler. To minimize latency, the system uses a hybrid approach: most contracts run on the interpreter, while 'hot' contracts (those with high cumulative gas consumption) are asynchronously compiled to native x86-64 machine code and cached. This ensures that frequently used contracts execute more efficiently while preserving exact EVM semantics, including gas accounting and error behavior.

  3. Overview of Card Issuing on Monad

    Card issuing platforms enable developers to launch debit, prepaid, and credit card programs where on-chain stablecoins are spent at everyday merchants. Card authorizations settle against on-chain balances, and stablecoins are converted to fiat at the point of sale. Monad's sub-second deterministic finality ensures that on-chain settlement occurs within the timing windows required by card networks (Visa, Mastercard), preventing authorization delays during transactions.

  4. Overview of Monad Network Capabilities

    Monad is a high-performance Ethereum-compatible Layer 1 (L1) blockchain. It provides full bytecode compatibility for the Ethereum Virtual Machine (EVM), allowing Ethereum applications to be ported without code changes, and full Ethereum RPC compatibility for seamless integration with infrastructure like Etherscan or The Graph.

    Key performance metrics include:

    • Throughput: 10,000 transactions per second (tps), or approximately 1 billion transactions per day.
    • Block Frequency: 300ms.
    • Finality: 600ms.

  5. Overview of Monad Layer-1 Blockchain

    Monad is a high-performance, decentralized Layer-1 blockchain that maintains full EVM bytecode compatibility and Ethereum JSON-RPC API compatibility. It is designed to eliminate the tradeoff between decentralization and performance by utilizing software architecture improvements rather than requiring specialized heavy hardware.

    Key performance metrics:

    • Throughput: 10,000 transactions per second (tps)
    • Block frequency: 300ms
    • Finality: 600ms

  6. Overview of Monad Solonet

    Solonet allows you to run a self-contained Monad network locally in Docker, including validator nodes, an execution client, and an RPC endpoint. It boots from genesis with unlimited tokens and uses the same binaries as testnet and mainnet to ensure node behavior matches production. It is primarily used for practicing node operations (upgrades, recoveries), testing validator workflows with staking-cli, developing tooling, and reproducing consensus or block-sync issues.

  7. Overview of MonadBFT Consensus

    MonadBFT is a fast, responsive, and fork-resistant Byzantine Fault Tolerant (BFT) consensus mechanism. It is designed to support 10,000+ transactions per second and sub-second time-to-finality with a large validator set. Key architectural advantages include:

    • Speculative Finality: Achieved in a single consensus round (approx. 300ms).
    • Full Finality: Achieved in two rounds (approx. 600ms).
    • Linear Communication: Uses a fan-out fan-in pattern (Leader $\rightarrow$ Validators $\rightarrow$ Next Leader) to avoid quadratic communication overhead, allowing the network to scale.
    • Tail-Forking Resistance: Built-in protection against MEV attacks where a malicious leader forks away a predecessor's block.
    • Leader Fault Isolation: A failed leader only incurs a single timeout delay.

  8. Overview of Monad JSON-RPC Interface

    Monad provides a JSON-RPC interface for blockchain interaction, designed to match the RPC behavior of Geth as closely as possible. While it aims for compatibility with Ethereum's RPC standards, certain behaviors deviate due to Monad's specific architectural differences.

  9. Overview of Monad Execution Events and WebSockets

    Execution Events provide a high-performance, low-level shared memory communication system for listening to real-time data from the Monad blockchain. Because it uses shared memory, consumers must run on the same host as the Monad node.

    WebSockets in the Monad JSON-RPC server serve two purposes: creating persistent connections for JSON-RPC requests and supporting the eth_subscribe API to push real-time data. WebSocket support requires Execution Events to be enabled; otherwise, the RPC server will crash on startup.

  10. Overview of Payment Orchestrators

    Payment orchestrators provide a single API to connect multiple providers, rails, and chains. They route stablecoin and fiat flows—including onramps, offramps, transfers, payouts, and swaps—across various networks, allowing developers to move money without managing fragmented individual integrations.

  11. Overview of Agentic Payments on Monad

    Agentic payments enable autonomous, machine-to-machine transactions over HTTP, allowing any HTTP endpoint to become payable via onchain payment authorization without requiring traditional accounts, subscriptions, or API keys. Monad serves as the settlement layer, leveraging high throughput, sub-second finality, and low fees to support micropayments and agent-to-agent commerce.

  12. Overview of Monad Authenticated UDP

    UDP Authentication provides secure, cryptographically authenticated peer-to-peer communication for Monad nodes using existing validator keys (secp256k1). It is currently an opt-in feature but will be required in a future release. Key benefits include enhanced security, DoS protection against spoofed packets, traffic prioritization for QoS, and significantly faster packet verification (~100x) compared to per-packet ECDSA signatures.