Ethereum tooling

​

Wallets

​

MetaMask

​

Trust Wallet

​

Rainbow

​

Rabby

​

Frame Desktop

​

IDEs

​

Remix IDE

1. Install and set up MetaMask to use a Chainstack node for interaction. You can refer to the guide on Interacting through MetaMask for detailed instructions.
2. Open Remix IDE and navigate the Connect Wallet button. Here, select Injected Web3 Provider and then MetaMask.

​

Programming languages and libraries

​

Communication protocols

​

web3.js

1. Install web3.js
   Bash

   Copy

   npm install web3
   

2. Initialize HTTP or WebSocket provider
   Javascript

   Copy

   import { Web3, HttpProvider, WebSocketProvider } from 'web3';
   
   // Using HTTP provider
   const httpProvider = new Web3(new HttpProvider("/*YOUR_HTTP_CHAINSTACK_ENDPOINT*/"));
   httpProvider.eth.getBlockNumber().then(console.log);
   
   // Using WebSocket provider
   const wsProvider = new Web3(new WebSocketProvider("/*YOUR_WS_CHAINSTACK_ENDPOINT*/"));
   wsProvider.eth.getBlockNumber().then((blockNumber) => {
       console.log(blockNumber);
       wsProvider.currentProvider.safeDisconnect();
   });
   

​

ethers.js

1. Install ethers.js
   Bash

   Copy

   npm install ethers
   

2. Initialize HTTP or WebSocket provider
   Javascript

   Copy

   import { ethers } from 'ethers';
   
   // Using HTTP provider
   const httpProvider = new ethers.JsonRpcProvider("/*YOUR_HTTP_CHAINSTACK_ENDPOINT*/");
   httpProvider.getBlockNumber().then(console.log);
   
   // Using WebSocket provider
   const wsProvider = new ethers.WebSocketProvider("/*YOUR_WS_CHAINSTACK_ENDPOINT*/");
   wsProvider.getBlockNumber().then((blockNumber) => {
       console.log(blockNumber);
       wsProvider.destroy();
   });
   

​

web3.py

1. Install web3.py
   Bash

   Copy

   pip install web3
   

2. Initialize HTTP or WebSocket provider
   Python

   Copy

   from web3 import Web3
   
   # Using HTTP provider
   http_web3 = Web3(Web3.HTTPProvider("/*YOUR_HTTP_CHAINSTACK_ENDPOINT*/"))
   print(http_web3.eth.block_number)
   
   # Using WebSocket provider
   with Web3(Web3.WebsocketProvider("/*YOUR_WS_CHAINSTACK_ENDPOINT*/")) as ws_web3:
       print(ws_web3.eth.block_number)
   

​

Nethereum (.NET)

1. Install Nethereum
2. Initialize HTTP or WebSocket provider
   C#

   Copy

   using Nethereum.JsonRpc.WebSocketClient;
   using Nethereum.Web3;
   
   namespace TutorialWeb3
   {
       internal class Program
       {
           static void Main(string[] args)
           {
               // Using HTTP provider
               var httpClient = new Web3("/*YOUR_HTTP_CHAINSTACK_ENDPOINT*/");
               var httpBlockNumber = httpClient.Eth.Blocks.GetBlockNumber.SendRequestAsync().GetAwaiter().GetResult();
               Console.WriteLine($"HTTP Block Number: {httpBlockNumber}");
   
               // Using WebSocket provider
               using (var wsClient = new WebSocketClient("/*YOUR_WS_CHAINSTACK_ENDPOINT*/"))
               {
                   var web3Ws = new Web3(wsClient);
                   var wsBlockNumber = web3Ws.Eth.Blocks.GetBlockNumber.SendRequestAsync().GetAwaiter().GetResult();
                   Console.WriteLine("WS Block Number: " + wsBlockNumber);
               }
           }
       }
   }
   

​

viem

