---
title: "Solana Geyser gRPC - Filtros"
description: "SLV - Solana Geyser gRPC - Filtros"
canonical: "https://erpc.global/pt/doc/geyser-grpc/filter/"
locale: "pt"
---

# Solana Geyser gRPC - Filtros

![Solana Stream SDK](https://storage.validators.solutions/SolanaStreamSDK.jpg)

O Solana Stream SDK é distribuído como software de código aberto. Para mais detalhes, visite o repositório GitHub abaixo.

[https://github.com/ValidatorsDAO/solana-stream](https://github.com/ValidatorsDAO/solana-stream)

### Visão geral dos filtros gRPC

O Solana Geyser gRPC usa filtros para buscar com eficiência apenas os dados que interessam a você, como contas, programas, transações, slots e blocos específicos.

Abaixo, mostramos exemplos em TypeScript com o Solana Stream SDK e explicamos claramente o papel de cada filtro. A estrutura e o significado dos filtros são os mesmos em Rust.

## Regras atuais de filtros Shared

No plano Shared atual, todo mapa `blocks` não vazio é apenas Dedicated, inclusive uma requisição limitada com `accountInclude` ou que exclui transações. Use uma assinatura de transações ou `blocksMeta` quando atender à necessidade; nenhum dos dois equivale a um bloco completo. Para blocos completos é necessário um stream Geyser gRPC Dedicated.

Cada entrada de filtro de conta deve incluir `account`, `owner` ou um filtro cuckoo compatível. Uma condição `memcmp` ou `dataSize` sozinha não seleciona um formato de conta compatível. Restrinja a requisição a um desses seletores ou use Geyser gRPC Dedicated quando um stream completo de contas for necessário.

## Funções e exemplos de cada filtro

### Assinar uma conta

Assine as atualizações em tempo real de uma conta específica. O exemplo a seguir assina a conta SOL-USDC do OpenBook no nível de commitment Confirmed:

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: { slots: {} },
  accounts: {
    'wsol/usdc': {
      account: ['8BnEgHoWFysVcuFFX7QztDmzuH8r5ZFvyP3sYwn1XTh6'],
    },
  },
  transactions: {},
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.CONFIRMED,
}
```

- `"wsol/usdc"` é um rótulo definido pelo cliente.
- É possível combinar vários filtros de contas, programas, blocos e slots em uma única requisição JSON.

### Assinar uma conta com `account_data_slice`

Este exemplo mostra como obter apenas uma parte específica dos dados de uma conta. Em vez de buscar os dados inteiros (165 bytes) de uma token account de USDC, ele obtém 40 bytes a partir do offset 32. Esse intervalo inclui informações como o proprietário e o saldo em lamports.

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {},
  accounts: {
    usdc: {
      owner: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'],
      filters: [
        {
          tokenAccountState: true,
        },
        {
          memcmp: {
            offset: 0,
            data: {
              base58: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
            },
          },
        },
      ],
    },
  },
  transactions: {},
  blocks: {},
  blocksMeta: {},
  entry: {},
  commitment: CommitmentLevel.CONFIRMED,
  accountsDataSlice: [{ offset: 32, length: 40 }],
}
```

### Assinar um programa

Este exemplo mostra como assinar as atualizações das contas associadas a um programa específico.

Abaixo, assinamos as atualizações das contas que pertencem ao programa Solend, no nível de commitment `Processed`.

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {
    slots: {},
  },
  accounts: {
    solend: {
      owner: ['So1endDq2YkqhipRh3WViPa8hdiSpxWy6z3Z6tMCpAo'],
    },
  },
  transactions: {},
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

- `"solend"` é um rótulo personalizado que o cliente pode definir livremente.
- Para assinar vários programas, consulte a próxima seção, "Assinar vários programas".

### Assinar vários programas

Este exemplo mostra como assinar de uma só vez as atualizações das contas associadas a vários programas.

O exemplo abaixo assina as atualizações das contas que pertencem aos programas Solend e Serum.

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {
    slots: {},
  },
  accounts: {
    programs: {
      owner: [
        'So1endDq2YkqhipRh3WViPa8hdiSpxWy6z3Z6tMCpAo',
        '9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin',
      ],
    },
  },
  transactions: {},
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

Se preferir atribuir um rótulo individual a cada programa, use a abordagem a seguir:

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {
    slots: {},
  },
  accounts: {
    solend: {
      owner: ['So1endDq2YkqhipRh3WViPa8hdiSpxWy6z3Z6tMCpAo'],
    },
    serum: {
      owner: ['9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin'],
    },
  },
  transactions: {},
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

### Assinar todas as transações finalized que não são de voto e não falharam

Este exemplo mostra como assinar todas as transações no nível de commitment `Finalized`, excluindo as transações de voto e as transações com falha.

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {
    slots: {},
  },
  accounts: {},
  transactions: {
    alltxs: {
      vote: false,
      failed: false,
    },
  },
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.FINALIZED,
}
```

- `vote: false` exclui as transações de voto.
- `failed: false` exclui as transações com falha.
- Se os campos ficarem vazios, todas as transações são obtidas.
- Quando vários campos são especificados, eles funcionam como uma condição AND.

### Assinar transações que não são de voto e mencionam uma conta

Este exemplo mostra como assinar as transações que envolvem uma conta específica, excluindo as transações de voto.

O exemplo abaixo assina as transações que não são de voto e mencionam contas associadas ao programa Serum.

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {
    slots: {},
  },
  accounts: {},
  transactions: {
    serum: {
      vote: false,
      accountInclude: ['9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin'],
    },
  },
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

### Assinar transações excluindo contas

Este exemplo mostra como assinar as transações, excluindo aquelas que envolvem contas específicas.

O exemplo abaixo obtém as transações, excluindo qualquer conta que pertença aos programas Serum e Tokenkeg.

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {
    slots: {},
  },
  accounts: {},
  transactions: {
    serum: {
      accountExclude: [
        '9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin',
        'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
      ],
    },
  },
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

### Assinar transações que mencionam contas e excluem determinadas contas

Este exemplo mostra como assinar as transações que envolvem determinadas contas, excluindo explicitamente outras contas especificadas.

O exemplo abaixo assina as transações que mencionam a conta do Serum, mas exclui uma conta especificada:

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {
    slots: {},
  },
  accounts: {},
  transactions: {
    serum: {
      accountInclude: ['9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin'],
      accountExclude: ['9wFFyRfZBsuAha4YcuxcXLKwMxJR43S7fPfQLusDBzvT'],
    },
  },
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

### Assinar atualizações de uma assinatura de transação

Este exemplo mostra como assinar as atualizações em tempo real de uma assinatura de transação específica, até que ela atinja o estado `Confirmed` ou `Finalized`.

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {},
  accounts: {},
  transactions: {
    sign: {
      signature:
        '5rp2hL9b6kexex11Mugfs3vfU9GhieKruj4CkFFSnu52WLxiGn4VcLLwsB62XURhMmT1j4CZiXT6FFtYbXsLq2Zs',
    },
  },
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

### Assinar slots

Este exemplo mostra como assinar as notificações de novos slots. Não é preciso nenhum detalhe além de atribuir um nome de tag personalizado:

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {
    incoming_slots: {},
  },
  accounts: {},
  transactions: {},
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

### Assinar blocos (apenas Dedicated no plano Shared atual)

Assine as atualizações em tempo real de todos os blocos gerados. Por padrão, todas as transações dentro de um bloco são obtidas:

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {},
  accounts: {},
  transactions: {},
  blocks: {
    blocks: {},
  },
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

#### Para excluir transações e obter apenas informações de conta atualizadas (apenas Dedicated no plano Shared atual):

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {},
  accounts: {},
  transactions: {},
  blocks: {
    blocks: {
      includeTransactions: false,
      includeAccounts: true,
    },
  },
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

#### Para obter apenas transações/contas que envolvam contas específicas (apenas Dedicated no plano Shared atual):

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {},
  accounts: {},
  transactions: {},
  blocks: {
    blocks: {
      accountInclude: ['So1endDq2YkqhipRh3WViPa8hdiSpxWy6z3Z6tMCpAo'],
    },
  },
  blocksMeta: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

### Assinar metadados de blocos

Assine apenas as notificações de metadados de blocos quando os blocos são processados. Os dados detalhados das transações não são incluídos.

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

const request = {
  slots: {},
  accounts: {},
  transactions: {},
  blocks: {},
  blocksMeta: {
    blockmetadata: {},
  },
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
}
```

