SDK Reference

npm install ethers

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("https://rpc.ankr.com/eth");
const balance = await provider.getBalance("0x...");
console.log(ethers.formatEther(balance));

npm install viem

import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

const blockNumber = await client.getBlockNumber();

npm install web3

import Web3 from "web3";

const web3 = new Web3("https://rpc.ankr.com/eth");
const balance = await web3.eth.getBalance("0x...");
console.log(web3.utils.fromWei(balance, "ether"));

npm install wagmi viem

import { useAccount, useBalance } from "wagmi";

function Wallet() {
  const { address } = useAccount();
  const { data: balance } = useBalance({ address });
  return <p>{balance?.formatted} {balance?.symbol}</p>;
}

npm install @solana/web3.js

import { Connection, PublicKey } from "@solana/web3.js";

const conn = new Connection("https://api.mainnet-beta.solana.com");
const balance = await conn.getBalance(
  new PublicKey("...")
);
console.log(balance / 1e9);

pip install web3

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://rpc.ankr.com/eth"))
balance = w3.eth.get_balance("0x...")
print(w3.from_wei(balance, "ether"))

npm install @rainbow-me/rainbowkit wagmi viem

import { getDefaultConfig, RainbowKitProvider } from "@rainbow-me/rainbowkit";
import "@rainbow-me/rainbowkit/styles.css";

const config = getDefaultConfig({
  appName: "My DApp",
  projectId: "YOUR_PROJECT_ID",
  chains: [mainnet],
  ssr: true,
});

export default function App() {
  return (
    <RainbowKitProvider>
      <YourApp />
    </RainbowKitProvider>
  );
}

npm install connectkit wagmi viem

import { ConnectKitProvider, getDefaultConfig } from "connectkit";

const config = getDefaultConfig({
  appName: "My DApp",
  walletConnectProjectId: "YOUR_PROJECT_ID",
  chains: [mainnet],
});

npm install @web3-onboard/react

import Onboard from "@web3-onboard/core";

const onboard = Onboard({
  wallets: [injectedModule()],
  chains: [{ id: "0x1", token: "ETH", label: "Ethereum", rpcUrl: "https://rpc.ankr.com/eth" }],
  appMetadata: { name: "My DApp" },
});

npm install moralis

import Moralis from "moralis";

await Moralis.start({ apiKey: "YOUR_API_KEY" });

const balance = await Moralis.EvmApi.token.getWalletTokenBalances({
  address: "0x...",
  chain: "0x1",
});

npm install @alchemy/alchemy-sdk

import { Alchemy, Network } from "alchemy-sdk";

const alchemy = new Alchemy({ apiKey: "demo", network: Network.ETH_MAINNET });
const balance = await alchemy.core.getBalance("0x...");
console.log(balance);

npm install --save-dev hardhat

// scripts/deploy.js
const hre = require("hardhat");

async function main() {
  const Token = await hre.ethers.getContractFactory("Token");
  const token = await Token.deploy();
  await token.waitForDeployment();
  console.log("Deployed to:", await token.getAddress());
}
main();

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

// Deploy & verify with forge
forge create --rpc-url $RPC \
  --private-key $PK \
  src/Token.sol:Token \
  --verify --etherscan-api-key $KEY

// Cast a call to read balance
cast call 0xTOKEN "balanceOf(address)(uint256)" 0xUSER \
  --rpc-url $RPC

npm install @openzeppelin/contracts

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
  constructor() ERC20("MyToken", "MTK") {
    _mint(msg.sender, 1_000_000 * 10 ** decimals());
  }
}

forge install vectorized/solady

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import { ERC20 } from "solady/tokens/ERC20.sol";

contract MyToken is ERC20 {
  function name() public pure override returns (string memory) { return "MyToken"; }
  function symbol() public pure override returns (string memory) { return "MTK"; }
}

pip install eth-brownie

from brownie import accounts, Token

def main():
    acct = accounts.load("dev")
    token = Token.deploy("MyToken", "MTK", 1e24, {"from": acct})
    print(f"Deployed: {token.address}")

pip install ape

from ape import accounts, project

def main():
    acct = accounts.load("dev")
    token = acct.deploy(project.Token)
    print(f"Deployed: {token.address}")

npm install -g truffle

// migrations/2_deploy.js
const Token = artifacts.require("Token");

module.exports = function (deployer) {
  deployer.deploy(Token);
};

cargo add ethers

use ethers::providers::{Provider, Http};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let provider = Provider::<Http>::try_from("https://rpc.ankr.com/eth")?;
    let block = provider.get_block_number().await?;
    println!("Block: {block}");
    Ok(())
}

go get github.com/ethereum/go-ethereum

package main

import (
  "context"
  "fmt"
  "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
  client, _ := ethclient.Dial("https://rpc.ankr.com/eth")
  block, _ := client.BlockByNumber(context.Background(), nil)
  fmt.Println("Block:", block.Number())
}

go get github.com/cosmos/cosmos-sdk

package main

import (
  "github.com/cosmos/cosmos-sdk/client"
  "github.com/cosmos/cosmos-sdk/types/tx"
)

// Broadcast a Cosmos transaction
func main() {
  ctx := client.Context{}
  _ = ctx.WithTxConfig(tx.NewTxConfig())
}

cargo install cosmwasm-check

use cosmwasm_std::{entry_point, DepsMut, MessageInfo, Response};

#[entry_point]
pub fn execute(
  _deps: DepsMut,
  _info: MessageInfo,
  msg: ExecuteMsg,
) -> Result<Response, cosmwasm_std::StdError> {
  match msg {
    ExecuteMsg::Increment {} => Ok(Response::new()
      .add_attribute("action", "increment")),
  }
}

npm install @polkadot/api

