Robinhood Chain-Integrationsleitfaden: RPC-Clients, Deployment und Events

Verwenden Sie Robinhood Chain RPC für öffentliche Verbindungsprüfungen und authentifizierte Leseabfragen oder die Data API für unterstützte Mainnet-Datensätze. Entwickler und KI-Agenten nutzen dieselben Endpunkte; trennen Sie Mainnet- und Testnet-Anfragen stets voneinander.

• Erster Schritt: Mit viem oder ethers verbinden, indem Sie network.mjs und ein Client-Beispiel vor dem Ausführen speichern.
• Abgeschlossen wenn: Der Client bestätigt, dass die RPC-Chain-ID mit der chain_id des Katalogs übereinstimmt, und die neueste Blocknummer ohne einen RPC chain ID mismatch-Fehler ausgibt.

Mainnet-Parameter und Zugriffsoptionen.

Aufgaben, bei denen dieser Leitfaden hilft

• Robinhood Chain RPC testen mit einem öffentlichen Lesezugriff mittels viem oder ethers, danach einen Key für authentifizierte Methoden verwenden.
• Testnet-RPC-Verbindung prüfen durch Auslesen von eth_chainId, bevor Testnet-Operationen ausgeführt werden.
• Aktivitäten tokenisierter Aktien abfragen mit der Mainnet-Data-API nach Prüfung der Datensatzunterstützung; die Metriken beschreiben On-Chain-Aktivitäten, keine Aktienkurse.

RPC- und WebSocket-Zugriff

• Öffentliche RPC-URL: Den schlüssellosen Endpunkt, unterstützte öffentliche Methoden und Ratenlimits finden Sie auf der Robinhood Chain Mainnet-Seite oder Testnet-Seite.
• JSON-RPC mit einem API key: Verwenden Sie die unten stehenden Endpunkte und curl-Beispiele. Zu Logs siehe die eth_getLogs-Methodenreferenz und den Leitfaden zu Blockbereichslimits.
• WebSocket mit einem API key: Verwenden Sie die nachfolgenden WebSocket-Endpunkte und folgen Sie dem Leitfaden für WebSocket-Abonnements für newHeads und logs. Öffentlicher RPC-Zugriff erfolgt über HTTP JSON-RPC; WebSocket-Verbindungen erfordern einen Key.

Netzwerkinformationen und Endpunkte

Jede Anfrage an Robinhood Chain identifiziert ihr Zielnetzwerk explizit im URL-Pfad über den Slug robinhood_mainnet. JSON-RPC unterstützt sowohl pfadbasierte Key-Authentifizierung als auch Authentifizierung per Request-Header (x-api-key), während die Data API REST-Endpunkte unter /v1/data/robinhood_mainnet/ bereitstellt.

Die nachfolgenden Parameter und Endpunkte spiegeln aktive Netzwerkparameter wider:

Mit viem oder ethers verbinden

Entwickler und KI-Agenten können dieselben serverseitigen Einstellungen verwenden. Nutzen Sie Node.js 24 oder höher, viem 2 oder ethers 6 und beginnen Sie mit öffentlichen Leseabfragen. Setzen Sie BLOCKVECTRA_API_KEY sicher in der Umgebung für Methoden mit Key-Pflicht und WebSocket. Halten Sie Keys und RPC-URLs, die Keys enthalten, von Browser-Code, Logs und der Versionskontrolle fern.

Speichern Sie dies als network.mjs. Beginnen Sie auf dem Testnet; setzen Sie BLOCKVECTRA_CHAIN=robinhood_mainnet, um zum Mainnet zu wechseln. Es liest chain_id und Methodenrichtlinie aus GET /v1/chains aus. Für schlüssellose Leseabfragen nutzen Sie die public.url des Katalogs und nur die unter public.methods aufgeführten Methoden; öffentliche HTTP-Verfügbarkeit impliziert keinen WebSocket-Zugriff.

