# JSON-RPC

> Source: https://docs.blockvectra.com/es/api/json-rpc/

## Visión general

Todas las solicitudes se miden en **Compute Units (CU)** y tienen límites de tasa por API key.

* **Punto de enlace**: `POST /v1/{chain}/{api_key}` (API key en la ruta) o `POST /v1/{chain}` (API key en un encabezado). Para Robinhood Chain, `{chain}` es `robinhood_mainnet`: `https://api.blockvectra.com/v1/robinhood_mainnet`. La misma [API key](https://docs.blockvectra.com/en/quickstart/#1-get-an-api-key) funciona en todas las cadenas compatibles
* **Protocolo**: HTTP `POST`, llamada individual o por lotes
* **Medición**: el costo total en CU de una solicitud cuenta para la capacidad de ráfaga (burst) de la API key en cuanto llega. Toda llamada aceptada que recibe una respuesta se factura según el peso público de CU del método; la [Referencia de errores](https://docs.blockvectra.com/en/errors/) enumera los casos sin facturación. La facturación se liquida por hora (redondeada a la baja en unidades enteras, con el resto transferido al siguiente período, ejecutada \~15 minutos después de finalizar el período)
* **Ethereum**: tiene su propia lista de métodos y una ventana de estado definida por `state_window_blocks` — consulte [Cadenas compatibles → Ethereum](https://docs.blockvectra.com/en/chains/#ethereum).

Para esquemas completos de parámetros, firmas de métodos y pruebas interactivas de solicitudes en todos los métodos, consulte la [Referencia completa](https://docs.blockvectra.com/en/api/json-rpc/reference/). Para control de versiones de rutas, reglas de compatibilidad con versiones anteriores y recomendaciones de SDK, consulte [Control de versiones y compatibilidad de la API](https://docs.blockvectra.com/en/api/versioning/).

Para obtener una API key y enviar la primera solicitud, consulte el [Inicio rápido](https://docs.blockvectra.com/en/quickstart/); también explica cómo enviar la API key y realizar solicitudes por lotes.

## Llamadas comunes

Ejemplos prácticos de llamadas comunes.

### Consultar logs (`eth_getLogs`)

Filtre los logs de un contrato en un rango reciente de bloques — aquí, el evento ERC-20 `Transfer` (topic `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`). Consulte la tabla [Reglas de medición en CU](#cu-metering-rules) a continuación para conocer el peso actual en CU de `eth_getLogs`; un rango mayor que el `max_logs_block_range` de la cadena (de `GET /v1/chains`) se rechaza con `-32602`.

**cURL**

```bash
export BLOCKVECTRA_API_KEY=rgw_your_api_key

curl -X POST "https://api.blockvectra.com/v1/robinhood_mainnet" \
  -H 'Content-Type: application/json' \
  -H "x-api-key: $BLOCKVECTRA_API_KEY" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getLogs",
    "params": [{
      "fromBlock": "0x45a2409",
      "toBlock": "0x45a2609",
      "address": "0x1111111111111111111111111111111111111111",
      "topics": ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"]
    }],
    "id": 1
  }'
```


  **TypeScript**

```ts
// npx tsx example.mts
import { createPublicClient, http } from 'viem'

const apiKey = process.env.BLOCKVECTRA_API_KEY!
const client = createPublicClient({
  transport: http('https://api.blockvectra.com/v1/robinhood_mainnet', { fetchOptions: { headers: { 'x-api-key': apiKey } } }),
})

const TRANSFER_TOPIC = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
const latest = await client.getBlockNumber()

const logs = await client.getLogs({
  address: '0x1111111111111111111111111111111111111111',
  topics: [TRANSFER_TOPIC],
  fromBlock: latest > 100n ? latest - 100n : 0n,
  toBlock: latest,
})
console.log(logs.length)
```


  **Python**

```python
# uv run --with web3 python example.py
import os
from web3 import Web3

api_key = os.environ["BLOCKVECTRA_API_KEY"]
w3 = Web3(
    Web3.HTTPProvider(
        "https://api.blockvectra.com/v1/robinhood_mainnet",
        request_kwargs={"headers": {"Content-Type": "application/json", "x-api-key": api_key}},
    )
)

TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
latest = w3.eth.block_number

logs = w3.eth.get_logs(
    {
        "address": "0x1111111111111111111111111111111111111111",
        "topics": [TRANSFER_TOPIC],
        "fromBlock": max(latest - 100, 0),
        "toBlock": latest,
    }
)
print(len(logs))
```


  **Go**

```go
// go mod init example && go get github.com/ethereum/go-ethereum && go mod tidy && go run .
package main

import (
	"context"
	"fmt"
	"log"
	"math/big"
	"os"

	"github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/ethclient"
	"github.com/ethereum/go-ethereum/rpc"
)

var transferTopic = common.HexToHash(
	"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
)

func main() {
	apiKey := os.Getenv("BLOCKVECTRA_API_KEY")
	ctx := context.Background()

	rpcClient, err := rpc.DialOptions(ctx, "https://api.blockvectra.com/v1/robinhood_mainnet", rpc.WithHeader("x-api-key", apiKey))
	if err != nil {
		log.Fatal(err)
	}
	client := ethclient.NewClient(rpcClient)

	latest, err := client.BlockNumber(ctx)
	if err != nil {
		log.Fatal(err)
	}
	from := uint64(0)
	if latest > 100 {
		from = latest - 100
	}

	address := common.HexToAddress("0x1111111111111111111111111111111111111111")
	logs, err := client.FilterLogs(ctx, ethereum.FilterQuery{
		FromBlock: new(big.Int).SetUint64(from),
		ToBlock:   new(big.Int).SetUint64(latest),
		Addresses: []common.Address{address},
		Topics:    [][]common.Hash{{transferTopic}},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(len(logs))
}
```


  **Rust**

Añada a `Cargo.toml`:

```toml
[dependencies]
alloy = { version = "1", features = ["provider-http", "rpc-types"] }
tokio = { version = "1", features = ["full"] }
eyre = "0.6"
reqwest = { version = "0.13", default-features = false }
```

```rust
// cargo run
use alloy::primitives::{address, b256};
use alloy::providers::{Provider, ProviderBuilder};
use alloy::rpc::types::Filter;

const TRANSFER_TOPIC: alloy::primitives::B256 =
    b256!("ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef");

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let api_key = std::env::var("BLOCKVECTRA_API_KEY").unwrap_or_default();
    let rpc_url: reqwest::Url = "https://api.blockvectra.com/v1/robinhood_mainnet".parse()?;

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-api-key", api_key.parse()?);
    let http_client = reqwest::Client::builder().default_headers(headers).build()?;

    let provider = ProviderBuilder::new().connect_reqwest(http_client, rpc_url);

    let latest = provider.get_block_number().await?;
    let from = latest.saturating_sub(100);

    let filter = Filter::new()
        .address(address!("1111111111111111111111111111111111111111"))
        .event_signature(TRANSFER_TOPIC)
        .from_block(from)
        .to_block(latest);

    let logs = provider.get_logs(&filter).await?;
    println!("{}", logs.len());

    Ok(())
}
```


### Rastrear una transacción (`debug_traceTransaction`)

Rastree las llamadas internas de una transacción con `callTracer`. Consulte la tabla [Reglas de medición en CU](#cu-metering-rules) a continuación para conocer el peso actual en CU de `debug_traceTransaction`. Al igual que otros métodos de lectura de estado, se rechaza si el bloque de destino está fuera de la ventana de estado reciente de la cadena (`-32011`). El tamaño de la ventana es `state_window_blocks` de la cadena (de `GET /v1/chains`). En las cadenas que ofrecen trazas, use la [Data API](https://docs.blockvectra.com/en/api/data/) para trazas históricas.

**cURL**

```bash
export BLOCKVECTRA_API_KEY=rgw_your_api_key

curl -X POST "https://api.blockvectra.com/v1/robinhood_mainnet" \
  -H 'Content-Type: application/json' \
  -H "x-api-key: $BLOCKVECTRA_API_KEY" \
  -d '{
    "jsonrpc": "2.0",
    "method": "debug_traceTransaction",
    "params": ["0xYOUR_TRANSACTION_HASH", {"tracer": "callTracer"}],
    "id": 1
  }'
```


  **TypeScript**

```ts
// npx tsx example.mts
import { createPublicClient, http } from 'viem'

const apiKey = process.env.BLOCKVECTRA_API_KEY!
const client = createPublicClient({
  transport: http('https://api.blockvectra.com/v1/robinhood_mainnet', { fetchOptions: { headers: { 'x-api-key': apiKey } } }),
})

const txHash = '0xYOUR_TRANSACTION_HASH'
const trace = await client.request({
  method: 'debug_traceTransaction' as any,
  params: [txHash, { tracer: 'callTracer' }] as any,
})
console.log(trace)
```


  **Python**

```python
# uv run --with web3 python example.py
import os
from web3 import Web3

api_key = os.environ["BLOCKVECTRA_API_KEY"]
w3 = Web3(
    Web3.HTTPProvider(
        "https://api.blockvectra.com/v1/robinhood_mainnet",
        request_kwargs={"headers": {"Content-Type": "application/json", "x-api-key": api_key}},
    )
)

tx_hash = "0xYOUR_TRANSACTION_HASH"
trace = w3.manager.request_blocking(
    "debug_traceTransaction", [tx_hash, {"tracer": "callTracer"}]
)
print(trace)
```


  **Go**

```go
// go mod init example && go get github.com/ethereum/go-ethereum && go mod tidy && go run .
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"os"

	"github.com/ethereum/go-ethereum/rpc"
)

func main() {
	apiKey := os.Getenv("BLOCKVECTRA_API_KEY")
	ctx := context.Background()

	client, err := rpc.DialOptions(ctx, "https://api.blockvectra.com/v1/robinhood_mainnet", rpc.WithHeader("x-api-key", apiKey))
	if err != nil {
		log.Fatal(err)
	}

	txHash := "0xYOUR_TRANSACTION_HASH"
	var trace json.RawMessage
	err = client.CallContext(ctx, &trace, "debug_traceTransaction", txHash, map[string]string{
		"tracer": "callTracer",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(trace))
}
```


  **Rust**

Añada a `Cargo.toml`:

```toml
[dependencies]
alloy = { version = "1", features = ["provider-http", "rpc-types"] }
tokio = { version = "1", features = ["full"] }
eyre = "0.6"
reqwest = { version = "0.13", default-features = false }
serde_json = "1"
```

```rust
// cargo run
use alloy::providers::{Provider, ProviderBuilder};
use serde_json::json;

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let api_key = std::env::var("BLOCKVECTRA_API_KEY").unwrap_or_default();
    let rpc_url: reqwest::Url = "https://api.blockvectra.com/v1/robinhood_mainnet".parse()?;

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-api-key", api_key.parse()?);
    let http_client = reqwest::Client::builder().default_headers(headers).build()?;

    let provider = ProviderBuilder::new().connect_reqwest(http_client, rpc_url);

    let tx_hash = "0xYOUR_TRANSACTION_HASH";
    let trace: serde_json::Value = provider
        .client()
        .request("debug_traceTransaction", (tx_hash, json!({ "tracer": "callTracer" })))
        .await?;
    println!("{trace}");

    Ok(())
}
```


## Reglas de medición en CU

Peso en Compute Units (CU) de cada método JSON-RPC.

| Método | Peso (CU) |
| --- | --- |
| `eth_blockNumber` | 1 |
| `eth_chainId` | 1 |
| `eth_getBlockByNumber` | 5 |
| `eth_blobBaseFee` | 10 |
| `eth_feeHistory` | 10 |
| `eth_gasPrice` | 10 |
| `eth_getBalance` | 10 |
| `eth_getBlockByHash` | 10 |
| `eth_getBlockReceipts` | 10 |
| `eth_getBlockTransactionCountByHash` | 10 |
| `eth_getBlockTransactionCountByNumber` | 10 |
| `eth_getCode` | 10 |
| `eth_getHeaderByHash` | 10 |
| `eth_getHeaderByNumber` | 10 |
| `eth_getProof` | 10 |
| `eth_getRawTransactionByBlockHashAndIndex` | 10 |
| `eth_getRawTransactionByBlockNumberAndIndex` | 10 |
| `eth_getRawTransactionByHash` | 10 |
| `eth_getStorageAt` | 10 |
| `eth_getTransactionByBlockHashAndIndex` | 10 |
| `eth_getTransactionByBlockNumberAndIndex` | 10 |
| `eth_getTransactionByHash` | 10 |
| `eth_getTransactionCount` | 10 |
| `eth_getTransactionReceipt` | 10 |
| `eth_getUncleByBlockHashAndIndex` | 10 |
| `eth_getUncleByBlockNumberAndIndex` | 10 |
| `eth_getUncleCountByBlockHash` | 10 |
| `eth_getUncleCountByBlockNumber` | 10 |
| `eth_maxPriorityFeePerGas` | 10 |
| `eth_syncing` | 10 |
| `net_version` | 10 |
| `web3_clientVersion` | 10 |
| `web3_sha3` | 10 |
| `eth_call` | 15 |
| `eth_createAccessList` | 20 |
| `eth_estimateGas` | 20 |
| `eth_simulateV1` | 20 |
| `eth_getLogs` | 30 |
| `eth_sendRawTransaction` | 30 |
| `debug_traceBlockByHash` | 100 |
| `debug_traceBlockByNumber` | 100 |
| `debug_traceCall` | 100 |
| `debug_traceTransaction` | 100 |
| `trace_block` | 100 |
| `trace_call` | 100 |
| `trace_get` | 100 |
| `trace_replayTransaction` | 100 |
| `trace_transaction` | 100 |

## Política de métodos

Los métodos disponibles varían según la cadena; la lista de cada cadena aparece a continuación, y [Cadenas compatibles](https://docs.blockvectra.com/en/chains/) presenta las funciones restantes. Solo se pueden llamar los métodos que coincidan con un nombre o patrón permitido; cualquier otro método devuelve `-32601 method not available`.

**Permitidos en todas las cadenas siguientes:**

- `eth_blockNumber`
- `eth_call`
- `eth_chainId`
- `eth_estimateGas`
- `eth_feeHistory`
- `eth_gasPrice`
- `eth_getBalance`
- `eth_getBlockByHash`
- `eth_getBlockByNumber`
- `eth_getBlockReceipts`
- `eth_getBlockTransactionCountByHash`
- `eth_getBlockTransactionCountByNumber`
- `eth_getCode`
- `eth_getLogs`
- `eth_getStorageAt`
- `eth_getTransactionByBlockHashAndIndex`
- `eth_getTransactionByBlockNumberAndIndex`
- `eth_getTransactionByHash`
- `eth_getTransactionCount`
- `eth_getTransactionReceipt`
- `eth_maxPriorityFeePerGas`
- `eth_syncing`
- `net_version`
- `web3_clientVersion`

### Arbitrum One

Rango máximo de bloques de eth_getLogs: 1,000 bloques; Ventana de estado: 6,000 bloques

**También permitidos:**

- `debug_traceBlockByHash`
- `debug_traceBlockByNumber`
- `debug_traceCall`
- `debug_traceTransaction`
- `eth_blobBaseFee`
- `eth_createAccessList`
- `eth_getHeaderByHash`
- `eth_getHeaderByNumber`
- `eth_getProof`
- `eth_getRawTransactionByBlockHashAndIndex`
- `eth_getRawTransactionByBlockNumberAndIndex`
- `eth_getRawTransactionByHash`
- `eth_getUncleByBlockHashAndIndex`
- `eth_getUncleByBlockNumberAndIndex`
- `eth_getUncleCountByBlockHash`
- `eth_getUncleCountByBlockNumber`
- `eth_sendRawTransaction`
- `eth_simulateV1`
- `web3_sha3`

### Base

Rango máximo de bloques de eth_getLogs: 1,000 bloques; Ventana de estado: 10,000 bloques

**También permitidos:**

- `eth_blobBaseFee`
- `eth_createAccessList`
- `eth_getProof`
- `eth_simulateV1`
- `eth_getRawTransactionByHash`
- `eth_getRawTransactionByBlockHashAndIndex`
- `eth_getRawTransactionByBlockNumberAndIndex`
- `eth_getUncleCountByBlockNumber`
- `eth_getUncleCountByBlockHash`
- `eth_getUncleByBlockNumberAndIndex`
- `eth_getUncleByBlockHashAndIndex`
- `eth_getHeaderByNumber`
- `eth_getHeaderByHash`
- `eth_sendRawTransaction`
- `web3_sha3`

### BNB Smart Chain

Rango máximo de bloques de eth_getLogs: 1,000 bloques; Ventana de estado: 100 bloques

**También permitidos:**

- `eth_sendRawTransaction`

### Ethereum

Rango máximo de bloques de eth_getLogs: 1,000 bloques; Ventana de estado: 250,000 bloques

**También permitidos:**

- `debug_traceBlockByHash`
- `debug_traceBlockByNumber`
- `debug_traceCall`
- `debug_traceTransaction`
- `eth_blobBaseFee`
- `eth_createAccessList`
- `eth_getProof`
- `eth_sendRawTransaction`
- `trace_block`
- `trace_call`
- `trace_get`
- `trace_replayTransaction`
- `trace_transaction`
- `web3_sha3`

### Ethereum Sepolia

Rango máximo de bloques de eth_getLogs: 1,000 bloques; Ventana de estado: —

**También permitidos:**

- `eth_blobBaseFee`
- `eth_createAccessList`
- `eth_getProof`
- `eth_sendRawTransaction`
- `web3_sha3`

### HyperEVM

El envío de transacciones aún no es compatible en esta cadena (`eth_sendRawTransaction` devuelve `-32601` `method_not_allowed`); los métodos de lectura funcionan con normalidad.

Rango máximo de bloques de eth_getLogs: 1,000 bloques; Ventana de estado: —

### Polygon

Rango máximo de bloques de eth_getLogs: 1,000 bloques; Ventana de estado: 126 bloques

**También permitidos:**

- `debug_traceBlockByHash`
- `debug_traceBlockByNumber`
- `debug_traceCall`
- `debug_traceTransaction`
- `eth_blobBaseFee`
- `eth_createAccessList`
- `eth_getHeaderByHash`
- `eth_getHeaderByNumber`
- `eth_getProof`
- `eth_getRawTransactionByBlockHashAndIndex`
- `eth_getRawTransactionByBlockNumberAndIndex`
- `eth_getRawTransactionByHash`
- `eth_getUncleByBlockHashAndIndex`
- `eth_getUncleByBlockNumberAndIndex`
- `eth_getUncleCountByBlockHash`
- `eth_getUncleCountByBlockNumber`
- `eth_sendRawTransaction`
- `eth_simulateV1`
- `web3_sha3`

### Robinhood Chain

Rango máximo de bloques de eth_getLogs: 1,000 bloques; Ventana de estado: 900 bloques

**También permitidos:**

- `eth_blobBaseFee`
- `eth_createAccessList`
- `eth_getProof`
- `eth_simulateV1`
- `eth_getRawTransactionByHash`
- `eth_getRawTransactionByBlockHashAndIndex`
- `eth_getRawTransactionByBlockNumberAndIndex`
- `eth_getUncleCountByBlockNumber`
- `eth_getUncleCountByBlockHash`
- `eth_getUncleByBlockNumberAndIndex`
- `eth_getUncleByBlockHashAndIndex`
- `eth_getHeaderByNumber`
- `eth_getHeaderByHash`
- `eth_sendRawTransaction`
- `web3_sha3`
- `debug_traceTransaction`
- `debug_traceCall`
- `debug_traceBlockByNumber`
- `debug_traceBlockByHash`

### Robinhood Chain Testnet

Rango máximo de bloques de eth_getLogs: 1,000 bloques; Ventana de estado: 1,023 bloques

**También permitidos:**

- `debug_traceBlockByHash`
- `debug_traceBlockByNumber`
- `debug_traceCall`
- `debug_traceTransaction`
- `eth_blobBaseFee`
- `eth_createAccessList`
- `eth_getHeaderByHash`
- `eth_getHeaderByNumber`
- `eth_getProof`
- `eth_getRawTransactionByBlockHashAndIndex`
- `eth_getRawTransactionByBlockNumberAndIndex`
- `eth_getRawTransactionByHash`
- `eth_getUncleByBlockHashAndIndex`
- `eth_getUncleByBlockNumberAndIndex`
- `eth_getUncleCountByBlockHash`
- `eth_getUncleCountByBlockNumber`
- `eth_sendRawTransaction`
- `eth_simulateV1`
- `web3_sha3`

**Límites**:

* **Lote**: máximo 100 llamadas por solicitud; también limitado por la capacidad de ráfaga de CU de la API key, como se describe a continuación.
* **Cuerpo de la solicitud**: máximo 2 MiB
* **Ráfaga de CU (burst)**: cada API key tiene un depósito de CU (reposición `cu_per_sec`, capacidad `burst_cu` — los valores predeterminados son 400 CU/s y ráfaga de 1,600 CU; mostrado por API key en la tabla Keys de la consola). Una única solicitud —incluido un lote JSON-RPC completo— cuyo total de CU supere la capacidad de ráfaga de la API key se rechaza con `-32022 request_exceeds_burst` (`request cost <N> CU exceeds burst capacity <M> CU`); divídala en lotes más pequeños.

## Códigos de error

Consulte la [Referencia de errores](https://docs.blockvectra.com/en/errors/) para ver cada código de error, si se factura y qué acción tomar.

## Referencia OpenAPI completa

Consulte la [Referencia OpenAPI completa](https://docs.blockvectra.com/en/api/json-rpc/reference/) para ver la especificación completa legible por máquina, con todas las firmas de métodos, esquemas de solicitud y respuesta, y detalles de parámetros presentados de forma interactiva.