> ## Documentation Index
> Fetch the complete documentation index at: https://docs.solanatracker.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Tablas de búsqueda de direcciones de Solana con RPC

> Encuentra tablas de búsqueda de Solana por autoridad, cuenta o mint. Selecciona tablas para una transacción y revisa la cobertura y el ahorro estimado.

Las tablas de búsqueda de direcciones permiten que una transacción de Solana haga referencia a cuentas por su índice en la tabla. Usa los métodos RPC de Ridge para encontrar tablas que contengan las cuentas de tu transacción y elige un conjunto antes de construir el mensaje.

* LUTs cuya autoridad es una wallet.
* LUTs que contienen una cuenta o un mint de token.
* LUTs que contienen todas las cuentas de un conjunto.
* Un conjunto de LUTs de mejor esfuerzo para reducir el tamaño de la transacción.

> [!NOTE]
>
> Cada método RPC de tablas de búsqueda cuesta **1 crédito** por llamada.

## Cuándo usar estos métodos

Usa estos métodos antes de construir una transacción versionada o para ver en qué tablas existentes aparece una cuenta.

| Objetivo | Método |
| - | - |
| Ver las LUTs que controla una wallet | [`getLookupTablesByAuthority`](https://docs.solanatracker.io/es/solana-rpc/http/getlookuptablesbyauthority) |
| Encontrar LUTs que contienen una cuenta | [`getLookupTablesByAccount`](https://docs.solanatracker.io/es/solana-rpc/http/getlookuptablesbyaccount) |
| Encontrar LUTs que contienen un mint de token | [`getLookupTablesByMint`](https://docs.solanatracker.io/es/solana-rpc/http/getlookuptablesbymint) |
| Encontrar LUTs que cubren varias cuentas | [`getLookupTablesByAccounts`](https://docs.solanatracker.io/es/solana-rpc/http/getlookuptablesbyaccounts) |

> [!TIP]
>
> Empieza con `getLookupTablesByAccounts` si tu objetivo es optimizar la transacción. Usa los métodos de una sola cuenta para explorar dónde aparece una cuenta o un mint concretos.

## Endpoint RPC

Todos los ejemplos usan JSON-RPC 2.0 sobre HTTP:

```bash theme={null}
https://rpc-mainnet.solanatracker.io/?api_key=YOUR_API_KEY
```

## Encuentra LUTs por autoridad

Consulta `getLookupTablesByAuthority` para obtener las tablas cuya autoridad es una wallet.

```bash cURL theme={null}
curl "https://rpc-mainnet.solanatracker.io/?api_key=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getLookupTablesByAuthority",
    "params": [{
      "authority": "WalletPubkey...",
      "limit": 100,
      "cursor": null,
      "mintsOnly": false,
      "includeDeactivated": false
    }]
  }'
```

```javascript JavaScript theme={null}
const rpcUrl = "https://rpc-mainnet.solanatracker.io/?api_key=YOUR_API_KEY";

const res = await fetch(rpcUrl, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "getLookupTablesByAuthority",
    params: [{
      authority: "WalletPubkey...",
      limit: 100,
      cursor: null,
      mintsOnly: false,
      includeDeactivated: false
    }]
  })
});

const { result } = await res.json();

for (const lut of result.lookupTables) {
  console.log(`${lut.pubkey}: ${lut.addressCount} addresses`);
}
```

La respuesta está paginada:

```json theme={null}
{
  "lookupTables": [
    {
      "pubkey": "LUTPubkey...",
      "authority": "WalletPubkey...",
      "deactivationSlot": 18446744073709551615,
      "addressCount": 12,
      "addresses": ["Account1...", "Account2..."],
      "mints": ["Mint1..."],
      "slot": 423867852
    }
  ],
  "nextCursor": "LUTPubkey...",
  "hasMore": false,
  "count": 1
}
```

`deactivationSlot` usa `18446744073709551615` para indicar una LUT activa.

## Encuentra LUTs que contienen una cuenta

Usa `getLookupTablesByAccount` cuando ya conoces una cuenta que aparecerá en una transacción y quieres encontrar LUTs que la contengan.

```bash theme={null}
curl "https://rpc-mainnet.solanatracker.io/?api_key=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getLookupTablesByAccount",
    "params": [{
      "account": "SomeAccountPubkey...",
      "owner": null,
      "limit": 100,
      "cursor": null
    }]
  }'
```

Los resultados con coincidencias incluyen metadatos para optimizar la transacción:

| Campo | Significado |
| - | - |
| `addressIndex` | Posición de la cuenta coincidente en la LUT |
| `matchedAccounts` | Cuentas de tu consulta encontradas en esta LUT |
| `matchedAddressIndices` | Índices de la LUT de las cuentas coincidentes |
| `estimatedBytesSaved` | Bytes aproximados que se ahorran al referenciar las cuentas coincidentes a través de la LUT |

## Encuentra LUTs que contienen un mint

`getLookupTablesByMint` sigue el mismo patrón de búsqueda que `getLookupTablesByAccount`, pero el parámetro se llama `mint`.

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getLookupTablesByMint",
  "params": [{
    "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "limit": 100
  }]
}
```

Úsalo cuando una transacción gira en torno a un token y quieres descubrir LUTs que ya contengan la dirección del mint.

## Encuentra LUTs para un conjunto completo de cuentas

`getLookupTablesByAccounts` tiene dos modos: intersección y mejor conjunto.

### Modo intersección

El modo intersección devuelve las LUTs que contienen **todas** las cuentas que indicas. Úsalo cuando necesitas una sola tabla que cubra el conjunto completo.

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getLookupTablesByAccounts",
  "params": [{
    "accounts": ["AccountA...", "AccountB..."],
    "owner": null,
    "limit": 100,
    "cursor": null
  }]
}
```

### Modo mejor conjunto

El modo mejor conjunto selecciona tablas que cubren las cuentas indicadas y reducen el tamaño del mensaje de la transacción.

Define `bestSet: true` y pasa la lista completa de cuentas que necesita tu transacción:

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getLookupTablesByAccounts",
  "params": [{
    "accounts": ["AccountA...", "AccountB...", "AccountC..."],
    "bestSet": true,
    "maxLookupTables": 8,
    "candidateLimit": 5000,
    "perAccountLimit": 500
  }]
}
```

La respuesta indica qué cubren las LUTs seleccionadas:

```json theme={null}
{
  "lookupTables": [
    {
      "pubkey": "LUT1...",
      "matchedAccounts": ["AccountA...", "AccountB..."],
      "matchedAddressIndices": [3, 17],
      "estimatedBytesSaved": 62
    }
  ],
  "coveredAccounts": ["AccountA...", "AccountB..."],
  "uncoveredAccounts": ["AccountC..."],
  "estimatedBytesSaved": 62,
  "count": 1
}
```

### Ajustes del mejor conjunto

| Parámetro | Valor por defecto | Úsalo cuando |
| - | - | - |
| `maxLookupTables` | `8` | Quieres limitar cuántas LUTs usa tu transacción |
| `candidateLimit` | `5000` | Necesitas limitar el total de tablas candidatas consideradas |
| `perAccountLimit` | `500` | Una cuenta aparece en demasiadas LUTs y la búsqueda de candidatas es demasiado amplia |

Empieza con los valores por defecto. Ajústalos solo después de medir la cobertura devuelta, el ahorro estimado y el tiempo de la solicitud.

## Ejemplo: elige LUTs antes de construir una transacción

El flujo habitual es:

1. Reúne las cuentas a las que hará referencia tu transacción.
2. Llama a `getLookupTablesByAccounts` con `bestSet: true`.
3. Añade las LUTs devueltas a tu constructor de transacciones.
4. Deja `uncoveredAccounts` como claves de cuenta normales.

```javascript theme={null}
const accounts = [
  "AccountA...",
  "AccountB...",
  "AccountC..."
];

const { result } = await fetch(
  "https://rpc-mainnet.solanatracker.io/?api_key=YOUR_API_KEY",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: 1,
      method: "getLookupTablesByAccounts",
      params: [{
        accounts,
        bestSet: true,
        maxLookupTables: 8
      }]
    })
  }
).then(r => r.json());

