> ## Documentation Index > Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt > Use this file to discover all available pages before exploring further. # preconfSubscribe > Usa preconfSubscribe para transmitir transacciones de Solana antes de convertirlas en shreds: las preconfirmaciones de Helius incluyen el estado de ejecución y las preconfirmaciones de BAM llegan antes de la ejecución. Inicia una suscripción a [Preconfirmations](/docs/es/pre-confirmations/overview): transacciones entregadas antes de agruparse en entradas y convertirse en shreds. Esta es la señal de transacción con menor latencia que ofrece Helius. Una suscripción transmite tanto las preconfirmaciones de Helius, emitidas en el instante en que el líder ejecuta la transacción e incluyen su estado de ejecución, como las [preconfirmaciones de BAM](/docs/es/pre-confirmations/overview#preconfirmaciones-de-bam), emitidas cuando el validador se compromete a ejecutarla; configura `includeBam: false` para recibir solo preconfirmaciones de Helius. ## Endpoints `preconfSubscribe` se proporciona desde el endpoint de [Gatekeeper](/docs/es/gatekeeper/overview) de Helius: * `wss://beta.helius-rpc.com/?api-key=` El nombre de host `beta` hace referencia al despliegue de Gatekeeper, no al nivel de madurez de Preconfirmations. Se convertirá en el endpoint estándar a medida que el tráfico migre a Gatekeeper. El flujo no es continuo. La cobertura aumenta según la proporción del stake de la red que reenvía datos a Helius o ejecuta BAM, así que habrá slots sin mensajes. Gestiona estas interrupciones correctamente. Consulta [Cobertura](/docs/es/pre-confirmations/overview#cobertura). ## Autorizaciones Tu clave de API de Helius, enviada como parámetro de consulta `api-key`. Requiere un plan Professional o superior. ## Cuerpo Opcional. Omite `params` para recibir todas las transacciones de Helius y BAM. Para limitar el flujo, pasa un objeto de filtro como primer elemento. El filtrado ocurre en el servidor, por lo que solo pagas y recibes las transacciones que te interesan. Todos los campos son opcionales. La ausencia de un campo significa "sin restricción" para ese predicado, por lo que un filtro vacío coincide con todas las transacciones de ambas fuentes. Los campos configurados se combinan con **AND** y se evalúan en el orden `includeBam` → `failed` → `regionInclude` → `accountExclude` → `accountRequired` → `accountInclude`. `false` descarta las preconfirmaciones de BAM para que recibas solo preconfirmaciones de Helius. `true`, al igual que omitir el campo, conserva ambas fuentes. `true` devuelve solo las transacciones fallidas (revertidas); `false` devuelve solo las transacciones correctas. Cualquiera de los dos valores excluye las transacciones de Helius con estado desconocido. Omite el campo para recibir todos los estados. Las preconfirmaciones con estado desconocido se siguen entregando si coinciden con los filtros de fuente, región y cuenta. Si no está vacío, la transacción debe originarse en **una de** estas [regiones](#códigos-de-región). Cuando se configura este campo, se descartan las transacciones sin información de región. Si no está vacío, la transacción debe hacer referencia a **al menos una** de estas cuentas (claves públicas en base58). El límite es de 500 entradas. La transacción se descarta si hace referencia a **cualquiera** de estas cuentas. Tiene prioridad sobre `accountInclude`. El límite es de 500 entradas. La transacción debe hacer referencia a **todas** estas cuentas. El límite es de 500 entradas. Un valor de cuenta no válido o un código de región no reconocido devuelve el error JSON-RPC `-32602` (parámetros no válidos). Los filtros de cuenta no solo coinciden con las claves de cuenta estáticas de la transacción. Helius resuelve las [tablas de consulta de direcciones](/docs/es/glossary#tabla-de-consulta-de-direcciones-alt) v0 en el servidor, por lo que `accountInclude`, `accountExclude` e `accountRequired` también coinciden con las cuentas que una transacción carga mediante una ALT. ### Códigos de región | Código | Ubicación | Código | Ubicación | | ------ | -------------- | ------ | ------------------ | | `slc` | Salt Lake City | `tyo` | Tokio | | `fra` | Fráncfort | `ams` | Ámsterdam | | `lon` | Londres | `dal` | Dallas | | `pit` | Pittsburgh | `dub` | Dublín | | `sgp` | Singapur | `mia` | Miami | | `ewr` | Newark | `lax` | Los Ángeles | | `iad` | Ashburn | `sea` | Seattle | | `hkg` | Hong Kong | `sqq` | Šiauliai, Lituania | En las preconfirmaciones de Helius, la región indica dónde Helius recibió la transacción. En las preconfirmaciones de BAM, indica el endpoint regional de BAM que emitió la preconfirmación, no dónde Helius la recibió. Los endpoints de BAM de Singapur y Dallas se asignan a `sgp` e `dal`. ## Respuesta Id. de la suscripción (necesario para cancelarla) ```json Request theme={"system"} { "jsonrpc": "2.0", "id": 1, "method": "preconfSubscribe", "params": [ { "failed": false, "regionInclude": ["ewr", "fra"], "accountInclude": ["9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM"] } ] } ``` ```json Helius only theme={"system"} { "jsonrpc": "2.0", "id": 1, "method": "preconfSubscribe", "params": [{ "includeBam": false }] } ``` ```javascript JavaScript theme={"system"} const WebSocket = require('ws'); const ws = new WebSocket('wss://beta.helius-rpc.com/?api-key='); ws.on('open', () => { ws.send(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'preconfSubscribe' // Helius and BAM preconfirmations by default // Optional filter: // params: [{ failed: false, accountInclude: ['9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM'] }] // Helius preconfirmations only: // params: [{ includeBam: false }] })); setInterval(() => ws.ping(), 30_000); }); ws.on('message', (data, isBinary) => { // The subscribe acknowledgement arrives as a JSON text frame if (!isBinary) { const msg = JSON.parse(data.toString()); if (msg.id === 1) console.log('Subscribed, ID:', msg.result); return; } // Notifications arrive as binary frames: // version (u8) | slot (u64 LE) | tx_index (u64 LE) | status (u8) | transaction bytes const buf = Buffer.from(data); const version = buf.readUInt8(0); if (version !== 1) return; // unknown schema version; update your decoder const slot = buf.readBigUInt64LE(1); const txIndex = buf.readBigUInt64LE(9); // always 0 for BAM preconfirmations const status = buf.readUInt8(17); // 0 = failed, 1 = success, 2 = unknown const txBytes = buf.subarray(18); // transaction in Solana wire format (legacy, v0, or v1) console.log('Preconfirmation:', { slot, txIndex, status, bytes: txBytes.length }); }); ``` ```json Response theme={"system"} { "jsonrpc": "2.0", "id": 1, "result": 24040 } ``` ```text Notification (binary frame) theme={"system"} version u8 payload schema version, currently 1 slot u64 (LE) slot the transaction is scheduled in tx_index u64 (LE) index of the transaction within the slot (always 0 for BAM) status u8 0 = failed, 1 = success, 2 = unknown tx bytes transaction in Solana wire format (legacy, v0, or v1) ``` ## Notificaciones Después de la confirmación JSON, las notificaciones se entregan como tramas WebSocket **binarias** (no JSON). Las preconfirmaciones de Helius y BAM comparten la misma estructura. Cada trama es una estructura compacta de bytes que contiene una sola transacción: | Bytes | Campo | Tipo | Descripción | | ----- | ------------- | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 0 | `version` | `u8` | Versión del esquema de la carga útil. Actualmente es `1`. | | 1–8 | `slot` | `u64` (little-endian) | El slot en el que está programada la transacción. | | 9–16 | `tx_index` | `u64` (little-endian) | Índice de la transacción dentro del slot. Siempre es `0` para las preconfirmaciones de BAM, que incluyen un id. de secuencia y una posición en el paquete en lugar de un índice de slot. | | 17 | `status` | `u8` | Estado de la transacción: `0` = fallida, `1` = correcta, `2` = desconocido. | | 18+ | `transaction` | `bytes` | La transacción en formato de transmisión de Solana. Consulta [Decodificar la transacción](#decodificar-la-transacción). | La carga útil no tiene un campo de origen. No deduzcas que el origen es BAM a partir de `tx_index = 0`, ya que las preconfirmaciones de Helius pueden contener los mismos valores. **Lee y comprueba siempre primero el byte `version`.** Actualmente es `1`. Si Helius necesita actualizar el formato de la carga útil, la versión aumentará. Crea una rama basada en ella para que tu decodificador siga funcionando tras los cambios de esquema. Una preconfirmación es una señal anticipada, no una garantía. La transacción aún no se ha registrado en la cadena y todavía podría fallar o descartarse. Confirma que se haya registrado mediante las comprobaciones de compromiso estándar antes de considerarla definitiva. ### Decodificar la transacción Los bytes de la transacción se reenvían exactamente como los serializó el validador, con la codificación de transmisión estándar correspondiente a la versión de la transacción. Las transacciones heredadas y v0 usan la estructura con las firmas primero que produce `bincode`. Las transacciones v1 ([SIMD-0385](https://github.com/solana-foundation/solana-improvement-documents/blob/main/proposals/0385-transaction-v1.md)) usan una estructura con el mensaje primero y las firmas al final, por lo que `bincode` falla con las cargas útiles v1. Usa un decodificador que admita todas las versiones. En Rust, [`agave-transaction-view`](https://docs.rs/agave-transaction-view) analiza las transacciones heredadas, v0 y v1 directamente y es la opción recomendada; [`wincode`](https://docs.rs/wincode) con un `VersionedTransaction` actual del SDK de Solana también funciona. En JavaScript, asegúrate de que la versión de tu biblioteca admita transacciones v1. Consulta la [guía](/docs/es/pre-confirmations/preconf-subscribe#decodificar-la-transacción) para ver un ejemplo en Rust. ## Notificaciones duplicadas Las preconfirmaciones de Helius y BAM se deduplican por fuente, no entre fuentes. Una pequeña proporción de transacciones llega a Helius por ambas fuentes, por lo que puedes recibir la misma firma dos veces y las dos copias pueden indicar slots diferentes. Deduplica por firma en el cliente y haz que las acciones activadas por transacciones sean idempotentes. Consulta la [guía](/docs/es/pre-confirmations/preconf-subscribe#notificaciones-duplicadas). ## Precios Preconfirmations requiere un **plan Professional o superior** y cuesta **10 créditos por mensaje**: un mensaje por cada transacción transmitida. Consulta [Créditos](/docs/es/billing/credits) para obtener más información. La facturación se calcula por mensaje, no por firma única. Una transacción entregada tanto por Helius como por BAM cuenta dos veces. Configura `includeBam: false` si solo quieres preconfirmaciones de Helius. ## Contenido relacionado Qué son las Preconfirmations y dónde se ubican en el flujo de procesamiento del validador. Detén una suscripción mediante su id.