So überwachst du einen Raydium-Liquiditätspool

Per Webhook

Für die Umsetzung per Webhook sind drei grundlegende Schritte erforderlich. Zuerst richten wir einen Cloudflare Worker ein. Danach richten wir einen Helius-Webhook ein und fügen die URL des Cloudflare Workers hinzu. Der Webhook löst den Worker jedes Mal aus, wenn eine Transaktion im Liquiditätspool erfasst wird. Abschließend passen wir den Code des Workers an, damit er diese Benachrichtigung verarbeitet und die Antwort protokolliert.

Cloudflare Worker einrichten

Wir richten einen Worker ein, den unser Webhook auslöst. Anschließend ergänzen wir den Worker um Code, der den Auslöser unseres Webhooks verarbeitet. Mit Cloudflare Workers kannst du serverlosen Code bereitstellen. Melde dich auf der Website von Cloudflare an oder registriere dich. Wähle dann auf der Hauptseite im linken Bereich Workers & Pages aus.

‍Klicke auf die Schaltfläche Create application.

‍Klicke anschließend auf Create Worker.

‍Klicke jetzt auf Deploy.

‍Der Worker wurde erfolgreich bereitgestellt. Kopiere den Link des Workers, da wir ihn zum Einrichten unseres Webhooks benötigen.

Webhook einrichten

Wir überwachen Raydium, den ersten auf Solana entwickelten AMM, der ein vollständig dezentrales Central Limit Order Book nutzt. Ein Central Limit Order Book ist eine im Aktienhandel übliche Ausführungsmethode, die alle Kauf- und Verkaufsaufträge nach Preis- und Zeitpriorität zusammenführt. Ein dezentrales Central Limit Order Book (CLOB) ist ein Börsensystem, das statt einer zentralen Instanz ein verteiltes Netzwerk von Nodes nutzt. 

Wir erstellen einen Webhook mit Helius. Mit Webhooks kannst du On-Chain-Ereignisse verfolgen und bestimmte Aktionen auslösen, sobald diese Ereignisse eintreten. Wir konfigurieren den Webhook so, dass er bestimmte Transaktionstypen in einem vorgegebenen Raydium-Liquiditätspool erfasst. Helius unterstützt derzeit die folgenden Transaktionstypen für Raydium: 

"RAYDIUM": [
   "WITHDRAW_LIQUIDITY"
   "ADD_LIQUIDITY"
   "CREATE_POOL"
   "SWAP"
 ]

Webhooks kannst du über das Helius Dashboard oder die API-Referenz erstellen. Um einen Webhook über das Dashboard zu erstellen, öffne im linken Bereich den Abschnitt Webhooks und klicke auf New Webhook.

Konfiguriere den Webhook anschließend mit den folgenden Angaben:

1. Netzwerk: Mainnet/Devnet
2. Webhook-Typ: Wähle je nach gewünschten Daten zwischen den Webhook-Typen Enhanced, Raw und Discord. Wenn du für Menschen lesbare Daten benötigst, wähle Enhanced. Das ist auch unsere Auswahl. Wenn du Discord bevorzugst, musst du die Webhook-URL angeben. Der Bot formatiert und sendet die Benachrichtigungen dann direkt. In diesem Artikel erfährst du, wie du einen Webhook für einen Discord-Bot einrichtest. Beachte bei der Auswahl von Raw, dass du den Transaktionstyp nicht angeben kannst.
3. Transaktionstyp: Wähle die im folgenden Bild gezeigten Transaktionstypen aus*.* Weitere von einem Programm unterstützte Transaktionstypen findest du hier. 
4. Webhook-URL: Füge die URL des Workers hinzu, den wir bei Cloudflare eingerichtet haben. (Wenn du Discord ausgewählt hast, musst du die Webhook-URL des Bots angeben.)
5. Authentifizierungs-Header: Gib einen Authentifizierungs-Header an, der in den POST-Anfragen für deinen Webhook übergeben wird. Diese Angabe ist optional.
6. Account-Adresse: Die Adresse des Raydium-AMM-Programms lautet: 675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8. Bei Bedarf kannst du mehrere Account-Adressen hinzufügen. Du kannst auch die Adressen deiner Vermögenswerte angeben, um sie zu überwachen. 

Sobald du auf Confirm, klickst, benachrichtigt dein Webhook unseren Cloudflare Worker.

Im nächsten Schritt schreiben wir den passenden Code zur Verarbeitung der Benachrichtigung.

Webhook-Benachrichtigung im Worker verarbeiten

Wir müssen die Wrangler CLI installieren, um unseren Code zum Worker hinzuzufügen. So kann er die Daten korrekt verarbeiten, wenn er ausgelöst wird.

Melde dich bei deinem Cloudflare-Konto an, damit Wrangler deine Skripte bei Cloudflare bereitstellen kann.

Öffne eine Eingabeaufforderung oder ein Terminal und gib Folgendes ein:

wrangler login

Wenn Wrangler automatisch deinen Browser öffnet und den Zustimmungsbildschirm von Cloudflare anzeigt, klicke auf Allow. Dadurch wird ein API-Token an Wrangler gesendet.‍

Initialisiere anhand des über das Cloudflare Dashboard erstellten Workers ein neues Projekt:

wrangler init --from-dash <worker-name>

Den Namen des Workers findest du im Abschnitt Metrics:

‍Der obige Befehl erstellt einen Ordner mit der Konfiguration und dem Code des Workers. Ersetze anschließend den Code in der Datei src/index.js durch den unten angegebenen Code. Füge unbedingt deinen API-Schlüssel ein. Wir empfehlen dir, diese Best Practices zu befolgen, um deinen API-Schlüssel zu schützen.

Wir verwenden jetzt den folgenden Code in unserem Worker:

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(requestBody[0].description);

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

