Guide d'intégration Robinhood Chain : clients RPC, déploiement et événements

Utilisez le RPC de Robinhood Chain pour les vérifications de connexion publiques et les lectures authentifiées, ou la Data API pour les jeux de données pris en charge sur le mainnet. Les développeurs et les agents IA utilisent les mêmes points de terminaison ; séparez bien les requêtes mainnet et testnet.

• Première étape : Se connecter avec viem ou ethers, en enregistrant network.mjs et un exemple de client avant de l'exécuter.
• Terminé quand : le client confirme que le chain ID RPC correspond au chain_id du catalogue et affiche le numéro du dernier bloc sans erreur RPC chain ID mismatch.

Paramètres du mainnet et options d'accès.

Tâches que ce guide vous aide à accomplir

• Tester le RPC Robinhood Chain avec une lecture publique à l'aide de viem ou ethers, puis utiliser une clé pour les méthodes authentifiées.
• Vérifier la connexion RPC au testnet en lisant eth_chainId avant d'exécuter des opérations sur le testnet.
• Interroger l'activité des actions tokenisées avec la Data API mainnet après avoir vérifié la prise en charge du jeu de données ; les métriques décrivent l'activité on-chain, et non le cours des actions.

Accès RPC et WebSocket

• URL RPC publique : retrouvez le point de terminaison sans clé, les méthodes publiques prises en charge et les limites de débit sur la page Robinhood Chain mainnet ou la page testnet.
• JSON-RPC avec une API key : utilisez les points de terminaison et les exemples curl ci-dessous. Pour les logs, consultez la référence de la méthode eth_getLogs et le guide sur les limites de plage de blocs.
• WebSocket avec une API key : utilisez les points de terminaison WebSocket ci-dessous et suivez le guide des abonnements WebSocket pour newHeads et logs. L'accès RPC public se fait en HTTP JSON-RPC ; les connexions WebSocket nécessitent une clé.

Informations sur le réseau et points de terminaison

Chaque requête vers Robinhood Chain identifie explicitement son réseau cible dans le chemin d'URL à l'aide du slug robinhood_mainnet. JSON-RPC prend en charge l'authentification par clé dans le chemin ainsi que par en-tête de requête (x-api-key), tandis que la Data API fournit des points de terminaison REST sous /v1/data/robinhood_mainnet/.

Les paramètres et points de terminaison ci-dessous reflètent les paramètres actifs du réseau :

Se connecter avec viem ou ethers

Les développeurs et les agents IA peuvent utiliser les mêmes paramètres côté serveur. Utilisez Node.js 24 ou une version ultérieure, viem 2 ou ethers 6, et commencez par des lectures publiques. Définissez BLOCKVECTRA_API_KEY de manière sécurisée dans l'environnement pour les méthodes avec clé et WebSocket. Ne laissez jamais de clés ni d'URL RPC contenant des clés dans le code du navigateur, les journaux ou le contrôle de version.

Enregistrez ceci sous network.mjs. Commencez sur le testnet ; définissez BLOCKVECTRA_CHAIN=robinhood_mainnet pour passer au mainnet. Il lit le chain_id et la politique de méthode depuis GET /v1/chains. Pour les lectures sans clé, utilisez l'adresse public.url du catalogue et uniquement les méthodes listées dans public.methods ; la disponibilité HTTP publique n'implique pas l'accès WebSocket.

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');

Enregistrez sous viem-client.mjs, installez avec npm install viem@2, puis exécutez node viem-client.mjs.

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());

Pour ethers, enregistrez sous ethers-client.mjs, installez avec npm install ethers@6, puis exécutez node ethers-client.mjs.

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();

Déployer avec Foundry ou Hardhat

Financez d'abord le déployeur avec de l'ETH de test via le faucet du testnet ; les transactions sur le mainnet nécessitent de l'ETH mainnet. Le guide officiel du réseau et du déploiement répertorie les chain ID du mainnet et du testnet (consulté le : 2026-10-07). Les tableaux de points de terminaison sur cette page utilisent /v1/chains.

Exportez l'URL sélectionnée et le chain ID depuis network.mjs. Vérifiez eth_sendRawTransaction par rapport à methods.allow et methods.deny avant la diffusion.

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)")"

Poursuivez avec le tutoriel de déploiement partagé Foundry ou Hardhat pour Hello.sol, les configurations d'outils, la diffusion et la vérification des reçus.

Écouter les événements de contrat via WebSocket

Enregistrez sous watch-logs.mjs et définissez LOG_ADDRESS avec l'adresse du contrat déployé ou du contrat de jeton que vous surveillez. Exécutez node watch-logs.mjs. Le code vérifie ws et subscriptions depuis /v1/chains avant de s'abonner aux logs.

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); });

Une fois l'écouteur démarré, envoyez une transaction ping() depuis un autre terminal en utilisant les mêmes variables de déploiement exportées :

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

Conservez le dernier bloc traité et dédupliquez par (blockHash, transactionHash, logIndex). Après une reconnexion, rattrapez les blocs manqués à l'aide de requêtes eth_getLogs bornées ; réconciliez les logs marqués removed en cas de réorganisation de chaîne (reorg). Consultez les abonnements WebSocket et les limites de plage de blocs.

