> ## 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.
# Gerenciando Reconexões e Erros em Streams Analisados
> Detecte desconexões em Streams Analisados, reconecte com backoff, reassine e preencha exatamente a janela de slot que você perdeu.
A entrega é **no máximo uma vez** — não há repetição. O que foi confirmado enquanto você estava desconectado não é reenviado, então um cliente em produção precisa detectar a lacuna e decidir se deve preenchê-la. O sinal para isso é `context.slot`: ele delimita a janela que você perdeu durante uma desconexão. Este guia cobre por que as conexões são fechadas, como reconectar de forma limpa e como usá-la.
## Por Que as Conexões São Fechadas
Toda desconexão tem um código de fechamento do WebSocket que indica o que aconteceu e o que fazer em seguida:
| Código | Motivo | O que fazer |
| ----------- | ------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1000 | Ocioso: sem mensagens do cliente e sem notificações por 10 minutos | Envie o método JSON-RPC `ping` a cada poucos minutos se seu filtro estiver quieto. Pings de protocolo do WebSocket que bibliotecas de clientes enviam automaticamente **não** redefinem o temporizador ocioso. |
| 1001 | Reinício do servidor (deploy) | Reconectar e reassinar |
| 1008 | Consumidor lento: você ficou mais de 2048 notificações atrás | Reconecte com um filtro mais estreito, `details: "matched"` ou `"raw"`, ou com processamento mais rápido |
| 1005 / 1006 | Borda de rede reciclou a conexão | Reconectar e reassinar; normal em alguma frequência em conexões de longa duração |
O servidor faz pings a cada 15 segundos, então uma conexão saudável, mas silenciosa, ainda carrega tráfego. Se você não vir nada por mais de um minuto — nenhuma notificação, nenhum ping — assuma que a conexão está morta e reconecte em vez de esperar que o socket lhe diga.
## Mantenha a Conexão Viva
Se seu filtro for estreito o suficiente para que possa passar 10 minutos sem uma correspondência, envie um JSON-RPC `ping` explícito em um intervalo menor do que isso:
```json theme={"system"}
{ "jsonrpc": "2.0", "id": 99, "method": "ping" }
```
Ele retorna o slot atual e, mais importante, conta como uma mensagem do cliente para o temporizador ocioso. Um quadro de ping do WebSocket a nível de biblioteca não conta.
## Reconectar e Detectar a Lacuna
Em qualquer desconexão — esperada ou não — reconecte com backoff exponencial. IDs de assinatura não sobrevivem a uma reconexão, então reenvie `parsedTransactionSubscribe` para cada filtro que você tinha aberto.
Mantenha o último `context.slot` que você viu antes da desconexão. A lacuna entre esse slot e o primeiro slot que você vê após reconectar é exatamente a janela que você perdeu — nada mais, nada menos.
Se sua aplicação não tolerar a lacuna, preencha essa janela de slot a partir do RPC: `getSignaturesForAddress` para enumerar transações no intervalo, depois `getTransaction` para buscar cada uma. Este é um passo de reconciliação manual — o Streams Analisados em si não reproduz.
```typescript theme={"system"}
import WebSocket from "ws";
const URL = "wss:///?api-key=";
const filters = [
{ programs: ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"] },
];
let lastSlotSeen: number | null = null;
let backoffMs = 1000;
function connect() {
const ws = new WebSocket(URL);
ws.on("open", () => {
backoffMs = 1000;
filters.forEach((filter, i) => {
ws.send(JSON.stringify({
jsonrpc: "2.0",
id: i + 1,
method: "parsedTransactionSubscribe",
params: [filter],
}));
});
});
ws.on("message", (data) => {
const msg = JSON.parse(data.toString());
if (msg.method === "parsedTransactionNotification") {
const { slot } = msg.params.result.context;
// Across reconnects, the slot bounds the backfill window.
if (lastSlotSeen !== null && slot > lastSlotSeen) {
// backfill candidates: slots lastSlotSeen+1 .. slot-1 while disconnected
}
lastSlotSeen = slot;
}
});
ws.on("close", (code) => {
console.warn(`connection closed (${code}); reconnecting in ${backoffMs}ms`);
setTimeout(connect, backoffMs);
backoffMs = Math.min(backoffMs * 2, 30_000);
});
}
connect();
```
`context.slot` é o que sobrevive a uma reconexão: acompanhe o slot mais alto que você processou completamente antes da desconexão e trate tudo depois dele como a janela de preenchimento.
## Lidando com Erros JSON-RPC
Pedidos que falham retornam um erro JSON-RPC em vez de um resultado, então você pode bifurcar em `error.code`:
| Código | Significado |
| -------- | ----------------------------------------------------------------------------------------------------------------- |
| `-32700` | Erro de análise (JSON inválido) |
| `-32600` | Solicitação inválida |
| `-32601` | Método não encontrado |
| `-32602` | Parâmetros inválidos: chave pública incorreta, campo desconhecido, valor de comprovação ou detalhes não suportado |
| `-32000` | Limite de filtro excedido |
| `-32001` | Servidor não está pronto; tente novamente com backoff |
| `-32002` | Limite de taxa (10 mensagens por segundo) |
| `-32006` | Muitas assinaturas (25 por conexão) |
`-32602` e `-32000` significam que a solicitação em si está errada — corrija o filtro, não tente novamente como está. `-32001` e `-32002` são transitórios; tente novamente com o mesmo backoff que você usa para reconexões.
## Próximos Passos
Referência completa do protocolo: métodos, campos de filtro, limites.
Construa um filtro ao qual essa conexão possa assinar.