Erstelle einen Solana-Telegram-Bot mit weniger als 100 Codezeilen

Projekt einrichten

Richte dein Projekt ein und starte es:

1. Repository klonen

git clone https://github.com/helius-labs/cloudfare-telegram-template.git

cd cloudfare-telegram-template

2. Abhängigkeiten installieren

npm install

3. Umgebungsvariablen konfigurieren

Öffne wrangler.toml und trage die folgenden Schlüssel ein:

TELEGRAM_BOT_TOKEN

1. Öffne Telegram und suche nach @BotFather.
2. Starte einen Chat mit BotFather und sende den Befehl /newbot. 
3. Folge den Anweisungen, um einen Namen und Benutzernamen für deinen Bot auszuwählen. 
4. Nach dem Erstellen gibt dir BotFather ein Token. Das ist dein TELEGRAM_BOT_TOKEN. 

TELEGRAM_CHAT_ID

1. Erstelle einen Kanal und füge deinen Bot als Administrator hinzu.
2. Sende eine Nachricht an den Kanal.
3. Öffne: https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates
4. Suche in der Antwort nach dem Feld "chat":{"id":. Das ist dein TELEGRAM_CHAT_ID.
5. Eine Schritt-für-Schritt-Anleitung findest du in diesem Video:

HELIUS_API_KEY Dein Helius API-Schlüssel (du erhältst ihn bei Helius)

AUTH_TOKEN Öffne Bash und generiere einen eindeutigen AUTH_TOKEN:

openssl rand -base64 32

4. Auf Cloudflare bereitstellen

npm run deploy

Nachdem du diesen Befehl ausgeführt hast, erscheint die URL deiner Bereitstellung in der Konsolenausgabe. Notiere dir diese URL. Du benötigst sie im nächsten Schritt.

5. Deinen webhook erstellen

Erstelle deinen webhook mit der Bereitstellungs-URL aus dem vorherigen Schritt:

curl -X POST https://your-worker-url.workers.dev/create-webhook

Nachdem du diesen Befehl ausgeführt hast, erhältst du eine Erfolgsmeldung.

Du kannst den neuen webhook anzeigen, den du in deinem Helius-Dashboard eingerichtet hast.

6. Deinen webhook bearbeiten

Nachdem du deinen webhook erstellt hast, kannst du ihn im Helius-Dashboard weiter anpassen: 

1. Öffne in deinem Dashboard den Bereich für webhooks
2. Dein neu erstellter webhook sollte in der Liste erscheinen. 
3. Klicke auf den webhook, um seine Einstellungen zu bearbeiten.
4. Hier kannst du verschiedene Parameter ändern, darunter:
   • Transaktionstypen, die du verfolgen möchtest
   • Bestimmte Wallet-Adressen, die du überwachen möchtest
   • Netzwerk (Mainnet, Devnet)

Der Code im Detail

Sehen wir uns zuerst die Imports und Typdefinitionen an:

import { Hono } from 'hono';

type Env = {
  HELIUS_API_KEY: string;
  TELEGRAM_BOT_TOKEN: string;
  TELEGRAM_CHAT_ID: string;
  AUTH_TOKEN: string;
};

‍Wir verwenden Hono, ein schlankes Web-Framework für Cloudflare Workers. Der Typ Env definiert unsere Umgebungsvariablen für die Integrationen mit Helius und Telegram.

Als Nächstes richten wir unsere Hono-App ein:‍

const app = new Hono<{ Bindings: Env }>();

app.get('/', (c) => c.text('Solana Action Bot is running!'));

Dadurch wird unsere App erstellt und ein einfacher Endpunkt für Zustandsprüfungen eingerichtet.

Erstellen wir nun unseren webhook:

app.post('/create-webhook', async (c) => {
  const webhookURL = `${new URL(c.req.url).origin}/webhook`;
  console.log('Setting up webhook with URL:', webhookURL);

  const response = await fetch(
    `https://api.helius.xyz/v0/webhooks?api-key=${c.env.HELIUS_API_KEY}`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        webhookURL: webhookURL,
        transactionTypes: ["NFT_SALE"],
        accountAddresses: ["M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"], // Magic Eden v2 program
        webhookType: "enhanced",
        authHeader: c.env.AUTH_TOKEN
      }),
    }
  );
  const data = await response.json();
  console.log('Helius webhook setup response:', data);
  return c.json({ success: true, webhook: data, webhookURL: webhookURL });
});