const chainSlug = process.env.BLOCKVECTRA_CHAIN ?? 'robinhood_testnet';
const key = process.env.BLOCKVECTRA_API_KEY;
const catalogUrl = 'https://api.blockvectra.com/v1/chains';
const response = await fetch(catalogUrl, { signal: AbortSignal.timeout(15_000) });
if (!response.ok) throw new Error(`Chains HTTP ${response.status}`);
const catalog = await response.json();
export const chainInfo = catalog.chains.find(item => item.chain === chainSlug);
if (!chainInfo || !Number.isSafeInteger(chainInfo.chain_id) || chainInfo.chain_id <= 0) {
  throw new Error('Missing chain or chain_id');
}
export function allows(method) {
  const matches = pattern => pattern.endsWith('*')
    ? method.startsWith(pattern.slice(0, -1)) : pattern === method;
  if (!key) return (chainInfo.public?.methods ?? []).some(matches);
  return (chainInfo.methods?.allow ?? []).some(matches)
    && !(chainInfo.methods?.deny ?? []).some(matches);
}
if (!allows('eth_chainId')) throw new Error('eth_chainId is unavailable');
export const rpcUrl = key
  ? new URL(`./${chainSlug}/${encodeURIComponent(key)}`, catalogUrl).href
  : chainInfo.public?.url;
if (!rpcUrl) throw new Error('Public RPC is unavailable; set BLOCKVECTRA_API_KEY');

Als viem-client.mjs speichern, mit npm install viem@2 installieren, dann node viem-client.mjs ausführen.

import { createPublicClient, defineChain, http } from 'viem';
import { chainInfo, rpcUrl } from './network.mjs';

export const chain = defineChain({
  id: chainInfo.chain_id,
  name: chainInfo.name,
  nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
  rpcUrls: { default: { http: [rpcUrl] } },
});
export const client = createPublicClient({ chain, transport: http(rpcUrl) });
if (await client.getChainId() !== chain.id) throw new Error('RPC chain ID mismatch');
console.log(await client.getBlockNumber());

Für ethers als ethers-client.mjs speichern, mit npm install ethers@6 installieren, dann node ethers-client.mjs ausführen.

import { JsonRpcProvider } from 'ethers';
import { chainInfo, rpcUrl } from './network.mjs';

const provider = new JsonRpcProvider(rpcUrl, chainInfo.chain_id, { batchMaxCount: 1 });
const network = await provider.getNetwork();
if (network.chainId !== BigInt(chainInfo.chain_id)) throw new Error('RPC chain ID mismatch');
console.log(await provider.getBlockNumber());
provider.destroy();

Mit Foundry oder Hardhat deployen

Statten Sie den Deployer zunächst über das Testnet-Faucet mit Test-ETH aus; Mainnet-Transaktionen benötigen Mainnet-ETH. Der offizielle Netzwerk- und Deployment-Leitfaden listet die Mainnet- und Testnet-Chain-IDs auf (abgerufen: 2026-10-07). Die Endpunkttabellen auf dieser Seite verwenden /v1/chains.

Exportieren Sie die ausgewählte URL und die Chain-ID aus network.mjs. Prüfen Sie eth_sendRawTransaction vor dem Übertragen anhand von methods.allow und methods.deny.

export RPC_URL="$(node --input-type=module -e "import { rpcUrl, allows } from './network.mjs'; if (!allows('eth_sendRawTransaction')) throw new Error('Broadcast unavailable'); console.log(rpcUrl)")"
export CHAIN_ID="$(node --input-type=module -e "import { chainInfo } from './network.mjs'; console.log(chainInfo.chain_id)")"

Fahren Sie mit dem gemeinsamen Deployment-Tutorial für Foundry oder Hardhat für Hello.sol, Tool-Einstellungen, Broadcasting und Receipt-Prüfungen fort.

Auf Contract-Events über WebSocket hören

Als watch-logs.mjs speichern und LOG_ADDRESS auf den deployten Contract oder Token-Contract setzen, den Sie überwachen. node watch-logs.mjs ausführen. Der Code prüft ws und subscriptions aus /v1/chains, bevor logs abonniert wird.

