So richtest du einen Solana-Telegram-Bot ein

Schritte zum Einrichten eines Telegram-Bots

1. Richte den Telegram-Kanal und den Telegram-Bot ein.
2. Erstelle einen Cloudflare Worker als Verbindung zwischen dem Webhook, der Updates sendet, und dem Telegram-Bot.
3. Erstelle einen Helius-Webhook.
4. Bearbeite über die Helius Webhook API die Adressen, die der Webhook verfolgt. Dieser Schritt ist nur erforderlich, wenn du ganze NFT-Sammlungen verfolgen möchtest.

Telegram-Bot einrichten

Mit Telegram-Bots kannst du bestimmte Aufgaben, insbesondere Updates, hervorragend automatisieren. So richtest du einen Bot ein.

1. Unterhaltung mit BotFather starten

Suche in der Telegram-Suchleiste nach „BotFather“ und klicke darauf, um eine Unterhaltung zu beginnen.

2. Neuen Bot erstellen

Gib „/newbot“ ein und sende die Nachricht. BotFather führt dich jetzt durch die Vergabe eines Namens und Benutzernamens für deinen Bot.

3. Zugriffstoken abrufen

Anschließend stellt BotFather ein Zugriffstoken bereit.

Notiere es an einem sicheren Ort, da wir es später in diesem Tutorial benötigen.

4. Deinen Kanal erstellen

Öffne das Menü (☰) und wähle „Neuer Kanal“ aus.

Nachdem du den Kanal eingerichtet hast, klicke auf seinen Namen, wähle „Administratoren“ aus und füge deinen Bot als Administrator hinzu.

5. Chat-ID ermitteln

So ermittelst du die Chat-ID deines Kanals:

Nachricht senden:

Sende zuerst eine Nachricht an den erstellten Kanal.

Telegram API verwenden

Rufe in deinem Browser https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates auf und ersetze <YOUR_BOT_TOKEN> durch das Token, das du von BotFather erhalten hast.

Chat-ID finden

In den zurückgegebenen Daten findest du ein Feld namens chat. Darin befindet sich eine id, die der Chat-ID deines Kanals entspricht.

Notiere diese Chat-ID sicher, da du sie für weitere Konfigurationen benötigst.

Cloudflare Worker erstellen

Mit Cloudflare Workers kannst du online gehosteten Code bereitstellen, der dauerhaft ausgeführt wird und kontinuierlich auf Updates deines Webhooks wartet.

1. Bei Cloudflare anmelden

Melde dich zunächst bei deinem Cloudflare-Konto an. Falls du noch keines hast, kannst du dich kostenlos registrieren.

2. Workers-Bereich öffnen

Öffne im Cloudflare-Dashboard den Tab „Workers“.

3. Neuen Worker erstellen

Klicke auf die Schaltfläche „Worker erstellen“. Dadurch gelangst du zum Worker-Editor.

4. Worker-Code bearbeiten

Im Editor siehst du eine Skriptvorlage. Ersetze den Standardcode durch den bereitgestellten Cloudflare-Code für deinen Telegram-Bot.

Suche im Code nach den Variablen für BOT_TOKEN und CHAT_ID. Dies sind Platzhalter, mit denen dein Bot Nachrichten an den richtigen Chat sendet.

5. Umgebungsvariablen konfigurieren

Öffne im Cloudflare-Workers-Dashboard den Tab „Einstellungen“ deines Workers.

Hier kannst du das Token deines Bots, das Chat-Token und deinen Helius-API-Schlüssel als Umgebungsvariablen hinzufügen. Dadurch bleiben vertrauliche Daten sicher und von deinem Hauptcode getrennt.

Achte darauf, diese Umgebungsvariablen so zu benennen, wie es dein Code erwartet, z. B. BOT_TOKEN, CHAT_ID usw.

6. Worker bereitstellen

Wenn Code und Umgebungsvariablen korrekt eingerichtet sind, klicke auf die Schaltfläche „Speichern und bereitstellen“. Dein Worker wird bereitgestellt und erhält eine eindeutige öffentliche URL.

7. Öffentliche URL notieren

Notiere nach der Bereitstellung die öffentliche URL deines Workers. Diese URL verwendest du als Webhook-Endpunkt für deinen Telegram-Bot.

Cloudflare-Worker-Code:

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

Helius-Webhook einrichten

Helius-Webhooks verbinden Änderungen auf der Solana-Blockchain mit deinem Telegram-Kanal. In diesem Beispiel richte ich einen Webhook ein, der alle Transaktionen eines bestimmten Wallets verfolgt.

1. Registrieren

Rufe dashboard.helius.dev auf und erstelle ein kostenloses Konto.

2. Webhook erstellen

Erstelle in deinem Dashboard einen neuen Webhook. Du kannst zwischen den Typen Raw, Enhanced, Discord und Account wählen. Für spezifische, kategorisierte Updates empfehlen wir „Enhanced“. Gib bei dieser Auswahl an, welche Updates dich interessieren, z. B. NFT_SALES oder NFT_LISTING.