1. Install viem
2. Initialize HTTP or WebSocket provider
   Typescript

   Copy

   import { createPublicClient, http, webSocket } from 'viem';
   import { mainnet } from 'viem/chains';
   
   // Using HTTP provider
   const httpClient = createPublicClient({
     chain: mainnet,
     transport: http("/*YOUR_HTTP_CHAINSTACK_ENDPOINT*/"),
   });
   
   const blockNumber = await httpClient.getBlockNumber();
   console.log(blockNumber);
   
   // Using WebSocket provider
   const wsClient = createPublicClient({
       chain: mainnet,
       transport: webSocket("/*YOUR_WS_CHAINSTACK_ENDPOINT*/"),
     })
   
   const wsBlockNumber = await wsClient.getBlockNumber();
   console.log(wsBlockNumber);
   await wsClient.transport.getRpcClient().then((rpcClient) => {
       rpcClient.close();
   });
   

​

Querying and indexing tools

​

Chainstack subgraphs (GraphQL)

​

Development frameworks and toolkits

​

Foundry

1. Install Foundry
   Bash

   Copy

   curl -L https://foundry.paradigm.xyz | bash
   foundryup
   

2. Configure environment in Foundry Create a new Foundry project:
   Bash

   Copy

   forge init my_project
   cd my_project
   

   Create a .env file in your project root and add your Chainstack endpoint and private key:
   Bash

   Copy

   CHAINSTACK_MAINNET_ENDPOINT=https://your-chainstack-mainnet-url
   CHAINSTACK_DEVNET_ENDPOINT=https://your-chainstack-devnet-url
   
   PRIVATE_KEY_MAINNET=your-mainnet-private-key
   PRIVATE_KEY_DEVNET=your-devnet-private-key
   

   You need to load the environment variables into your shell session:
   Bash

   Copy

   source .env
   echo $CHAINSTACK_DEVNET_ENDPOINT
   echo $PRIVATE_KEY_DEVNET
   

   Update your foundry.toml file to include the Chainstack network:
   TOML

   Copy

   [profile.default]
   src = 'src'
   out = 'out'
   libs = ['lib']
   
   [rpc_endpoints]
   mainnet = "${CHAINSTACK_MAINNET_ENDPOINT}"
   devnet = "${CHAINSTACK_DEVNET_ENDPOINT}"
   

3. Before deploying, ensure that your contracts are compiled. This step is crucial to avoid deployment issues.
   Bash

   Copy

   forge build
   

4. To use the Chainstack endpoint for deployment, you can use the following command:
   Bash

   Copy

   forge create --rpc-url ${CHAINSTACK_DEVNET_ENDPOINT} --private-key ${PRIVATE_KEY_DEVNET} src/YourContract.sol:YourContract
   

   Alternatively, you can create a deployment script in the script folder, for example Deploy.s.sol:
   solidity

   Copy

   // script/Deploy.s.sol
   
   // Specify the Solidity version
   pragma solidity ^0.8.20;
   
   // Import the Forge script library
   import "forge-std/Script.sol";
   
   // Import your contract
   import "../src/YourContract.sol";
   
   contract DeployScript is Script {
       function run() external {
           // Retrieve the deployer's private key from the environment variables
           uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY_DEVNET"); // Change to PRIVATE_KEY_MAINNET for mainnet
   
           // Start broadcasting transactions using the deployer's private key
           vm.startBroadcast(deployerPrivateKey);
   
           // Deploy the contract
           YourContract yourContract = new YourContract();
   
           // Stop broadcasting transactions
           vm.stopBroadcast();
   
           // Log the deployed contract address
           console2.log("Contract deployed at:", address(yourContract));
       }
   }
   

   Then run the script with:
   Bash

   Copy

   forge script script/Deploy.s.sol:DeployScript --rpc-url devnet--broadcast
   

5. Interact with the blockchain using Cast. Use the following command to query the balance of an Ethereum address:
   Bash

   Copy

   cast balance <ETH_ADDRESS> --rpc-url $CHAINSTACK_DEVNET_ENDPOINT
   

   Replace <ETH_ADDRESS> with the actual Ethereum address you want to query.

