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

# 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](https://chainstack.com/build-better-with-avalanche/) 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`        | —                  |

<Note>
  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.
</Note>

### C-Chain HTTPS

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

<CodeGroup>
  ```bash cURL theme={"system"}
  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}'
  ```
</CodeGroup>

### C-Chain WebSocket

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

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

## C-Chain

### MetaMask

On [node access details](/docs/manage-your-node#view-node-access-and-credentials), click **Connect wallet**.

### Hardhat

Configure [Hardhat](https://hardhat.org/) to deploy contracts and interact through your Avalanche nodes.

1. Install [Hardhat](https://hardhat.org/) and create a project.
2. Create a new environment in `hardhat.config.js`:

   <CodeGroup>
     ```javascript Javascript theme={"system"}
     require("@nomiclabs/hardhat-waffle");
     ...
     module.exports = {
       solidity: "0.7.3",
       networks: {
         chainstack: {
             url: "YOUR_CHAINSTACK_ENDPOINT",
             accounts: ["YOUR_PRIVATE_KEY"]
         },
       }
     };
     ```
   </CodeGroup>

   where

   * YOUR\_CHAINSTACK\_ENDPOINT — your node HTTPS or WSS endpoint protected either with the key or password. See [node access details](/docs/manage-your-node#view-node-access-and-credentials).
   * 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](https://support.chainstack.com/hc/en-us/articles/900004242406).

### Remix IDE

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

1. Get [MetaMask](https://metamask.io/) and set it to interact through a Chainstack node. See [Interacting through MetaMask](/docs/avalanche-tooling#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.js

Build DApps using [web3.js](https://github.com/ethereum/web3.js/) and Avalanche nodes deployed with Chainstack.

1. Install [web3.js](https://web3js.readthedocs.io/).
2. Connect over HTTP or WebSocket.

#### HTTP

Use the `HttpProvider` object to connect to your node HTTPS endpoint and get the latest block number:

<CodeGroup>
  ```javascript Javascript theme={"system"}
  const Web3 = require('web3');

  const web3 = new Web3(new Web3.providers.HttpProvider('YOUR_CHAINSTACK_ENDPOINT'));

  web3.eth.getBlockNumber().then(console.log);
  ```
</CodeGroup>

where YOUR\_CHAINSTACK\_ENDPOINT is your node HTTPS endpoint protected either with the key or password.

#### WebSocket

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

<CodeGroup>
  ```javascript Javascript theme={"system"}
  const Web3 = require('web3');

  const web3 = new Web3(new Web3.providers.WebsocketProvider('YOUR_CHAINSTACK_ENDPOINT'));

  web3.eth.getBlockNumber().then(console.log);
  ```
</CodeGroup>

where YOUR\_CHAINSTACK\_ENDPOINT is your node WSS endpoint protected either with the key or password.

### web3.py

Build DApps using [web3.py](https://github.com/ethereum/web3.py) and Avalanche nodes deployed with Chainstack.

1. Install [web3.py](https://web3py.readthedocs.io/).
2. Connect over HTTP or WebSocket. See also [EVM node connection: HTTP vs WebSocket](https://support.chainstack.com/hc/en-us/articles/900002187586-Ethereum-node-connection-HTTP-vs-WebSocket).

#### HTTP

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

<CodeGroup>
  ```python Key Protected theme={"system"}
  from web3 import Web3

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

  ```python Password Protected theme={"system"}
  from web3 import Web3

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

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](/docs/manage-your-node#view-node-access-and-credentials).

#### WebSocket

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

<CodeGroup>
  ```python Key Protected theme={"system"}
  from web3 import Web3

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

  ```python Password Protected theme={"system"}
  from web3 import Web3

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

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](https://support.chainstack.com/hc/en-us/articles/900001918763-WebSocket-connection-to-an-Ethereum-node).

### web3.php

Build DApps using [web3.php](https://github.com/web3p/web3.php) and Avalanche nodes deployed with Chainstack.

1. Install [web3.php](https://github.com/web3p/web3.php).
2. Connect over HTTP:

   <CodeGroup>
     ```php Php theme={"system"}
     <?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)));
     ?>
     ```
   </CodeGroup>

   where YOUR\_CHAINSTACK\_ENDPOINT is your node HTTPS endpoint protected either with the key or password
3. Use [JSON-RPC methods](https://eth.wiki/json-rpc/API) to interact with the node.

   Example to get the latest block number:

   <CodeGroup>
     ```php Key Protected theme={"system"}
     <?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";
     });
     ?>
     ```
   </CodeGroup>

### web3j

Build DApps using [web3j](https://github.com/web3j/web3j) and Avalanche nodes deployed with Chainstack.

Use the `HttpService` object to connect to your node endpoint.

Example to get the latest block number:

<CodeGroup>
  ```java Java theme={"system"}
  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);
      }
    }

  }
  ```
</CodeGroup>

where

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

See also [the full code on GitHub](https://github.com/chainstack/web3j-getLatestBlock).

### ethers.js

Build DApps using [ethers.js](https://github.com/ethers-io/ethers.js/) and Avalanche nodes deployed with Chainstack.

1. Install [ethers.js](https://www.npmjs.com/package/ethers).
2. Connect over HTTP or WebSocket. See also [EVM node connection: HTTP vs WebSocket](https://support.chainstack.com/hc/en-us/articles/900002187586-Ethereum-node-connection-HTTP-vs-WebSocket).

### HTTP

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

<CodeGroup>
  ```javascript Key Protected theme={"system"}
  const { ethers } = require("ethers");

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

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

  ```javascript Password Protected theme={"system"}
  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);
  ```
</CodeGroup>

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](/docs/manage-your-node#view-node-access-and-credentials).

#### WebSocket

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

<CodeGroup>
  ```javascript Javascript theme={"system"}
  const { ethers } = require("ethers");

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

  provider.getBlockNumber().then(console.log);
  ```
</CodeGroup>

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](/docs/manage-your-node#view-node-access-and-credentials).

### Brownie

1. Install [Brownie](https://eth-brownie.readthedocs.io/en/stable/install.html).
2. Use the `brownie networks add` command with the node endpoint:

   <CodeGroup>
     ```bash Shell theme={"system"}
     brownie networks add Avalanche ID name="NETWORK_NAME" host= YOUR_CHAINSTACK_ENDPOINT chainid=NETWORK_ID
     ```
   </CodeGroup>

   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:

<CodeGroup>
  ```bash Shell theme={"system"}
  brownie run deploy.py --network chainstack-mainnet
  ```
</CodeGroup>

### Foundry

1. Install [Foundry](https://getfoundry.sh/).
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:

<CodeGroup>
  ```bash Shell theme={"system"}
  forge create CONTRACT_NAME --contracts CONTRACT_PATH --private-key YOUR_PRIVATE_KEY --rpc-url YOUR_CHAINSTACK_ENDPOINT
  ```
</CodeGroup>

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:

<CodeGroup>
  ```bash Shell theme={"system"}
  cast block-number --rpc-url YOUR_CHAINSTACK_ENDPOINT
  ```
</CodeGroup>

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](https://curl.haxx.se) or [Postman](https://www.getpostman.com) 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:

<CodeGroup>
  ```bash Curl theme={"system"}
  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
  ```
</CodeGroup>

where YOUR\_CHAINSTACK\_ENDPOINT is your node HTTPS endpoint protected either with the key or password

### AvalancheJS

1. Install [AvalancheJS](https://github.com/ava-labs/avalanchejs).
2. Use [AvalancheJS examples](https://github.com/ava-labs/avalanchejs/tree/master/examples) to interact with the X-Chain through your Avalanche node with the following settings:

<CodeGroup>
  ```javascript Javascript theme={"system"}
  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)
  ```
</CodeGroup>

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:

<CodeGroup>
  ```javascript Javascript theme={"system"}
  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()
  ```
</CodeGroup>