Avalanche tooling

Set up MetaMask, Hardhat, Foundry, and development tools to build and deploy smart contracts on Avalanche C-Chain through Chainstack RPC endpoints.

Get started with a reliable Avalanche RPC endpoint to use the tools below.

Endpoint structure

Avalanche runs three built-in chains (C, X, P) on the same node. Your Chainstack base endpoint serves all three — to target a specific chain, append the chain-specific URI before your auth key.

The URL pattern is:

https://avalanche-mainnet.core.chainstack.com/<CHAIN_URI>/<AUTH_KEY>

Chain	Purpose	HTTPS URI	WSS URI
C-Chain	EVM smart contracts (eth_* methods)	/ext/bc/C/rpc	/ext/bc/C/ws
X-Chain	Native asset transfers (UTXO)	/ext/bc/X	/ext/bc/X/events
P-Chain	Validator and subnet management	/ext/P	—

The most common reason an Avalanche endpoint “doesn’t work” is forgetting the chain URI. The node access page in the Chainstack console shows the full URL for each chain — copy from there to avoid path errors.

C-Chain HTTPS

To call EVM methods, use the C-Chain HTTPS endpoint:

cURL

curl -X POST \
  'https://avalanche-mainnet.core.chainstack.com/ext/bc/C/rpc/AUTH_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

C-Chain WebSocket

For real-time subscriptions, connect over WSS to the C-Chain WSS endpoint:

wscat

wscat -c wss://avalanche-mainnet.core.chainstack.com/ext/bc/C/ws/AUTH_KEY
> {"jsonrpc":"2.0","method":"eth_subscribe","params":["newHeads"],"id":1}

C-Chain

MetaMask

On node access details, click Connect wallet.

Hardhat

Configure Hardhat to deploy contracts and interact through your Avalanche nodes.

1. Install Hardhat and create a project.

2. Create a new environment in hardhat.config.js:

   Javascript

   require("@nomiclabs/hardhat-waffle");
   ...
   module.exports = {
     solidity: "0.7.3",
     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.

See also Forking EVM-compatible mainnet with Hardhat.

Remix IDE

To make Remix IDE interact with the network through a Chainstack node:

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.

This will engage MetaMask and make Remix IDE interact with the network through a Chainstack node.

web3.py

Build DApps using web3.py and Avalanche nodes deployed with Chainstack.

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

HTTP

Use the HTTPProvider to connect to your node endpoint and get the latest block number.

Key Protected

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)

where

• 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)

See also node access details.

WebSocket

Use the WebsocketProvider object to connect to your node WSS endpoint and get the latest block number.

Key Protected

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)

where

• 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)

See also WebSocket connection to an EVM node.

web3.php

Build DApps using web3.php and Avalanche nodes deployed with Chainstack.

1. Install web3.php.

2. Connect over HTTP:

   Php

   <?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

   <?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

Build DApps using web3j and Avalanche nodes deployed with Chainstack.

Use the HttpService object to connect to your node endpoint.

Example to get the latest block number:

Java

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(RPC_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);
    }
  }

}

where

• ENDPOINT — your node HTTPS endpoint
• USERNAME — your node access username
• PASSWORD — your node access password

See also the full code on GitHub.

ethers.js

Build DApps using ethers.js and Avalanche nodes deployed with Chainstack.

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

HTTP

Use the JsonRpcProvider object to connect to your node endpoint and get the latest block number:

Key Protected

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);

where

• 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 — Avalanche C-Chain network ID:

  • Mainnet: 43114
  • Fuji Testnet: 43113

See also node access details.

WebSocket

Use the WebSocketProvider object to connect to your node WSS endpoint and get the latest block number:

Javascript

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

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

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

where

• YOUR_CHAINSTACK_ENDPOINT — your node WSS endpoint endpoint protected either with the key or password

• NETWORK_ID — Avalanche C-Chain network ID:

  • Mainnet: 43114
  • Fuji Testnet: 43113

See also node access details.

Brownie

1. Install Brownie.

2. Use the brownie networks add command with the node endpoint:

   Shell

   brownie networks add Avalanche 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 — Avalanche C-Chain network ID:

     • Mainnet: 43114
     • Fuji Testnet: 43113

Example to run the deployment script:

Shell

brownie run deploy.py --network chainstack-mainnet

Foundry

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

Forge

Use forge to develop, test, and deploy your smart contracts.

To deploy a contract:

Shell

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

where

• 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

Use cast to interact with the network and the deployed contracts.

To get the latest block number:

Shell

cast block-number --rpc-url YOUR_CHAINSTACK_ENDPOINT

where YOUR_CHAINSTACK_ENDPOINT is your node HTTPS endpoint protected either with the key or password

X-Chain

JSON-RPC API

Interact with the X-Chain through your Avalanche nodes using JSON-RPC API.

Use curl or Postman to invoke Avalanche X-Chain API methods.

Example below demonstrates how to get AVAX balance of an address through your Avalanche node HTTPS endpoint on the X-Chain mainnet:

Curl

curl -X POST --data '{
  "jsonrpc":"2.0",
  "id"     : 1,
  "method" :"avm.getBalance",
  "params" :{
      "address":"X-avax1slt2dhfu6a6qezcn5sgtagumq8ag8we75f84sw",
      "assetID": "FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z"
  }
}' -H 'content-type:application/json;' YOUR_CHAINSTACK_ENDPOINT

where YOUR_CHAINSTACK_ENDPOINT is your node HTTPS endpoint protected either with the key or password

AvalancheJS

1. Install AvalancheJS.
2. Use AvalancheJS examples to interact with the X-Chain through your Avalanche node with the following settings:

Javascript

const ip: string = "BASE_ENDPOINT"
// const port: number = 9650
const protocol: string = "https"
const networkID: number = CHAIN_ID
const avalanche: Avalanche = new Avalanche(ip, null, protocol, networkID)

where

• BASE_ENDPOINT — your node key-protected endpoint without the https prefix and the ext postfix. For example, nd-123-456-789.p2pify.com/3c6e0b8a9c15224a8228b9a98ca1531d.

• CHAIN_ID — the chain ID of the network you are connecting to:

  • Mainnet: 43114
  • Fuji Testnet: 43113

Make sure you remove const port and change port to null in the default example.

Example to get AVAX balance of an address through your Avalanche node HTTPS endpoint on the X-Chain mainnet:

Javascript

import { Avalanche } from "../../dist"
import { AVMAPI } from "../../dist/apis/avm"

const ip: string = "nd-123-456-789.p2pify.com/3c6e0b8a9c15224a8228b9a98ca1531d"
// const port: number = 9650
const protocol: string = "https"
const networkID: number = 1
const avalanche: Avalanche = new Avalanche(ip, null, protocol, networkID)
const xchain: AVMAPI = avalanche.XChain()

const main = async (): Promise<any> => {
  const address: string = "X-avax1k30tskunzxr2tmapy8p4y0ujn2802yr3743679"
  const balance: object = await xchain.getBalance(address, "AVAX")
  console.log(balance)
}

main()