# Robinhood Chain RPC: Chain ID 4663, eth_getLogs and WebSocket ## Robinhood RPC plans and rate limits - **Free plan:** 20 responses per second, up to 100,000 responses a day. - **Plans:** $49/mo, $299/mo, $999/mo with 25M, 150M, and 500M included responses. Overages billed at $5/$3/$2 per million responses respectively. - **Paid rate limits:** 100 to 5,000 responses per second (bursts from 500 to 10,000), no daily limit. - **Billing:** 1 response = 1 API credit on every shared plan, over HTTPS or WebSocket (WSS) where Robinhood supports it. Details: [Pricing](https://www.dwellir.com/docs/getting-started/pricing) · [Rate limits](https://www.dwellir.com/docs/getting-started/rate-limits) · [Authentication](https://www.dwellir.com/docs/getting-started/authentication) · [Archive nodes](https://www.dwellir.com/docs/getting-started/archive-nodes) ## Robinhood Chain endpoints and chain facts | Item | Value | | ------------------------ | ------------------------------------------------------------------ | | HTTPS endpoint | `https://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY` | | WebSocket (WSS) endpoint | `wss://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY` | | Chain ID | 4663 (`0x1237`) | | Block time | About 0.1 s | | Archive state | Yes | | `debug_*` methods | Yes | | `trace_*` methods | No, use `debug_trace*` | Every Dwellir endpoint needs an API key. There is no keyless Dwellir endpoint for Robinhood Chain. The cheapest plan with `eth_getLogs` and WebSocket is Developer at $49/month. It allows 500 blocks per [`eth_getLogs`](https://www.dwellir.com/docs/robinhood/eth_getLogs) request, about 50 seconds of Robinhood Chain blocks. Growth at $299/month raises the range to 10,000 blocks. The Free plan (20 responses per second, 100,000 responses a day) includes HTTPS and WebSocket access but not `eth_getLogs`. The plans section above lists the remaining limits, and [rate limits](https://www.dwellir.com/docs/getting-started/rate-limits#eth_getlogs-block-range-limits) has the block-range table for every plan. Provider pricing for Robinhood Chain is compared in [best Robinhood Chain RPC providers](https://www.dwellir.com/blog/best-robinhood-chain-rpc-providers). For swaps, pool state and Stock Token data, see [how to get Robinhood Chain data for DeFi strategies](https://www.dwellir.com/blog/robinhood-chain-defi-data). ## 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. ## Sequencer feed Stream ordered Nitro messages through Dwellir's [Robinhood sequencer feed](https://www.dwellir.com/docs/robinhood/sequencer-feed). The WebSocket endpoint has a three-day trial and an optional $100 monthly add-on, plus usage. The feed starts sending messages when you connect. Use a raw WebSocket client and a Nitro payload decoder. ## Quick Start with Robinhood Chain Connect to Robinhood Chain mainnet through Dwellir's archive-enabled HTTPS and WebSocket endpoints: ### Installation and Setup Ethers.js viem WebSocket ```javascript import { ethers } from 'ethers'; const provider = new ethers.JsonRpcProvider( 'https://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY' ); const network = await provider.getNetwork(); console.log(network.chainId === 4663n); const blockNumber = await provider.getBlockNumber(); console.log('Latest block:', blockNumber); ``` ```typescript import { createPublicClient, defineChain, http } from 'viem'; const robinhood = defineChain({ id: 4663, name: 'Robinhood Chain', nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 }, rpcUrls: { default: { http: ['https://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY'], }, }, }); const client = createPublicClient({ chain: robinhood, transport: http(), }); const blockNumber = await client.getBlockNumber(); ``` ```javascript import { ethers } from 'ethers'; const provider = new ethers.WebSocketProvider( 'wss://api-robinhood-mainnet-archive.n.dwellir.com/YOUR_API_KEY' ); provider.on('block', (blockNumber) => { console.log('New Robinhood Chain block:', blockNumber); }); ``` ## Network Specifications | Parameter | Value | Details | | ---------------- | -------------------------------------------------------------------- | ------------------------------------------- | | Chain ID | 4663 | Mainnet, hexadecimal `0x1237` | | Native currency | ETH | Gas and transaction fees | | Execution stack | Arbitrum Nitro | EVM-compatible optimistic rollup | | Settlement layer | Ethereum | L1 data availability and settlement | | RPC standard | Ethereum | JSON-RPC 2.0 over HTTPS and WSS | | State access | Archive | Historical state queries are supported | | Trace support | `debug_*` | Parity-style `trace_*` is not enabled | | Explorer | [Robinhood Chain Blockscout](https://robinhoodchain.blockscout.com/) | Mainnet blocks, transactions, and contracts | ## 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 | Capability | Support | Operational note | | ------------------------------ | ---------------------- | ----------------------------------------------------------------------------- | | HTTPS JSON-RPC | Supported | Use for reads, writes, archive queries, and debug calls | | WebSocket JSON-RPC | Supported | Use for `eth_subscribe` and persistent stateful workflows | | Historical state | Archive | Fixed block parameters are available for state reads | | `debug_*` namespace | Supported | Transaction and block tracing methods are enabled | | `trace_*` namespace | Not enabled | Use the corresponding `debug_trace*` method | | Stateful filters | Supported | Filter IDs are backend-local and require connection affinity | | `txpool_*` namespace | Not exposed | Do not depend on node-local mempool inspection | | Pending transaction monitoring | No public pending feed | Accepted filter or subscription IDs do not imply pending transaction delivery | ## 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: ```typescript 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: ```javascript 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: ```javascript 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: ```javascript 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); } }); ``` ### Pending transactions and the sequencer feed Robinhood Chain uses Arbitrum Nitro. Dwellir's follower nodes do not expose the sequencer's private transaction queue before ordering. `eth_newPendingTransactionFilter` can return a filter ID, and `eth_subscribe("newPendingTransactions")` can return a subscription ID. Neither provides a public pending transaction feed on this endpoint. Empty results do not mean the chain has stopped processing transactions. For block and event updates, use `eth_subscribe("newHeads")` or `eth_subscribe("logs")`. These report activity after sequencing and execution, before Ethereum settlement. Robinhood publishes a public Nitro sequencer feed at `wss://feed.mainnet.chain.robinhood.com`. It streams ordered messages, rather than exposing the private queue before ordering. This is Robinhood's upstream service. It uses the Nitro feed protocol, not JSON-RPC `eth_subscribe`. For authenticated access through Dwellir, see the [sequencer feed guide](https://www.dwellir.com/docs/robinhood/sequencer-feed). It covers access, usage billing, and a Node.js consumer example. See Robinhood's [public endpoint list](https://docs.robinhood.com/chain/connecting/#public-endpoints) and [full-node guide](https://docs.robinhood.com/chain/run-a-full-node/). The [Nitro whitepaper](https://docs.arbitrum.io/nitro-whitepaper.pdf) describes the feed's ordering guarantees. ### Keep stateful filters on one backend Filter IDs belong to the backend that created them. Create, poll, and uninstall a filter over one persistent WebSocket connection. For HTTP, preserve the `DWSESSION` cookie between requests. HTTP connection reuse alone does not keep requests on one backend. If the backend changes or a filter expires, recreate the filter. Backfill missed logs with `eth_getLogs` from the last processed block. ## 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 | Stage | Meaning | Application guidance | | ---------------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------ | | Sequencer confirmation | The sequencer has accepted and ordered the transaction | Suitable for responsive UI updates, but still a soft L2 confirmation | | L2 block inclusion | The transaction has a receipt in a Robinhood Chain block | Persist the block number and hash so reorg handling is deterministic | | Ethereum settlement | The rollup data and state commitment progress through Ethereum | Use this stage when the workflow requires stronger settlement assurance | | L2-to-L1 withdrawal | Assets move through the canonical Arbitrum bridge | Account for the rollup challenge period before funds are available on L1 | ### 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](https://docs.robinhood.com/chain/) - [Connect to Robinhood Chain](https://docs.robinhood.com/chain/connecting/) - [Gas and fees](https://docs.robinhood.com/chain/gas-and-fees/) - [Transaction finality](https://docs.robinhood.com/chain/transaction-finality/) - [Robinhood Chain explorer](https://robinhoodchain.blockscout.com/) - [Arbitrum bridge for Robinhood Chain](https://portal.arbitrum.io/bridge?destinationChain=robinhood-chain\&sourceChain=ethereum) - [Robinhood Chain status](https://status.robinhoodchain.offchain.io/)