Comment configurer un bot Telegram sur Solana

Étapes pour configurer un bot Telegram

1. Configurez le canal Telegram et le bot Telegram.
2. Créez un worker Cloudflare pour assurer la connexion entre le webhook qui envoie les mises à jour et le bot Telegram.
3. Créez un webhook Helius.
4. Modifiez les adresses suivies par le webhook via l’API Helius Webhook. Cette étape est uniquement nécessaire pour suivre des collections NFT entières.

Configurer un bot Telegram

Les bots Telegram sont un excellent moyen d’automatiser certaines tâches, notamment l’envoi de mises à jour. Voici comment en configurer un.

1. Démarrer une conversation avec BotFather

Recherchez « BotFather » dans la barre de recherche de Telegram, puis cliquez dessus pour démarrer une conversation.

2. Créer un nouveau bot

Saisissez et envoyez « /newbot ». BotFather vous guidera ensuite pour nommer votre bot et lui attribuer un nom d’utilisateur.

3. Obtenir un token d’accès

Une fois l’opération terminée, BotFather vous fournira un token d’accès.

Conservez-le en lieu sûr, car nous l’utiliserons plus tard dans ce tutoriel.

4. Créer votre canal

Ouvrez le menu (☰) et sélectionnez « Nouveau canal ».

Une fois le canal configuré, cliquez sur son nom, sélectionnez « Administrateurs », puis ajoutez votre bot en tant qu’administrateur.

5. Trouver l’ID du chat

Pour déterminer l’ID du chat de votre canal, procédez comme suit :

Envoyer un message :

Commencez par envoyer un message au canal que vous avez créé.

Utiliser l’API Telegram

Accédez à https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates dans votre navigateur, en remplaçant <YOUR_BOT_TOKEN> par le token reçu de BotFather.

Localiser l’ID du chat

Dans les données renvoyées, vous trouverez un champ nommé chat contenant un id, qui correspond à l’ID du chat de votre canal.

Pensez à conserver cet ID de chat en lieu sûr, car vous en aurez besoin pour la suite de la configuration.

Créer un worker Cloudflare

Les workers Cloudflare vous permettent de déployer du code hébergé en ligne et exécuté en continu afin de surveiller les mises à jour provenant de votre webhook.

1. Se connecter à Cloudflare

Commencez par vous connecter à votre compte Cloudflare. Si vous n’en avez pas encore, vous pouvez en créer un gratuitement.

2. Accéder à la section Workers

Dans le tableau de bord Cloudflare, accédez à l’onglet « Workers ».

3. Créer un nouveau Worker

Cliquez sur le bouton « Create a Worker ». Vous accéderez alors à l’éditeur de Worker.

4. Modifier le code du Worker

Dans l’éditeur, vous verrez un modèle de script. Remplacez le code par défaut par le code Cloudflare fourni pour votre bot Telegram.

Repérez les variables BOT_TOKEN et CHAT_ID dans le code. Il s’agit d’espaces réservés qui serviront à envoyer des messages via votre bot vers le bon chat.

5. Configurer les variables d’environnement

Dans le tableau de bord Cloudflare Workers, accédez à l’onglet « Settings » de votre worker.

Vous pouvez y ajouter le token de votre bot, le token du chat et votre clé API Helius en tant que variables d’environnement. Cela permet de sécuriser les données sensibles en les séparant de votre code principal.

Veillez à nommer correctement ces variables d’environnement afin qu’elles correspondent aux noms attendus dans votre code (par exemple, BOT_TOKEN, CHAT_ID, etc.).

6. Déployer le Worker

Après avoir vérifié que votre code et vos variables d’environnement sont correctement configurés, cliquez sur le bouton « Save and Deploy ». Votre worker sera déployé et se verra attribuer une URL publique unique.

7. Noter l’URL publique

Après le déploiement, veillez à noter l’URL publique attribuée à votre worker. Vous l’utiliserez comme endpoint du webhook pour votre bot Telegram.

Code du worker Cloudflare :

