> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monad.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# Deployment Summary for Developers

> Deployment Summary for Developers

export const CopyToClipboard = ({value, children}) => {
  const [copied, setCopied] = useState(false);
  const handleCopy = async () => {
    try {
      await navigator.clipboard.writeText(value);
      setCopied(true);
      setTimeout(() => setCopied(false), 1000);
    } catch {
      const textarea = document.createElement("textarea");
      textarea.value = value;
      textarea.style.position = "fixed";
      textarea.style.opacity = "0";
      document.body.appendChild(textarea);
      textarea.select();
      document.execCommand("copy");
      document.body.removeChild(textarea);
      setCopied(true);
      setTimeout(() => setCopied(false), 1000);
    }
  };
  return <span style={{
    display: "inline",
    whiteSpace: "nowrap"
  }}>
      {children}
      <button onClick={handleCopy} title={copied ? "Copied!" : "Copy to clipboard"} style={{
    background: "none",
    border: "none",
    cursor: "pointer",
    padding: "2px",
    display: "inline-flex",
    alignItems: "center",
    verticalAlign: "middle",
    marginLeft: "4px",
    opacity: copied ? 1 : 0.4,
    transition: "opacity 0.15s"
  }} onMouseEnter={e => {
    if (!copied) e.currentTarget.style.opacity = "0.8";
  }} onMouseLeave={e => {
    if (!copied) e.currentTarget.style.opacity = "0.4";
  }}>
        {copied ? <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="#22c55e" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
            <polyline points="20 6 9 17 4 12" />
          </svg> : <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
            <rect x="9" y="9" width="13" height="13" rx="2" ry="2" />
            <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
          </svg>}
      </button>
    </span>;
};

This page summarizes what you need to know when developing or deploying smart contracts for
Monad.

## Start with

* [Network Information](/developer-essentials/network-information) - for RPC & block explorer URLs, and canonical
  contract deployments.
