Monad tooling

​

MetaMask

​

Phantom

1. Install Phantom browser extension or mobile app.
2. In Phantom, navigate to Settings > Developer Settings > Add Network.
3. Enter the network details:
   • Network name — Monad Mainnet
   • RPC URL — your Chainstack endpoint
   • Chain ID — 143
   • Currency symbol — MON
   • Block explorer URL — https://monvision.io
4. Click Save.

​

Backpack

1. Install Backpack browser extension or mobile app.
2. Navigate to Settings > Networks > Add Custom Network.
3. Enter the network details:
   • Network name — Monad Mainnet
   • RPC URL — your Chainstack endpoint
   • Chain ID — 143
   • Currency symbol — MON
   • Block explorer URL — https://monvision.io
4. Save the configuration.

​

Rabby

1. Install Rabby browser extension.
2. In Rabby, navigate to Settings > Custom Network.
3. Add your Chainstack endpoint with chain ID 143.

​

HaHa

1. Install HaHa browser extension or mobile app.
2. Navigate to wallet settings and select Add Network.
3. Enter the network details:
   • Network name — Monad Mainnet
   • RPC URL — your Chainstack endpoint
   • Chain ID — 143
   • Currency symbol — MON
   • Block explorer URL — https://monvision.io
4. Save the configuration.

​

Hardhat

1. Install Hardhat and create a project.
2. Create a new environment in hardhat.config.js:
   Javascript

   Copy

   require("@nomiclabs/hardhat-waffle");
   ...
   module.exports = {
     solidity: "0.8.19",
     networks: {
       chainstack: {
           url: "YOUR_CHAINSTACK_ENDPOINT",
           accounts: ["YOUR_PRIVATE_KEY"]
       },
     }
   };
   

   where
   • YOUR_CHAINSTACK_ENDPOINT — your node HTTPS or WSS endpoint protected either with the key or password. See node access details.
   • YOUR_PRIVATE_KEY — the private key of the account that you use to deploy the contract
3. Run npx hardhat run scripts/deploy.js --network chainstack and Hardhat will deploy using Chainstack.

​

Remix IDE

1. Get MetaMask and set it to interact through a Chainstack node. See Interacting through MetaMask.
2. In Remix IDE, navigate to the Deploy tab. Select Injected Provider - MetaMask in Environment.

​

web3.py

1. Install web3.py.
2. Connect over HTTP or WebSocket. See also EVM node connection: HTTP vs WebSocket.

​

HTTP

from web3 import Web3

web3 = Web3(Web3.HTTPProvider('YOUR_CHAINSTACK_ENDPOINT'))
print(web3.eth.block_number)

from web3 import Web3

web3 = Web3(Web3.HTTPProvider('https://%s:%s@%s'% ("USERNAME", "PASSWORD", "HOSTNAME")))
print(web3.eth.block_number)

• YOUR_CHAINSTACK_ENDPOINT — your node HTTPS endpoint protected either with the key or password
• HOSTNAME — your node HTTPS endpoint hostname
• USERNAME — your node access username (for password-protected endpoints)
• PASSWORD — your node access password (for password-protected endpoints)

​

WebSocket

from web3 import Web3

web3 = Web3(Web3.WebsocketProvider('YOUR_CHAINSTACK_ENDPOINT'))
print(web3.eth.block_number)

from web3 import Web3

web3 = Web3(Web3.WebsocketProvider('wss://%s:%s@%s'% ("USERNAME", "PASSWORD", "HOSTNAME")))
print(web3.eth.block_number)

• YOUR_CHAINSTACK_ENDPOINT — your node WSS endpoint protected either with the key or password
• HOSTNAME — your node WSS endpoint hostname
• USERNAME — your node access username (for password-protected endpoints)
• PASSWORD — your node access password (for password-protected endpoints)

​

web3.php

1. Install web3.php.
2. Connect over HTTP:
   Php

   Copy

   <?php
   
   require_once "vendor/autoload.php";
   
   use Web3\Web3;
   use Web3\Providers\HttpProvider;
   use Web3\RequestManagers\HttpRequestManager;
   
   $web3 = new Web3(new HttpProvider(new HttpRequestManager("YOUR_CHAINSTACK_ENDPOINT", 5)));
   ?>
   

   where YOUR_CHAINSTACK_ENDPOINT is your node HTTPS endpoint protected either with the key or password
3. Use JSON-RPC methods to interact with the node. Example to get the latest block number:
   Key Protected

   Copy

   <?php
   
   require_once "vendor/autoload.php";
   
   use Web3\Web3;
   use Web3\Providers\HttpProvider;
   use Web3\RequestManagers\HttpRequestManager;
   
   $web3 = new Web3(new HttpProvider(new HttpRequestManager("YOUR_CHAINSTACK_ENDPOINT", 5)));
   
   $eth = $web3->eth;
   
   $eth->blockNumber(function ($err, $data) {
        print "$data \n";
   });
   ?>
   

​

web3j

package getLatestBlock;

import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.web3j.protocol.Web3j;
import org.web3j.protocol.core.DefaultBlockParameterName;
import org.web3j.protocol.core.methods.response.EthBlock;
import org.web3j.protocol.exceptions.ClientConnectionException;
import org.web3j.protocol.http.HttpService;

import okhttp3.Authenticator;
import okhttp3.Credentials;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.Route;

public final class App {

