> 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/fr/developper/notions-avancees/notifications-telegram-pour-transferts.md).

# Recevoir des notifications Telegram pour les transferts de Fan Tokens

Surveiller les transferts de Fan Tokens™ qui se produisent sur Chiliz Chain est un excellent moyen de rester informé sur les mouvements de grande valeur et de tenir votre communauté au courant.

Avec un peu de configuration et de code, vous pouvez mettre en place un bot Telegram pour notifier un groupe chaque fois qu'un transfert de Fan Token™ dépasse un certain seuil.

## Comment procéder avec Envio ?

[Envio](https://envio.dev/) est un outil d'indexation puissant qui permet aux développeurs d'écouter des événements de smart contracts sur Chiliz et d'effectuer une action sur la base de l'événement.

Dans ce guide, vous verrez comment configurer le bot, capturer les événements pertinents et déclencher automatiquement des alertes Telegram, transformant ainsi votre configuration en un "whale watcher" pour les transferts importants.

### Étape 1 : Installer les prérequis

Avant de commencer, assurez-vous d'avoir les [outils requis](https://docs.envio.dev/docs/HyperIndex/getting-started#prerequisites) installés :

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

{% hint style="info" %}
Le projet complet peut être trouvé [sur ce dépôt GitHub](https://github.com/DenhamPreen/fc-barce-fan-token-indexer/tree/main).
{% endhint %}

### Étape 2 : Initialiser l'indexeur Envio

Exécutez la commande suivante pour initialiser un indexeur Envio et suivez les instructions pour générer un template ERC-20 sur Chiliz Chain (qui est une blockchain compatible EVM) :

```bash
pnpx envio init
```

Voici les différentes sélections que vous devriez faire lorsque vous y êtes invité :

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

### Étape 3 : Configurer `config.yaml`

Modifiez le fichier `config.yaml` pour spécifier l'adresse du contrat du FC Barcelona Fan Token™ (ou tout autre Fan Token™ que vous souhaitez suivre) :

{% 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 %}

**Note :** Nous retirons l'événement `approval` car nous ne nous intéressons qu'aux transferts.

### Étape 4 : Simplifier le Schéma GraphQL

Modifiez le fichier `schema.graphql` pour ne suivre que les soldes des comptes :

```graphql
type Account {
  id: ID!   # Adresse du compte
  balance: BigInt! # Solde du compte en tokens
}
```

À ce stade, nous avons un indexeur ERC-20 qui écoute les événements.

Maintenant, ajoutons la logique pour publier des notifications Telegram.

### Étape 5 : Implémenter la logique de notification Telegram

Modifiez le fichier `/src/EventHandlers.ts` pour inclure la logique de détection des transferts importants et d'envoi d'alertes 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" %}
Le dossier `/libs/` de l'exemple peut être trouvé [directement ici sur GitHub](https://github.com/DenhamPreen/fc-barce-fan-token-indexer/tree/main/src/libs), y compris les fichiers `helpers.ts` et `ens.ts`.
{% endhint %}

### Étape 6 : Configurer les constantes

Créez un fichier `constants.ts` pour stocker les variables d'environnement :

{% 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 %}

### Étape 7 : Envoyer des messages Telegram

Installez le [client HTTP Axios](https://axios-http.com/) :

```bash
pnpm i axios
```

Créez une fonction helper dans `libs/telegram.ts` pour envoyer des messages en utilisant 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 %}

### Étape 8 : Configuration finale et lancement de l'indexeur

#### Configurer le fichier `.env`

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

Éditez `.env` avec vos identifiants de 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
```

#### Créer un bot Telegram

1. Envoyez un message à `@BotFather` sur Telegram et exécutez :

   ```
   /newbot
   ```
2. Suivez les instructions pour obtenir votre token de bot.
3. Ajoutez le bot à votre groupe Telegram et exécutez `/start`.
4. Visitez `https://api.telegram.org/bot<YourBOTToken>/getUpdates` pour trouver l'ID du chat de groupe.

{% hint style="success" %}
Si vous avez créé le nouveau groupe avec le bot et que vous n'obtenez que `{"ok":true,"result":[]}`, retirez et rajoutez le bot dans le groupe.
{% endhint %}

#### Enfin, installez les dépendances et démarrez l'indexeur

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

Avec cette configuration, vous disposez maintenant d'un indexeur alimenté par Envio qui écoute les transferts de Fan Tokens et publie des alertes de baleines sur Telegram.

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

Pour aller plus loin, vous pouvez auto-héberger l'indexeur ou le déployer sur le service hébergé d'Envio.

Et puisque nous sauvegardons les soldes, il peut également être utilisé comme API GraphQL pour les soldes.


---

# 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/fr/developper/notions-avancees/notifications-telegram-pour-transferts.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.