## Gerenciar os níveis de commitment

Por padrão, o stream Solana Geyser gRPC usa o nível de commitment `Processed`.

Você pode especificar níveis de commitment mais altos, como `Confirmed` ou `Finalized`. Nesses casos, o Geyser armazena os dados em buffer e envia as notificações quando o nível de commitment especificado é atingido.

Para obter o máximo desempenho, recomenda-se gerenciar os níveis de commitment no lado do cliente.

Veja como especificar os níveis de commitment:

```typescript
import { CommitmentLevel } from '@validators-dao/solana-stream-sdk'

enum CommitmentLevel {
  PROCESSED = 0,
  CONFIRMED = 1,
  FINALIZED = 2,
}
```

- **`PROCESSED`**: dados imediatos após o processamento. Obtenção rápida, mas ainda sem confirmação.
- **`CONFIRMED`**: dados confirmados pelo cluster, com maior certeza.
- **`FINALIZED`**: dados totalmente finalizados, sem risco de reorganização.

### Vantagens de trabalhar em `Processed`

A principal vantagem do nível de commitment `Processed` é obter as transações imediatamente, o que permite um processamento rápido no lado do cliente. Depois, os clientes podem detectar as transições para `Confirmed` ou `Finalized`, com resposta rápida.

### Como gerenciar `Confirmed` e `Finalized`

Ao usar os níveis `Confirmed` ou `Finalized`, os eventos (transações ou atualizações de contas) devem ser armazenados em buffer por slot.

Armazene os eventos em buffer slot a slot, assine as notificações de slot e libere os eventos do buffer quando um slot específico atingir o commitment desejado (`Confirmed` ou `Finalized`).

Os eventos chegam inicialmente antes de um slot atingir `Confirmed` ou `Finalized`.

### A particularidade do `Finalized`

Pelas especificações do Solana Geyser, nem todos os slots recebem uma notificação finalized explícita. Por isso, ao receber uma notificação finalized de um slot, você deve tratar todos os slots ancestrais como finalizados, mesmo que nenhuma notificação tenha sido recebida explicitamente.

Concretamente, ao receber uma notificação finalized, trate retroativamente todos os slots ancestrais como finalizados.