‍In diesem Code protokollieren wir nur die Beschreibung der Benachrichtigung. Antwortbenachrichtigungen haben ein geparstes Transaktionsformat. Beachte, dass keine Finanzdaten wie Preisinformationen bereitgestellt werden. Finanzinformationen kannst du über Plattformen wie Jupiter und Birdeye abrufen.‍

Stelle dein Projekt im globalen Netzwerk von Cloudflare bereit:

wrangler publish

Nachdem der Code erfolgreich veröffentlicht wurde, sehen wir uns die Logs an.

Kehre zur Cloudflare-Website zurück und öffne den Abschnitt Logs:

‍Klicke auf die Schaltfläche Begin Log Stream.

‍Du kannst die protokollierten Daten unter "message" anzeigen, indem du einen empfangenen Log-Eintrag aufklappst.

Per WebSockets

WebSockets sind ein Kommunikationsprotokoll, das den Datenaustausch zwischen Clients und Servern in Echtzeit ermöglicht. Das unterscheidet sie von herkömmlichen Methoden, bei denen ein Client eine Anfrage sendet und auf die Antwort des Servers wartet. Bei WebSockets bleibt die Verbindung geöffnet und tauscht kontinuierlich Daten aus. Wir verwenden WebSockets, um den Raydium-Liquiditätspool zu überwachen.

Um in unserem Projekt schnellere Antwortzeiten zu erreichen, verwenden wir die Geyser-erweiterte Methode transactionSubscribe, die als Betafunktion verfügbar ist. Beachte, dass diese Methode nur in den Tarifen Business oder Professional verfügbar ist. Die Geyser Enhanced WebSockets sind schneller als die standardmäßigen RPC-WebSocket-Methoden. Erstelle zunächst ein einfaches JavaScript-Projekt und einen neuen Ordner namens websocket-test. Danach müssen wir eine Datei namens package.json erstellen.

{
    "name": "websocket-test",
    "version": "1.0.0",
    "description": "",
    "main": "index.js",
    "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1",
        "start": "ts-node src/index.js"
    },
    "keywords": [],
    "author": "",
    "license": "ISC",
    "devDependencies": {
        "@types/bn.js": "^5.1.0",
        "ts-node": "^10.7.0",
        "typescript": "^4.6.3"
    },
    "dependencies": {
        "@solana/web3.js": "^1.41.3",
        "dotenv": "^16.0.0"
    }
}

Erstelle einen Ordner namens src und füge eine Datei namens index.js hinzu.

Kopiere den folgenden Code in die Datei und ersetze <your-api-key> durch deinen eigenen Helius API-Schlüssel. 

const WebSocket = require('ws');

// Function to send a request to the WebSocket server
function sendRequest(ws) {
    const request = {
        jsonrpc: "2.0",
        id: 420,
        method: "transactionSubscribe",
        params: [{
                failed: false,
                accountInclude: ["675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"]
            },
            {
                commitment: "processed",
                encoding: "base64",
                transactionDetails: "full",
                showRewards: true,
                maxSupportedTransactionVersion: 0
            }
        ]
    };
    ws.send(JSON.stringify(request));
}

function websocketHandler() {
    // Create a WebSocket connection
    let ws = new WebSocket('wss://atlas-mainnet.helius-rpc.com?api-key=<your-api-key>');

    // Define WebSocket event handlers

    ws.on('open', function open() {
        console.log('WebSocket is open');
        sendRequest(ws); // Send a request once the WebSocket is open
    });

    ws.on('message', function incoming(data) {
        const messageStr = data.toString('utf8');
        console.log('Received:', messageStr);
    });

    ws.on('error', function error(err) {
        console.error('WebSocket error:', err);
    });

    ws.on('close', function close() {
        console.log('WebSocket is closed');
        // connection closed, discard old websocket and create a new one in 5s
        ws = null
        setTimeout(startWebsocket, 5000)
    });
}

websocketHandler();

Wir haben die Adresse des Raydium-AMM-Programms 675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8 im Array-Parameter accountInclude der Anfrage hinzugefügt. Mit geeigneten Parametern kannst du die benötigten Daten abrufen. 

Der Code stellt eine WebSocket-Verbindung her und protokolliert die gesamte Antwort in der Konsole. Die WebSocket-Verbindung wird nach ~5 Minuten Inaktivität geschlossen. Um das zu verhindern, enthält der Handler onClose eine Logik zur erneuten Verbindungsherstellung. 

Führe diesen Befehl in der Eingabeaufforderung oder im Terminal aus: 

npm install && npm start

In der Konsole erscheinen nun Logs wie dieser:

Fazit

Das war's! Ein Webhook zur Überwachung eines Liquiditätspools ist schnell eingerichtet. Alternativ kannst du für schnellere Antwortzeiten die Geyser-erweiterte WebSocket-Methode verwenden. Nach der Einrichtung kannst du ein passendes Frontend zur Darstellung der Daten entwickeln. Für eine dedizierte und schnellere Verbindung kannst du einen dedizierten Node mit einem Geyser-RPC-Plugin verwenden. Wenn du Probleme hast oder Unterstützung benötigst, kontaktiere uns gerne auf Discord!

Trage unten deine E-Mail-Adresse ein, damit du keine Neuigkeiten zu Solana verpasst. Möchtest du tiefer einsteigen? Entdecke die neuesten Artikel im Helius-Blog und setze deine Reise mit Solana noch heute fort.

Ressourcen

• Webhook erstellen
• Cloudflare Worker
• Helius-Dokumentation zu WebSockets
• Was sind Liquiditätspools? – CoinDesk
• Solana Dev 101 – Einen Solana-Discord-Bot mit Webhooks erstellen

‍