  private static final String USERNAME = "USERNAME";
  private static final String PASSWORD = "PASSWORD";
  private static final String ENDPOINT = "ENDPOINT";

  public static void main(String[] args) {
    try {

      OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder();
      clientBuilder.authenticator(new Authenticator() {
          @Override public Request authenticate(Route route, Response response) throws IOException {
              String credential = Credentials.basic(USERNAME, PASSWORD);
              return response.request().newBuilder().header("Authorization", credential).build();
          }
      });

      HttpService service = new HttpService(ENDPOINT, clientBuilder.build(), false);
      Web3j web3 = Web3j.build(service);

      EthBlock.Block latestBlock = web3.ethGetBlockByNumber(DefaultBlockParameterName.LATEST, false).send().getBlock();

      System.out.println("Latest Block: #" + latestBlock.getNumber());

    } catch (IOException | ClientConnectionException ex) {

      Logger.getLogger(App.class.getName()).log(Level.SEVERE, null, ex);
    }
  }

}

• ENDPOINT — your node HTTPS endpoint protected either with the key or password
• USERNAME — your node access username (for password-protected endpoints)
• PASSWORD — your node access password (for password-protected endpoints)

​

ethers.js

1. Install ethers.js.
2. Connect over HTTP or WebSocket. See also EVM node connection: HTTP vs WebSocket.

​

HTTP

const { ethers } = require("ethers");

var urlInfo = {
  url: "YOUR_CHAINSTACK_ENDPOINT",
};
var provider = new ethers.providers.JsonRpcProvider(urlInfo, NETWORK_ID);

provider.getBlockNumber().then(console.log);

const { ethers } = require("ethers");

var urlInfo = {
  url: "YOUR_CHAINSTACK_ENDPOINT",
  user: "USERNAME",
  password: "PASSWORD",
};
var provider = new ethers.providers.JsonRpcProvider(urlInfo, NETWORK_ID);

provider.getBlockNumber().then(console.log);

• YOUR_CHAINSTACK_ENDPOINT — your node HTTPS endpoint protected either with the key or password
• USERNAME — your node access username (for password-protected endpoints)
• PASSWORD — your node access password (for password-protected endpoints)
• NETWORK_ID — Monad network ID:
  • Mainnet: 143
  • Testnet: 10143

​

WebSocket

const { ethers } = require("ethers");

const provider = new ethers.providers.WebSocketProvider(
  "YOUR_CHAINSTACK_ENDPOINT",
  NETWORK_ID
);

provider.getBlockNumber().then(console.log);

• YOUR_CHAINSTACK_ENDPOINT — your node WSS endpoint endpoint protected either with the key or password
• NETWORK_ID — Monad network ID:
  • Mainnet: 143
  • Testnet: 10143

​

viem

1. Install viem.
2. Connect over HTTP or WebSocket.

​

HTTP

import { createPublicClient, http } from 'viem'

const client = createPublicClient({
  transport: http('YOUR_CHAINSTACK_ENDPOINT')
})

const blockNumber = await client.getBlockNumber()
console.log(blockNumber)

​

WebSocket

import { createPublicClient, webSocket } from 'viem'

const client = createPublicClient({
  transport: webSocket('YOUR_CHAINSTACK_ENDPOINT')
})

const blockNumber = await client.getBlockNumber()
console.log(blockNumber)

​

Brownie

1. Install Brownie.
2. Use the brownie networks add command with the node endpoint. For example, Monad mainnet:
   Shell

   Copy

   brownie networks add Monad ID name="NETWORK_NAME" host=YOUR_CHAINSTACK_ENDPOINT chainid=NETWORK_ID
   

   where
   • ID — any name that you will use as the network tag to run a deployment. For example, chainstack-mainnet.
   • NETWORK_NAME — any name that you want to identify the network by in the list of networks. For example, Mainnet (Chainstack).
   • YOUR_CHAINSTACK_ENDPOINT — your node HTTPS or WSS endpoint protected either with the key or password
   • NETWORK_ID — Monad network ID:
     • Mainnet: 143
     • Testnet: 10143

brownie run deploy.py --network chainstack-mainnet

​

Foundry

1. Install Foundry.
2. Use --rpc-url to run the operation through your Chainstack node.

​

Forge

forge create CONTRACT_NAME --contracts CONTRACT_PATH --private-key YOUR_PRIVATE_KEY --rpc-url YOUR_CHAINSTACK_ENDPOINT

• CONTRACT_NAME — name of the contract in the Solidity source code
• CONTRACT_PATH — path to your smart contract
• YOUR_PRIVATE_KEY — the private key to your funded account that you will use to deploy the contract.
• YOUR_CHAINSTACK_ENDPOINT — your node HTTPS endpoint protected either with the key or password

​

Cast

cast block-number --rpc-url YOUR_CHAINSTACK_ENDPOINT

​

Verify contracts

forge verify-contract CONTRACT_ADDRESS CONTRACT_NAME \
  --verifier sourcify \
  --verifier-url https://sourcify-api-monad.blockvision.org \
  --rpc-url YOUR_CHAINSTACK_ENDPOINT

forge verify-contract CONTRACT_ADDRESS CONTRACT_NAME \
  --verifier etherscan \
  --verifier-url https://api.monadscan.com/api \
  --etherscan-api-key YOUR_MONADSCAN_API_KEY \
  --rpc-url YOUR_CHAINSTACK_ENDPOINT