Monad · Beginner

How to deploy a smart contract on Monad (step by step, from the browser)

Deploy a Solidity smart contract to Monad testnet in under ten minutes using only a browser: add the network to MetaMask, get test MON, compile in Monsmith, and deploy with one click.

Deploying to Monad is the same motion as deploying to any EVM chain, with one pleasant difference: it is fast and nearly free. This guide uses Monsmith so the whole thing happens in a browser tab, but every step maps directly onto Hardhat or Foundry if you prefer a local toolchain.

Before you start

• A browser wallet such as MetaMask, Rabby, or Phantom.
• A Solidity contract, or the willingness to use a template.
• Nothing else. No Node.js, no compiler install, no RPC key.

Step 1: Add Monad testnet to your wallet

Monsmith will prompt your wallet to add and switch to this network automatically when you press Deploy, so you can also skip this and let the tool do it.

Step 2: Get test MON from the faucet

Open https://faucet.monad.xyz, paste your address, and request tokens. Deploying a typical ERC-20 costs a small fraction of one MON, so a single faucet claim covers dozens of deployments.

Step 3: Write or paste your contract

Open monsmith.com/studio. The editor is Monaco (the same engine as VS Code) with Solidity highlighting and autocomplete. OpenZeppelin imports resolve without any package install. If you are starting from scratch, the ERC-20 template is a good first contract:

solidity// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyToken is ERC20, Ownable {
    constructor(uint256 initialSupply)
        ERC20("My Token", "MTK")
        Ownable(msg.sender)
    {
        _mint(msg.sender, initialSupply);
    }

    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }
}

Step 4: Compile

Press Compile. Errors show inline at the offending line. On success you get the ABI and bytecode, and the deploy console builds a form for the constructor arguments from the ABI, so you never hand-encode anything.

Step 5: Audit and profile before you deploy

This is the step most guides skip and the one that saves you. Run the security audit: it checks for reentrancy, missing access control, unchecked calls, and other known bug classes, and scores the risk. Then run the parallel profiler to see whether your contract's functions can execute concurrently on Monad or whether shared storage will serialise them.

Step 6: Deploy

Connect your wallet, enter constructor arguments (for the token above, an initial supply such as 1000000000000000000000000 for one million tokens with 18 decimals), and press Deploy. MetaMask shows the transaction; confirm it. Monad's 300 ms blocks mean the contract address appears almost immediately.

Step 7: Verify and interact

Click the explorer link to view the deployed contract. Back in Monsmith, the deploy console lists every function from the ABI so you can call mint, transfer, or balanceOf directly and watch the results.

Going to mainnet

The steps are identical with the mainnet RPC (https://rpc.monad.xyz, chain ID 143) and real MON. Before you do: get an independent audit for anything that holds value, and use Chain Fit at monsmith.com/compare to see exactly what deployment and each function call will cost.