​

Hardhat

1. Install Hardhat and other dependencies
   Bash

   Copy

   npm init -y
   npm install --save-dev hardhat @nomiclabs/hardhat-ethers ethers dotenv
   

2. Configure environment in Hardhat Create a .env file in your project root and add your Chainstack endpoint and private key:
   Bash

   Copy

   CHAINSTACK_MAINNET_ENDPOINT=https://your-chainstack-mainnet-url
   CHAINSTACK_DEVNET_ENDPOINT=https://your-chainstack-devnet-url
   
   PRIVATE_KEY_MAINNET=your-mainnet-private-key
   PRIVATE_KEY_DEVNET=your-devnet-private-key
   

   Initiate a project:
   Bash

   Copy

   npx hardhat init
   

   Update your hardhat.config.js file to use the Chainstack endpoint:
   Javascript

   Copy

   require('@nomiclabs/hardhat-ethers');
   require('dotenv').config();
   
   module.exports = {
     solidity: "0.8.20", // Specify the required compiler version
     networks: {
       mainnet: {
         url: process.env.CHAINSTACK_MAINNET_ENDPOINT,
         accounts: [process.env.PRIVATE_KEY_MAINNET]  // Mainnet private key
       },
       devnet: {
         url: process.env.CHAINSTACK_DEVNET_ENDPOINT,
         accounts: [process.env.PRIVATE_KEY_DEVNET]  // Devnet private key
       }
     }
   };
   

3. To deploy your contracts using the Chainstack endpoint, you can create a deployment script in the scripts folder, for example deploy.js:
   Javascript

   Copy

   const hre = require("hardhat");
   
   async function main() {
     // Retrieve the deployer account from the list of signers
     const [deployer] = await hre.ethers.getSigners();
     console.log("Deploying contracts with the account:", deployer.address);
   
     // Load the contract factory from the contracts folder
     const Token = await hre.ethers.getContractFactory("MyToken");  // Replace "MyToken" with your contract name
   
     // Specify the initial supply for the token (adjust as necessary)
     const initialSupply = hre.ethers.utils.parseUnits("1000", 18);  // Adjust the supply and decimals as needed
   
     // Deploy the contract and wait for it to be mined
     const token = await Token.deploy(initialSupply);
     await token.deployed();
   
     // Output the contract address and transaction hash once deployed
     console.log("Contract deployed at address:", token.address);
     console.log("Transaction hash:", token.deployTransaction.hash);
   }
   
   // Execute the main function and handle potential errors
   main()
     .then(() => process.exit(0))
     .catch((error) => {
       console.error("Error during deployment:", error);
       process.exit(1);
     });
   

4. Compile the contracts
   Bash

   Copy

   npx hardhat compile
   

5. Use the appropriate network flag (mainnet or devnet) to deploy to the respective network
   Bash

   Copy

   npx hardhat run scripts/deploy.js --network devnet
   

​

Scaffold-ETH 2

1. Clone the Scaffold-ETH 2 repository
   Bash

   Copy

   git clone https://github.com/scaffold-eth/scaffold-eth-2.git
   cd scaffold-eth-2
   

2. Install dependencies
   Bash

   Copy

   yarn install
   

3. Create a .env.local file in the root directory of your project
   Bash

   Copy

   touch .env.local
   

4. Add your Chainstack endpoint and private key to the .env.local file
   Copy

   CHAINSTACK_MAINNET_ENDPOINT=https://your-chainstack-mainnet-url
   CHAINSTACK_DEVNET_ENDPOINT=https://your-chainstack-devnet-url
   
   DEPLOYER_PRIVATE_KEY=your-private-key-here
   

   Note: by default, Scaffold-ETH 2 uses Alchemy RPC nodes and it assumes the config contains an Alchemy API key. We can override this setting Chainstack RPC nodes and updating some other configs.