Pour les événements d'adresses livrés à votre récepteur HTTPS, GET /v1/push/chains liste les chaînes prises en charge et les paramètres de confirmation ; utilisez un en-tête x-api-key. Suivez le guide webhook push pour les abonnements, la vérification de signature, la déduplication et le rejeu. Pour interroger l'activité des actions tokenisées sur le mainnet, poursuivez avec le guide des actions.

Exemples curl directs

Vous pouvez effectuer des appels JSON-RPC immédiatement à l'aide de clients HTTP standard. Remplacez {api_key} par votre API key BlockVectra :

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

Structure de réponse

Les réponses respectent la spécification JSON-RPC 2.0 :

• Succès : renvoie une enveloppe avec jsonrpc: "2.0", le même id, et une chaîne result contenant la quantité encodée en hexadécimal (eth_chainId renvoie le chain ID encodé en hexadécimal ; eth_blockNumber renvoie la hauteur du dernier bloc).
• Méthodes refusées : la demande d'une méthode non autorisée par le réseau renvoie le code d'erreur JSON-RPC -32601 (method not available, non facturé).
• Requêtes hors fenêtre : les requêtes d'état historique antérieures à la fenêtre de rétention d'état renvoient le code d'erreur JSON-RPC -32011 (non facturé).
• Paramètres non valides : des paramètres de requête mal formés ou non autorisés renvoient le code d'erreur JSON-RPC -32602 (non facturé).

Capacités et politique des méthodes

Les méthodes JSON-RPC disponibles, les limites de plage de blocs pour les logs et la rétention de l'état historique sur Robinhood Chain sont publiées de manière dynamique via GET /v1/chains. Le traçage d'exécution (debug_trace*, incluant debug_traceTransaction) est régi par la politique de méthode de la chaîne :

Testnet

Pour obtenir de l'ETH de test pour vos transactions, consultez le guide du faucet testnet Robinhood Chain.

Le Testnet Robinhood Chain (chain ID : 46630) utilise la même API key que le mainnet sur le point de terminaison https://api.blockvectra.com/v1/robinhood_testnet, authentifié via l'en-tête de requête x-api-key.

Les requêtes testnet utilisent les mêmes poids en CU que le mainnet et sont déduites du même solde et des mêmes crédits gratuits. Les méthodes JSON-RPC disponibles et la rétention de l'état historique sur le Testnet Robinhood Chain sont publiées dynamiquement via GET /v1/chains.

Pour un guide de démarrage exécutable en trois étapes qui lit le testnet sans clé, diffuse les logs via WebSocket, puis utilise la même clé sur le mainnet, consultez le guide de démarrage sur le Testnet Robinhood Chain.

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

Réponse attendue :

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

Données des actions tokenisées

Sur Robinhood Chain, la Data API de BlockVectra fournit des métriques on-chain quotidiennes et des métadonnées pour les actions tokenisées via deux points de terminaison :

• Classement quotidien (GET /v1/data/robinhood_mainnet/stocks) : classement quotidien de l'activité des actions tokenisées pour une date UTC spécifiée, trié par activité de transfert décroissante.
• Obtenir une action tokenisée (GET /v1/data/robinhood_mainnet/stocks/{token}) : métadonnées du contrat de jeton et jusqu'à 30 jours de métriques quotidiennes récentes par adresse de jeton.

Pour les paramètres de requête détaillés, les enveloppes de réponse (StockDailyListEnvelope et StockTokenEnvelope), les notes de pagination et les estimations de consommation en CU, consultez le guide des actions tokenisées.

Modèle de démarrage complet : blockvectra/robinhood-stock-tokens

Démarrage et API keys

Vous pouvez d'abord essayer le point de terminaison public sans clé https://api.blockvectra.com/v1/robinhood_mainnet/public (méthodes JSON-RPC de portefeuille uniquement, la Data API nécessite une clé ; les méthodes et limites dépendent de /v1/chains) ; créez un compte si vous avez besoin d'une limite de débit plus élevée.

• Console web : inscrivez-vous via une signature de portefeuille Ethereum et générez une API key dans la Console. Consultez le guide de démarrage rapide pour les détails de configuration.
• Inscription programmatique : les agents IA autonomes, les scripts automatisés et les pipelines CI peuvent se connecter et approvisionner des API keys à l'aide de signatures de portefeuille Ethereum (EIP-191) sans navigateur. Suivez le guide d'inscription programmatique.
• Agents IA : les agents IA autonomes peuvent découvrir les fonctionnalités de Robinhood Chain à l'aide du serveur officiel Model Context Protocol (MCP). Consultez Connecter des agents IA à BlockVectra.
• Mise à niveau des limites : après une recharge, la limite d'appels par seconde à l'échelle du compte est supprimée ; chaque clé reste soumise aux limites de débit en Compute Units (CU) et de burst. Pour les tarifs et unités de facturation actuels, consultez la page Tarifs.

Prochaines étapes

• Parcourir le catalogue des jeux de données pour découvrir chaque jeu de données indexé par BlockVectra.
• Consulter le forfait gratuit et les tarifs pour vérifier ce que comprend votre compte.
• Se connecter à la console pour créer une API key.