Guia de integração da Robinhood Chain: clientes RPC, deploy e eventos

Use o RPC da Robinhood Chain para verificações públicas de conexão e leituras autenticadas, ou a Data API para conjuntos de dados suportados na mainnet. Desenvolvedores e agentes de IA usam os mesmos endpoints; mantenha as requisições para a mainnet e a testnet separadas.

Tarefas que este guia ajuda você a realizar

• Testar o RPC da Robinhood Chain com uma leitura pública usando viem ou ethers e, em seguida, usar uma chave para métodos autenticados.
• Verificar a conexão RPC com a testnet lendo eth_chainId antes de executar operações na testnet.
• Consultar a atividade de ações tokenizadas com a Data API da mainnet após verificar o suporte ao conjunto de dados; as métricas descrevem a atividade on-chain, não cotações de ações.

Acesso a RPC e WebSocket

• URL do RPC público: Encontre o endpoint sem chave, os métodos públicos suportados e os limites de taxa na página da mainnet da Robinhood Chain ou na página da testnet.
• JSON-RPC com uma API key: Use os endpoints e exemplos com curl abaixo. Para logs, consulte a referência do método eth_getLogs e o guia de limites de intervalo de blocos.
• WebSocket com uma API key: Use os endpoints WebSocket abaixo e siga o guia de inscrições WebSocket para newHeads e logs. O acesso ao RPC público é feito via HTTP JSON-RPC; conexões WebSocket exigem uma chave.

Informações da rede e endpoints

Cada requisição para a Robinhood Chain identifica sua rede de destino explicitamente no caminho da URL usando o slug robinhood_mainnet. O JSON-RPC suporta autenticação por chave tanto no caminho da URL quanto no cabeçalho da requisição (x-api-key), enquanto a Data API disponibiliza endpoints REST em /v1/data/robinhood_mainnet/.

Os parâmetros e endpoints abaixo refletem os parâmetros ativos da rede:

Conectar-se com viem ou ethers

Desenvolvedores e agentes de IA podem usar as mesmas configurações no servidor. Utilize Node.js 24 ou superior, viem 2 ou ethers 6 e comece com leituras públicas. Configure BLOCKVECTRA_API_KEY de forma segura no ambiente para métodos autenticados e WebSocket. Mantenha chaves e URLs RPC contendo chaves fora do código do navegador, de logs e de sistemas de controle de versão.

Salve este arquivo como network.mjs. Comece na testnet; defina BLOCKVECTRA_CHAIN=robinhood_mainnet para migrar para a mainnet. Ele lê chain_id e a política de métodos a partir de GET /v1/chains. Para leituras sem chave, use a public.url do catálogo e apenas os métodos listados em public.methods; a disponibilidade HTTP pública não implica acesso via 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');

Salve como viem-client.mjs, instale com npm install viem@2 e execute 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());

Para o ethers, salve como ethers-client.mjs, instale com npm install ethers@6 e execute 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();

Fazer deploy com Foundry ou Hardhat

Financie a conta de deploy com test ETH por meio do faucet da testnet primeiro; transações na mainnet exigem ETH da mainnet. O guia oficial de rede e deploy lista os IDs de cadeia da mainnet e testnet (acessado em: 07/10/2026). As tabelas de endpoints nesta página utilizam /v1/chains.

Exporte a URL e o chain ID selecionados a partir de network.mjs. Verifique eth_sendRawTransaction em relação a methods.allow e methods.deny antes de transmitir.

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

Continue com o tutorial compartilhado de deploy com Foundry ou Hardhat para Hello.sol, configurações das ferramentas, transmissão e verificação de recibos.

Escutar eventos de contratos via WebSocket

Salve como watch-logs.mjs e defina LOG_ADDRESS com o endereço do contrato implantado ou do token que você deseja monitorar. Execute node watch-logs.mjs. O código verifica ws e subscriptions a partir de /v1/chains antes de se inscrever em 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); });

Depois que o listener iniciar, envie uma transação ping() a partir de outro terminal usando as mesmas variáveis de deploy exportadas:

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

Persista o último bloco processado e elimine duplicatas por (blockHash, transactionHash, logIndex). Após reconectar, recupere os blocos perdidos com requisições delimitadas de eth_getLogs; reconcilie os logs marcados como removed em caso de reorganização de cadeia. Consulte inscrições WebSocket e limites de intervalo de blocos.

Para eventos de endereço entregues ao seu receptor HTTPS, GET /v1/push/chains lista as redes suportadas e as configurações de confirmação; use o cabeçalho x-api-key. Siga o guia de envio de webhooks para inscrições, verificação de assinaturas, desduplicação e repetição. Para consultas de atividade de tokens de ações na mainnet, continue com o guia de ações.