Dieser Endpunkt richtet unseren Helius webhook ein. In diesem Beispiel verfolgen wir NFT-Verkäufe über das Magic-Eden-v2-Programm. Du kannst transactionTypes und accountAddresses jedoch an deine Anforderungen anpassen.‍

So senden wir Nachrichten an Telegram:

async function sendTelegramMessage(message: string, env: Env) {
  const url = `https://api.telegram.org/bot${env.TELEGRAM_BOT_TOKEN}/sendMessage`;
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      chat_id: env.TELEGRAM_CHAT_ID,
      text: message,
      parse_mode: 'Markdown',
    }),
  });
  return response.json();
}

Diese Funktion formatiert unsere Nachricht und sendet sie an unseren Telegram-Chat.

Zum Schluss verarbeiten wir die eingehenden webhook-Daten:

app.post('/webhook', async (c) => {

  const authToken = c.req.header('Authorization');
  if (authToken !== c.env.AUTH_TOKEN) {
    return c.text('Unauthorized', 401);
  }

  let data;
  try {
    data = await c.req.json();
    console.log('Received webhook data:', JSON.stringify(data, null, 2));
  } catch (error) {
    console.error('Error parsing webhook data:', error);
    return c.text('Error processing webhook', 400);
  }

  if (!Array.isArray(data) || data.length === 0) {
    console.log('No transactions in webhook data');
    return c.text('No transactions to process', 200);
  }

  for (const transaction of data) {
    if (transaction.type === 'NFT_SALE') {
      const { amount, buyer, seller, signature, nfts } = transaction.events.nft;
      const message = `🎉 *NFT Sale*\n\n` +
        `*Price*: ${amount / 1e9} SOL\n` +
        `*Buyer*: \`${buyer}\`\n` +
        `*Seller*: \`${seller}\`\n` +
        `*Signature*: [View on Solana Explorer](https://explorer.solana.com/tx/${signature})`;

      try {
        const result = await sendTelegramMessage(message, c.env);
        console.log('Telegram message sent:', result);
      } catch (error) {
        console.error('Error sending Telegram message:', error);
      }
    }
  }

  return c.text('Webhook processed');
});

‍Hier verarbeiten wir die Daten von Helius und senden formatierte Nachrichten an Telegram. Du kannst diesen Teil an deinen Anwendungsfall anpassen, um andere Transaktionstypen zu verarbeiten oder andere Informationen zu extrahieren.

Anpassungsmöglichkeiten

Unser Beispiel konzentriert sich auf NFT-Verkäufe. Du kannst diese Vorlage aber leicht an verschiedene Anwendungsfälle anpassen:

1. Ändere transactionTypes beim Erstellen des webhooks, um andere Ereignisse zu verfolgen
2. Ändere accountAddresses, um bestimmte Programme oder Wallets zu überwachen
3. Passe die Nachrichtenformatierung im Endpunkt /webhook an deine Datenanforderungen an
4. Implementiere zusätzliche Logik, um die eingehenden Daten zu filtern oder zu verarbeiten‍

In der Dokumentation zu Helius webhooks findest du alle Daten und Ereignisse, die du verfolgen kannst. Beschränke dich jedoch nicht auf die ausdrücklich definierten Ereignisse. Helius webhooks sind äußerst vielseitig und können zahlreiche Onchain-Aktivitäten verfolgen, selbst wenn diese in unserer Dokumentation nicht direkt geparst oder erwähnt werden.

Du könntest zum Beispiel folgende Ereignisse verfolgen:

• Token-Transfers für bestimmte SPL-Token
• Bereitstellungen neuer Programme
• Erstellung von Raydium-Pools oder Hinzufügen von Liquidität
• Erstellung von Governance-Vorschlägen oder Abstimmungen
• Starts von Metaplex Candy Machines
• Erstellung von Serum-Märkten

Mit dieser Vorlage kannst du Telegram-Bots für zahlreiche Solana-Überwachungsaufgaben erstellen – von Ereignissen in DeFi-Protokollen bis zur Verfolgung von Wallet-Aktivitäten und mehr.

Vielen Dank, dass du bis hierher gelesen hast! Wir hoffen, diese Anleitung hat dir den Einstieg in die Erstellung deines eigenen Solana-Telegram-Bots erleichtert. Abonniere unseren Newsletter, damit du keine Neuigkeiten zu Solana verpasst. Möchtest du tiefer einsteigen? Entdecke die neuesten Artikel im Helius-Blog und setze deine Solana-Reise noch heute fort.

Weitere Ressourcen

1. Helius-Dokumentation
2. Dokumentation zu Cloudflare Workers
3. Telegram Bot API
4. Hono-Dokumentation