[ chain: robinhood ] [ chain-id: 4663 ] [ runtime: rust ]

contract-aware robinhood chain pipelines, from blocks to structured data.

Yellowstone Vixen is developer tooling for real-time Robinhood Chain data. Read EVM blocks, transactions, receipts, and contract logs, decode ABI events, and route structured output into indexes, APIs, alerts, or analytics systems.

>_ get started </> view github

networkrobinhood chain

chain id4663

interfaceevm json-rpc

gasETH

RUST

use alloy::providers::{Provider, ProviderBuilder};
use url::Url;

const RPC: &str =
    "https://rpc.mainnet.chain.robinhood.com";

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let provider = ProviderBuilder::new()
        .connect_http(Url::parse(RPC)?);

    let chain_id = provider.get_chain_id().await?;
    assert_eq!(chain_id, 4663);
    Ok(())
}use alloy::sol;

sol! {
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 value
    );
}

// Decode EVM logs into typed contract events.
let transfer = Transfer::decode_log(&log)?;

chain output live

</> ABI decoding ⌁ JSON-RPC sources ▤ EVM contract events ▥ metrics + tracing ⌬ fixture replay ◉ block streaming

// robinhood chain

built for real-time EVM data.

Robinhood Chain is an Ethereum-compatible Layer 2. Vixen keeps the data path focused so applications can read chain activity, decode the contracts they care about, and send clean events into the systems that need them.

#01

chain native

Target Robinhood Chain mainnet directly with chain ID 4663 and standard EVM JSON-RPC tooling.

{ }02

typed decoding

Turn raw logs and calldata into typed events using contract ABIs instead of hand-parsing bytes.

⌁03

observable

Track provider health, block progress, decode failures, throughput, and downstream delivery.

◇04

composable

Mix RPC sources, contract decoders, handlers, indexes, queues, and APIs around your workload.

// architecture

read → decode → handle → deliver

Blocks, receipts, and logs enter through an EVM provider, flow through contract-aware decoders, reach your application logic, and continue into databases, queues, APIs, or analytics systems.

sourcerobinhood rpcblocks · txs · logs

→

decoderABI-awareevents + calls

→

handlersyour logictransform + react

→

runtimeasync rustpipeline execution

→

downstreamstructured datadb · queue · api · lake

// contracts + events

decode the contracts your app understands.

Use standard EVM ABIs to turn Robinhood Chain logs, transactions, and calls into clean application data without tying the rest of the pipeline to raw RPC responses.

events

ABI log decoding

Transfer::decode_log(&log)

Decode indexed topics and event payloads into typed Rust structures.

transactions

receipts + traces

eth_getTransactionReceipt

Follow transaction outcomes, emitted logs, gas usage, and contract interactions.

contracts

custom ABIs

sol! { ... }

Model ERC-20s, tokenized assets, protocols, or your own contracts with standard EVM interfaces.

provider flexibility

Use Robinhood public RPC for development or connect a production provider for higher limits.

metrics support

Expose pipeline health, block lag, provider errors, and delivery counters.

offline testing

Replay saved JSON-RPC responses and logs to test decoders without a live endpoint.

standard EVM tooling

Build with familiar Ethereum libraries, wallets, ABIs, and contract development workflows.

// network

robinhood chain, directly.

Robinhood Chain is an Arbitrum-based Ethereum Layer 2 with ETH as its native gas token. The mainnet uses chain ID 4663 and exposes standard EVM RPC endpoints.

public RPC

Direct JSON-RPC access for development, reads, transactions, and contract calls.

rpc.mainnet.chain.robinhood.com

provider RPC

Use supported infrastructure providers when production workloads need higher limits and reliability.

alchemy · quicknode · others

archive reads

Query historical state and older blocks through an archive-capable provider endpoint.

historical EVM state

full node

Run Robinhood Chain’s Arbitrum Nitro node stack when you need independent full data access.

arbitrum nitro

// quick-start

connect to chain ID 4663.

Start with an async Rust runtime and an EVM provider. The public endpoint is convenient for development, while production workloads should use an infrastructure provider with appropriate capacity.

1add dependencies

[dependencies]
alloy = { version = "1", features = ["full"] }
tokio = { version = "1", features = ["full"] }
eyre = "0.6"
url = "2"

2connect the provider

let provider = ProviderBuilder::new()
  .connect_http(Url::parse(
    "https://rpc.mainnet.chain.robinhood.com"
  )?);

assert_eq!(provider.get_chain_id().await?, 4663);

3stream + decode

INFO  chain_id=4663 connected
INFO  block=... received
DEBUG logs=... fetched
INFO  decoded transfer event
INFO  structured event delivered

mainnet RPC https://rpc.mainnet.chain.robinhood.com · chain ID 4663 · gas token ETH · EVM-compatible

// YELLOWVIX

build for robinhood chain.

CA TBA

open repository ↗ $YELLOWVIX page open launchpad ↗