Exemplos diretos com curl

Você pode fazer chamadas JSON-RPC imediatamente usando clientes HTTP padrão. Substitua {api_key} pela sua API key da 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":[]}'

Estrutura de resposta

As respostas seguem a especificação JSON-RPC 2.0:

• Sucesso: Retorna um envelope com jsonrpc: "2.0", o mesmo id e uma string result contendo a quantidade codificada em hexadecimal (eth_chainId retorna o ID da rede em hex; eth_blockNumber retorna a altura do bloco mais recente).
• Métodos não permitidos: Solicitar um método fora dos métodos permitidos da rede retorna o código de erro JSON-RPC -32601 (method not available, não tarifado).
• Consultas fora da janela: Requisições de estado histórico anteriores à janela de retenção de estado retornam o código de erro JSON-RPC -32011 (não tarifado).
• Parâmetros inválidos: Parâmetros de requisição malformados ou não permitidos retornam o código de erro JSON-RPC -32602 (não tarifado).

Recursos e política de métodos

Os métodos JSON-RPC disponíveis, os limites de intervalo de blocos para logs e a retenção de estado histórico na Robinhood Chain são publicados dinamicamente via GET /v1/chains. O rastreamento de execução (debug_trace*, incluindo debug_traceTransaction) é regido pela política de métodos da rede:

Testnet

Para obter test ETH para transações, consulte o guia do faucet da testnet da Robinhood Chain.

A Robinhood Chain Testnet (chain ID: 46630) usa a mesma API key da mainnet no endpoint https://api.blockvectra.com/v1/robinhood_testnet, autenticada por meio do cabeçalho de requisição x-api-key.

As requisições na testnet usam os mesmos pesos em CU da mainnet e consomem do mesmo saldo e créditos gratuitos. Os métodos JSON-RPC disponíveis e a retenção de estado histórico na Robinhood Chain Testnet são publicados dinamicamente via GET /v1/chains.

Para um modelo inicial executável em três passos que lê a testnet sem chave, transmite logs via WebSocket e depois migra a mesma chave para a mainnet, consulte o guia de início rápido da testnet da 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":[]}'

Resposta esperada:

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

Dados de ações tokenizadas

Na Robinhood Chain, a BlockVectra Data API fornece métricas diárias on-chain e metadados para ações tokenizadas em dois endpoints:

• Classificação diária (GET /v1/data/robinhood_mainnet/stocks): Classificação diária de atividade de ações tokenizadas para uma data UTC especificada, ordenada por atividade de transferências em ordem decrescente.
• Consultar uma ação tokenizada (GET /v1/data/robinhood_mainnet/stocks/{token}): Metadados do contrato do token e até 30 dias de métricas diárias recentes por endereço do token.

Para parâmetros detalhados de requisição, envelopes de resposta (StockDailyListEnvelope e StockTokenEnvelope), observações sobre paginação e estimativas de consumo de CU, consulte o guia de ações tokenizadas.

Modelo inicial completo: blockvectra/robinhood-stock-tokens

Primeiros passos e chaves de API

Você pode experimentar primeiro o endpoint público sem chave https://api.blockvectra.com/v1/robinhood_mainnet/public (apenas métodos JSON-RPC de carteira; a Data API exige uma chave; métodos e limites estão sujeitos a /v1/chains); cadastre-se para obter uma conta se precisar de limites de taxa maiores.

• Console web: Cadastre-se por meio de assinatura com carteira Ethereum e gere uma API key no Console. Consulte o guia de início rápido para detalhes de configuração.
• Cadastro programático: Agentes autônomos de IA, scripts automatizados e pipelines de CI podem fazer login e provisionar chaves de API usando assinaturas de carteiras Ethereum (EIP-191) sem a necessidade de um navegador. Siga o guia de cadastro programático.
• Agentes de IA: Agentes autônomos de IA podem descobrir os recursos da Robinhood Chain usando o servidor oficial do Model Context Protocol (MCP). Consulte Conectar agentes de IA à BlockVectra.
• Aumentar limites: Após a recarga, o limite de chamadas por segundo em toda a conta é removido; cada chave continua sujeita aos limites de taxa e de pico de Unidades de Computação (CU). Para as tarifas atuais e unidades de cobrança, consulte a página de preços.

Próximos passos

• Navegue pelo diretório de conjuntos de dados para ver todos os conjuntos de dados indexados pela BlockVectra.
• Veja o plano gratuito e os preços para verificar o que sua conta inclui.
• Entre no console para criar uma API key.