Documentation

{
  "jsonrpc": "2.0",
  "method": "eth_blockNumber",
  "params": [],
  "id": 1
}

[
  {"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1},
  {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":2}
]

curl -X POST https://rpc-litvm.pro \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_KEY" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://rpc-litvm.pro", {
  chainId: 4441,
  name: "litvm-liteforge",
});

const block = await provider.getBlockNumber();
console.log("Latest block:", block);

const balance = await provider.getBalance("0xYourAddress");
console.log("Balance:", balance.toString());

import { createPublicClient, http, defineChain } from "viem";

const litvm = defineChain({
  id: 4441,
  name: "LitVM RPC PRO",
  nativeCurrency: { name: "zkLTC", symbol: "zkLTC", decimals: 18 },
  rpcUrls: {
    default: { http: ["https://rpc-litvm.pro"] },
  },
  blockExplorers: {
    default: { name: "Explorer", url: "https://explorer.litvm.io" },
  },
});

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

const blockNumber = await client.getBlockNumber();
const gasPrice = await client.getGasPrice();

import Web3 from "web3";

const web3 = new Web3("https://rpc-litvm.pro");

const block = await web3.eth.getBlockNumber();
const gasPrice = await web3.eth.getGasPrice();

console.log("Block:", block, "Gas:", gasPrice);

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://rpc-litvm.pro"))

print("Connected:", w3.is_connected())
print("Block:", w3.eth.block_number)
print("Gas price:", w3.eth.gas_price)

GET https://rpc-litvm.pro/api/gas

{
  "timestamp": 1781355126141,
  "block": "0x11e3c58",
  "baseFee": "0x989680",
  "baseFeeGwei": 0.01,
  "tiers": {
    "safe":     { "maxFeePerGas": "0xb71b00", "maxPriorityFeePerGas": "0xf4240",  "maxFeePerGasGwei": 0.012, "maxPriorityFeePerGasGwei": 0.001, "estimatedSeconds": 30 },
    "standard": { "maxFeePerGas": "0x14fb180","maxPriorityFeePerGas": "0x989680", "maxFeePerGasGwei": 0.022, "maxPriorityFeePerGasGwei": 0.01,  "estimatedSeconds": 15 },
    "fast":     { "maxFeePerGas": "0x3dfd240","maxPriorityFeePerGas": "0x2faf080","maxFeePerGasGwei": 0.065, "maxPriorityFeePerGasGwei": 0.05,  "estimatedSeconds": 5  }
  }
}

async function sendWithAutoGas(to, data) {
  // 1. Get current fee recommendations
  const gas = await fetch("https://rpc-litvm.pro/api/gas").then(r => r.json());

  // 2. Pick tier: "safe" | "standard" | "fast"
  const tier = gas.tiers.standard;

  // 3. Send — maxFeePerGas and maxPriorityFeePerGas are ready-to-use hex strings
  const txHash = await window.ethereum.request({
    method: "eth_sendTransaction",
    params: [{
      from:                 await ethereum.request({ method: "eth_requestAccounts" }).then(a => a[0]),
      to,
      data,
      maxFeePerGas:         tier.maxFeePerGas,
      maxPriorityFeePerGas: tier.maxPriorityFeePerGas,
    }],
  });

  console.log("Sent:", txHash);
  return txHash;
}

import { JsonRpcProvider, Wallet, parseUnits } from "ethers";

const provider = new JsonRpcProvider("https://rpc-litvm.pro");
const signer = new Wallet("0xYOUR_PRIVATE_KEY", provider);

async function sendWithAutoGas(to, value) {
  const gas = await fetch("https://rpc-litvm.pro/api/gas").then(r => r.json());
  const tier = gas.tiers.standard;

  const tx = await signer.sendTransaction({
    to,
    value,
    maxFeePerGas:         tier.maxFeePerGas,
    maxPriorityFeePerGas: tier.maxPriorityFeePerGas,
  });

  console.log("Tx hash:", tx.hash);
  await tx.wait();
  console.log("Confirmed in block:", tx.blockNumber);
}

import { createWalletClient, http, defineChain, parseEther } from "viem";
import { privateKeyToAccount } from "viem/accounts";

