# Guide d'intégration Robinhood Chain : clients RPC, déploiement et événements > Source: https://docs.blockvectra.com/fr/guides/robinhood-chain/ 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](#connect-with-viem-or-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](https://blockvectra.com/fr/chains/robinhood_mainnet/). ## Tâches que ce guide vous aide à accomplir * [Tester le RPC Robinhood Chain](#connect-with-viem-or-ethers) 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](#testnet) en lisant `eth_chainId` avant d'exécuter des opérations sur le testnet. * [Interroger l'activité des actions tokenisées](#tokenized-stock-data) 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](https://blockvectra.com/fr/chains/robinhood_mainnet/) ou la [page testnet](https://blockvectra.com/fr/chains/robinhood_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](https://docs.blockvectra.com/fr/api/json-rpc/methods/eth_getLogs/) et le [guide sur les limites de plage de blocs](https://docs.blockvectra.com/fr/guides/getlogs-block-range/). * **WebSocket avec une API key** : utilisez les points de terminaison WebSocket ci-dessous et suivez le [guide des abonnements WebSocket](https://docs.blockvectra.com/fr/guides/websocket-subscriptions/) 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 : | Paramètre / Endpoint | Valeur / Modèle | Authentification | |---|---|---| | Chain ID (EIP-155) | `4663` | — | | JSON-RPC (clé dans le chemin) | `POST https://api.blockvectra.com/v1/robinhood_mainnet/{api_key}` | Clé API dans le chemin d'URL | | JSON-RPC (clé dans l'en-tête) | `POST https://api.blockvectra.com/v1/robinhood_mainnet` | En-tête x-api-key: {api_key} | | WebSocket (clé dans le chemin) | `wss://api.blockvectra.com/v1/robinhood_mainnet/{api_key}` | Clé API dans le chemin d'URL | | WebSocket (clé dans l'en-tête) | `wss://api.blockvectra.com/v1/robinhood_mainnet` | En-tête x-api-key: {api_key} ou Authorization: Bearer {api_key} | | Abonnements WebSocket | `newHeads, logs` | — | | Base de la Data API | `GET https://api.blockvectra.com/v1/data/robinhood_mainnet/…` | En-tête x-api-key: {api_key} | | Statut public | `GET https://api.blockvectra.com/v1/status` | Non authentifié (public) | ## 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](https://api.blockvectra.com/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. ```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'); ``` Enregistrez sous `viem-client.mjs`, installez avec `npm install viem@2`, puis exécutez `node viem-client.mjs`. ```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()); ``` Pour ethers, enregistrez sous `ethers-client.mjs`, installez avec `npm install ethers@6`, puis exécutez `node ethers-client.mjs`. ```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(); ``` ## Déployer avec Foundry ou Hardhat Financez d'abord le déployeur avec de l'ETH de test via le [faucet du testnet](https://docs.blockvectra.com/fr/guides/robinhood-testnet-faucet/) ; les transactions sur le mainnet nécessitent de l'ETH mainnet. Le [guide officiel du réseau et du déploiement](https://docs.robinhood.com/chain/deploy-smart-contracts/) 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. ```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)")" ``` Poursuivez avec le [tutoriel de déploiement partagé Foundry ou Hardhat](https://docs.blockvectra.com/fr/guides/deploy-contract/) 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`. ```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); }); ``` 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 : ```bash 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](https://docs.blockvectra.com/fr/guides/websocket-subscriptions/) et les [limites de plage de blocs](https://docs.blockvectra.com/fr/guides/getlogs-block-range/). 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](https://docs.blockvectra.com/fr/guides/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](https://docs.blockvectra.com/fr/guides/stocks/). ## 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 : **eth_chainId (Header)** Interrogez le chain ID EIP-155 à l'aide de l'en-tête de requête `x-api-key` : ```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)** Interrogez le dernier numéro de bloc en transmettant votre API key dans le chemin de l'URL : ```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":[]}' ``` ### 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 : ### Paramètres et limites du réseau - **Plage de blocs eth_getLogs**: Max 1000 blocs par requête - **Fenêtre d'état historique**: 900 blocs récents (les requêtes au-delà renvoient -32011) - **Traçage d'exécution (debug_trace*)**: Pris en charge (debug_traceTransaction, debug_traceCall, debug_traceBlockByNumber, debug_traceBlockByHash) Méthodes autorisées par chaîne : [Chaînes prises en charge](https://docs.blockvectra.com/en/chains/) ## Testnet Pour obtenir de l'ETH de test pour vos transactions, consultez le [guide du faucet testnet Robinhood Chain](https://docs.blockvectra.com/fr/guides/robinhood-testnet-faucet/). 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](https://docs.blockvectra.com/fr/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":[]}' ``` Réponse attendue : ```json {"jsonrpc":"2.0","id":1,"result":"0xb626"} ``` | Paramètre / Endpoint | Valeur / Modèle | Authentification | |---|---|---| | Chain ID (EIP-155) | `46630` | — | | JSON-RPC (clé dans le chemin) | `POST https://api.blockvectra.com/v1/robinhood_testnet/{api_key}` | Clé API dans le chemin d'URL | | JSON-RPC (clé dans l'en-tête) | `POST https://api.blockvectra.com/v1/robinhood_testnet` | En-tête x-api-key: {api_key} | | WebSocket (clé dans le chemin) | `wss://api.blockvectra.com/v1/robinhood_testnet/{api_key}` | Clé API dans le chemin d'URL | | WebSocket (clé dans l'en-tête) | `wss://api.blockvectra.com/v1/robinhood_testnet` | En-tête x-api-key: {api_key} ou Authorization: Bearer {api_key} | | Abonnements WebSocket | `newHeads, logs` | — | | Base de la Data API | `Pas encore disponible` | — | | Statut public | `GET https://api.blockvectra.com/v1/status` | Non authentifié (public) | ### Paramètres et limites du réseau - **Plage de blocs eth_getLogs**: Max 1000 blocs par requête - **Fenêtre d'état historique**: 1023 blocs récents (les requêtes au-delà renvoient -32011) - **Traçage d'exécution (debug_trace*)**: Pris en charge (debug_traceTransaction, debug_traceCall, debug_traceBlockByNumber, debug_traceBlockByHash) Méthodes autorisées par chaîne : [Chaînes prises en charge](https://docs.blockvectra.com/en/chains/) ## 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](https://docs.blockvectra.com/fr/guides/stocks/). Modèle de démarrage complet : [blockvectra/robinhood-stock-tokens](https://github.com/blockvectra/robinhood-stock-tokens) ## Démarrage et API keys Les nouveaux comptes reçoivent 30,000,000 CU à l'inscription — aucune carte bancaire requise. 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](https://console.blockvectra.com/login/?next=%2Fkeys%2F). Consultez le [guide de démarrage rapide](https://docs.blockvectra.com/fr/quickstart/) 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](https://docs.blockvectra.com/fr/guides/programmatic-signup/). * **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](https://docs.blockvectra.com/fr/guides/ai-agents/). * **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](https://blockvectra.com/fr/pricing/). ## Prochaines étapes * [Parcourir le catalogue des jeux de données](https://blockvectra.com/fr/data/) pour découvrir chaque jeu de données indexé par BlockVectra. * [Consulter le forfait gratuit et les tarifs](https://blockvectra.com/fr/pricing/#free) pour vérifier ce que comprend votre compte. * [Se connecter à la console](https://console.blockvectra.com/login/?next=%2Fkeys%2F) pour créer une API key.