5. Modify the packages/hardhat/hardhat.config.ts file to configure the Chainstack endpoint. Locate the networks section and add or modify the configuration for the Chainstack networks
   Bash

   Copy

   const config: HardhatUserConfig = {
     solidity: "0.8.20", // Ensure to specify the correct Solidity version
     networks: {
       mainnet: {
         url: process.env.CHAINSTACK_MAINNET_ENDPOINT || `https://eth-mainnet.alchemyapi.io/v2/${providerApiKey}`, // Use the Chainstack mainnet endpoint
         // accounts: [process.env.DEPLOYER_PRIVATE_KEY_MAINNET as string], // Mainnet private key
       },
       sepolia: {
         url: process.env.CHAINSTACK_DEVNET_ENDPOINT || `https://eth-sepolia.g.alchemy.com/v2/${providerApiKey}`, // Use the Chainstack devnet endpoint
         // accounts: [process.env.DEPLOYER_PRIVATE_KEY_DEVNET as string], // Devnet private key
       },
       // ... other network configurations
     },
   };
   

6. Compile contracts using Hardhat
   Bash

   Copy

   cd packages/hardhat
   yarn hardhat compile
   

7. To deploy your contracts using the Chainstack endpoint, run
   Copy

   yarn deploy --network sepolia
   

8. To start the Next.js app with the Chainstack configuration
   Copy

   yarn start
   

​

Truffle (no longer maintained)

1. Install Truffle and other dependencies
   Copy

   # Initialize a new npm project
   npm init -y
   
   # Install Truffle as a local development dependency
   npm install --save-dev truffle @truffle/hdwallet-provider dotenv
   

2. Configure environment in Truffle Initialize a new Truffle project:
   Bash

   Copy

   npx truffle init
   

   Create a .env file in your project root and add your Chainstack endpoint and private key:
   Bash

   Copy

   CHAINSTACK_MAINNET_ENDPOINT=https://your-chainstack-mainnet-url
   CHAINSTACK_DEVNET_ENDPOINT=https://your-chainstack-devnet-url
   
   PRIVATE_KEY_MAINNET=your-mainnet-private-key
   PRIVATE_KEY_DEVNET=your-devnet-private-key
   

   Update your truffle-config.js file to use the Chainstack endpoint:
   Javascript

   Copy

   require('dotenv').config();
   const HDWalletProvider = require('@truffle/hdwallet-provider');
   
   module.exports = {
     networks: {
       // Configuration for Mainnet
       mainnet: {
         provider: () => new HDWalletProvider(process.env.PRIVATE_KEY_MAINNET, process.env.CHAINSTACK_MAINNET_ENDPOINT),
         network_id: 1,       // Mainnet's network ID
       },
       // Configuration for Devnet
       devnet: {
         provider: () => new HDWalletProvider(process.env.PRIVATE_KEY_DEVNET, process.env.CHAINSTACK_DEVNET_ENDPOINT),
         network_id: 11155111,    // Sepolia
       },
     },
     compilers: {
       solc: {
         version: "0.8.20",  // Specify the Solidity compiler version
       },
     },
   };
   

3. Create a migration script in the migrations folder to deploy your contract (migrations/1_deploy_contract_name.js)
   Javascript

   Copy

   // Import your contract artifact
   const YourContract = artifacts.require("CONTRACT_NAME");
   
   module.exports = function (deployer) {
     deployer.deploy(YourContract);
   };
   

4. Compile the contracts
   Bash

   Copy

   npx truffle compile
   

5. To deploy your contract using the Chainstack endpoint, run
   Bash

   Copy

   truffle migrate --network devnet
   

​

Ape

1. Install Ape and dependencies
   Bash

   Copy

   pip install eth-ape
   

2. Configure environment in Ape Initialize a project:
   Bash

   Copy

   ape init
   

   Create or update your ape-config.yaml file in your project root:
   yaml

   Copy

   name: ape-1
   
   contracts_folder: contracts  # Default is contracts
   
   default_ecosystem: ethereum # Default is ethereum
   
   node:
     ethereum:
       mainnet:
         uri: CHAINSTACK_MAINNET_ENDPOINT
       sepolia:
         uri: CHAINSTACK_SEPOLIA_ENDPOINT
   
   dependencies:
     - name: OpenZeppelin
       github: OpenZeppelin/openzeppelin-contracts/token/ERC20/ERC20.sol # Example
       version: 4.4.2
   