const litvm = defineChain({
  id: 4441,
  name: "LitVM RPC PRO",
  nativeCurrency: { name: "zkLTC", symbol: "zkLTC", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc-litvm.pro"] } },
});

const account = privateKeyToAccount("0xYOUR_PRIVATE_KEY");
const client = createWalletClient({ account, chain: litvm, transport: http() });

async function sendWithAutoGas(to, value) {
  const gas = await fetch("https://rpc-litvm.pro/api/gas").then(r => r.json());
  const tier = gas.tiers.standard;

  const hash = await client.sendTransaction({
    to,
    value,
    maxFeePerGas:         BigInt(tier.maxFeePerGas),
    maxPriorityFeePerGas: BigInt(tier.maxPriorityFeePerGas),
  });

  console.log("Tx hash:", hash);
}

import requests
from web3 import Web3

RPC = "https://rpc-litvm.pro"
w3  = Web3(Web3.HTTPProvider(RPC))

def get_gas(tier="standard"):
    """Fetch live fee recommendation. tier: 'safe' | 'standard' | 'fast'"""
    data = requests.get(f"{RPC}/api/gas").json()
    t = data["tiers"][tier]
    return {
        "maxFeePerGas":         int(t["maxFeePerGas"], 16),
        "maxPriorityFeePerGas": int(t["maxPriorityFeePerGas"], 16),
    }

def send_tx(private_key, to, value_wei, urgency="standard"):
    account = w3.eth.account.from_key(private_key)
    gas = get_gas(urgency)

    tx = {
        "from":               account.address,
        "to":                 to,
        "value":              value_wei,
        "nonce":              w3.eth.get_transaction_count(account.address),
        "gas":                21000,
        "maxFeePerGas":         gas["maxFeePerGas"],
        "maxPriorityFeePerGas": gas["maxPriorityFeePerGas"],
        "chainId":            4441,
        "type":               2,
    }

    signed = account.sign_transaction(tx)
    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash)

    print(f"Confirmed in block {receipt['blockNumber']}, status={receipt['status']}")
    return receipt

# Usage:
# Normal bot cycle — standard speed
send_tx(PRIVATE_KEY, RECIPIENT, w3.to_wei(0.01, "ether"), urgency="standard")

# Time-sensitive arb — fast
send_tx(PRIVATE_KEY, RECIPIENT, w3.to_wei(0.01, "ether"), urgency="fast")

import requests

def get_gas_oracle(tier="standard"):
    res = requests.get("https://rpc-litvm.pro/api/gas").json()
    t   = res["tiers"][tier]
    return {
        "maxFeePerGasHex":         t["maxFeePerGas"],
        "maxPriorityFeePerGasHex": t["maxPriorityFeePerGas"],
        "gwei":                    t["maxFeePerGasGwei"],
        "estimatedSeconds":        t["estimatedSeconds"],
    }

# Example: pick fast tier when latency matters
g = get_gas_oracle("fast")
print(f"Fast: {g['gwei']} Gwei — confirms in ~{g['estimatedSeconds']}s")
# → Fast: 0.065 Gwei — confirms in ~5s

const ws = new WebSocket("wss://rpc-litvm.pro/ws?key=YOUR_KEY");

ws.onopen = () => {
  // Subscribe to new block headers
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    method: "eth_subscribe",
    params: ["newHeads"],
    id: 1
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log("New block:", data.params?.result?.number);
};

npm install @litvm/sdk viem

import { createPublicClient } from "viem";
import { liteforgeTestnet, litvmHttp } from "@litvm/sdk";

const client = createPublicClient({
  chain: liteforgeTestnet,
  transport: litvmHttp(),
});

const blockNumber = await client.getBlockNumber();
const balance = await client.getBalance({ address: "0xYourAddress" });

import { createPublicClient } from "viem";
import { liteforgeTestnet, litvmHttp } from "@litvm/sdk";

const client = createPublicClient({
  chain: liteforgeTestnet,
  transport: litvmHttp({ apiKey: "lrpc_your_key_here" }),
});

const block = await client.getBlock({ blockTag: "latest" });

import { createPublicClient } from "viem";
import { liteforgeTestnet, litvmHttp } from "@litvm/sdk";
import type { CuInfo } from "@litvm/sdk";

const client = createPublicClient({
  chain: liteforgeTestnet,
  transport: litvmHttp({
    apiKey: "lrpc_your_key_here",
    onCu: (cu: CuInfo) => {
      console.log(`CU used: ${cu.used} / ${cu.limit}  (this call: ${cu.cost})`);
    },
  }),
});

import { createPublicClient } from "viem";
import { liteforgeTestnet, litvmWebSocket } from "@litvm/sdk";

const client = createPublicClient({
  chain: liteforgeTestnet,
  transport: litvmWebSocket({ apiKey: "lrpc_your_key_here" }),
});

// Real-time block subscription
const unwatch = client.watchBlocks({
  onBlock: (block) => console.log("New block:", block.number),
});

{
  "mcpServers": {
    "litvm-rpc": {
      "command": "bun",
      "args": ["run", "/absolute/path/to/src/mcp.ts"],
      "env": {
        "MCP_API_KEY": "lrpc_your_key_here",
        "RPC_BASE_URL": "https://rpc-litvm.pro"
      }
    }
  }
}

{
  "name": "litvm-rpc",
  "command": "bun",
  "args": ["run", "/absolute/path/to/src/mcp.ts"],
  "env": {
    "MCP_API_KEY": "lrpc_your_key_here",
    "RPC_BASE_URL": "https://rpc-litvm.pro"
  }
}

{
  "mcpServers": {
    "litvm-rpc": {
      "command": "bun",
      "args": ["run", "/absolute/path/to/src/mcp.ts"],
      "env": {
        "MCP_API_KEY": "lrpc_your_key_here",
        "RPC_BASE_URL": "https://rpc-litvm.pro"
      }
    }
  }
}

What's the latest block on LiteForge?
What's the balance of 0xAbC...?
Show details for transaction 0x123...
What's the current gas price?
How many CU have I used today?
Is the RPC node healthy?