* [Differences between Monad and Ethereum](/developer-essentials/differences)
* [`protocols` repo](https://github.com/monad-crypto/protocols) (add yours!)
* [`token-list` repo](https://github.com/monad-crypto/token-list) (add yours!)
* [RPC API](/reference/json-rpc/) - an interactive reference

## Supported Tooling & Infra

Here are some of the most commonly-requested tools:

| Tool                                                    | Status | Notes                                                                   |
| ------------------------------------------------------- | ------ | ----------------------------------------------------------------------- |
| [Tenderly](https://dashboard.tenderly.co/explorer)      | ✅      |                                                                         |
| [Safe](https://app.safe.global)                         | ✅      |                                                                         |
| [Monadscan](https://monadscan.com) (by Etherscan)       | ✅      |                                                                         |
| [MonadVision](https://monadvision.com) (by Blockvision) | ✅      |                                                                         |
| [Foundry](https://getfoundry.sh)                        | ✅      | Use the [Monad Foundry](/tooling-and-infra/toolkits/monad-foundry) fork |
| [Viem](https://github.com/wevm/viem)                    | ✅      | `viem >= 2.40.0`                                                        |

<br />

See [Tooling and Infra](/tooling-and-infra) for a complete list of what is supported,
including:

| Category                                                                                                   |
| ---------------------------------------------------------------------------------------------------------- |
| [AA Infra](/tooling-and-infra/wallet-infra/account-abstraction)                                            |
| [Analytics](/tooling-and-infra/analytics)                                                                  |
| [Block Explorers](/tooling-and-infra/block-explorers)                                                      |
| [Cross-Chain](/tooling-and-infra/cross-chain)                                                              |
| [Custody](/tooling-and-infra/custody)                                                                      |
| [Embedded Wallets](/tooling-and-infra/wallet-infra/embedded-wallets)                                       |
| [Indexers - Common Data](/tooling-and-infra/indexers/common-data) (e.g. token balances, transfers, trades) |
| [Indexing Frameworks (incl Subgraphs)](/tooling-and-infra/indexers/indexing-frameworks)                    |
| [Onramps](/tooling-and-infra/onramps)                                                                      |
| [Oracles](/tooling-and-infra/oracles)                                                                      |
| [RPC Providers](/tooling-and-infra/rpc-providers)                                                          |

## Accounts

<div class="mintlify-table-wrapper">
  <table class="mintlify-table">
    <thead>
      <tr>
        <th />

        <th />
      </tr>
    </thead>

    <tbody>
      <tr>
        <td>Address space</td>
        <td>Same address space as Ethereum (last 20 bytes of ECDSA public key)</td>
      </tr>

      <tr>
        <td>EIP-7702</td>
        <td>Supported. See [EIP-7702 reference](/developer-essentials/eip-7702)</td>
      </tr>
    </tbody>
  </table>
</div>

## Smart Contracts

For deployment and verification guides, see:

* [Deploy a Contract](/guides/deploy-smart-contract)
* [Verify a Contract](/guides/verify-smart-contract)
* [MonadVision verification guide](https://docs.blockvision.org/reference/verify-smart-contract-on-monad-explorer)

<div class="mintlify-table-wrapper">
  <table class="mintlify-table">
    <thead>
      <tr>
        <th />

        <th />
      </tr>
    </thead>

    <tbody>
      <tr>
        <td>Opcodes</td>
        <td>All [opcodes](https://www.evm.codes/) as of the Fusaka fork are supported.</td>
      </tr>

      <tr>
        <td>Precompiles</td>
        <td>All Ethereum precompiles as of the Fusaka fork (`0x01` to `0x11`), plus P256 signature verification at `0x0100` ([EIP-7951](https://eips.ethereum.org/EIPS/eip-7951)) and the staking precompile at `0x1000`. See [Precompiles](/developer-essentials/precompiles)</td>
      </tr>

      <tr>
        <td>Max contract size</td>
        <td>128 kb (up from 24.5 kb in Ethereum)</td>
      </tr>
    </tbody>
  </table>
</div>

## Transaction types

Full article: [Transactions](/developer-essentials/transactions)

<div class="mintlify-table-wrapper">
  <table class="mintlify-table">
    <thead>
      <tr>
        <th />

        <th />
      </tr>
    </thead>

    <tbody>
      <tr>
        <td>Transaction types</td>
        <td>Supported:
        <ul><li>0 ("legacy")</li>
        <li>1 ("EIP-2930")</li>
        <li>2 ("EIP-1559", the "default" on Ethereum)</li>
        <li>4 (["EIP-7702"](/developer-essentials/eip-7702))</li></ul>
        Not supported:
        <ul><li>3 ("EIP-4844")</li></ul></td>
      </tr>
    </tbody>
  </table>
</div>

## Gas limits

<div class="mintlify-table-wrapper">
  <table class="mintlify-table">
    <thead>
      <tr>
        <th />

        <th />
      </tr>
    </thead>

    <tbody>
      <tr>
        <td>Per-transaction gas limit</td>
        <td>30M gas</td>
      </tr>

      <tr>
        <td>Block gas limit</td>
        <td>200M gas</td>
      </tr>

      <tr>
        <td>Block gas target</td>
        <td>80% (160M gas)</td>
      </tr>

      <tr>
        <td>Gas throughput</td>
        <td>500M gas/sec (200M gas/block divided by 0.4 sec/block)</td>
      </tr>
    </tbody>
  </table>
</div>

## Gas pricing

Full article: [Gas pricing](/developer-essentials/gas-pricing)

<div class="mintlify-table-wrapper">
  <table class="mintlify-table">
    <thead>
      <tr>
        <th />

        <th />
      </tr>
    </thead>

    <tbody>
      <tr>
        <td>Gas charged</td>
        <td>The **gas limit** is what is charged. That is: total tokens deducted from the sender's balance is `value + gas_price * gas_limit`. See [discussion](/developer-essentials/gas-pricing#gas-limit-not-gas-used).</td>
      </tr>

      <tr>
        <td>EIP-1559 dynamics</td>
        <td>Monad is EIP-1559-compatible; base fee and priority fee work as on Ethereum. [EIP-1559 explainer](/developer-essentials/gas-pricing#eip-1559-compatibility)</td>
      </tr>

      <tr>
        <td>Base fee</td>
        <td>Min base fee of 100 MON-gwei (100 \* 10^-9 MON).<br />The base fee controller is similar to Ethereum's but stays elevated for less time ([details](/developer-essentials/gas-pricing#base_price_per_gas-controller)).</td>
      </tr>
    </tbody>
  </table>
</div>

## Opcode pricing

Full article: [Opcode Pricing](/developer-essentials/opcode-pricing)

Opcode pricing is the same as on Ethereum (see: [evm.codes](https://www.evm.codes/)), **except**
for the below repricings needed to reweight relative scarcities of resources due to Monad
optimizations.

<div class="mintlify-table-wrapper">
  <table class="mintlify-table">
    <thead>
      <tr>
        <th>Item</th>
        <th>Ethereum</th>
        <th>Monad</th>
        <th>Notes</th>
      </tr>
    </thead>

    <tbody>
      <tr>
        <td>Cold access cost - account</td>
        <td>2,600</td>
        <td>10,100</td>
        <td>Affected opcodes: `BALANCE`, `EXTCODESIZE`, `EXTCODECOPY`, `EXTCODEHASH`, `CALL`, `CALLCODE`, `DELEGATECALL`, `STATICCALL`, `SELFDESTRUCT`<br />See [details](/developer-essentials/opcode-pricing#cold-access-cost)</td>
      </tr>

      <tr>
        <td>Cold access cost - storage</td>
        <td>2,100</td>
        <td>8,100</td>
        <td>Affected opcodes: `SLOAD`, `SSTORE`. See [details](/developer-essentials/opcode-pricing#cold-access-cost)</td>
      </tr>

      <tr>
        <td>`ecRecover`, `ecAdd`, `ecMul`, `ecPairing`, `blake2f`, `point_eval` precompiles</td>

        <td />

        <td />

        <td>See [details](/developer-essentials/opcode-pricing#precompiles)<br /><br />Precompiles `0x01`, `0x06`, `0x07`, `0x08`, `0x09`, `0x0a`</td>
      </tr>
    </tbody>
  </table>
</div>

## Timing considerations

<div class="mintlify-table-wrapper">
  <table class="mintlify-table">
    <thead>
      <tr>
        <th />

        <th />
      </tr>
    </thead>

    <tbody>
      <tr>
        <td>Block frequency</td>
        <td>400 ms</td>
      </tr>

      <tr>
        <td>`TIMESTAMP` opcode</td>
        <td>As in Ethereum, `TIMESTAMP` is a second-granularity unix timestamp. Since blocks
        are every 400 ms, this means that 2-3 blocks will likely have the same timestamp.</td>
      </tr>

      <tr>
        <td>Finality</td>
        <td>Blocks are finalized after two blocks (800 ms). Once a block is finalized, it
        cannot be reorged. See
        [MonadBFT](/monad-arch/consensus/monad-bft) for a fuller discussion.</td>
      </tr>

      <tr>
        <td>Speculative finality</td>
        <td>Blocks can be
        [speculatively finalized](/monad-arch/consensus/monad-bft#speculative-finality)
        after one block (400 ms), when it is marked as being in the `Voted` stage.<br /><br />
        Speculative finality can revert under very rare circumstances (see fuller discussion
        [here](/monad-arch/consensus/monad-bft#speculative-finality)).</td>
      </tr>
    </tbody>
  </table>
</div>

## Mempool

Full article: [Local Mempool](/monad-arch/consensus/local-mempool)

Monad does not have a global mempool, as this approach is not suitable for high-performance
blockchains.

Each validator maintains a local mempool with transactions that it is aware of. When an RPC
receives a transaction, it forwards it strategically to upcoming leaders, repeating this process
if it doesn't observe the transaction getting included.

Although this is an important part of Monad's design, it is not one that should generally affect
smart contract developers in their system designs.

## Parallel Execution and JIT Compilation

Monad utilizes [parallel execution](/monad-arch/execution/parallel-execution) and
[JIT compilation](/monad-arch/execution/native-compilation) for efficiency,
but smart contract developers don't need to change anything to account for this.

In Monad, transactions are still linearly ordered, and the only correct outcome of execution is
the result as if the transactions were serially executed. All aspects of parallel execution can
be treated by smart contract developers as implementation details.
See [further discussion](/monad-arch/execution/parallel-execution).

## Asynchronous Execution

Full article: [Asynchronous Execution](/monad-arch/consensus/asynchronous-execution)

Monad utilizes asynchronous execution for efficiency, but most developers shouldn't need to
change anything.

Developers with significant off-chain financial logic (e.g. exchanges, bridges, and
stablecoin/RWA issuers) should wait until blocks reach the
[`Verified`](/monad-arch/consensus/block-states#verified)
phase (aka state root finality), three blocks later than
[`Finalized`](/monad-arch/consensus/block-states#finalized),
to be sure that the entire network agrees with their own node's local execution of a
finalized block.

<Accordion title="Async execution and block stages">
  Asynchronous execution is a technique that allows Monad to substantially
  increase execution throughput by decoupling consensus from execution. In asynchronous execution,
  validators **vote first, execute later** - because once the transaction order is determined, the
  state is determined. Afterward, each node executes locally. There is a
  [delayed merkle root](/monad-arch/consensus/asynchronous-execution#delayed-merkle-root)
  three blocks later which confirms that the network got the same state trie as local execution.

  From the developer perspective:

  * Someone submits a transaction through your frontend which interacts with your smart contract.
    You make note of the hash.
  * A block gets [`Proposed`](/monad-arch/consensus/block-states#proposed) with the transaction included.
  * The block gets [`Voted`](/monad-arch/consensus/block-states#voted) (speculatively finalized)
    one block later. (`T+1`)
  * The block gets [`Finalized`](/monad-arch/consensus/block-states#finalized) one block later
    (`T+2`)
  * The block gets [`Verified`](/monad-arch/consensus/block-states#verified) (state root
    finalized) three blocks later (`T+5`)

  You listen for transaction receipts by calling
  [`eth_getTransactionReceipt`](/reference/json-rpc/eth_getTransactionReceipt).
  Receipts will first be available after a block becomes `Proposed` (speculatively executed).

  Your choice of when to update your UI to give feedback to the user depends on risk preference, but
  for most applications it is reasonable to do so when the block becomes `Proposed` because speculative
  finality reversion is extremely rare. A more conservative approach would be to wait until the
  block is `Finalized`, since then you will never have to handle a reorg. Waiting until `Verified`
  is not generally necessary (except for the aforementioned developers with off-chain financial
  logic).
</Accordion>

## Reserve balance

Full article: [Reserve Balance](/developer-essentials/reserve-balance)

Monad introduces the Reserve Balance mechanism to enable Asynchronous Execution.

The Reserve Balance mechanism places light restrictions on when transactions can be included at
consensus time, and imposes some conditions under which transactions will revert at execution time.

The Reserve Balance mechanism is designed to preserve safety under asynchronous execution without
interfering with normal usage patterns. Most users and developers need not worry about the Reserve
Balance constraints.

| Parameter               | Value  |
| ----------------------- | ------ |
| Default reserve balance | 10 MON |

## EIP-7702

EIP-7702 is supported; see the full notes [here](/developer-essentials/eip-7702).

There are two caveats:

1. If an EOA is EIP-7702-delegated, its balance cannot be lowered below 10 MON due to the
   [Reserve Balance](/developer-essentials/reserve-balance) rules. (If the delegation is removed, dipping below 10 MON
   is allowed.) [Discussion](/developer-essentials/eip-7702#delegated-eoas-cant-dip-below-10-mon).

2. If an EOA is EIP-7702-delegated, when it is called as a smart contract, the
   `CREATE` and `CREATE2` opcodes are banned. [Discussion](/developer-essentials/eip-7702#delegated-contract-code-cannot-call-createcreate2).

## Reading blockchain data

The following methods are supported for reading blockchain data:

<div class="mintlify-table-wrapper">
  <table class="mintlify-table">
    <thead>
      <tr>
        <th />

        <th />
      </tr>
    </thead>

    <tbody>
      <tr>
        <td>JSON-RPC</td>
        <td>See [RPC API](/reference/json-rpc). Monad supports all standard RPC methods
        from Ethereum. Differences are noted in [RPC Differences](/reference/rpc-differences). For rate limits, see [here](/reference/rpc-limits).</td>
      </tr>

      <tr>
        <td>WebSocket</td>
        <td>See the [WebSocket Guide](/reference/websockets).<br /><br />
        Monad implements the `eth_subscribe` method with the following subscription types:<ul>
        <li>`newHeads` and `logs`</li>
        <li>`monadNewHeads` and `monadLogs` (similar, but include additional data for tracking
        each block's progression through consensus)</li></ul>
        The `syncing` and `newPendingTransactions` subscription types are not supported.
        For more details see [Real-time Data Sources](/monad-arch/realtime-data/data-sources).</td>
      </tr>

      <tr>
        <td>Execution Events</td>
        <td>See [Execution Events](/execution-events).<br /><br />
        The Execution Events system allows developers to build high-performance applications
        that receive lowest-latency event data from a Monad node via shared memory queue.</td>
      </tr>
    </tbody>
  </table>
</div>

You can also use the supported [Indexers](/tooling-and-infra/indexers).

## Historic data

Monad full nodes provide access to all historic ledger data (blocks, transactions, receipts,
events, and traces). Monad full nodes do not provide access to arbitrary historic state as
discussed [here](/developer-essentials/historical-data).

There is a special RPC service at <CopyToClipboard value="https://rpc-mainnet.monadinfra.com">[`https://rpc-mainnet.monadinfra.com`](https://rpc-mainnet.monadinfra.com)</CopyToClipboard>
that provides access to historical data.

## Recommended Open Source Tooling Versions

* `foundry`: use the [Monad Foundry](/tooling-and-infra/toolkits/monad-foundry) fork, which incorporates Monad gas pricing and precompiles
* `viem >= 2.40.0` (just to bring in [monad.ts](https://github.com/wevm/viem/blob/main/src/chains/definitions/monad.ts))
* `alloy-chains >= 0.2.20`

## Canonical contract addresses

See [Canonical Contracts](/developer-essentials/network-information#canonical-contracts-on-testnet)

## Source code

* [`monad-bft`](https://github.com/category-labs/monad-bft) (consensus)
* [`monad`](https://github.com/category-labs/monad) (execution)

## Running a full node

See [Node Operations](/node-ops)

## Need Help?

Please ask in the [developer discord](https://discord.gg/monaddev). We are here to help!