# Guía de integración de Robinhood Chain: clientes RPC, despliegue y eventos

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

Utilice el RPC de Robinhood Chain para comprobaciones de conexión públicas y lecturas autenticadas, o la Data API para conjuntos de datos compatibles de mainnet. Los desarrolladores y agentes de IA utilizan los mismos endpoints; mantenga separadas las solicitudes de mainnet y testnet.

## Tareas que esta guía le ayuda a completar

* [Probar el RPC de Robinhood Chain](#connect-with-viem-or-ethers) con una lectura pública usando viem o ethers, luego use una clave para métodos autenticados.
* [Verificar la conexión RPC de testnet](#testnet) leyendo `eth_chainId` antes de ejecutar operaciones en testnet.
* [Consultar la actividad de acciones tokenizadas](#tokenized-stock-data) con la Data API de mainnet después de verificar la compatibilidad del conjunto de datos; las métricas describen la actividad on-chain, no precios de acciones.

## Acceso a RPC y WebSocket

* **URL de RPC público**: Encuentre el endpoint sin clave, los métodos públicos compatibles y los límites de tasa en la [página de mainnet de Robinhood Chain](https://blockvectra.com/en/chains/robinhood_mainnet/) o en la [página de testnet](https://blockvectra.com/en/chains/robinhood_testnet/).
* **JSON-RPC con una API key**: Utilice los endpoints y ejemplos de curl a continuación. Para logs, consulte la [referencia del método eth\_getLogs](https://docs.blockvectra.com/en/api/json-rpc/methods/eth_getLogs/) y la [guía de límites de rango de bloques](https://docs.blockvectra.com/en/guides/getlogs-block-range/).
* **WebSocket con una API key**: Utilice los endpoints de WebSocket a continuación y siga la [guía de suscripciones WebSocket](https://docs.blockvectra.com/en/guides/websocket-subscriptions/) para `newHeads` y `logs`. El acceso a RPC público es JSON-RPC por HTTP; las conexiones WebSocket requieren una clave.

## Información de la red y endpoints

Cada solicitud a Robinhood Chain identifica explícitamente su red de destino en la ruta de la URL mediante el slug `robinhood_mainnet`. JSON-RPC admite tanto la autenticación por clave en la ruta como mediante el encabezado de solicitud (`x-api-key`), mientras que la Data API ofrece endpoints REST bajo `/v1/data/robinhood_mainnet/`.

Los parámetros y endpoints a continuación reflejan los parámetros de red activos:

| Parámetro / Endpoint | Valor / Plantilla | Autenticación |
|---|---|---|
| Chain ID (EIP-155) | `4663` | — |
| JSON-RPC (clave en la ruta) | `POST https://api.blockvectra.com/v1/robinhood_mainnet/{api_key}` | API key en la ruta de la URL |
| JSON-RPC (clave en el encabezado) | `POST https://api.blockvectra.com/v1/robinhood_mainnet` | Encabezado x-api-key: {api_key} |
| WebSocket (clave en la ruta) | `wss://api.blockvectra.com/v1/robinhood_mainnet/{api_key}` | API key en la ruta de la URL |
| WebSocket (clave en el encabezado) | `wss://api.blockvectra.com/v1/robinhood_mainnet` | Encabezado x-api-key: {api_key} o Authorization: Bearer {api_key} |
| Suscripciones WebSocket | `newHeads, logs` | — |
| Base de Data API | `GET https://api.blockvectra.com/v1/data/robinhood_mainnet/…` | Encabezado x-api-key: {api_key} |
| Estado público | `GET https://api.blockvectra.com/v1/status` | Sin autenticación (público) |

## Conectar con viem o ethers

Los desarrolladores y los Agentes de IA pueden usar la misma configuración del lado del servidor. Use Node.js 24 o posterior, viem 2 o ethers 6, y comience con lecturas públicas. Establezca `BLOCKVECTRA_API_KEY` de forma segura en el entorno para métodos con clave y WebSocket. Mantenga las claves y las URL de RPC que contengan claves fuera del código del navegador, los logs y el control de versiones.

Guarde esto como `network.mjs`. Comience en testnet; establezca `BLOCKVECTRA_CHAIN=robinhood_mainnet` para cambiar a mainnet. Lee `chain_id` y la política de métodos desde [GET /v1/chains](https://api.blockvectra.com/v1/chains). Para lecturas sin clave, use la `public.url` del catálogo y solo los métodos enumerados en `public.methods`; la disponibilidad pública de HTTP no implica acceso por 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');
```

Guarde como `viem-client.mjs`, instale con `npm install viem@2`, y luego ejecute `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());
```

Para ethers, guarde como `ethers-client.mjs`, instale con `npm install ethers@6`, y luego ejecute `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();
```

## Desplegar con Foundry o Hardhat

Financie la cuenta de despliegue con test ETH a través del [faucet de testnet](https://docs.blockvectra.com/en/guides/robinhood-testnet-faucet/) primero; las transacciones de mainnet requieren ETH de mainnet. La [guía oficial de red y despliegue](https://docs.robinhood.com/chain/deploy-smart-contracts/) enumera los chain ID de mainnet y testnet (consultado: 2026-10-07). Las tablas de endpoints en esta página utilizan `/v1/chains`.

Exporte la URL y el chain ID seleccionados desde `network.mjs`. Verifique `eth_sendRawTransaction` contra `methods.allow` y `methods.deny` antes de la difusión.

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

Continúe con el [tutorial compartido de despliegue con Foundry o Hardhat](https://docs.blockvectra.com/en/guides/deploy-contract/) para `Hello.sol`, configuración de herramientas, difusión y comprobaciones de recibos.

## Escuchar eventos de contratos a través de WebSocket

Guarde como `watch-logs.mjs` y establezca `LOG_ADDRESS` en el contrato desplegado o contrato de token que vigila. Ejecute `node watch-logs.mjs`. El código verifica `ws` y `subscriptions` desde `/v1/chains` antes de suscribirse a `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); });
```

Después de iniciar el listener, envíe una transacción `ping()` desde otra terminal utilizando las mismas variables de despliegue exportadas:

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

Persista el último bloque procesado y deduplique por `(blockHash, transactionHash, logIndex)`. Después de reconectarse, recupere los bloques perdidos con solicitudes delimitadas de `eth_getLogs`; reconcilie los logs marcados como `removed` ante una reorganización. Consulte [suscripciones WebSocket](https://docs.blockvectra.com/en/guides/websocket-subscriptions/) y [límites de rango de bloques](https://docs.blockvectra.com/en/guides/getlogs-block-range/).

Para eventos de direcciones entregados a su receptor HTTPS, **GET /v1/push/chains enumera las cadenas compatibles** y la configuración de confirmación; utilice un encabezado `x-api-key`. Siga la [guía de push de webhook](https://docs.blockvectra.com/en/guides/webhook-push/) para suscripciones, verificación de firmas, deduplicación y reproducción. Para consultas de actividad de tokens de acciones en mainnet, continúe con la [guía de acciones](https://docs.blockvectra.com/en/guides/stocks/).

## Ejemplos directos con curl

Puede realizar llamadas JSON-RPC de inmediato utilizando clientes HTTP estándar. Reemplace `{api_key}` con su API key de BlockVectra:

**eth_chainId (Header)**

Consulte el chain ID según EIP-155 utilizando el encabezado de solicitud `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)**

Consulte el número del bloque más reciente pasando su API key en la ruta de la 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":[]}'
```


### Estructura de la respuesta

Las respuestas siguen la especificación JSON-RPC 2.0:

* **Éxito**: Devuelve una estructura de respuesta con `jsonrpc: "2.0"`, el mismo `id` y una cadena `result` que contiene la cantidad codificada en hexadecimal (`eth_chainId` devuelve el chain ID codificado en hexadecimal; `eth_blockNumber` devuelve la altura del bloque más reciente).
* **Métodos no permitidos**: Solicitar un método fuera de los métodos permitidos de la red devuelve el código de error JSON-RPC `-32601` (`method not available`, no facturado).
* **Consultas fuera de la ventana**: Las solicitudes de estado histórico anteriores a la ventana de retención de estado devuelven el código de error JSON-RPC `-32011` (no facturado).
* **Parámetros no válidos**: Los parámetros de solicitud mal formados o no permitidos devuelven el código de error JSON-RPC `-32602` (no facturado).

## Capacidad y política de métodos

Los métodos JSON-RPC disponibles, los límites de rango de bloques para logs y la retención de estado histórico en Robinhood Chain se publican dinámicamente a través de `GET /v1/chains`. El rastreo de ejecución (`debug_trace*`, incluido `debug_traceTransaction`) se rige por la política de métodos de la cadena:

### Parámetros y límites de la red

- **Rango de bloques para eth_getLogs**: Máx. 1000 bloques por solicitud
- **Ventana de estado histórico**: Últimos 900 bloques (consultas posteriores devuelven -32011)
- **Rastreo de ejecución (debug_trace*)**: Compatible (debug_traceTransaction, debug_traceCall, debug_traceBlockByNumber, debug_traceBlockByHash)

Métodos permitidos por cadena: [Cadenas compatibles](https://docs.blockvectra.com/en/chains/)

## Testnet

Para obtener test ETH para transacciones, consulte la [guía del faucet de testnet de Robinhood Chain](https://docs.blockvectra.com/en/guides/robinhood-testnet-faucet/).

Robinhood Chain Testnet (chain ID: 46630) utiliza la misma API key que mainnet en el endpoint `https://api.blockvectra.com/v1/robinhood_testnet`, autenticado mediante el encabezado de solicitud `x-api-key`.

Las solicitudes de testnet utilizan los mismos pesos de CU que mainnet y consumen del mismo saldo y créditos gratuitos. Los métodos JSON-RPC disponibles y la retención de estado histórico en Robinhood Chain Testnet se publican dinámicamente a través de `GET /v1/chains`.

Para ver un inicio en tres pasos ejecutable que lee la testnet sin clave, transmite logs mediante WebSocket y luego traslada la misma clave a mainnet, consulte la [guía de inicio de Robinhood Chain Testnet](https://docs.blockvectra.com/en/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":[]}'
```

Respuesta esperada:

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

| Parámetro / Endpoint | Valor / Plantilla | Autenticación |
|---|---|---|
| Chain ID (EIP-155) | `46630` | — |
| JSON-RPC (clave en la ruta) | `POST https://api.blockvectra.com/v1/robinhood_testnet/{api_key}` | API key en la ruta de la URL |
| JSON-RPC (clave en el encabezado) | `POST https://api.blockvectra.com/v1/robinhood_testnet` | Encabezado x-api-key: {api_key} |
| WebSocket (clave en la ruta) | `wss://api.blockvectra.com/v1/robinhood_testnet/{api_key}` | API key en la ruta de la URL |
| WebSocket (clave en el encabezado) | `wss://api.blockvectra.com/v1/robinhood_testnet` | Encabezado x-api-key: {api_key} o Authorization: Bearer {api_key} |
| Suscripciones WebSocket | `newHeads, logs` | — |
| Base de Data API | `Aún no disponible` | — |
| Estado público | `GET https://api.blockvectra.com/v1/status` | Sin autenticación (público) |

### Parámetros y límites de la red

- **Rango de bloques para eth_getLogs**: Máx. 1000 bloques por solicitud
- **Ventana de estado histórico**: Últimos 1023 bloques (consultas posteriores devuelven -32011)
- **Rastreo de ejecución (debug_trace*)**: Compatible (debug_traceTransaction, debug_traceCall, debug_traceBlockByNumber, debug_traceBlockByHash)

Métodos permitidos por cadena: [Cadenas compatibles](https://docs.blockvectra.com/en/chains/)

## Datos de acciones tokenizadas

En Robinhood Chain, la Data API de BlockVectra proporciona métricas diarias on-chain y metadatos para acciones tokenizadas a través de dos endpoints:

* **Clasificación diaria (`GET /v1/data/robinhood_mainnet/stocks`)**: Clasificación de actividad diaria de acciones tokenizadas para una fecha UTC especificada, ordenada por actividad de transferencias de forma descendente.
* **Consultar una acción tokenizada (`GET /v1/data/robinhood_mainnet/stocks/{token}`)**: Metadatos del contrato del token y hasta 30 días de métricas diarias recientes por dirección del token.

Para ver parámetros de solicitud detallados, estructuras de respuesta (`StockDailyListEnvelope` y `StockTokenEnvelope`), notas de paginación y estimaciones de consumo de CU, consulte la [guía de acciones tokenizadas](https://docs.blockvectra.com/en/guides/stocks/).

Plantilla de inicio completa: [blockvectra/robinhood-stock-tokens](https://github.com/blockvectra/robinhood-stock-tokens)

## Primeros pasos y API keys

Las cuentas nuevas reciben 30,000,000 CU al registrarse — sin tarjeta de crédito.

Puede probar primero el endpoint público sin clave `https://api.blockvectra.com/v1/robinhood_mainnet/public` (solo métodos JSON-RPC de billetera, la Data API requiere clave; los métodos y límites están sujetos a `/v1/chains`); registre una cuenta si necesita un límite de tasa mayor.

* **Consola web**: Regístrese mediante firma de billetera Ethereum y genere una API key en la [consola](https://console.blockvectra.com/login/?next=%2Fkeys%2F). Consulte la [Guía de inicio rápido](https://docs.blockvectra.com/en/quickstart/) para ver los detalles de configuración.
* **Registro programático**: Los agentes de IA autónomos, scripts automatizados y pipelines de CI pueden iniciar sesión y aprovisionar API keys utilizando firmas de billetera Ethereum (EIP-191) sin navegador. Siga la [Guía de registro programático](https://docs.blockvectra.com/en/guides/programmatic-signup/).
* **Agentes de IA**: Los agentes de IA autónomos pueden descubrir las capacidades de Robinhood Chain utilizando el servidor oficial de Model Context Protocol (MCP). Consulte [Conectar agentes de IA a BlockVectra](https://docs.blockvectra.com/en/guides/ai-agents/).
* **Actualización de límites**: Tras recargar, se elimina el límite de llamadas por segundo a nivel de cuenta; cada clave permanece sujeta a los límites de tasa y ráfaga de Compute Units (CU). Para conocer las tarifas actuales y las unidades de facturación, consulte la [página de Precios](https://blockvectra.com/en/pricing/).

## Próximos pasos

* [Explore el directorio de conjuntos de datos](https://blockvectra.com/en/data/) para ver todos los conjuntos de datos indexados por BlockVectra.
* [Consulte el plan gratuito y los precios](https://blockvectra.com/en/pricing/#free) para comprobar lo que incluye su cuenta.
* [Inicie sesión en la consola](https://console.blockvectra.com/login/?next=%2Fkeys%2F) para crear una API key.