import { ApiPromise, WsProvider } from "@polkadot/api";

const provider = new WsProvider("wss://rpc.polkadot.io");
const api = await ApiPromise.create({ provider });
const block = await api.rpc.chain.getBlock();
console.log("Block:", block.block.header.number.toString());

npm install near-api-js

import { connect, keyStores } from "near-api-js";

const near = await connect({
  networkId: "mainnet",
  keyStore: new keyStores.BrowserLocalStorageKeyStore(),
  nodeUrl: "https://rpc.mainnet.near.org",
});
const account = await near.account("example.near");
const balance = await account.getAccountBalance();
console.log(balance.total);

npm install @aptos-labs/ts-sdk

import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";

const aptos = new Aptos(new AptosConfig({ network: Network.MAINNET }));
const balance = await aptos.getAccountBalance({
  accountAddress: "0x...",
});
console.log(balance);

npm install starknet

import { RpcProvider, Account } from "starknet";

const provider = new RpcProvider({ nodeUrl: "https://starknet-mainnet.public.blastapi.io" });
const account = new Account(provider, "0x...", "0x...");
const balance = await account.getBalance();
console.log(balance);

npm install fuels

import { Provider, Wallet } from "fuels";

const provider = await Provider.create("https://mainnet.fuel.network/v1/graphql");
const wallet = Wallet.fromPrivateKey("0x...", provider);
const balance = await wallet.getBalance();
console.log(balance.toString());

npm install @hashgraph/sdk

import { Client, AccountBalanceQuery } from "@hashgraph/sdk";

const client = Client.forMainnet();
client.setOperator(myAccountId, myPrivateKey);

const balance = await new AccountBalanceQuery()
  .setAccountId("0.0.1")
  .execute(client);
console.log(balance.hbars.toString());

npm install tronweb

import TronWeb from "tronweb";

const tronWeb = new TronWeb({
  fullHost: "https://api.trongrid.io",
  privateKey: "YOUR_PRIVATE_KEY",
});
const balance = await tronWeb.trx.getBalance("...");
console.log(balance / 1e6);

npm install eosjs

import { Api, JsonRpc } from "eosjs";

const rpc = new JsonRpc("https://eos.greymass.com", { fetch });
const api = new Api({ rpc });
const info = await rpc.get_info();
console.log(info.head_block_num);

npm install @taquito/taquito

import { TezosToolkit } from "@taquito/taquito";

const Tezos = new TezosToolkit("https://mainnet.api.tez.ie");
const balance = await Tezos.tz.getBalance("tz1...");
console.log(balance.toNumber() / 1e6);

npm install stellar-sdk

import { Horizon } from "stellar-sdk";

const server = new Horizon.Server("https://horizon.stellar.org");
const account = await server.loadAccount("G...");
console.log(account.balances);

npm install @emurgo/cardano-serialization-lib-browser

import * as CSL from "@emurgo/cardano-serialization-lib-browser";

const amount = CSL.Value.new(CSL.BigNum.from_str("1000000"));
console.log(amount.coin().to_str());

npm install @multiversx/sdk-core @multiversx/sdk-network-providers

import { ApiNetworkProvider } from "@multiversx/sdk-network-providers";

const provider = new ApiNetworkProvider("https://api.multiversx.com");
const account = await provider.getAccount("erd1...");
console.log(account.balance);

npm install avalanche

import { Avalanche } from "avalanche";

const avax = new Avalanche("api.avax.network", 443, "https");
const xchain = avax.XChain();
const balance = await xchain.getBalance("X-avax1...", "AVAX");
console.log(balance.balance);

npm install @cityofzion/neon-js

import { rpc } from "@cityofzion/neon-js";

const client = new rpc.RPCClient("https://mainnet1.neo.coz.io:443");
const block = await client.getBlockCount();
console.log("Block:", block);

npm install @onflow/fcl

import * as fcl from "@onflow/fcl";

fcl.config()
  .put("accessNode.api", "https://rest-mainnet.onflow.org");

const balance = await fcl.query({
  cadence: `
    import FungibleToken from 0xf233dcee88fe0abe
    pub fun main(addr: Address): UFix64 {
      return 0.0
    }
  `,
  args: (arg, t) => [arg("0x...", t.Address)],
});
console.log(balance);

npm install @iota/sdk

import { Client } from "@iota/sdk";

const client = new Client({ nodes: ["https://api.mainnet.iota.cafe"] });
const info = await client.getInfo();
console.log(info.nodeInfo.name);

npm install lisk-sdk

import { apiClient } from "lisk-sdk";

const client = await apiClient.createWSClient("wss://mainnet.lisk.com/ws");
const info = await client.node.getNodeInfo();
console.log(info.height);

npm install @gear-js/api

import { GearApi } from "@gear-js/api";

const api = await GearApi.create({ providerAddress: "wss://rpc-vara.gear-tech.io" });
const block = await api.blocks.getLatest();
console.log(block);

composer require web3p/ethers

use Ethers\Provider\Provider;

$provider = Provider::fromJsonRpc("https://rpc.ankr.com/eth");
$balance = $provider->getBalance("0x...");
echo $balance->toString();

dotnet add package Nethereum.Web3

using Nethereum.Web3;

var web3 = new Web3("https://rpc.ankr.com/eth");
var balance = await web3.Eth.GetBalance.SendRequestAsync("0x...");
Console.WriteLine(balance.Value);

implementation 'org.web3j:core:4.12.0'

import org.web3j.protocol.Web3j;
import org.web3j.protocol.http.HttpService;

Web3j web3 = Web3j.build(new HttpService("https://rpc.ankr.com/eth"));
var balance = web3.ethGetBalance("0x...", DefaultBlockParameterName.LATEST)
  .send();
System.out.println(balance.getBalance());