> ## 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.

# Fantom tooling

> Complete Fantom tooling guide for Chainstack nodes. Use MetaMask, Hardhat, ethers.js, Foundry, Remix IDE, and more to build dApps on Fantom blockchain.

Get started with a [reliable Fantom RPC endpoint](https://chainstack.com/build-better-with-fantom/) to use the tools below.

## Node.js

You can build a web app to query data using Node.js and [axios](https://www.npmjs.com/package/axios):

```javascript Javascript theme={"system"}
const axios = require('axios');
const main = async () => {
  try {
    const result = await axios.post(
      'YOUR_CHAINSTACK_ENDPOINT',
      {
        query: `
          QUERY
        `
      }
    );
    console.log(result.data);
  } catch(error) {
    console.error(error);
  }
}
main();
```

where

* YOUR\_CHAINSTACK\_ENDPOINT — your node GraphQL endpoint
* QUERY — your GraphQL query

See also [node access details](https://docs.chainstack.com/docs/manage-your-node.md#view-node-access-and-credentials).

See also [Using GraphQL with EVM-compatible nodes](https://support.chainstack.com/hc/en-us/articles/4409604331161-Using-GraphQL-with-EVM-compatible-nodes).

## MetaMask

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

## Hardhat

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

1. Install [Hardhat](https://hardhat.org/) 2 with the ethers plugin by running `npm install --save-dev hardhat@hh2 @nomicfoundation/hardhat-ethers@hh2 ethers`, and create a project with `npx hardhat init`. The `hh2` tag installs Hardhat 2, which this configuration uses.

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

   ```javascript Javascript theme={"system"}
   require("@nomicfoundation/hardhat-ethers");
   ...
   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](https://docs.chainstack.com/docs/manage-your-node.md#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](#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](https://github.com/ethereum/web3.py) and Fantom 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.

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

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

### WebSocket

Use `AsyncWeb3` with the `WebSocketProvider` object to connect to your node WSS endpoint and get the latest block number. The web3.py WebSocket provider is asynchronous, so the example runs in an `asyncio` event loop.

```python Key Protected theme={"system"}
import asyncio
from web3 import AsyncWeb3, WebSocketProvider

async def main():
    async with AsyncWeb3(WebSocketProvider('YOUR_CHAINSTACK_ENDPOINT')) as web3:
        print(await web3.eth.block_number)

asyncio.run(main())
```

```python Password Protected theme={"system"}
import asyncio
from web3 import AsyncWeb3, WebSocketProvider

async def main():
    async with AsyncWeb3(WebSocketProvider('wss://%s:%s@%s'% ("USERNAME", "PASSWORD", "HOSTNAME"))) as web3:
        print(await web3.eth.block_number)

asyncio.run(main())
```

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 Fantom nodes deployed with Chainstack.

1. Install [web3.php](https://github.com/web3p/web3.php).

2. Connect over HTTP:

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

   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:

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

   $eth = $web3->eth;

   $eth->blockNumber(function ($err, $data) {
        print "$data \n";
   });
   ?>
   ```

## web3j

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

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

Example to get the latest block number:

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

}
```

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 Fantom 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:

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

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

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

```javascript Password Protected theme={"system"}
const { ethers } = require("ethers");

const request = new ethers.FetchRequest('YOUR_CHAINSTACK_ENDPOINT');
request.setCredentials('USERNAME', 'PASSWORD');
const provider = new ethers.JsonRpcProvider(request, 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 — Fantom network ID:

  * Mainnet: `250`
  * Testnet: `4002`

See [node access details](https://docs.chainstack.com/docs/manage-your-node.md#view-node-access-and-credentials).

### WebSocket

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

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

const provider = new ethers.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 — Fantom network ID:

  * Mainnet: `250`
  * Testnet: `4002`

See also [node access details](https://docs.chainstack.com/docs/manage-your-node.md#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:

   ```shell Shell theme={"system"}
   brownie networks add Fantom 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 — Fantom network ID:

     * Mainnet: `250`
     * Testnet: `4002`

Example to run the deployment script:

```shell Shell theme={"system"}
brownie run deploy.py --network chainstack-mainnet
```

## 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:

```shell Shell theme={"system"}
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 Shell theme={"system"}
cast block-number --rpc-url YOUR_CHAINSTACK_ENDPOINT
```

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