monad-developmentBuilds dapps on Monad blockchain. Use when deploying contracts, setting up frontends with viem/wagmi, or verifying contracts on Monad testnet or mainnet.
Install via ClawdBot CLI:
clawdbot install portdeveloper/monad-developmentFor questions not covered here, fetch https://docs.monad.xyz/llms.txt
| Network | Chain ID | RPC |
|---------|----------|-----|
| Testnet | 10143 | https://testnet-rpc.monad.xyz |
| Mainnet | 143 | https://rpc.monad.xyz |
Docs: https://docs.monad.xyz
| Explorer | Testnet | Mainnet |
|----------|---------|---------|
| Socialscan | https://monad-testnet.socialscan.io | https://monad.socialscan.io |
| MonadVision | https://testnet.monadvision.com | https://monadvision.com |
| Monadscan | https://testnet.monadscan.com | https://monadscan.com |
IMPORTANT: Do NOT use a browser. Use these APIs directly with curl.
Faucet (Testnet Funding):
curl -X POST https://agents.devnads.com/v1/faucet \
-H "Content-Type: application/json" \
-d '{"chainId": 10143, "address": "0xYOUR_ADDRESS"}'Returns: {"txHash": "0x...", "amount": "1000000000000000000", "chain": "Monad Testnet"}
Fallback (official faucet): https://faucet.monad.xyz
If the agent faucet fails, ask the user to fund via the official faucet (do not use a browser yourself).
Verification (All Explorers):
ALWAYS use the verification API first. It verifies on all 3 explorers (MonadVision, Socialscan, Monadscan) with one call. Do NOT use forge verify-contract as first choice.
# 1. Get verification data
forge verify-contract <ADDR> <CONTRACT> \
--chain 10143 \
--show-standard-json-input > /tmp/standard-input.json
cat out/<Contract>.sol/<Contract>.json | jq '.metadata' > /tmp/metadata.json
COMPILER_VERSION=$(jq -r '.metadata | fromjson | .compiler.version' out/<Contract>.sol/<Contract>.json)
# 2. Call verification API
STANDARD_INPUT=$(cat /tmp/standard-input.json)
FOUNDRY_METADATA=$(cat /tmp/metadata.json)
cat > /tmp/verify.json << EOF
{
"chainId": 10143,
"contractAddress": "0xYOUR_CONTRACT_ADDRESS",
"contractName": "src/MyContract.sol:MyContract",
"compilerVersion": "v${COMPILER_VERSION}",
"standardJsonInput": $STANDARD_INPUT,
"foundryMetadata": $FOUNDRY_METADATA
}
EOF
curl -X POST https://agents.devnads.com/v1/verify \
-H "Content-Type: application/json" \
-d @/tmp/verify.jsonWith constructor arguments: Add constructorArgs (ABI-encoded, WITHOUT 0x prefix):
ARGS=$(cast abi-encode "constructor(string,string,uint256)" "MyToken" "MTK" 1000000000000000000000000)
ARGS_NO_PREFIX=${ARGS#0x}
# Add to request: "constructorArgs": "$ARGS_NO_PREFIX"Manual verification fallback (if API fails):
forge verify-contract <ADDR> <CONTRACT> --chain 10143 \
--verifier sourcify \
--verifier-url "https://sourcify-api-monad.blockvision.org/"CRITICAL for agents: If you generate a wallet for the user, you MUST persist it for future use.
When generating a new wallet:
cast wallet newStorage options:
~/.monad-wallet with chmod 600.env file (add to .gitignore)Why this matters: Users need access to their wallet to:
Use forge script for deployments:
forge script script/Deploy.s.sol:DeployScript \
--rpc-url https://testnet-rpc.monad.xyz \
--private-key $PRIVATE_KEY \
--broadcastDeploy script template:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;
import "forge-std/Script.sol";
import "../src/MyContract.sol";
contract DeployScript is Script {
function run() external {
vm.startBroadcast();
MyContract contract = new MyContract();
console.log("Contract deployed at:", address(contract));
vm.stopBroadcast();
}
}Always set evmVersion: "prague". Requires Solidity 0.8.27+.
Foundry (foundry.toml):
[profile.default]
evm_version = "prague"
solc_version = "0.8.28"Flags that don't exist (don't use):
--no-commit - not a valid flag for forge init or forge installDeployment - use forge script, NOT forge create:
forge create --broadcast is buggy and often ignored. Use forge script instead.
forge script script/Deploy.s.sol:DeployScript \
--rpc-url https://testnet-rpc.monad.xyz \
--private-key $PRIVATE_KEY \
--broadcastDeploy script must NOT hardcode addresses:
// ✅ Correct - reads private key from --private-key flag
function run() external {
vm.startBroadcast();
new MyContract();
vm.stopBroadcast();
}
// ❌ Wrong - hardcodes address, causes "No associated wallet" error
function run() external {
vm.startBroadcast(0x1234...);
}Import from viem/chains. Do NOT define custom chain:
import { monadTestnet } from "viem/chains";Use with wagmi:
import { createConfig, http } from 'wagmi'
import { monadTestnet } from 'viem/chains'
const config = createConfig({
chains: [monadTestnet],
transports: {
[monadTestnet.id]: http()
}
})1. Create project:
forge init my-token
cd my-token2. Configure foundry.toml:
[profile.default]
src = "src"
out = "out"
libs = ["lib"]
evm_version = "prague"
solc_version = "0.8.28"3. Create contract src/MyToken.sol:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract MyToken is ERC20 {
constructor(uint256 initialSupply) ERC20("MyToken", "MTK") {
_mint(msg.sender, initialSupply);
}
}4. Install dependencies:
forge install OpenZeppelin/openzeppelin-contracts --no-commit5. Create deploy script script/Deploy.s.sol:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;
import "forge-std/Script.sol";
import "../src/MyToken.sol";
contract DeployScript is Script {
function run() external {
vm.startBroadcast();
MyToken token = new MyToken(1000000 * 10**18);
console.log("Token deployed at:", address(token));
vm.stopBroadcast();
}
}6. Deploy:
forge script script/Deploy.s.sol:DeployScript \
--rpc-url https://testnet-rpc.monad.xyz \
--private-key $PRIVATE_KEY \
--broadcast7. Verify:
# Use verification API (verifies on all explorers)
STANDARD_INPUT=$(forge verify-contract <TOKEN_ADDRESS> src/MyToken.sol:MyToken --chain 10143 --show-standard-json-input)
COMPILER_VERSION=$(jq -r '.metadata | fromjson | .compiler.version' out/MyToken.sol/MyToken.json)
curl -X POST https://agents.devnads.com/v1/verify \
-H "Content-Type: application/json" \
-d "{
\"chainId\": 10143,
\"contractAddress\": \"<TOKEN_ADDRESS>\",
\"contractName\": \"src/MyToken.sol:MyToken\",
\"compilerVersion\": \"v${COMPILER_VERSION}\",
\"standardJsonInput\": $STANDARD_INPUT,
\"constructorArgs\": \"$(cast abi-encode 'constructor(uint256)' 1000000000000000000000000 | sed 's/0x//')\"
}"Generated Mar 1, 2026
A developer wants to create and deploy an ERC-20 token on the Monad testnet for testing purposes. The agent assists by generating a wallet, funding it via the faucet API, setting up a Foundry project with the correct EVM version, and deploying the contract using a script. It then verifies the contract on all explorers using the verification API.
A team is developing a dapp that interacts with smart contracts on Monad. The agent helps integrate the frontend using viem and wagmi, configuring the network settings for testnet or mainnet, and ensuring proper wallet persistence for user interactions. It provides code snippets for connecting to the Monad chain without custom definitions.
After deploying a contract, a user needs to verify it on Monad explorers for transparency. The agent guides through generating verification data with Foundry, using the verification API to submit to all explorers at once, and handling fallback methods if the API fails, ensuring the contract is publicly accessible.
A new developer wants to start building on Monad blockchain. The agent assists in installing required tools like Foundry and Node.js, creating a project with proper configuration for EVM version and Solidity compiler, and persisting a wallet securely for future deployments and interactions.
A project is ready to launch on Monad mainnet after testing. The agent helps switch network configurations, update RPC URLs and chain IDs, ensure contract verification processes are adjusted, and manage wallet funding through mainnet faucets or transfers, following the default to testnet unless specified.
Offer custom smart contract creation and deployment for clients on Monad blockchain. Revenue comes from one-time development fees or ongoing maintenance contracts, leveraging the agent's tools for efficient deployment, verification, and frontend integration to reduce time and costs.
Provide consulting services to businesses integrating decentralized applications with Monad. Revenue is generated through hourly rates or fixed packages for setting up frontends with viem/wagmi, ensuring compatibility, and optimizing wallet persistence for user experience.
Host workshops or create online courses teaching developers how to build on Monad using this skill package. Revenue streams include ticket sales for live sessions, subscription access to tutorial content, or certification programs that cover deployment, verification, and tool usage.
💬 Integration Tip
Always use the verification API first for contract verification to save time, and persist generated wallets securely to avoid loss of access for future interactions.
Connect Claude to Clawdbot instantly and keep it connected 24/7. Run after setup to link your subscription, then auto-refreshes tokens forever.
ERC-8004 Trustless Agents - Register, discover, and build reputation for AI agents on Ethereum. Use when registering agents on-chain, querying agent registries, giving/receiving reputation feedback, or interacting with the AI agent trust layer.
Autonomous crypto trading on Base via Bankr. Use for trading tokens, monitoring launches, executing strategies, or managing a trading portfolio. Triggers on "trade", "buy", "sell", "launch", "snipe", "profit", "PnL", "portfolio balance", or any crypto trading task on Base.
Deploy ERC20 tokens on Base using Clanker SDK. Create tokens with built-in Uniswap V4 liquidity pools. Supports Base mainnet and Sepolia testnet. Requires PRIVATE_KEY in config.
Query DeFi portfolio data across 50+ chains via Zapper's GraphQL API. Use when the user wants to check wallet balances, DeFi positions, NFT holdings, token prices, or transaction history. Supports Base, Ethereum, Polygon, Arbitrum, Optimism, and more. Requires ZAPPER_API_KEY.
Interact with Solana blockchain via Helius APIs. Create/manage wallets, check balances (SOL + tokens), send transactions, swap tokens via Jupiter, and monitor addresses. Use for any Solana blockchain operation, crypto wallet management, token transfers, DeFi swaps, or portfolio tracking.