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

> Source: https://docs.blockvectra.com/de/guides/robinhood-chain/

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](#connect-with-viem-or-ethers), 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](https://blockvectra.com/de/chains/robinhood_mainnet/).

## Aufgaben, bei denen dieser Leitfaden hilft

* [Robinhood Chain RPC testen](#connect-with-viem-or-ethers) mit einem öffentlichen Lesezugriff mittels viem oder ethers, danach einen Key für authentifizierte Methoden verwenden.
* [Testnet-RPC-Verbindung prüfen](#testnet) durch Auslesen von `eth_chainId`, bevor Testnet-Operationen ausgeführt werden.
* [Aktivitäten tokenisierter Aktien abfragen](#tokenized-stock-data) 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](https://blockvectra.com/de/chains/robinhood_mainnet/) oder [Testnet-Seite](https://blockvectra.com/de/chains/robinhood_testnet/).
* **JSON-RPC mit einem API key**: Verwenden Sie die unten stehenden Endpunkte und curl-Beispiele. Zu Logs siehe die [eth\_getLogs-Methodenreferenz](https://docs.blockvectra.com/de/api/json-rpc/methods/eth_getLogs/) und den [Leitfaden zu Blockbereichslimits](https://docs.blockvectra.com/de/guides/getlogs-block-range/).
* **WebSocket mit einem API key**: Verwenden Sie die nachfolgenden WebSocket-Endpunkte und folgen Sie dem [Leitfaden für WebSocket-Abonnements](https://docs.blockvectra.com/de/guides/websocket-subscriptions/) 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:

| Parameter / Endpunkt | Wert / Vorlage | Authentifizierung |
|---|---|---|
| Chain-ID (EIP-155) | `4663` | — |
| JSON-RPC (Schlüssel im Pfad) | `POST https://api.blockvectra.com/v1/robinhood_mainnet/{api_key}` | API-Key im URL-Pfad |
| JSON-RPC (Schlüssel im Header) | `POST https://api.blockvectra.com/v1/robinhood_mainnet` | Header x-api-key: {api_key} |
| WebSocket (Schlüssel im Pfad) | `wss://api.blockvectra.com/v1/robinhood_mainnet/{api_key}` | API-Key im URL-Pfad |
| WebSocket (Schlüssel im Header) | `wss://api.blockvectra.com/v1/robinhood_mainnet` | Header x-api-key: {api_key} oder Authorization: Bearer {api_key} |
| WebSocket-Abonnements | `newHeads, logs` | — |
| Data-API-Basis | `GET https://api.blockvectra.com/v1/data/robinhood_mainnet/…` | Header x-api-key: {api_key} |
| Öffentlicher Status | `GET https://api.blockvectra.com/v1/status` | Nicht authentifiziert (öffentlich) |

## 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](https://api.blockvectra.com/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.

```js
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.

```js
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.

```js
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](https://docs.blockvectra.com/de/guides/robinhood-testnet-faucet/) mit Test-ETH aus; Mainnet-Transaktionen benötigen Mainnet-ETH. Der [offizielle Netzwerk- und Deployment-Leitfaden](https://docs.robinhood.com/chain/deploy-smart-contracts/) 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`.

```bash
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](https://docs.blockvectra.com/de/guides/deploy-contract/) 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.

```js
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:

```bash
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](https://docs.blockvectra.com/de/guides/websocket-subscriptions/) und [Blockbereichslimits](https://docs.blockvectra.com/de/guides/getlogs-block-range/).

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](https://docs.blockvectra.com/de/guides/webhook-push/) für Abonnements, Signaturüberprüfung, Deduplizierung und Replay. Für Abfragen von Mainnet-Aktien-Token-Aktivitäten fahren Sie mit dem [Aktien-Leitfaden](https://docs.blockvectra.com/de/guides/stocks/) 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:

**eth_chainId (Header)**

Fragen Sie die EIP-155 Chain ID über den Request-Header `x-api-key` ab:

```bash
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":[]}'
```


  **eth_blockNumber (Path)**

Fragen Sie die neueste Blocknummer ab, indem Sie Ihren API key im URL-Pfad übergeben:

```bash
curl -s "https://api.blockvectra.com/v1/robinhood_mainnet/{api_key}" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","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:

### Netzwerkparameter und Limits

- **eth_getLogs-Blockbereich**: Max. 1000 Blöcke pro Anfrage
- **Historisches Statusfenster**: Letzte 900 Blöcke (Abfragen darüber hinaus geben -32011 zurück)
- **Ausführungstracing (debug_trace*)**: Unterstützt (debug_traceTransaction, debug_traceCall, debug_traceBlockByNumber, debug_traceBlockByHash)

Zulässige Methoden pro Chain: [Unterstützte Chains](https://docs.blockvectra.com/en/chains/)

## Testnet

Um Test-ETH für Transaktionen zu erhalten, siehe den [Robinhood Chain Testnet-Faucet-Leitfaden](https://docs.blockvectra.com/de/guides/robinhood-testnet-faucet/).

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](https://docs.blockvectra.com/de/guides/robinhood-testnet-starter/).

```bash
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:

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

| Parameter / Endpunkt | Wert / Vorlage | Authentifizierung |
|---|---|---|
| Chain-ID (EIP-155) | `46630` | — |
| JSON-RPC (Schlüssel im Pfad) | `POST https://api.blockvectra.com/v1/robinhood_testnet/{api_key}` | API-Key im URL-Pfad |
| JSON-RPC (Schlüssel im Header) | `POST https://api.blockvectra.com/v1/robinhood_testnet` | Header x-api-key: {api_key} |
| WebSocket (Schlüssel im Pfad) | `wss://api.blockvectra.com/v1/robinhood_testnet/{api_key}` | API-Key im URL-Pfad |
| WebSocket (Schlüssel im Header) | `wss://api.blockvectra.com/v1/robinhood_testnet` | Header x-api-key: {api_key} oder Authorization: Bearer {api_key} |
| WebSocket-Abonnements | `newHeads, logs` | — |
| Data-API-Basis | `Noch nicht verfügbar` | — |
| Öffentlicher Status | `GET https://api.blockvectra.com/v1/status` | Nicht authentifiziert (öffentlich) |

### Netzwerkparameter und Limits

- **eth_getLogs-Blockbereich**: Max. 1000 Blöcke pro Anfrage
- **Historisches Statusfenster**: Letzte 1023 Blöcke (Abfragen darüber hinaus geben -32011 zurück)
- **Ausführungstracing (debug_trace*)**: Unterstützt (debug_traceTransaction, debug_traceCall, debug_traceBlockByNumber, debug_traceBlockByHash)

Zulässige Methoden pro Chain: [Unterstützte Chains](https://docs.blockvectra.com/en/chains/)

## 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](https://docs.blockvectra.com/de/guides/stocks/).

Vollständige Starter-Vorlage: [blockvectra/robinhood-stock-tokens](https://github.com/blockvectra/robinhood-stock-tokens)

## Erste Schritte und API keys

Neue Konten erhalten 30,000,000 CU bei der Registrierung — keine Kreditkarte erforderlich.

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](https://console.blockvectra.com/login/?next=%2Fkeys%2F). Siehe den [Schnellstart-Leitfaden](https://docs.blockvectra.com/de/quickstart/) 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](https://docs.blockvectra.com/de/guides/programmatic-signup/).
* **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](https://docs.blockvectra.com/de/guides/ai-agents/).
* **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](https://blockvectra.com/de/pricing/).

## Nächste Schritte

* [Datensatzverzeichnis durchsuchen](https://blockvectra.com/de/data/), um alle von BlockVectra indexierten Datensätze zu sehen.
* [Kostenlosen Tarif und Preise ansehen](https://blockvectra.com/de/pricing/#free), um zu prüfen, was Ihr Konto beinhaltet.
* [In der Konsole anmelden](https://console.blockvectra.com/login/?next=%2Fkeys%2F), um einen API key zu erstellen.