const TELEGRAM_BOT_TOKEN = BOT_TOKEN;
const TELEGRAM_CHAT_ID = CHAT_ID;
const HELIUS_API_KEY=API_KEY;
const HELIUS_RPC_URL = `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`;

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  if (request.method === 'POST') {
    const requestBody = await request.json();
    console.log('Received POST request with body:', requestBody);

    //THIS IS FOR NFT UPDATES (comment this section out if you are doing something else)
    // Extract transaction description, timestamp, signature, and mint address
      // const NFTdescription = requestBody[0].description;
      // const NFTtimestamp = new Date(requestBody[0].timestamp * 1000).toLocaleString(); // Convert Unix timestamp to readable date-time
      // const NFTsignature = `https://solscan.io/tx/${requestBody[0].signature}`
      // const NFTmintAddress = requestBody[0].events.nft.nfts[0].mint;
      // const NFTimageUrl = await getAssetImageUrl(NFTmintAddress);// Get NFT image URL
      // // Construct the message
      // const messageToSendNFT =
      // `----NEW UPDATE---\n`+
      // `Description:\n${NFTdescription}\n` +
      // `Mint Address:\n${NFTmintAddress}\n` +
      // `Signature:\n${NFTsignature}\n` +
      // `Timestamp:\n${NFTtimestamp}`;
      // await sendToTelegramNFT(messageToSendNFT, NFTimageUrl); // Send to Telegram

    //THIS IS FOR TRANSFER UPDATES (comment this section out if you are doing something else)
    // Extract transaction description, timestamp, signature
      const Transferdescription = requestBody[0].description;
      const Transfertimestamp = new Date(requestBody[0].timestamp * 1000).toLocaleString(); // Convert Unix timestamp to readable date-time
      const Transfersignature = `https://xray.helius.xyz/tx/${requestBody[0].signature}`
      // Construct the message
      const messageToSendTransfer =
      `----NEW UPDATE---\n`+
      `Description:\n${Transferdescription}\n` +
      `Signature:\n${Transfersignature}\n` +
      `Timestamp:\n${Transfertimestamp}`;
      await sendToTelegramTransfer(messageToSendTransfer); // Send to Telegram

    return new Response('Logged POST request body.', {status: 200});
  } else {
    return new Response('Method not allowed.', {status: 405});
  }
}

// This function is used to send NFT Updates to the bot
async function sendToTelegramNFT(message, imageUrl) {
  const telegramUrl = `https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendPhoto`;
  const response = await fetch(telegramUrl, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      chat_id: TELEGRAM_CHAT_ID,
      photo: imageUrl,
      caption: message,
      parse_mode: "HTML"
    }),
  });
  const responseData = await response.json();

  if (!response.ok) {
    console.error('Failed to send photo to Telegram:', responseData);
  }
}

//This function is used to send Transfer Updates to the Bot
async function sendToTelegramTransfer(message) {
  const telegramUrl = `https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage`;
  const response = await fetch(telegramUrl, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      chat_id: TELEGRAM_CHAT_ID,
      text: message,
      parse_mode: "HTML"
    }),
  });
  const responseData = await response.json();

  if (!response.ok) {
    console.error('Failed to send message to Telegram:', responseData);
  }
}

//This function gets images associated to NFTs that are features in updates.
async function getAssetImageUrl(mintAddress) {
  const response = await fetch(HELIUS_RPC_URL, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-id',
      method: 'getAsset',
      params: {
        id: mintAddress,
      },
    }),
  });
  const { result } = await response.json();
  return result.content.links.image;
}

Configurer un webhook Helius

Les webhooks Helius font le lien entre les changements sur la blockchain Solana et votre canal Telegram. Dans cet exemple, je vais configurer un webhook pour suivre toutes les transactions effectuées par un portefeuille donné.

1. S’inscrire

Accédez à dashboard.helius.dev et créez un compte gratuit.

2. Créer un webhook

Dans votre tableau de bord, choisissez de créer un nouveau webhook. Vous pourrez sélectionner son type : Raw, Enhanced, Discord ou Account. Pour recevoir des mises à jour classées par catégorie, le type « Enhanced » est recommandé. Lorsque vous le sélectionnez, précisez les mises à jour qui vous intéressent, par exemple NFT_SALES ou NFT_LISTING.

Une liste complète est disponible ici.

3. Fournir le lien du worker et l’adresse Solana

Veillez à fournir le lien vers votre worker Cloudflare déployé. Indiquez également l’adresse du compte Solana que vous souhaitez surveiller, qu’il s’agisse du portefeuille d’un utilisateur ou d’une liste de mints d’une collection.

Comment suivre des collections NFT (configuration d’un bot de ventes)

Si vous souhaitez suivre une collection et recevoir des mises à jour lorsqu’un événement concerne l’un de ses NFT, vous devez ajouter toutes les adresses de mint des NFT comme comptes dans votre webhook. Pour cela, utilisez l’endpoint du webhook Helius afin de modifier le webhook créé précédemment. Une fois la configuration terminée, vous pourrez suivre les ventes, les mises en vente, les enchères, les destructions et toute autre transaction impliquant un NFT.

Vous aurez d’abord besoin d’une liste de hachages ou de mints pour la collection à suivre. Vous pouvez utiliser le code suivant pour obtenir une liste de mints avec DAS. Il vous suffit d’ajouter votre clé API Helius et de remplacer creatorAddress par l’adresse du premier créateur vérifié d’un NFT. Pour trouver ce premier créateur vérifié, accédez à votre explorateur de blocs Solana préféré, consultez les métadonnées et repérez l’adresse dans la section des créateurs :

Code du snapshot :

