Ethereum tooling

npm install web3

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

npm install ethers

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

pip install web3

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)

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

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

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

forge init my_project
cd my_project

source .env
echo $CHAINSTACK_DEVNET_URL
echo $PRIVATE_KEY_DEVNET

[profile.default]
src = 'src'
out = 'out'
libs = ['lib']

[rpc_endpoints]
mainnet = "${CHAINSTACK_MAINNET_URL}"
devnet = "${CHAINSTACK_DEVNET_URL}"

forge build

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

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

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

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

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

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

npx hardhat init

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

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

npx hardhat compile

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

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

yarn install

touch .env.local

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
  },
};

cd packages/hardhat
yarn hardhat compile

yarn deploy --network sepolia

yarn start

# Initialize a new npm project
npm init -y

# Install Truffle as a local development dependency
npm install --save-dev truffle @truffle/hdwallet-provider dotenv

npx truffle init

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
    },
  },
};

// Import your contract artifact
const YourContract = artifacts.require("CONTRACT_NAME");

module.exports = function (deployer) {
  deployer.YourContract();
};

npx truffle compile

truffle migrate --network devnet

pip install eth-ape

ape init

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

ape accounts import devnet_deployer

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

ape compile

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

brownie init

source .env

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

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

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}")

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