# Monad Developer Documentation

## Docs

- [Best Practices for Building High Performance Apps](developer-essentials/best-practices): Learn best practices for building high performance apps on Monad
- [Mainnet Changelog](developer-essentials/changelog/mainnet): This is a curated list of only changes affecting mainnet.
- [Changelog](developer-essentials/changelog/README): We provide several changelogs:
- [Releases](developer-essentials/changelog/releases): This page catalogues every notable release. Some releases target only specific networks; for a
- [Testnet Changelog](developer-essentials/changelog/testnet): This is a curated list of only changes affecting testnet.
- [Differences between Monad and Ethereum](developer-essentials/differences): This list assembles notable behavioral differences between Monad and Ethereum from the
- [EIP-7702 on Monad](developer-essentials/eip-7702): Summary
- [Faucet](developer-essentials/faucet): Monad Faucet
- [Gas Pricing](developer-essentials/gas-pricing): Summary
- [Historical Data](developer-essentials/historical-data): Summary
- [Network Information - Mainnet](developer-essentials/network-information): | Name                  | Value                                                                  |
- [Opcode Pricing](developer-essentials/opcode-pricing): Summary
- [Precompiles](developer-essentials/precompiles): All Ethereum precompiles as of the Pectra fork (0x01 to 0x11), plus precompile 0x0100
- [Developer Essentials](developer-essentials/README): Quick Reference
- [Reserve Balance](developer-essentials/reserve-balance): Introduction
- [Staking](developer-essentials/staking/README): Monad uses staking to determine the voting weights and leader schedule in
- [Staking Behavior](developer-essentials/staking/staking-behavior): Overview
- [Staking Precompile](developer-essentials/staking/staking-precompile): This page is intended for developers looking to build smart contracts or interfaces
- [Deployment Summary for Developers](developer-essentials/summary): Deployment Summary for Developers
- [Network Information - Testnets](developer-essentials/testnets): Summary
- [Transactions](developer-essentials/transactions): Summary
- [Advanced topics](execution-events/advanced): When are events published?
- [C API](execution-events/c-api): Core concepts
- [Consensus events](execution-events/consensus-events): As explained here,
- [Event rings in detail](execution-events/event-ring): Event ring files and content types
- [Building the C example program](execution-events/getting-started/c): The C and C++ languages do not have a standard package manager, so using a
- [Running the example program on live data, and next steps](execution-events/getting-started/final): If you're following this guide in order, you should have already built one
- [Getting started](execution-events/getting-started/README): In this guide, we will:
- [Building the Rust example program](execution-events/getting-started/rust): The execution event SDK is made up of two packages, called monad-event-ring
- [Setting up your Monad node](execution-events/getting-started/setup-node): The execution events SDK relies on a shared memory communication system,
- [Running the example program on snapshot data](execution-events/getting-started/snapshot): The easiest way to get acquainted with the execution event system is to
- [Execution events overview](execution-events/overview): The execution daemon includes a system for recording events that occur during
- [Execution Events](execution-events/README): The Execution Events system allows developers to build high-performance
- [Release notes](execution-events/release-notes): v1.0
- [Rust API](execution-events/rust-api): Modules
- [Frequently Asked Questions](faq): Execution
- [Add Monad Mainnet to Wallet](guides/add-monad-to-wallet/mainnet): Follow this quick guide to add Monad Mainnet to your wallet.
- [Add Monad to Wallet](guides/add-monad-to-wallet/README): <CustomDocCard
- [Add Monad Testnet to Wallet](guides/add-monad-to-wallet/testnet): Follow this quick guide to add Monad Testnet to your wallet.
- [How to build a donation blink](guides/blinks-guide): In this guide, you will learn how to build a Blink that allows people to donate MON with a single click.
- [How to build custom deep links in an Expo-based mobile app](guides/deeplinks-using-expo): Deep links are URLs that take users directly to specific content within a mobile app or website, rather than just launching the app's home screen. They work like shortcuts, enabling smoother navigation and improving user experience.
- [Deploy a smart contract on Monad using Foundry](guides/deploy-smart-contract/foundry): Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.
- [Deploy a smart contract on Monad using Hardhat](guides/deploy-smart-contract/hardhat): Hardhat is a comprehensive development environment consisting of different components for editing, compiling, debugging, and deploying your smart contracts.
- [Deploy a Contract](guides/deploy-smart-contract/README): <CustomDocCard
- [Deploy a smart contract on Monad using Remix](guides/deploy-smart-contract/remix): Remix IDE is a browser-based IDE that can be used for the entire journey of smart contract development by users at every knowledge level. It requires no setup, fosters a fast development cycle, and has a rich set of plugins with intuitive GUIs.
- [EVM Behavior](guides/evm-resources/evm-behavior): EVM Behavioral Specification
- [Huff](guides/evm-resources/other-languages/huff): Huff is most closely described as EVM assembly. Unlike Yul, Huff does not provide control flow constructs or abstract away the inner working of the program stack. Only the most upmost performance sensitive applications take advantage of Huff, however it is a great educational tool to learn how the EVM interprets instructions its lowest level.
- [Other Languages](guides/evm-resources/other-languages/README): 
- [Vyper](guides/evm-resources/other-languages/vyper): Vyper is a popular programming language for the EVM that is logically similar to Solidity and syntactically similar with Python.
- [Yul](guides/evm-resources/other-languages/yul): Yul is a intermediate language for Solidity that can generally be thought of as inline assembly for the EVM. It is not quite pure assembly, providing control flow constructs and abstracting away the inner working of the stack while still exposing the raw memory backend to developers. Yul is targeted at developers needing exposure to the EVM's raw memory backend to build high performance gas optimized EVM code.
- [EVM Resources](guides/evm-resources/README): 
- [Solidity Resources](guides/evm-resources/solidity-resources): Monad is fully EVM bytecode-compatible, with all supported opcodes and precompiles as of the Cancun fork. Monad also preserves the standard Ethereum JSON-RPC interfaces.
- [How to index token transfers with GhostGraph](guides/indexers/ghost): Introduction
- [How to index every WMON transfer using QuickNode Streams](guides/indexers/quicknode-streams): In this guide, you will learn how to use QuickNode Streams to index every WMON transfer, including internal transactions, on Monad Testnet.
- [Use an Indexer](guides/indexers/README): <CustomDocCard
- [How to build a transfer notification bot with Envio HyperIndex](guides/indexers/tg-bot-using-envio): In this guide, you will learn how to use Envio HyperIndex to create a Telegram bot that sends notifications whenever WMON tokens are transferred on the Monad Testnet. We'll walk through setting up both the indexer and the Telegram bot.
- [How to build an MCP server that can interact with Monad Testnet](guides/monad-mcp): In this guide, you will learn how to build a Model Context Protocol (MCP) server that allows an MCP Client (Claude Desktop) to query Monad Testnet to check the MON balance of an account.
- [Guides](guides/README): Start building smart contracts and applications on Monad with our quickstart guides.
- [Getting Started with Reown AppKit on Monad Testnet using AppKit CLI](guides/reown-guide): This guide shows you how to use Reown AppKit to enable wallet connections and interact with the Monad network. AppKit provides seamless wallet connections, including email/social logins, smart accounts, one-click authentication, and wallet notifications.
- [How to build a basic dApp with Scaffold-ETH](guides/scaffold-eth): In this guide, you will learn how to use Scaffold-ETH 2 to quickly build a new dapp project.
- [Set up Execution Events](guides/setup-execution-events): This guide walks you through configuring your Monad node to enable the Execution Events system, which allows you to build high-performance applications that receive lowest-latency event data via shared memory.
- [Verify a smart contract on Monad using Foundry](guides/verify-smart-contract/foundry): Once your contract is deployed to a live network, the next step is to verify its source code on the block explorer.
- [Verify a smart contract on Monad using Hardhat](guides/verify-smart-contract/hardhat): Once your contract is deployed to a live network, the next step is to verify its source code on the block explorer.
- [Verify a Contract](guides/verify-smart-contract/README): <CustomDocCard
- [How to setup x402-enabled endpoints with Monad support](guides/x402-guide): This guide shows how to setup payable endpoints using x402 payments and Thirdweb’s built‑in facilitator. It works on Monad testnet/mainnet.
- [Introduction](introduction/introduction): * Network Information
- [Monad for Developers](introduction/monad-for-developers): Technical one-pager on Monad for developers
- [Monad for Users](introduction/monad-for-users): One-pager on Monad for users
- [Why Blockchain?](introduction/why-blockchain): A simple mental model for the 'what' and 'why'.
- [Why Monad: Decentralization + Performance](introduction/why-monad): Decentralization matters
- [Asynchronous I/O](monad-arch/concepts/asynchronous-io): Asynchronous I/O is a form of input/output processing that allows the CPU to continue executing concurrently while communication is in progress.
- [Pipelining](monad-arch/concepts/pipelining): Pipelining is a technique for implementing parallelism by dividing tasks into a series of smaller tasks which can be processed in parallel.
- [Concepts](monad-arch/concepts/README): 
- [Asynchronous Execution](monad-arch/consensus/asynchronous-execution): Pipelined consensus-execution staging
- [Message Authentication](monad-arch/consensus/authentication): BLS Multi-Signatures
- [Block States](monad-arch/consensus/block-states): Block lifecycle
- [Blocksync](monad-arch/consensus/blocksync): Mechanism for synchronizing missing blocks
- [Local Mempool](monad-arch/consensus/local-mempool): Mempool local to each node
- [MonadBFT](monad-arch/consensus/monad-bft): MonadBFT - Fast, Responsive, Fork-Resistant, Streamlined Consensus
- [Peer Discovery](monad-arch/consensus/peer-discovery): Summary
- [RaptorCast](monad-arch/consensus/raptorcast): Multicast message delivery protocol used for block propagation
- [Consensus](monad-arch/consensus/README): <CustomDocCard
- [Statesync](monad-arch/consensus/statesync): Mechanism for synchronizing MonadDb state
- [Transport Protocol Usage](monad-arch/consensus/transport-protocols): Overview of transport protocol usage for node communication
- [MonadDb](monad-arch/execution/monaddb): High-performance database for storing blockchain data.
- [JIT Compilation](monad-arch/execution/native-compilation): High-performance execution of EVM bytecode by compiling to machine code.
- [Parallel Execution](monad-arch/execution/parallel-execution): Summary
- [Execution](monad-arch/execution/README): <CustomDocCard
- [Monad Architecture](monad-arch/README): <CustomDocCard
- [Real-Time Data Sources](monad-arch/realtime-data/data-sources): For many use cases, developers and users can access current and historical
- [Real-time Data](monad-arch/realtime-data/README): <CustomDocCard
- [Speculative Real-Time Data](monad-arch/realtime-data/spec-realtime): The Monad architectural overview explains the asynchronous execution
- [Transaction Lifecycle in Monad](monad-arch/transaction-lifecycle): Transaction Submission
- [Configuring RPC to use archive data](node-ops/archive-data/configuring-rpc): Integration with the archive is designed for full nodes servicing RPC requests, not for validator
- [The Data Waterfall](node-ops/archive-data/data-waterfall): Background
- [Archive Data Setup](node-ops/archive-data/README): <CustomDocCard
- [Running an Archive Server](node-ops/archive-data/running-an-archive-server): Please see The Data Waterfall for an overview
- [Execution Events and WebSocket Setup](node-ops/events-and-websockets): Summary
- [How Full Nodes Receive Blocks](node-ops/full-node-block-delivery): See here for instructions on how to set up a full node.
- [Full Node Installation](node-ops/full-node-installation): Components
- [General Operations](node-ops/general-operations): Version Information
- [Hardware Requirements](node-ops/hardware-requirements): Cloud-based environments are not officially supported.
- [Full Replay](node-ops/node-recovery/full-replay): Full Replay allows a node to catch up on missed blocks by simply retrieving and replaying them
- [Hard Reset Instructions](node-ops/node-recovery/hard-reset): Hard reset wipes the local state and downloads the most recent chain snapshot. After the snapshot
- [Recovering a Node](node-ops/node-recovery/README): When a node is stopped (e.g. due to an upgrade or network outage), it may miss some blocks
- [Soft Reset Instructions](node-ops/node-recovery/soft-reset): A soft reset is typically required when node is (re-)joining the network and the node tip is close to the network tip. Soft reset utilizes statesync to
- [Node Operations](node-ops/README): <CustomDocCard
- [Upgrade Instructions](node-ops/upgrade-instructions/README): <CustomDocCard
- [v0.12.3](node-ops/upgrade-instructions/v0.12.3): Please do not proceed until Monad Foundation provides notice.
- [v0.12.5 - testnet re-genesis](node-ops/upgrade-instructions/v0.12.5-testnet-regenesis): These instructions are only applicable to testnet. This can be ignored for mainnet.
- [Validator Installation](node-ops/validator-installation): Setting up a validator is very similar to setting up a full node with a few extra steps.
- [Official Links](official-links): Mainnet Network
- [JSON-RPC API](reference/json-rpc/index): This section provides an interactive reference for the Monad's JSON-RPC API.
- [RPC Reference](reference/README): Monad supports a JSON-RPC interface for interacting
- [RPC Differences](reference/rpc-differences): Monad aims to match the RPC behavior as close as possible to Geth’s behavior, but due to
- [RPC Error Codes](reference/rpc-error-codes): Monad supports a JSON-RPC interface for interacting with the blockchain.
- [RPC Limits](reference/rpc-limits): ethcall / ethestimateGas
- [WebSocket Guide](reference/websockets): Monad's RPC server supports JSON-RPC over WebSocket connections. This feature
- [How to generate user specific images in the Farcaster Mini App](templates/farcaster-miniapp/generating-custom-og-images): Creating shareable moments in the Farcaster Mini App is a great way to engage with your users.
- [How to build a Farcaster Mini App](templates/farcaster-miniapp/getting-started): In this guide, you will learn how to use the Monad Farcaster Mini App Template to build apps.
- [How to add haptics to a Farcaster Mini App](templates/farcaster-miniapp/haptics): Haptics are a way to add tactile feedback to your app to enhance user interaction and responsiveness.
- [How to publish a Farcaster Mini App](templates/farcaster-miniapp/publishing-miniapp): Publishing the Mini App makes it discoverable in the Farcaster app. However, the Mini App has to be hosted on a domain before it can be published.
- [Farcaster Mini Apps](templates/farcaster-miniapp/README): Mini Apps enable developers to distribute native-like apps to Farcaster users. Mini Apps are the easiest way to deliver engaging, high-retention, and easy-to-monetize applications!
- [How to send notifications to users of the Farcaster Mini App](templates/farcaster-miniapp/sending-notifications): This guide walks you through how you can send notifications to your Mini App users.
- [How to use the Next.js Serwist 0x Privy embedded wallet template](templates/next-serwist-0x-privy-embedded-wallet): This guide walks you through using the template which uses Next.js, Serwist (offline capabilities), 0x (token trading), and Privy embedded wallet (authentication) to build a Progressive Web Application (PWA) on Monad.
- [How to use the Next.js PWA Privy embedded wallet template](templates/next-serwist-privy-embedded-wallet): This guide walks you through using the template which uses Next.js, Serwist (offline capabilities), and Privy embedded wallet to build a Progressive Web App (PWA) on Monad.
- [How to use the Next.js PWA sponsored transactions template](templates/next-serwist-privy-smart-wallet): This guide walks you through using the template which uses Next.js, Serwist (offline capabilities), and Privy smart wallet (authentication and transaction sponsorship) to build a Progressive Web Application (PWA) on Monad.
- [How to use the Next.js Serwist Thirdweb embedded wallet template](templates/next-serwist-thirdweb): This guide walks you through using the template which uses Next.js, Serwist (offline capabilities), and Thirdweb embedded wallet to build a Progressive Web Application (PWA) on Monad.
- [How to use the React Native Privy embedded wallet template](templates/react-native-privy-embedded-wallet): This guide walks you through using the wallet template which uses Expo, React Native, and Privy embedded wallet to build a mobile app on Monad.
- [How to use the React Native sponsored transactions template](templates/react-native-privy-pimlico-sponsored-transactions): Sponsored transactions enable users to interact with blockchain applications without needing to pay gas fees themselves, improving accessibility, user experience, and onboarding - especially for newcomers unfamiliar with crypto.
- [How to use the React Native Thirdweb embedded wallet template](templates/react-native-thirdweb-embedded-wallet): This guide walks you through using the embedded wallet template which uses Expo, React Native, and Thirdweb embedded wallet to build a mobile app on Monad.
- [Analytics](tooling-and-infra/analytics): Provider Summary
- [Block Explorers](tooling-and-infra/block-explorers): Block Explorer Summary
- [Cross-Chain](tooling-and-infra/cross-chain): Definitions
- [Custody](tooling-and-infra/custody): Provider Summary
- [Debugging Onchain](tooling-and-infra/debugging-onchain): Transaction introspection/tracing
- [Common Data](tooling-and-infra/indexers/common-data): Features
- [Indexing Frameworks](tooling-and-infra/indexers/indexing-frameworks): Background
- [Indexers](tooling-and-infra/indexers/README): <CustomDocCard
- [Local Nodes](tooling-and-infra/local-nodes): Developers often find it helpful to be able to run a 1-node Ethereum network with modified parameters to test interaction with the blockchain:
- [Onramps](tooling-and-infra/onramps): Onramps are services that allow users to convert fiat currency into cryptocurrency. They serve
- [Oracles](tooling-and-infra/oracles): Oracles make off-chain data accessible on chain.
- [Tooling and Infrastructure](tooling-and-infra/README): Many leading Ethereum developer tools support Monad Testnet. The enclosing pages survey each category of tools and attempt a feature comparison.
- [RPC Providers](tooling-and-infra/rpc-providers): See also: API reference
- [Toolkits](tooling-and-infra/toolkits): Summary
- [Account Abstraction Providers](tooling-and-infra/wallet-infra/account-abstraction): Account Abstraction Providers provide bundler and paymaster services, enabling features like
- [Embedded Wallets](tooling-and-infra/wallet-infra/embedded-wallets): Background
- [Wallet Infrastructure](tooling-and-infra/wallet-infra/README): Summary
- [Smart Account Implementations](tooling-and-infra/wallet-infra/smart-accounts): Background
- [Hardware Wallets](tooling-and-infra/wallets/hardware-wallets): Provider Summary
- [Multisig Wallets](tooling-and-infra/wallets/multisig-wallets): Provider Summary
- [Wallets](tooling-and-infra/wallets/README): <CustomDocCard
- [Software Wallets](tooling-and-infra/wallets/software-wallets): Provider Summary