3. Import an account. You’ll be prompted to enter a private key and pass phrase to encrypt it.
   Bash

   Copy

   ape accounts import devnet_deployer
   

4. To deploy your contracts using the Chainstack endpoint, you can create a deployment script, for example scripts/deploy.py
   Python

   Copy

   from ape import accounts, project
   
   def main():
       # Load the account for deployment
       # Change 'devnet_deployer' to 'mainnet_deployer' when deploying to mainnet
       account = accounts.load("devnet_deployer")
   
       # Deploy the contract
       contract = account.deploy(project.MyContract)  # Replace 'MyContract' with your contract's name and add its arguments
   
       # Output the contract address
       print(f"Contract deployed at: {contract.address}")
   
       # Output the transaction hash
       print(f"Transaction hash: {contract.txn_hash.hex()}")
   
   if __name__ == "__main__":
       main()
   

5. Compile contracts. Before deploying, ensure your contracts are compiled. Ape automatically compiles contracts when deploying, but you can manually compile them if needed
   Bash

   Copy

   ape compile
   

6. Run the deployment script using
   Bash

   Copy

   ape run scripts/deploy.py --network ethereum:sepolia
   

​

Brownie

1. Create a Python virtual environment and install Brownie
   Bash

   Copy

   python -m venv venv
   source venv/bin/activate  # On Windows, use venv\Scripts\activate
   
   pip install eth-brownie
   

2. Configure environment in Brownie Create a new Brownie project (add --force if a folder is not empty):
   Bash

   Copy

   brownie init
   

   In your project directory, create a .env file and add your Chainstack endpoint and private key:
   Bash

   Copy

   CHAINSTACK_MAINNET_ENDPOINT=https://your-chainstack-mainnet-url
   CHAINSTACK_DEVNET_ENDPOINT=https://your-chainstack-devnet-url
   
   PRIVATE_KEY_MAINNET=your-mainnet-private-key
   PRIVATE_KEY_DEVNET=your-devnet-private-key
   

   Ensure that your terminal session loads these environment variables. You can manually source the .env file:
   Bash

   Copy

   source .env
   

   Update the brownie-config.yaml file in your project root:
   yaml

   Copy

   dotenv: .env
   
   networks:
     default: development
   
     chainstack-mainnet:
       host: ${CHAINSTACK_MAINNET_ENDPOINT}
       chainid: 1
       explorer: https://etherscan.io
   
     chainstack-devnet:
       host: ${CHAINSTACK_DEVNET_ENDPOINT}
       chainid: 1337  # Example chain ID for devnet; adjust if different
   

   Add a custom network to Brownie’s network list:
   Bash

   Copy

   brownie networks add Ethereum chainstack-mainnet host=${CHAINSTACK_MAINNET_ENDPOINT} chainid=1
   brownie networks add Ethereum chainstack-devnet host=${CHAINSTACK_DEVNET_ENDPOINT} chainid=1337
   

   To use your private key for deployments, you can create a scripts/deploy.py file:
   Python

   Copy

   import os
   from brownie import accounts, Counter  # Replace 'Counter' with your contract's class name
   
   def main():
       # Load the deployer's account using the private key from the environment variable
       acct = accounts.add(os.getenv("PRIVATE_KEY_DEVNET"))  # Use PRIVATE_KEY_MAINNET for mainnet
   
       # Deploy the contract (Replace 'Counter' with the actual name of your contract)
       contract = Counter.deploy({'from': acct})
   
       # Output the contract address and transaction hash
       print(f"Contract deployed at: {contract.address}")
       print(f"Transaction hash: {contract.tx.txid}")
   

3. To deploy your contracts using the Chainstack endpoint, run
   Bash

   Copy

   brownie run scripts/deploy.py --network chainstack-devnet