Robinhood Chain RPC Documentation

Robinhood RPC

With Dwellir, you get access to our global Robinhood network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

Get your API key

Why Build on Robinhood Chain?

Robinhood Chain is an Ethereum-compatible Layer 2 built with Arbitrum Nitro. It is designed for tokenized real-world assets and other onchain financial applications while retaining the standard EVM development model.

Ethereum-Compatible Development

• Standard EVM tooling - Use ethers, viem, web3.js, Hardhat, Foundry, and Solidity without a chain-specific SDK.
• ETH-denominated fees - ETH is the native currency for execution and L1 data costs.
• Arbitrum Nitro - Applications use familiar Ethereum JSON-RPC methods and Nitro's execution model.

Fast Application Feedback

• Sub-second soft confirmations - The sequencer gives applications a fast view of accepted transactions.
• WebSocket subscriptions - Stream new heads and logs instead of polling the HTTPS endpoint.
• Ethereum settlement - L2 activity is ultimately settled through the underlying Arbitrum rollup on Ethereum.

Archive and Debug Access

• Historical state - Query balances, contract state, calls, and logs at earlier block heights.
• Execution traces - Use Nitro's debug_* methods to inspect transaction and block execution.
• Production routing - Use the same authenticated Dwellir endpoint format as other supported EVM networks.

Quick Start with Robinhood Chain

Connect to Robinhood Chain mainnet through Dwellir's archive-enabled HTTPS and WebSocket endpoints:

Robinhood RPC Endpoints

HTTPShttps://api-robinhood-mainnet-archive.n.dwellir.com/<API_Keys_Are_Not_Made_for_Bots>

WSSwss://api-robinhood-mainnet-archive.n.dwellir.com/<API_Keys_Are_Not_Made_for_Bots>

curlJavaScriptPythonGo

curl -sS -X POST https://api-robinhood-mainnet-archive.n.dwellir.com/<API_Keys_Are_Not_Made_for_Bots> \  -H 'Content-Type: application/json' \  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

import { JsonRpcProvider } from 'ethers';const provider = new JsonRpcProvider(  'https://api-robinhood-mainnet-archive.n.dwellir.com/<API_Keys_Are_Not_Made_for_Bots>');const latest = await provider.getBlockNumber();console.log('block', latest);

import requestsurl = 'https://api-robinhood-mainnet-archive.n.dwellir.com/<API_Keys_Are_Not_Made_for_Bots>'payload = {  'jsonrpc': '2.0', 'id': 1,  'method': 'eth_blockNumber', 'params': []}resp = requests.post(url, json=payload)print(resp.json())

package mainimport (  "bytes"  "fmt"  "io"  "net/http")func main() {  url := "https://api-robinhood-mainnet-archive.n.dwellir.com/<API_Keys_Are_Not_Made_for_Bots>"  payload := []byte(`{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`)  resp, err := http.Post(url, "application/json",    bytes.NewBuffer(payload))  if err != nil { panic(err) }  defer resp.Body.Close()  body, _ := io.ReadAll(resp.Body)  fmt.Println(string(body))}

Installation and Setup

Network Specifications

API Reference

The reference covers the Ethereum JSON-RPC and Nitro debug methods enabled on Dwellir's Robinhood Chain deployment. Parity-style trace_* methods are not enabled; use the corresponding debug_trace* methods for execution analysis.

RPC Capabilities and Limitations

Common Integration Patterns

Verify the Network Before Sending Transactions

Check the chain ID when your application starts so a misconfigured provider cannot sign or submit transactions to the wrong network:

import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider(
  'https://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

const network = await provider.getNetwork();
if (network.chainId !== 4663n) {
  throw new Error(`Expected Robinhood Chain (4663), received ${network.chainId}`);
}

Query Historical State

The archive endpoint accepts fixed block numbers for state reads. This is useful for accounting, indexers, audits, and point-in-time portfolio views:

import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider(
  'https://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);
const address = '0x0000000000000000000000000000000000000000';
const historicalBlock = 1_000_000;

const [balance, code] = await Promise.all([
  provider.getBalance(address, historicalBlock),
  provider.getCode(address, historicalBlock),
]);

console.log({ balance, code });

For large log ranges, split eth_getLogs queries into bounded block windows and checkpoint the last completed block. This keeps retries small and makes an indexer resumable.

Trace Transaction Execution

Use the debug namespace when you need internal call frames or execution diagnostics:

import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider(
  'https://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

async function traceTransaction(transactionHash) {
  return provider.send('debug_traceTransaction', [
    transactionHash,
    {
      tracer: 'callTracer',
      tracerConfig: { onlyTopCall: false },
    },
  ]);
}

const trace = await traceTransaction('0xTRANSACTION_HASH');
console.log(trace);

debug_traceBlockByNumber and debug_traceBlockByHash are available for block-level analysis. Trace requests can be computationally expensive, so cache immutable results and avoid tracing the same finalized transaction repeatedly.

Subscribe to New Blocks over WebSocket

Use one long-lived WSS connection for real-time events. The subscription remains attached to that connection until it is closed or explicitly unsubscribed:

import WebSocket from 'ws';

const ws = new WebSocket(
  'wss://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'eth_subscribe',
    params: ['newHeads'],
  }));
});

ws.on('message', (data) => {
  const message = JSON.parse(data.toString());
  if (message.method === 'eth_subscription') {
    console.log(message.params.result);
  }
});

Keep Stateful Filters on One Connection

Filter IDs created by eth_newFilter, eth_newBlockFilter, or eth_newPendingTransactionFilter are backend-local. Create the filter and poll it over the same persistent connection. If the connection is replaced, create a new filter and resume from your last processed block rather than reusing the old filter ID.

Gas and Finality

Robinhood Chain fees contain an L2 execution component and an L1 data component for publishing transaction data to Ethereum. Both are paid in ETH.

Robinhood Chain uses first-come, first-served transaction ordering. eth_maxPriorityFeePerGas currently returns zero; raising the priority tip does not buy earlier ordering. Gas tracker execution-cost estimates do not include the variable Nitro L1 data fee.

Confirmation Stages

Transaction Submission Checklist

1. Verify the connected chain ID is 4663 (0x1237).
2. Estimate execution gas immediately before signing.
3. Leave enough ETH for both L2 execution and the variable L1 data component.
4. Submit the signed transaction with eth_sendRawTransaction.
5. Treat the sequencer receipt as a soft confirmation and apply the finality threshold appropriate for your application.

Troubleshooting

method not found for trace_*

Robinhood Chain exposes Nitro's debug_* namespace, not the Parity-style trace_* namespace. Use debug_traceTransaction, debug_traceBlockByNumber, or debug_traceBlockByHash.

filter not found after reconnecting

The filter was created on a previous backend connection. Create a new filter and resume from the last block your application persisted. Use a WebSocket subscription when continuous real-time delivery is a better fit.

Chain ID mismatch

Confirm the provider URL points to Robinhood Chain and that eth_chainId returns 0x1237. Do not submit a transaction until the configured chain and wallet network both report Chain ID 4663.

Official Resources

• Robinhood Chain documentation
• Connect to Robinhood Chain
• Gas and fees
• Transaction finality
• Robinhood Chain explorer
• Arbitrum bridge for Robinhood Chain
• Robinhood Chain status