> ## 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.

# Negocie em Transações Pré-processadas

> Observe as transações Solana de um programa antes que atinjam o nível de compromisso processado com preprocessedSubscribe.

`preprocessedSubscribe` transmite transações assinadas antes que atinjam o nível de compromisso `processed`, decodificadas a partir de shreds à medida que chegam ao validador, sem necessidade de infraestrutura de desfragmentação do seu lado.

Este guia constrói um monitor que observa um programa de negociação pré-execução, remove duplicações do feed, permanece dentro do limite de backpressure do servidor e reconcilia com dados processados antes de agir.

<Tip>
  [Transações Pré-processadas](/docs/pt-BR/preprocessed-transactions/overview) estão disponíveis em todos os planos pagos e custam 0,1 créditos por mensagem, com até 10 conexões simultâneas por chave de API.
</Tip>

## Defina a assinatura para seu alvo

Não há fluxo não filtrado: `accountInclude` e `accountRequired` devem nomear pelo menos uma conta entre elas. Para um monitor de negociação, inclua o programa contra o qual negocia e exclua o ruído que você pagaria de outra forma:

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "preprocessedSubscribe",
  "params": {
    "accountInclude": ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"],
    "accountExclude": ["Vote111111111111111111111111111111111111111"],
    "accountRequired": []
  }
}
```

Os filtros combinam com AND, cada lista aceita até 5.000 endereços, e Helius resolve tabelas de lookup de endereços no lado do servidor, então uma conta carregada por meio de um ALT ainda corresponde. Para observar as interações de uma carteira específica com o programa, coloque ambos no campo `accountRequired` em vez disso.

## Decodificar frames e remover duplicações por assinatura

As notificações chegam como frames binários: um prefixo de 73 bytes, seguido pela transação serializada em bincode. A assinatura está no prefixo, então você pode remover duplicações sem decodificar o corpo. O fluxo agrega várias fontes de pré-execução, e a mesma transação pode chegar mais de uma vez:

```javascript monitor.js 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=YOUR_API_KEY');
const seen = new Set(); // rotate or expire entries in production
const queue = [];       // decode off the receive path; see next step

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'preprocessedSubscribe',
    params: {
      accountInclude: ['JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'],
      accountExclude: ['Vote111111111111111111111111111111111111111'],
      accountRequired: []
    }
  }));
  setInterval(() => ws.ping(), 30_000);
});

ws.on('message', (data, isBinary) => {
  if (!isBinary) {
    const msg = JSON.parse(data.toString());
    if (msg.id === 1) console.log('Subscribed, ID:', msg.result);
    return;
  }

  // version (u8) | slot (u64 LE) | signature ([u8; 64]) | bincode(VersionedTransaction)
  const buf = Buffer.from(data);
  if (buf.readUInt8(0) !== 1) return; // unknown schema version; update your decoder
  const signature = bs58.encode(buf.subarray(9, 73));
  if (seen.has(signature)) return;
  seen.add(signature);

  queue.push({
    slot: buf.readBigUInt64LE(1),
    signature,
    txBytes: buf.subarray(73)
  });
});

ws.on('error', console.error);
ws.on('close', () => process.exit(1)); // supervisor restarts and resubscribes
```

## Mantenha o loop de recebimento mais rápido que o fluxo

Helius não armazena em buffer indefinidamente para consumidores lentos: se mais de 4.000 mensagens acumularem no lado do servidor, a conexão é fechada. Por isso o handler acima só lê o prefixo de 73 bytes e coloca na fila.

A desserialização e a lógica de estratégia rodam em um loop separado:

```javascript theme={"system"}
setImmediate(async function drain() {
  const { VersionedTransaction } = require('@solana/web3.js');
  while (true) {
    const item = queue.shift();
    if (!item) { await new Promise(r => setTimeout(r, 1)); continue; }
    const tx = VersionedTransaction.deserialize(item.txBytes);
    strategy.onPreExecution(item.slot, item.signature, tx);
  }
});
```

Se a fila crescer sem limites, aperte os filtros. Transações descartadas do lado do cliente ainda custam 0,1 créditos cada e ainda contam para o limite de backpressure.

## Reconcilie com dados processados

Uma transação pré-processada mostra o que o remetente tentou fazer, não o que aconteceu. Ela não traz status de execução, alterações de saldo ou registros, e pode falhar, ser descartada ou cair em um fork diferente. A entrega é feita com melhor esforço, sem replay histórico, então:

* Reconcilie com [`transactionSubscribe`](/docs/pt-BR/rpc/websocket/transaction-subscribe) em compromisso `processed` ou `confirmed` antes que sua estratégia registre qualquer coisa como fato.
* Ao desconectar, reative a assinatura imediatamente e aceite a lacuna, pois não há replay para preenchê-la.
* Se precisar do estado da conta em tempo real ao invés de intenções de transação, isso só existe pós-execução: use [LaserStream gRPC](/docs/pt-BR/laserstream) em `processed`.

## Guias relacionados

<CardGroup cols={2}>
  <Card title="Referência de preprocessedSubscribe" icon="code" href="/docs/pt-BR/preprocessed-transactions/preprocessed-subscribe">
    Layout completo de payload, regras de filtro, backpressure, e preços
  </Card>

  <Card title="Negocie em Pré-confirmações" icon="stopwatch" href="/docs/pt-BR/pre-confirmations/guides/trade-on-preconfirmations">
    O sinal de transação mais cedo que Helius oferece, diretamente do scheduler
  </Card>
</CardGroup>