> For the complete documentation index, see [llms.txt](https://docs.chiliz.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.chiliz.com/pt-br/desenvolver/avancado/notificacoes-telegram-fan-tokens.md).

# Receber notificações no Telegram para transferências de Fan Tokens

Monitorar as transferências de Fan Tokens™ que acontecem na Chiliz Chain é uma ótima forma de se manter informado sobre movimentações de alto valor e manter sua comunidade atualizada.

Com um pouco de configuração e código, você pode configurar um bot no Telegram para notificar um grupo sempre que uma transferência de Fan Token™ ultrapassar um determinado limite.

## Como fazer usando Envio?

O [Envio](https://envio.dev/) é uma poderosa ferramenta de indexação que permite aos desenvolvedores monitorar eventos de smart contracts na Chiliz e executar uma ação com base no evento.

Neste guia, você verá como configurar o bot, capturar os eventos relevantes e acionar alertas no Telegram automaticamente, transformando sua configuração em um "observador de baleias" para grandes transferências.

### Passo 1: Instalar os Pré-requisitos

Antes de começar, certifique-se de ter as [ferramentas necessárias](https://docs.envio.dev/docs/HyperIndex/getting-started#prerequisites) instaladas:

* [pnpm](https://pnpm.io/)
* [Node.js](https://nodejs.org/en)
* [Docker](https://www.docker.com/)

{% hint style="info" %}
O projeto completo pode ser encontrado [neste repositório GitHub](https://github.com/DenhamPreen/fc-barce-fan-token-indexer/tree/main).
{% endhint %}

### Passo 2: Inicializar o Indexador Envio

Execute o seguinte comando para inicializar um indexador Envio e siga as instruções para gerar um template ERC20 na Chiliz Chain (que é um blockchain compatível com EVM):

```bash
pnpx envio init
```

Veja as seleções que você deve fazer quando solicitado:

<figure><img src="/files/1FalRymYQzoMMETDxFkg" alt=""><figcaption></figcaption></figure>

### Passo 3: Configurar o `config.yaml`

Modifique o arquivo `config.yaml` para especificar o endereço do contrato do Fan Token™ do FC Barcelona (ou qualquer outro Fan Token™ que você queira rastrear):

{% code overflow="wrap" lineNumbers="true" %}

```yaml
# yaml-language-server: $schema=./node_modules/envio/evm.schema.json
name: fan-token-watcher
description: A simple indexer for Fan Tokens that posts notifications to Telegram on large transfers
networks:
  - id: 8888 # Chiliz
    start_block: 0
    contracts:
      - name: ERC20
        address: "0xFD3C73b3B09D418841dd6Aff341b2d6e3abA433b" # FC Barcelona
        handler: src/EventHandlers.ts
        events:          
          - event: "Transfer(address indexed from, address indexed to, uint256 value)"
field_selection:
  transaction_fields:
    - "hash"
```

{% endcode %}

**Nota:** Removemos o evento `approval` pois nos interessam apenas as transferências.

### Passo 4: Simplificar o Schema GraphQL

Modifique o arquivo `schema.graphql` para rastrear apenas saldos de contas:

```graphql
type Account {
  id: ID!   # Address of the account
  balance: BigInt! # Account balance of tokens
}
```

Neste ponto, temos um indexador ERC20 que monitora eventos.

Agora, vamos adicionar lógica para enviar notificações no Telegram.

### Passo 5: Implementar a Lógica de Notificação no Telegram

Modifique o arquivo `/src/EventHandlers.ts` para incluir lógica de detecção de grandes transferências e envio de alertas no Telegram.

{% code overflow="wrap" lineNumbers="true" %}

```typescript
import { ERC20 } from "generated";
import { isIndexingAtHead, indexBalances } from "./libs/helpers";
import { fetchEnsHandle } from "./libs/ens";
import { sendMessageToTelegram } from "./libs/telegram";
import { WHALE_THRESHOLD, explorerUrlAddress, explorerUrlTx } from "./constants";

ERC20.Transfer.handler(async ({ event, context }) => {
  if (isIndexingAtHead(event.block.timestamp) && event.params.value >= BigInt(WHALE_THRESHOLD)) {
    const ensHandleOrFromAddress = await fetchEnsHandle(event.params.from); 
    const ensHandleOrToAddress = await fetchEnsHandle(event.params.to);
    const msg = `FC Barcelona WHALE ALERT 🐋: A new transfer has been made by <a href="${explorerUrlAddress(
      event.params.from
    )}">${ensHandleOrFromAddress}</a> to <a href="${explorerUrlAddress(
      event.params.to
    )}">${ensHandleOrToAddress}</a> for ${event.params.value} FC Barcelona! 🔥 - <a href="${explorerUrlTx(
      event.transaction.hash
    )}">transaction</a>`;

    await sendMessageToTelegram(msg);
  }

  await indexBalances(context, event);
});
```

{% endcode %}

{% hint style="success" %}
A pasta de exemplo `/libs/` pode ser encontrada [aqui no GitHub](https://github.com/DenhamPreen/fc-barce-fan-token-indexer/tree/main/src/libs), incluindo os arquivos `helpers.ts` e `ens.ts`.
{% endhint %}

### Passo 6: Configurar as Constantes

Crie um arquivo `constants.ts` para armazenar variáveis de ambiente:

{% code overflow="wrap" lineNumbers="true" %}

```typescript
export const EXPLORER_URL_MONAD = process.env.ENVIO_EXPLORER_URL_MONAD;
export const WHALE_THRESHOLD: string = process.env.ENVIO_WHALE_THRESHOLD ?? "1000";
export const BOT_TOKEN = process.env.ENVIO_BOT_TOKEN;
export const CHANNEL_ID = process.env.ENVIO_TELEGRAM_CHANNEL_ID;
export const MESSAGE_THREAD_ID = process.env.ENVIO_TELEGRAM_MESSAGE_THREAD_ID;

export const explorerUrlAddress = (address: string) =>
  EXPLORER_URL_MONAD + "address/" + address;
export const explorerUrlTx = (txHash: string) =>
  EXPLORER_URL_MONAD + "tx/" + txHash;
```

{% endcode %}

### Passo 7: Enviar Mensagens no Telegram

Instale o [cliente HTTP Axios](https://axios-http.com/):

```bash
pnpm i axios
```

Crie uma função auxiliar em `libs/telegram.ts` para enviar mensagens usando Axios:

{% code overflow="wrap" lineNumbers="true" %}

```typescript
import axios from "axios";
import { CHANNEL_ID, MESSAGE_THREAD_ID, BOT_TOKEN } from "../constants";

export const sendMessageToTelegram = async (message: string): Promise<void> => {
  try {
    const apiUrl = `https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`;
    await axios.post(apiUrl, {
      chat_id: CHANNEL_ID,
      text: message,
      parse_mode: "HTML",
    });
  } catch (error) {
    console.error("Error sending message:", error);
  }
};
```

{% endcode %}

### Passo 8: Configuração Final e Execução do Indexador

#### Configurar o arquivo `.env`

```sh
cp .env.example .env
```

Edite `.env` com as credenciais do seu bot Telegram:

```sh
ENVIO_BOT_TOKEN=
ENVIO_TELEGRAM_CHANNEL_ID=
ENVIO_TELEGRAM_MESSAGE_THREAD_ID=
ENVIO_EXPLORER_URL="https://chiliscan.com/"
ENVIO_WHALE_THRESHOLD=1000
```

#### Criar um Bot no Telegram

1. Envie mensagem para `@BotFather` no Telegram e execute:

   ```
   /newbot
   ```
2. Siga as instruções para obter o token do seu bot.
3. Adicione o bot ao seu grupo no Telegram e execute `/start`.
4. Acesse `https://api.telegram.org/bot<YourBOTToken>/getUpdates` para encontrar o ID do chat do grupo.

{% hint style="success" %}
Se você criou o novo grupo com o bot e só recebe `{"ok":true,"result":[]}`, remova e adicione o bot ao grupo novamente.
{% endhint %}

#### Por fim, instale as dependências e inicie o indexador

```sh
pnpm i
pnpm envio dev
```

Com essa configuração, você agora tem um indexador alimentado pelo Envio que monitora transferências de Fan Tokens e publica alertas de baleia no Telegram.

<figure><img src="/files/Q8Uerd3bcgb0vxxZa6XR" alt=""><figcaption></figcaption></figure>

Para ir além, você pode hospedar o indexador você mesmo ou implantá-lo no serviço hospedado do Envio.

E como estamos salvando os saldos, ele também pode ser usado como uma API GraphQL de saldos.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.chiliz.com/pt-br/desenvolver/avancado/notificacoes-telegram-fan-tokens.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.