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

# Moonbeam tooling

> Set up MetaMask, Hardhat, Foundry, and Polkadot.js to build and deploy smart contracts on Moonbeam through your Chainstack RPC node endpoints.

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

## Substrate tools

Polkadot's Substrate provides a powerful toolkit for building and managing custom blockchains within the Moonbeam ecosystem. Key components include modular pallets, forkless upgrades, and native interoperability.

Find the [Substrate tools](https://docs.moonbeam.network/builders/build/substrate-api/overview/) in the Moonbeam docs.

## MetaMask

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

## web3.js

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

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

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

## web3.py

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

1. Install [web3.py](https://web3py.readthedocs.io/).
2. Connect over HTTP. 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).

## ethers.js

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

1. Install [ethers.js](https://www.npmjs.com/package/ethers).
2. Connect over HTTP. 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.JsonRpcProvider(urlInfo.url, 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 — Moonbeam network ID:
  * Moonbeam Mainnet: `1284`

See also [node access details](/docs/manage-your-node#view-node-access-and-credentials).

## Hardhat

Configure [Hardhat](https://hardhat.org/) to deploy contracts and interact through your Moonbeam 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](#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.php

Build DApps using [web3.php](https://github.com/web3p/web3.php) and Moonbeam 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 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";
  });
  ?>
  ```
</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>
  ```shell 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>
  ```shell 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