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

# Como Usar getFeeForMessage

> Aprenda sobre casos de uso de getFeeForMessage, exemplos de código, parâmetros de solicitação, estrutura de resposta e dicas.

O método RPC [`getFeeForMessage`](https://www.helius.dev/docs/api-reference/rpc/http/getfeeformessage) permite estimar a taxa que a rede cobrará pelo processamento de uma determinada mensagem de transação. Isso é útil para entender os [custos de transação](https://www.helius.dev/blog/solana-fees-in-theory-and-practice) antes de serem submetidos à rede.

**Nota de Versão:** Este método está disponível na `solana-core` v1.9 ou mais recente. Para versões anteriores, considere usar `getFees`.

## Casos de Uso Comuns

* **Estimativa de Taxa:** Determine a provável taxa de transação (em lamports) para uma mensagem específica.
* **Otimização de Custos:** Analise taxas para diferentes estruturas de transação ou em diferentes momentos.
* **Exibição na Interface do Usuário:** Mostre aos usuários um custo estimado de transação antes de assinarem e enviarem uma transação.

## Parâmetros de Solicitação

1. **`message`** (string, obrigatório): A mensagem da transação, codificada em base64. Você pode obter isso compilando uma transação.
2. **`config`** (objeto, opcional): Um objeto de configuração com os seguintes campos:
   * **`commitment`** (string, opcional): Especifica o [nível de compromisso](https://www.helius.dev/blog/solana-commitment-levels) a ser usado. O padrão é `finalized`.
   * **`minContextSlot`** (número, opcional): O slot mínimo no qual a solicitação pode ser avaliada.

## Estrutura da Resposta

O campo `result` da resposta JSON-RPC é um objeto com a seguinte estrutura:

* **`context`** (objeto):
  * **`slot`** (u64): O slot no qual a taxa foi avaliada.
* **`value`** (u64 | null): A taxa estimada em lamports. Isso pode ser `null` se a taxa não puder ser determinada (por exemplo, se o blockhash usado na mensagem for muito antigo ou inválido).

## Exemplos

### 1. Estimar Taxa para uma Mensagem de Transferência Simples

Este exemplo demonstra como construir uma transferência simples, compilar sua mensagem e, em seguida, obter a taxa estimada.

<CodeGroup>
  ```bash cURL theme={"system"}
  # First, you need a base64 encoded message. 
  # This typically involves creating a transaction, compiling its message, 
  # and then base64 encoding the serialized message.
  # The example message below is illustrative.
  # Replace "MESSAGE_BASE64_ENCODED" with your actual encoded message.
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getFeeForMessage",
      "params": [
        "MESSAGE_BASE64_ENCODED", // Replace with your actual base64 encoded message
        { "commitment": "processed" }
      ]
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  const { Connection, Keypair, SystemProgram, Transaction, LAMPORTS_PER_SOL } = require('@solana/web3.js');

  async function estimateTransactionFee() {
    const connection = new Connection('https://devnet.helius-rpc.com/?api-key=<api-key>');

    try {
      const fromPublicKey = Keypair.generate().publicKey;
      const toPublicKey = Keypair.generate().publicKey;

      let transaction = new Transaction().add(
        SystemProgram.transfer({
          fromPubkey: fromPublicKey,
          toPubkey: toPublicKey,
          lamports: 1000,
        })
      );

      transaction.feePayer = fromPublicKey;
      const { blockhash } = await connection.getLatestBlockhash('confirmed');
      transaction.recentBlockhash = blockhash;

      const message = transaction.compileMessage();
      const messageBase64 = message.serialize().toString('base64');

      console.log(`Compiled Message (Base64): ${messageBase64}`);

      const feeResult = await connection.getFeeForMessage(message, 'confirmed');

      if (feeResult && feeResult.value !== null) {
        console.log(`Estimated Fee: ${feeResult.value} lamports`);
      } else {
        console.log('Could not estimate fee. The value was null.');
        console.log('This might happen if the blockhash is too old or the message is invalid.');
      }

    } catch (error) {
      console.error('Error estimating transaction fee:', error);
      if (error.message.includes('failed to get recent blockhash')) {
          console.error('Ensure your RPC endpoint is responsive or try a different commitment level for getLatestBlockhash.');
      }
    }
  }

  estimateTransactionFee();
  ```
</CodeGroup>

## Dicas para Desenvolvedores

* **Construção de Mensagem:** A chave para usar `getFeeForMessage` é construir e serializar corretamente a transação `Message`. Isso envolve definir o pagador da taxa, instruções e um blockhash recente.
* **Blockhash Recente:** A mensagem deve ser construída com um blockhash recente. Se o blockhash for muito antigo, o `value` na resposta pode ser `null`.
* **Taxa vs. Taxa de Prioridade:** Este método retorna a taxa base da rede. Não inclui taxas de prioridade adicionais que você possa adicionar a uma transação para aumentar sua probabilidade de ser processada rapidamente durante períodos de congestão na rede. Use `getRecentPrioritizationFees` para estimar [taxas de prioridade](https://www.helius.dev/blog/priority-fees-understanding-solanas-transaction-fee-mechanics).
* **Lamports:** A taxa é retornada em lamports (1 SOL = 1.000.000.000 lamports).
* **Valor Nulo:** Um valor `null` para a taxa pode indicar problemas com a mensagem (por exemplo, blockhash inválido, mensagem malformada) ou que o nó não pode calcular uma taxa para ela no nível de compromisso ou slot especificado.

Este guia fornece as etapas necessárias para utilizar o método RPC `getFeeForMessage` para estimar taxas de transação na rede Solana.

## Métodos Relacionados

<CardGroup cols={2}>
  <Card title="getLatestBlockhash" href="/docs/pt-BR/api-reference/rpc/http/getlatestblockhash">
    Obtenha um blockhash recente para construir mensagens
  </Card>

  <Card title="getRecentPrioritizationFees" href="/docs/pt-BR/api-reference/rpc/http/getrecentprioritizationfees">
    Estime taxas de prioridade para processamento mais rápido
  </Card>
</CardGroup>