import { createPublicClient, webSocket, isAddress } from 'viem';
import { chain } from './viem-client.mjs';
import { chainInfo, rpcUrl } from './network.mjs';

if (!process.env.BLOCKVECTRA_API_KEY) throw new Error('WebSocket requires BLOCKVECTRA_API_KEY');
const address = process.env.LOG_ADDRESS;
if (!chainInfo.ws || !chainInfo.subscriptions?.includes('logs')) {
  throw new Error('WebSocket logs are unavailable; use HTTP backfill or webhook push');
}
if (!address || !isAddress(address)) throw new Error('Set LOG_ADDRESS');
const wsUrl = new URL(rpcUrl);
wsUrl.protocol = 'wss:';
const client = createPublicClient({ chain, transport: webSocket(wsUrl.href) });
const unwatch = client.watchEvent({
  address, poll: false,
  onLogs: logs => console.log(logs),
  onError: error => console.error(error),
});
process.once('SIGINT', () => { unwatch(); process.exit(0); });

Senden Sie nach dem Start des Listeners eine ping()-Transaktion aus einem anderen Terminal unter Verwendung derselben exportierten Deployment-Variablen:

cast send "$CONTRACT_ADDRESS" "ping()" --rpc-url "$RPC_URL" \
  --private-key "$DEPLOYER_PRIVATE_KEY"

Persistieren Sie den zuletzt verarbeiteten Block und deduplizieren Sie nach (blockHash, transactionHash, logIndex). Füllen Sie nach einer Wiederverbindung verpasste Blöcke mit begrenzten eth_getLogs-Anfragen nach; gleichen Sie bei einer Reorg als removed markierte Logs ab. Siehe WebSocket-Abonnements und Blockbereichslimits.

Für an Ihren HTTPS-Empfänger zugestellte Adress-Events listet GET /v1/push/chains unterstützte Chains und Bestätigungseinstellungen auf; verwenden Sie einen x-api-key-Header. Folgen Sie dem Webhook-Push-Leitfaden für Abonnements, Signaturüberprüfung, Deduplizierung und Replay. Für Abfragen von Mainnet-Aktien-Token-Aktivitäten fahren Sie mit dem Aktien-Leitfaden fort.

Direkte curl-Beispiele

Sie können JSON-RPC-Aufrufe sofort mit standardmäßigen HTTP-Clients durchführen. Ersetzen Sie {api_key} durch Ihren BlockVectra-API-Key:

curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \
  -H "Content-Type: application/json" \
  -H "x-api-key: {api_key}" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

Antwortstruktur

Antworten folgen der JSON-RPC 2.0-Spezifikation:

• Erfolg: Gibt einen Umschlag mit jsonrpc: "2.0", derselben id und einem result-String zurück, der den hexadezimal kodierten Wert enthält (eth_chainId gibt die hexadezimale Chain ID zurück; eth_blockNumber gibt die neueste Blockhöhe zurück).
• Nicht zulässige Methoden: Das Anfordern einer Methode außerhalb der zulässigen Methoden des Netzwerks gibt den JSON-RPC-Fehlercode -32601 zurück (method not available, wird nicht abgerechnet).
• Abfragen außerhalb des Fensters: Historische State-Anfragen vor dem State-Aufbewahrungsfenster geben den JSON-RPC-Fehlercode -32011 zurück (wird nicht abgerechnet).
• Ungültige Parameter: Fehlerhafte oder unzulässige Anforderungsparameter geben den JSON-RPC-Fehlercode -32602 zurück (wird nicht abgerechnet).

Funktions- und Methodenrichtlinie

Verfügbare JSON-RPC-Methoden, Log-Blockbereichslimits und historische State-Aufbewahrung auf Robinhood Chain werden dynamisch über GET /v1/chains veröffentlicht. Execution Tracing (debug_trace*, einschließlich debug_traceTransaction) unterliegt der Methodenrichtlinie der Chain:

Testnet

