Powiadomienia Telegram o transferach

Skonfiguruj bota Telegram do śledzenia wielorybów transferów Fan Tokens używając indeksera Envio, przechwytując zdarzenia transferów na Chiliz Chain i wyzwalając alerty po przekroczeniu progu.

Monitorowanie transferów Fan Tokens na Chiliz Chain to świetny sposób na śledzenie ruchów o wysokiej wartości i informowanie społeczności.

Przy odrobinie konfiguracji i kodu możesz skonfigurować bota Telegram, który powiadomi grupę za każdym razem, gdy transfer Fan Tokena przekroczy określony próg.

Jak to zrobić za pomocą Envio?

Envio to potężne narzędzie indeksowania, które pozwala deweloperom nasłuchiwać zdarzeń smart kontraktów na Chiliz i podejmować działania na podstawie zdarzenia.

W tym poradniku zobaczysz, jak skonfigurować bota, przechwytywać odpowiednie zdarzenia i automatycznie wyzwalać alerty Telegram, zamieniając konfigurację w "strażnika wielorybów" dla dużych transferów.

Krok 1: Zainstaluj wymagania wstępne

Zanim zaczniesz, upewnij się, że masz zainstalowane wymagane narzędzia:

• pnpm

• Node.js

• Docker

Pełny projekt znajdziesz w tym repozytorium GitHub.

Krok 2: Zainicjuj indekser Envio

Uruchom następujące polecenie, aby zainicjować indekser Envio i postępuj zgodnie z promptami, aby wygenerować szablon ERC20 na Chiliz Chain (która jest blockchainem kompatybilnym z EVM):

pnpx envio init

Oto wybory, które powinieneś dokonać po wyświetleniu promptów:

Krok 3: Skonfiguruj config.yaml

Zmodyfikuj plik config.yaml, aby określić adres kontraktu Fan Tokena FC Barcelona (lub dowolnego innego Fan Tokena, który chcesz śledzić):

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

Uwaga: Usuwamy zdarzenie approval, ponieważ interesują nas tylko transfery.

Krok 4: Uprość schemat GraphQL

Zmodyfikuj plik schema.graphql, aby śledzić tylko salda kont:

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

W tym miejscu mamy indekser ERC20, który nasłuchuje zdarzeń.

Teraz dodajmy logikę do wysyłania powiadomień Telegram.

Krok 5: Zaimplementuj logikę powiadomień Telegram

Zmodyfikuj plik /src/EventHandlers.ts, aby zawierał logikę wykrywania dużych transferów i wysyłania alertów Telegram.

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);
});

Przykładowy folder /libs/ znajdziesz tutaj na GitHub, w tym pliki helpers.ts i ens.ts.

Krok 6: Skonfiguruj stałe

Utwórz plik constants.ts do przechowywania zmiennych środowiskowych:

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;

Krok 7: Wysyłanie wiadomości Telegram

Zainstaluj klienta HTTP Axios:

pnpm i axios

Utwórz funkcję pomocniczą w libs/telegram.ts do wysyłania wiadomości za pomocą Axios:

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);
  }
};

Krok 8: Finalna konfiguracja i uruchomienie indeksera

Skonfiguruj plik .env

cp .env.example .env

Edytuj .env z danymi uwierzytelniającymi bota Telegram:

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

Utwórz bota Telegram

1. Wyślij wiadomość do @BotFather na Telegram i uruchom:

   /newbot

2. Postępuj zgodnie z promptami, aby uzyskać token bota.

3. Dodaj bota do grupy Telegram i uruchom /start.

4. Odwiedź https://api.telegram.org/bot<YourBOTToken>/getUpdates, aby znaleźć ID czatu grupy.

Jeśli stworzyłeś nową grupę z botem i dostajesz tylko {"ok":true,"result":[]}, usuń bota z grupy i dodaj go ponownie.

Na koniec, zainstaluj zależności i uruchom indekser

pnpm i
pnpm envio dev

Dzięki tej konfiguracji masz teraz indekser oparty na Envio, który nasłuchuje transferów Fan Tokens i wysyła alerty o wielorybach do Telegrama.

Idąc dalej, możesz samodzielnie hostować indekser lub wdrożyć go do usługi hostowanej Envio.

Ponieważ zapisujemy salda, może być też używany jako API sald GraphQL.