const fs = require('fs');
const url = `https://mainnet.helius-rpc.com/?api-key=`;

const getAssetsByCreator = async () => {
  let page = 1;
  let allMintAddresses = [];

  while (true) {
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: `my-id-page-${page}`,
        method: 'getAssetsByCreator',
        params: {
          creatorAddress: 'GFQBHxuNcAwYwHtEpggMwbH5kwV6Ne4JowHbLVfsMC6C',
          onlyVerified: true,
          page: page,
          limit: 1000
        },
      }),
    });

    const { result } = await response.json();

    // If there are no more items, break the loop
    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }else{
      if (!result.items || result.items.length === 0) {
        break;
      }
    }

    // Extract mint addresses and add them to the list
    const mintAddresses = result.items.map(item => item.id);
    allMintAddresses.push(...mintAddresses);

    // Check if there are less than 1000 results to stop further requests
    if (result.items.length < 1000) {
      break;
    }

    page++;
  }

  // Join the addresses by comma
  const addressesString = allMintAddresses.join(',');
  console.log("All Mint Addresses: ", addressesString);
  fs.writeFileSync('addresses.json', JSON.stringify(allMintAddresses, null, 2));
};

getAssetsByCreator();

Une fois cette étape terminée, vous pouvez exécuter le script en ouvrant votre terminal, en accédant au répertoire qui contient le script, puis en exécutant node snapshot.js. Cela créera dans ce répertoire un fichier JSON nommé addresses.json. Vous pouvez également utiliser un outil comme l’outil de snapshot de Magic Eden pour obtenir une liste de hachages.

Une fois votre liste de hachages obtenue, vous pouvez mettre à jour la liste des comptes suivis par votre webhook. Pour cela, vous devez utiliser l’endpoint des webhooks Helius. Le code ci-dessous simplifie cette opération. Créez simplement un fichier JavaScript nommé webhookUpdate.js dans le même répertoire que votre liste de hachages, puis ajoutez-y le code ci-dessous. Modifiez ensuite le code pour inclure votre clé API Helius et l’ID de votre webhook, disponible sur le portail développeur. Vous devrez également modifier le corps de la requête afin qu’il corresponde aux données utilisées lors de la création du webhook. Par exemple, si vous avez choisi de suivre les mises en vente et les ventes de NFT, veillez à les inclure. Ne modifiez pas le champ accountAddresses, car il est configuré pour utiliser la liste de hachages créée précédemment.

Une fois ces modifications effectuées, vous pouvez exécuter ce script depuis votre terminal avec node webhookUpdate.js. Après l’exécution du code, un message de confirmation devrait s’afficher dans le terminal.

webhookUpdate.js :

const fs = require('fs');

const editWebhook = async () => {
    try {
      // Read the JSON file
      const addresses = JSON.parse(fs.readFileSync('addresses.json', 'utf8'));
  
      const response = await fetch(
        "https://api.helius.xyz/v0/webhooks/?api-key=",
        {
          method: 'PUT',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            webhookURL: "",
            transactionTypes: ["NFT_LISTING","NFT_SALE"],
            accountAddresses: addresses,  // Use the addresses from the file
            webhookType: "enhanced"
          }),
        }
      );
      const data = await response.json();
      console.log({ data });
    } catch (e) {
      console.error("error", e);
    }
  };
  
  editWebhook();

Une fois le webhook mis à jour, vous pouvez revenir au worker Cloudflare et modifier le code afin qu’il renvoie des informations propres aux NFT. Le code nécessaire est déjà inclus : il vous suffit de commenter la section qui envoie les mises à jour TRANSFER et de décommenter celle qui envoie les mises à jour NFT.

Lorsqu’un événement que vous suivez se produit en chaîne, le webhook envoie une mise à jour au worker Cloudflare. Cette mise à jour est au format JSON et contient généralement de nombreuses informations, notamment tous les comptes impliqués, les changements apportés à chaque compte et des informations sur le type d’événement. Dans le code fourni, nous extrayons les éléments qui nous semblent importants.

Si vous souhaitez personnaliser le message envoyé ou modifier les données extraites de la mise à jour du webhook, vous pouvez modifier la variable messageToSend. Vous pouvez également suivre d’autres événements que les transferts et les événements NFT. Modifiez le code Cloudflare afin d’envoyer l’intégralité de requestBody[0]. La réponse JSON complète du webhook sera alors transférée à votre bot Telegram, ce qui vous permettra d’en examiner la structure. Vous pourrez ensuite choisir les sections à inclure dans votre message.

Grâce à cette configuration, votre canal Telegram devient un hub de mises à jour en temps réel provenant de la blockchain Solana, le tout grâce aux webhooks Helius. Nous espérons que ce guide vous a été utile. Si vous avez des questions ou rencontrez des problèmes, n’hésitez pas à contacter l’équipe sur Discord ou X.