Um Test-ETH für Transaktionen zu erhalten, siehe den Robinhood Chain Testnet-Faucet-Leitfaden.

Das Robinhood Chain Testnet (Chain ID: 46630) verwendet denselben API key wie das Mainnet am Endpunkt https://api.blockvectra.com/v1/robinhood_testnet, authentifiziert über den Request-Header x-api-key.

Testnet-Anfragen verwenden dieselben CU-Gewichtungen wie das Mainnet und schöpfen aus demselben Guthaben und denselben kostenlosen Credits. Verfügbare JSON-RPC-Methoden und historische State-Aufbewahrung im Robinhood Chain Testnet werden dynamisch über GET /v1/chains veröffentlicht.

Einen lauffähigen dreistufigen Starter, der das Testnet ohne Key ausliest, Logs über WebSocket streamt und anschließend denselben Key auf das Mainnet überträgt, finden Sie im Robinhood Chain Testnet-Starter-Leitfaden.

curl -s "https://api.blockvectra.com/v1/robinhood_testnet" \
  -H "Content-Type: application/json" \
  -H "x-api-key: {api_key}" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

Erwartete Antwort:

{"jsonrpc":"2.0","id":1,"result":"0xb626"}

Tokenisierte Aktiendaten

Auf Robinhood Chain stellt die BlockVectra Data API tägliche On-Chain-Metriken und Metadaten für tokenisierte Aktien über zwei Endpunkte bereit:

• Tägliche Bestenliste (GET /v1/data/robinhood_mainnet/stocks): Tägliche Aktivitäts-Bestenliste tokenisierter Aktien für ein bestimmtes UTC-Datum, absteigend nach Transferaktivität sortiert.
• Einzelne tokenisierte Aktie abrufen (GET /v1/data/robinhood_mainnet/stocks/{token}): Token-Contract-Metadaten und bis zu 30 Tage aktueller täglicher Metriken nach Token-Adresse.

Detaillierte Anforderungsparameter, Response-Envelopes (StockDailyListEnvelope und StockTokenEnvelope), Paginierungshinweise und Schätzungen zum CU-Verbrauch finden Sie im Leitfaden für tokenisierte Aktien.

Vollständige Starter-Vorlage: blockvectra/robinhood-stock-tokens

Erste Schritte und API keys

Sie können zunächst den schlüssellosen öffentlichen Endpunkt https://api.blockvectra.com/v1/robinhood_mainnet/public ausprobieren (nur Wallet-JSON-RPC-Methoden, die Data API erfordert einen Key; Methoden und Limits unterliegen /v1/chains); registrieren Sie ein Konto, wenn Sie ein höheres Ratenlimit benötigen.

• Web-Konsole: Registrieren Sie sich über eine Ethereum-Wallet-Signatur und erstellen Sie einen API key in der Konsole. Siehe den Schnellstart-Leitfaden für Einrichtungsdetails.
• Programmatische Registrierung: Autonome KI-Agenten, automatisierte Skripte und CI-Pipelines können sich ohne Browser über Ethereum-Wallet-Signaturen (EIP-191) anmelden und API keys bereitstellen. Folgen Sie dem Leitfaden zur programmatischen Registrierung.
• KI-Agenten: Autonome KI-Agenten können Funktionen der Robinhood Chain über den offiziellen Model Context Protocol (MCP)-Server ermitteln. Siehe KI-Agenten mit BlockVectra verbinden.
• Limits hochstufen: Nach dem Aufladen entfällt das kontoweite Limit für Aufrufe pro Sekunde; jeder Key unterliegt weiterhin den Compute Unit (CU)-Raten- und Burst-Limits. Aktuelle Tarife und Abrechnungseinheiten finden Sie auf der Preisseite.

Nächste Schritte

• Datensatzverzeichnis durchsuchen, um alle von BlockVectra indexierten Datensätze zu sehen.
• Kostenlosen Tarif und Preise ansehen, um zu prüfen, was Ihr Konto beinhaltet.
• In der Konsole anmelden, um einen API key zu erstellen.