console.log("Use LUTs:", result.lookupTables.map(lut => lut.pubkey));
console.log("Covered:", result.coveredAccounts);
console.log("Still inline:", result.uncoveredAccounts);
console.log("Estimated bytes saved:", result.estimatedBytesSaved);
```

## Consejos prácticos

* Usa `bestSet: true` para optimizar el tamaño de la transacción, no para hacer una búsqueda exhaustiva.
* Usa `owner` cuando solo confías en las LUTs que controla una autoridad concreta o solo te interesan esas.
* Usa `mintsOnly` en las búsquedas por autoridad cuando construyas una UX centrada en tokens y no necesites todas las direcciones almacenadas.
* Trata `estimatedBytesSaved` como una señal de planificación y simula igualmente la transacción final.
* Mantén la lógica de paginación en las búsquedas por autoridad, cuenta y mint. Las cuentas populares pueden aparecer en muchas LUTs.

> [card] [getLookupTablesByAccounts](https://docs.solanatracker.io/es/solana-rpc/http/getlookuptablesbyaccounts.md)
>
> Encuentra LUTs para varias cuentas u obtén el conjunto de LUTs que mejor se ajusta.

> [card] [Créditos y límites](https://docs.solanatracker.io/es/solana-rpc/credits-and-rate-limits.md)
>
> Revisa cuántos créditos cuesta cada llamada RPC y los límites de cada plan.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.