Eine vollständige Liste findest du hier.

3. Worker-Link und Solana-Adresse angeben

Gib den Link zu deinem bereitgestellten Cloudflare Worker an. Füge außerdem die Adresse des Solana-Kontos hinzu, das du überwachen möchtest. Das kann das Wallet eines Benutzers oder eine Liste von Mints aus einer Sammlung sein.

NFT-Sammlungen verfolgen (Verkaufs-Bot einrichten)

Wenn du eine bestimmte Sammlung verfolgen und bei Ereignissen zu einem NFT aus dieser Sammlung Updates erhalten möchtest, musst du alle NFT-Mint-Adressen als Konten zu deinem Webhook hinzufügen. Verwende dazu den Helius-Webhook-Endpunkt, um den zuvor erstellten Webhook zu bearbeiten. Nach der Einrichtung kannst du Verkäufe, Listings, Gebote, Burns und alle anderen Transaktionen verfolgen, an denen ein NFT beteiligt ist.

Zuerst benötigst du eine Hash-/Mint-Liste für die Sammlung, die du verfolgen möchtest. Mit dem folgenden Code kannst du über DAS eine Mint-Liste abrufen. Füge einfach deinen Helius-API-Schlüssel ein und ersetze creatorAddress durch die Adresse des ersten verifizierten Erstellers eines NFT. Du findest den ersten verifizierten Ersteller in deinem bevorzugten Solana-Block-Explorer. Suche dort nach den Metadaten und dann im Abschnitt für Ersteller nach der Adresse:

Snapshot-Code:

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

Anschließend kannst du das Skript ausführen. Öffne dazu dein Terminal, navigiere zum Verzeichnis mit dem Skript und führe node snapshot.js aus. Dadurch wird in diesem Verzeichnis eine JSON-Datei namens addresses.json erstellt. Alternativ kannst du mit einem Tool wie dem Snapshot-Tool von Magic Eden eine Hash-Liste abrufen.

Mit einer Hash-Liste kannst du die Liste der Konten aktualisieren, die dein Webhook verfolgt. Verwende dazu den Helius-Webhook-Endpunkt. Unten findest du Code, der diesen Vorgang vereinfacht. Erstelle eine neue JavaScript-Datei namens webhookUpdate.js im selben Verzeichnis wie deine Hash-Liste und füge den folgenden Code ein. Trage anschließend deinen Helius-API-Schlüssel und deine Webhook-ID ein. Die ID findest du im Entwicklerportal. Passe dann den Body der Anfrage an die Daten an, die du beim Erstellen des Webhooks verwendet hast. Wenn du beispielsweise NFT-Listings und -Verkäufe verfolgen möchtest, musst du diese angeben. Bearbeite das Feld accountAddresses nicht, da es bereits die zuvor erstellte Hash-Liste verwendet.

Nachdem du diese Änderungen vorgenommen hast, kannst du das Skript im Terminal mit node webhookUpdate.js ausführen. Anschließend solltest du im Terminal eine Bestätigung erhalten.

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

Nachdem du den Webhook aktualisiert hast, kannst du zum Cloudflare Worker zurückkehren und den Code so bearbeiten, dass er NFT-spezifische Details zurückgibt. Der erforderliche Code ist bereits enthalten. Du musst lediglich den Abschnitt zum Senden von TRANSFER-Updates auskommentieren und den Abschnitt zum Senden von NFT-Updates einkommentieren.

Wenn ein von dir verfolgtes Ereignis On-Chain stattfindet, sendet der Webhook ein Update an den Cloudflare Worker. Dieses Update hat das JSON-Format und enthält normalerweise viele Informationen, etwa alle beteiligten Konten, Änderungen an jedem Konto und Angaben zum Ereignistyp. Der bereitgestellte Code extrahiert die Informationen, die wir für wichtig halten.

Wenn du die gesendete Nachricht anpassen oder die aus dem Webhook-Update extrahierten Daten ändern möchtest, kannst du die Variable messageToSend bearbeiten. Du kannst auch andere Ereignisse als Übertragungen und NFT-Ereignisse verfolgen. Passe den Cloudflare-Code so an, dass er den gesamten requestBody[0] sendet. Dadurch wird die vollständige JSON-Antwort des Webhooks an deinen Telegram-Bot weitergeleitet und du kannst ihre Struktur prüfen. Anschließend kannst du entscheiden, welche Abschnitte du in deine Nachricht aufnehmen möchtest.

Mit dieser Einrichtung wird dein Telegram-Kanal dank Helius-Webhooks zu einer zentralen Anlaufstelle für Echtzeit-Updates von der Solana-Blockchain. Wir hoffen, dass dir dieser Leitfaden geholfen hat. Bei Fragen oder Problemen kannst du dem Team gerne auf Discord oder X schreiben.