> ## 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. # Cómo usar preprocessedSubscribe > Transmite transacciones de Solana previas a la ejecución mediante WebSocket con el método preprocessedSubscribe: suscríbete, filtra por cuenta y decodifica cargas útiles binarias. **Beta pública.** `preprocessedSubscribe` está disponible en **todos los planes de pago** y se contabiliza a **0.1 créditos por mensaje** (un mensaje por cada transacción entregada). ## ¿Qué es `preprocessedSubscribe`? `preprocessedSubscribe` es un método WebSocket de Helius que transmite transacciones preprocesadas, es decir, transacciones de Solana previas a la ejecución que se entregan **antes de alcanzar el nivel de compromiso `processed`**. Helius agrega varias fuentes previas a la ejecución —principalmente shreds decodificados directamente a medida que llegan al validador, complementados con señales de [preconfirmación](/docs/es/pre-confirmations/overview)— y las entrega como un único flujo sin duplicados de mensajes binarios compactos, sin que necesites infraestructura para reconstruir los shreds. Las transacciones provenientes de señales de preconfirmación llegan más tarde a este flujo que al producto dedicado [Preconfirmations](/docs/es/pre-confirmations/overview), que sigue ofreciendo el acceso más temprano a ellas. Es el sucesor del producto anterior LaserStream preprocesado (gRPC). Si actualmente consumes transacciones preprocesadas mediante gRPC, cambia a este método: entrega la misma clase de datos mediante una conexión WebSocket convencional con menor latencia, y la entrega mediante gRPC quedará obsoleta. | Flujo | Momento relativo | Cobertura | Datos | | -------------------------------------------------------------------------------- | ------------------------------------------------------------------ | ------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | | [Preconfirmations](/docs/es/pre-confirmations/overview) | El más temprano | Transacciones programadas por validadores participantes | Transacción y estado de ejecución (solo preconfirmaciones de Helius; las preconfirmaciones de BAM informan un estado desconocido) | | `preprocessedSubscribe` | Por lo general, después de Preconfirmations y antes de `processed` | Amplia cobertura de transacciones de Solana | Transacción firmada antes de la ejecución | | [`transactionSubscribe`](/docs/es/rpc/websocket/transaction-subscribe) en `processed` | Después de la ejecución | Transacciones procesadas | Transacción con metadatos de ejecución | `preprocessedSubscribe` es una **señal previa a la ejecución de mejor esfuerzo**, no un nivel de compromiso. Una transacción transmitida puede fallar, descartarse o llegar a una bifurcación diferente. Compárala con un flujo procesado o confirmado antes de considerarla definitiva. ## Punto de conexión `preprocessedSubscribe` se ofrece desde `wss://beta.helius-rpc.com` —el punto de conexión de Helius Gatekeeper— en lugar de `mainnet.helius-rpc.com`. Autentícate con tu clave de API como parámetro de consulta: ``` wss://beta.helius-rpc.com/?api-key= ``` Cada clave de API está limitada a **10 conexiones/suscripciones simultáneas**. ## Suscribirse Envía una solicitud JSON-RPC con el método `preprocessedSubscribe`. `params` contiene los filtros de cuentas y es obligatorio: `accountInclude` y `accountRequired` deben especificar al menos una cuenta entre ambos (consulta [Filtrado](#filtrado)): ```json theme={"system"} { "jsonrpc": "2.0", "id": 1, "method": "preprocessedSubscribe", "params": { "accountInclude": ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"], "accountExclude": [], "accountRequired": [] } } ``` El servidor confirma la suscripción con una trama de texto JSON que contiene el ID de la suscripción: ```json theme={"system"} { "jsonrpc": "2.0", "result": 1, "id": 1 } ``` Después de esta confirmación, las actualizaciones de transacciones llegan como tramas WebSocket **binarias**; consulta [Carga útil de la notificación](#carga-útil-de-la-notificación). ## Filtrado Cada suscripción está delimitada por los filtros de cuentas de `params`. El filtrado ocurre en el servidor, por lo que solo recibes las transacciones que te interesan: ```json theme={"system"} { "jsonrpc": "2.0", "id": 1, "method": "preprocessedSubscribe", "params": { "accountInclude": ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"], "accountExclude": ["Vote111111111111111111111111111111111111111"], "accountRequired": [] } } ``` | Filtro | Comportamiento de coincidencia | | ----------------- | ------------------------------------------------------------------------------------------ | | `accountInclude` | Coincide cuando la transacción hace referencia a **cualquiera** de las cuentas enumeradas. | | `accountExclude` | Descarta la transacción si hace referencia a **cualquiera** de las cuentas enumeradas. | | `accountRequired` | Coincide solo cuando la transacción hace referencia a **todas** las cuentas enumeradas. | Reglas de filtrado: * Los tres filtros se combinan con lógica AND. * `accountInclude` y `accountRequired` deben especificar **al menos una cuenta** entre ambos; no existe un flujo completo sin filtros. * Las cuentas son claves públicas codificadas en base58. Cada lista acepta hasta **5,000** direcciones. ### Resolución de tablas de consulta de direcciones (ALT) Los filtros de cuentas no solo coinciden con las claves de cuentas estáticas de la transacción: Helius resuelve las [tablas de consulta de direcciones](/docs/es/glossary#tabla-de-consulta-de-direcciones-alt) en el servidor, por lo que `accountInclude`, `accountExclude` e `accountRequired` también coinciden con las cuentas que una transacción carga mediante una ALT. Solo proporciona la clave pública de la cuenta; no necesitas mantener asignaciones de ALT ni resolver las tablas por tu cuenta. ## Carga útil de la notificación Las notificaciones se entregan como tramas WebSocket **binarias** (no JSON). Cada trama contiene una sola transacción en una estructura compacta de bytes: | 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 se observó la transacción. | | 9–72 | `signature` | 64 bytes | La primera firma de la transacción, en formato binario. | | 73+ | `transaction` | `bytes` | La transacción firmada en el formato de transmisión de Solana. Consulta [Decodificación de la transacción](#decodificación-de-la-transacción). | Lee en orden el prefijo fijo de 73 bytes y luego decodifica los bytes restantes para leer las instrucciones, las cuentas y las consultas de tablas de direcciones. La firma se incluye en el prefijo para que puedas identificar y eliminar duplicados de una transacción sin decodificar todo el cuerpo de la transacción. Siempre lee y verifica primero el byte `version`. Si Helius necesita actualizar el formato de la carga útil, la versión aumentará. Bifurca la lógica según ese valor para que tu decodificador siga funcionando aunque cambie el esquema. ### Decodificación de la transacción Los bytes de la transacción se reenvían exactamente como se observaron en la red, 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 al principio que genera `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 al principio y las firmas al final, por lo que `bincode` falla con las cargas útiles v1. Usa un decodificador que admita todas las versiones: * **Rust:** [`agave-transaction-view`](https://docs.rs/agave-transaction-view) analiza transacciones heredadas, v0 y v1 directamente, sin una copia intermedia. Esta es la opción recomendada. [`wincode`](https://docs.rs/wincode), el serializador compatible con bincode que usan los SDK actuales de Solana, también decodifica v1 en `VersionedTransaction`. * **JavaScript / TypeScript:** asegúrate de que la versión de tu biblioteca admita transacciones v1. Las implementaciones anteriores de `VersionedTransaction.deserialize` solo admiten transacciones heredadas y v0. Usa `@solana/kit` 8.0+ o `@solana/web3.js` v3. Consulta [Compatibilidad con transacciones v1](/docs/es/rpc/transaction-v1). ```rust theme={"system"} use agave_transaction_view::transaction_view::TransactionView; // `frame` is the full binary WebSocket message let tx_bytes = &frame[73..]; let tx = TransactionView::try_new_unsanitized(tx_bytes)?; println!("version: {:?}", tx.version()); // Legacy, V0, or V1 for ix in tx.instructions_iter() { println!("program index {}: {} bytes", ix.program_id_index, ix.data.len()); } ``` ## Ejemplo ```javascript theme={"system"} const WebSocket = require('ws'); const bs58module = require('bs58'); const bs58 = bs58module.default ?? bs58module; const ws = new WebSocket('wss://beta.helius-rpc.com/?api-key='); ws.on('open', () => { ws.send(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'preprocessedSubscribe', // Only Jupiter v6 transactions — accountInclude/accountRequired must // specify at least one account between them. params: { accountInclude: ['JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'], accountExclude: [], accountRequired: [] } })); // Keep the connection alive 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) | signature ([u8; 64]) | transaction bytes const buf = Buffer.from(data); const version = buf.readUInt8(0); // currently 1 — branch on this if it changes if (version !== 1) return; // unknown schema version; update your decoder const slot = buf.readBigUInt64LE(1); const signature = bs58.encode(buf.subarray(9, 73)); const txBytes = buf.subarray(73); // transaction in Solana wire format (legacy, v0, or v1) console.log('Preprocessed transaction:', { slot, signature, bytes: txBytes.length }); // Decode txBytes with a decoder that supports transaction v1 (see "Decoding the transaction") }); ws.on('error', console.error); ws.on('close', () => process.exit(1)); ``` ## ¿Qué datos están disponibles? Cada notificación contiene la transacción firmada, su primera firma y su slot. Como la entrega ocurre antes de la ejecución, el flujo **no** incluye: * Estado o errores de ejecución * Saldos previos y posteriores, ni cambios en los saldos de tokens * Mensajes de registro ni instrucciones internas * Unidades de cómputo consumidas Piensa en esto como recibir la «propuesta» sin el «resultado»: ves lo que el remitente intentó hacer, pero no lo que realmente ocurrió. Las actualizaciones del estado de cuentas y programas tampoco existen todavía en esta etapa. Si necesitas el estado de las cuentas en tiempo real, usa [LaserStream gRPC](/docs/es/laserstream) con el nivel de compromiso `processed`. ## Contrapresión El flujo no almacena datos indefinidamente para los consumidores lentos. Si tu cliente lee con demasiada lentitud y se acumulan más de **4,000 mensajes** en el servidor, Helius cierra la conexión y recibes una trama de cierre de WebSocket correcta. Procesa las tramas más rápido de lo que llegan: mantén las tareas pesadas, como la decodificación de transacciones y la lógica de estrategia, fuera del bucle de recepción; después de una desconexión, vuelve a conectarte y a suscribirte. ## Garantías de entrega La entrega es de mejor esfuerzo, no está garantizada y no existe reproducción histórica. Los clientes deben: 1. Volver a conectarse y suscribirse después de que se cierre una conexión. 2. Eliminar duplicados según la firma de la transacción. 3. Tratar el slot como una observación, no como una finalidad. 4. Comparar los datos con un flujo procesado o confirmado cuando importen los resultados de la ejecución. ## Precios `preprocessedSubscribe` está disponible en **todos los planes de pago** y se contabiliza a **0.1 créditos por mensaje**: un mensaje por cada transacción entregada, facturado con cargo a tu plan. Consulta [Créditos](/docs/es/billing/credits) para obtener más información. ## Recursos relacionados Transacciones transmitidas antes de convertirse en shreds: la señal de transacción más temprana. Paquetes de shreds sin procesar mediante UDP. Tú implementas su reconstrucción. Transacciones posteriores a la ejecución con filtros avanzados y metadatos de ejecución.