So baust du einen sicheren KI-Agenten auf Solana

Die Sicherheitsfrage: Wie können KI-Agenten sicher auf Solana-Wallets zugreifen?

Mit dem Aufstieg von KI-Agenten auf Solana und anderen Netzwerken entsteht eine große Sicherheitsfrage: Wie können autonome Systeme auf Wallets zugreifen, ohne die Sicherheit zu gefährden? 

Ein KI-Agent benötigt Zugriff auf eine Wallet, um Onchain-Aktionen auszuführen. Doch im Code gespeicherte private Schlüssel schaffen massive Sicherheitslücken: 

• Sie sind bevorzugte Ziele für Angreifer
• Sie sind anfällig für Codefehler, die zum Verlust von Geldern führen können 
• Entwickler strukturieren sie selten so, dass Gelder voneinander getrennt sind
• Sie könnten unkontrolliertem Verhalten von KI-Systemen Tür und Tor öffnen

Ein reales Beispiel für diese Risiken ereignete sich im September 2024, als Angreifer eine Schwachstelle in Banana Gun ausnutzten, einem Telegram-basierten Trading-Bot. Durch einen Fehler in seinem Message Oracle konnten Hacker 3 Mio. USD aus den Wallets der Nutzer stehlen.

Ein Bot oder Agent mit direktem Wallet-Zugriff kann unbeabsichtigte, unumkehrbare Transaktionen ausführen – sei es durch einen Exploit, einen Fehler oder eine ungeprüfte Entscheidungsschleife.

Sicherheit und Autonomie in Einklang bringen 

Herkömmliche Lösungen zwingen Entwickler, zwischen Sicherheit und echter Autonomie des Agenten zu wählen. Sie legen entweder private Schlüssel offen oder erfordern eine zentrale Verwahrung. Beides ist für Produktionssysteme inakzeptabel.

Eine Lösung bietet Turnkey, eine äußerst flexible Infrastruktur zur Schlüsselverwaltung, die speziell für Sicherheit, Skalierbarkeit und Automatisierung entwickelt wurde. Statt private Schlüssel offenzulegen, ermöglicht Turnkey KI-Agenten den Zugriff auf Wallets über eingeschränkte, richtliniengesteuerte API-Zugänge.

So funktioniert es: 

Eingeschränkte API-Schlüssel

KI-Agenten erhalten eingeschränkte API-Zugangsdaten, die an bestimmte Wallets und Aktionen gebunden sind.

Granulare Richtlinien

Entwickler können genau festlegen, was ein KI-Agent tun darf – etwa Transaktionen unter bestimmten Bedingungen signieren, mit bestimmten Smart Contracts interagieren oder Ratenbegrenzungen einhalten.

Kontrolle durch den Nutzer

Endnutzer oder Entwickler behalten die vollständige Kontrolle über Wallets und delegieren nur bestimmte Aktionen an KI-Agenten.

Warum das funktioniert:

Dieser Ansatz ermöglicht KI-Agenten, autonom mit Onchain-Assets zu interagieren, ohne jemals unverarbeitete private Schlüssel zu speichern. So bleibt die Sicherheit gewahrt, ohne die vertrauens- und erlaubnisfreie Natur von Krypto einzuschränken.

Zusätzlich können Teams mit der verifizierbaren Computing-Umgebung von Turnkey KI-Agenten in einer Umgebung bereitstellen, in der jeder den ausgeführten Code überprüfen kann. Dazu später mehr.

Sehen wir uns anhand eines praktischen Beispiels an, wie du einen API-Schlüssel mit Wallet-Berechtigungen für einen einfachen Bot bereitstellst. Anschließend kannst du den nächsten Schritt gehen und den Bot zu einem vollständig autonomen KI-Agenten weiterentwickeln.

So erstellst du einen Solana-KI-Agenten

Wir erstellen mit Turnkey einen sicheren Trading-Bot. Dabei behandeln wir:

• Eine Solana-Wallet mit Richtlinienkontrollen einrichten 
• Einen reinen API-Benutzer für den Bot erstellen 
• Richtlinien definieren, die das Verhalten des Bots einschränken 
• Eine einfache Trading-Funktion mit Jupiter Exchange implementieren

Voraussetzungen

Bevor du mit dem Code beginnst, müssen Node.js und npm installiert sein.

Du benötigst außerdem ein Turnkey-Konto.

Eine Solana-Wallet in Turnkey erstellen

Melde dich bei deinem Turnkey-Dashboard an und gehe dann wie folgt vor:

• Navigiere zu Wallets
• Klicke auf Neue Wallet erstellen
• Wähle Solana und ED25519 als Wallet-Einstellungen aus
• Statte diese Wallet für den Handel mit etwas SOL aus

Einen reinen API-Benutzer für deinen Bot erstellen

Als Nächstes:

• Öffne den Tab Benutzer
• Klicke auf Benutzer hinzufügen
• Wähle unter den Zugriffstypen API-Schlüssel aus
• Vergib einen Namen, z. B. "Trading Bot Alpha"

Notiere die Benutzer-ID und klicke dann auf Genehmigen. Du benötigst diesen Schlüssel für die Konfiguration deiner Richtlinien.

Deinen Bot mit Richtlinien einschränken

Navigiere zunächst zum Tab Richtlinien und klicke auf Neue Richtlinie hinzufügen. Konfiguriere dann eine Richtlinie, die die möglichen Aktionen des Bots einschränkt. Definieren wir eine Richtlinie, die Folgendes sicherstellt:

• Der Bot kann nur Token-Transfers ausführen, keine anderen Transaktionstypen
• Der Bot kann nur mit SOL und USDC handeln
• Der Bot kann keine Transaktionen über 1 SOL ausführen

{
  "policyName": "AI Trading Bot Policy",
  "effect": "EFFECT_ALLOW",
  "consensus": "approvers.any(user, user.id == '<BOT_USER_ID>')",
  "condition": "solana.tx.instructions.count() == solana.tx.spl_transfers.count() && solana.tx.spl_transfers.all(transfer, transfer.token_mint == '<USDC_MINT>' || transfer.token_mint == '<SOL_MINT>') && solana.tx.spl_transfers.all(transfer, transfer.amount < 1000000000)"
}

Dein Projekt einrichten

Erstelle als Nächstes dein Projekt und installiere die Abhängigkeiten.

mkdir ai-trading-bot
cd ai-trading-bot
npm init -y
npm install @solana/web3.js @turnkey/sdk-server @turnkey/solana @jup-ag/api

Erstelle eine .env-Datei, um deine Zugangsdaten zu speichern.

TURNKEY_API_PRIVATE_KEY="YOUR_API_PRIVATE_KEY_HERE"
TURNKEY_API_PUBLIC_KEY="YOUR_API_PUBLIC_KEY_HERE"
TURNKEY_ORGANIZATION_ID="YOUR_TURNKEY_ORGANIZATION_ID_HERE"

Einen einfachen Bot erstellen

Jetzt schreiben wir den Code. Erstelle eine index.js-Datei:

import process from "node:process";
import { Turnkey } from "@turnkey/sdk-server";
import { TurnkeySigner } from "@turnkey/solana";
import {
  Connection,
  clusterApiUrl,
  PublicKey,
  VersionedTransaction
} from "@solana/web3.js";
import { createJupiterApiClient } from "@jup-ag/api";

// Load environment variables
process.loadEnvFile(".env");

// Define token addresses
const USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
const SOL = "So11111111111111111111111111111111111111112";
const BOT_ADDRESS = "YOUR_TURNKEY_WALLET_ADDRESS_HERE";
const BOT_PUBLIC_KEY = new PublicKey(BOT_ADDRESS);

async function main() {
  // Initialize Turnkey and Jupiter clients
  const turnkey = new Turnkey({
    apiBaseUrl: "https://api.turnkey.com",
    apiPrivateKey: process.env.TURNKEY_API_PRIVATE_KEY,
    apiPublicKey: process.env.TURNKEY_API_PUBLIC_KEY,
    defaultOrganizationId: process.env.TURNKEY_ORGANIZATION_ID,
  });

  const signer = new TurnkeySigner({
    organizationId: process.env.TURNKEY_ORGANIZATION_ID,
    client: turnkey.apiClient(),
  });

  const connection = new Connection(clusterApiUrl("mainnet-beta"), "confirmed");
  const jupiterClient = createJupiterApiClient();

Richtliniengesteuerte Zugangsdaten erstellen

Jetzt wird es interessant. Statt deinem KI-Agenten vollständigen Zugriff auf die Wallet zu geben, erstellen wir richtliniengesteuerte Zugangsdaten: 

const agentUSDCPolicy = {
  "policyName": "Require consensus on Solana transactions containing SPL token transfers of over 1000 USDC",
  "effect": "EFFECT_ALLOW",
  "consensus": "approvers.count() >= 2",
  "condition": "solana.tx.spl_transfers.all(transfer, transfer.token_mint == 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v') && solana.tx.spl_transfers.all(transfer, transfer.amount > 1000000000)",
  "notes": "",
}

const agentSOLPolicy = {
  "policyName": "Require consensus on Solana transactions containing SOL transfers over 1 SOL",
  "effect": "EFFECT_ALLOW",
  "consensus": "approvers.count() >= 2",
  "condition": "solana.tx.transfers.count == 1 && solana.tx.transfers[0].amount > 1000000000",
  "notes": "",
}

const createUSDCPolicyResponse = await turnkey.apiClient().createPolicy(agentUSDCPolicy);

const createSOLPolicyResponse = await turnkey.apiClient().createPolicy(agentSOLPolicy);

Die Trading-Funktion des Bots implementieren

Nachdem die Einschränkungen eingerichtet sind, kannst du deine Trading-Funktion implementieren: 

async function executeTrade(fromToken: string, toToken: string, amount: string) {
  // Get quote from Jupiter
  const quoteResponse = await jupiterClient.quoteGet({
    inputMint: fromToken,
    outputMint: toToken,
    amount: amount
  });

  // Create swap transaction
  const swapResponse = await jupiterClient.swapPost({
    swapRequest: {
      userPublicKey: BOT_PUBLIC_KEY,
      quoteResponse: quoteResponse,
    },
  });

  // Sign and submit transaction
  const transaction = VersionedTransaction.deserialize(
    Buffer.from(swapResponse.swapTransaction, "base64")
  );

  const signedTx = await signer.signTransaction(
    transaction,
    BOT_PUBLIC_KEY
  );

  const txid = await connection.sendRawTransaction(
    signedTx.serialize(),
    { skipPreflight: true, maxRetries: 5 }
  );

  await connection.confirmTransaction(txid);
  return txid;
}

main();

Das war’s!

Noch ist es kein vollwertiger KI-Agent. Aber dieser einfache, richtliniengesteuerte Bot legt das Fundament. 

Von hier aus kannst du seine Autonomie erweitern, Entscheidungslogik hinzufügen und ihn zu einem komplexeren Agenten weiterentwickeln.

Du kannst die Sicherheit weiter erhöhen, indem du für Transaktionen mit hohem Wert Multi-Sig-Genehmigungen verlangst oder Agenten Zugriff auf Wallets gewährst, die von Endnutzern kontrolliert werden.

Mehr als sichere Wallets: Wie verifizierbare Umgebungen sichere KI-Agenten ermöglichen

Damit KI-Agenten sichere Transaktionen ausführen, reicht es nicht, den Wallet-Zugriff zu schützen. Du musst auch überprüfen können, ob ein Agent tatsächlich den angegebenen Code ausführt.

Stell dir eine Welt vor, in der KI-Agenten sichere Transaktionen ausführen und in einer vollständig verifizierbaren Umgebung arbeiten. Dort kann jeder unabhängig prüfen, welchen Code ein Agent ausführt.

Mit der verifizierbaren Computing-Infrastruktur von Turnkey kann jeder überprüfen, welche Software in einer sicheren Enklave läuft. Das löst eine der größten Herausforderungen für vertrauenswürdige Software.

Turnkey nutzt im Kern Trusted Execution Environments (TEEs), insbesondere AWS Nitro Enclaves, um eine manipulationssichere Umgebung für sensible Vorgänge bereitzustellen. Diese Enklaven arbeiten als isolierte virtuelle Maschinen ohne dauerhaften Speicher, externen Netzwerkzugriff oder die Möglichkeit, nach dem Start verändert zu werden. Sobald eine Enklave bereitgestellt wurde, bleiben ihr Code und ihre Daten dadurch vor externen Eingriffen geschützt – selbst vor dem Infrastrukturanbieter.

Eine sichere Ausführung allein reicht jedoch nicht. Entscheidend ist die Verifizierbarkeit. Turnkey erreicht sie durch drei zentrale Innovationen:

1. Remote-Attestierungen

Jede Turnkey-Enklave erzeugt einen kryptografischen Nachweis, der genau bestätigt, welchen Code sie ausführt. Diese Attestierung enthält einen Hash des Betriebssystems und der Anwendungs-Binärdatei der Enklave, signiert vom Nitro Secure Module (NSM) von AWS. Bald kann jeder diesen Nachweis unabhängig prüfen und bestätigen, dass in der Enklave die erwartete Software läuft.

2. QuorumOS (QOS)

Ein minimales Open-Source-Betriebssystem, das speziell für Verifizierbarkeit entwickelt wurde. QOS stellt sicher, dass jede Enklave ausschließlich genehmigten, überprüfbaren Code ausführt. Außerdem stellt es QOS-Manifeste bereit – maschinenlesbare Nachweise, die die Ausführung einer Enklave mit einem öffentlich verifizierbaren Software-Fingerabdruck verknüpfen.

3. StageX und reproduzierbare Builds

Um das Risiko von Lieferkettenangriffen auszuschließen, erzwingt Turnkey reproduzierbare Builds. Jede in einer Enklave ausgeführte Binärdatei kann unabhängig aus menschenlesbarem Quellcode neu kompiliert werden. So lässt sich prüfen, dass sie nicht verändert wurde. Dadurch entsteht eine eindeutige 1:1-Zuordnung zwischen dem von Entwicklern geprüften Code und der Software, die in einer sicheren Umgebung läuft.

Durch die Kombination von TEEs, Remote-Attestierungen und reproduzierbaren Builds ermöglicht Turnkey die absolut verifizierbare Ausführung von Anwendungen – ob für Wallet-Sicherheit, kryptografische Signaturen oder KI-Agenten. Diese Architektur geht über herkömmliche Cloud-Sicherheitsmodelle hinaus, die Vertrauen voraussetzen. Sie schafft ein neues Paradigma, in dem Sicherheit nachweisbar, transparent und dezentral ist.

Warum das für KI-Agenten wichtig ist

Eine verifizierbare Ausführungsumgebung erhöht die Sicherheit und erweitert den Gestaltungsspielraum für autonome Systeme, Finanzanwendungen und alle Dienste, die nachweisbares Vertrauen benötigen. 

Wenn Nutzer die in einer Enklave ausgeführte Software unabhängig prüfen können, entstehen neue Möglichkeiten. Dazu gehört die vertrauensfreie Ausführung von KI, bei der Entwickler und Nutzer „Wizard of OZ“-Agenten zuverlässig vermeiden können, also Menschen, die sich als echte KI-Agenten ausgeben.

Über verifizierbare KI hinaus können Teams alles bereitstellen: von Offchain-Coprozessoren über vertrauenswürdige Oracles bis hin zu KI-Inferenz-Engines. Dabei weist ein kryptografischer Nachweis darauf hin, dass sie genau wie versprochen ausgeführt werden und nicht einseitig aktualisiert werden können. Die folgende Tabelle zeigt einige Beispiele für sensible Workloads, die von einem Wechsel zu attestierbaren Umgebungen profitieren könnten:

Möchtest du dich beteiligen und deine eigenen kritischen Anwendungen verifizierbar ausführen?

Das Turnkey-Team arbeitet jetzt mit ausgewählten Teams zusammen, um KI-Agenten und andere Anwendungen in einer vollständig verifizierbaren Ausführungsumgebung bereitzustellen. Dort kann jeder exakt validieren, welcher Code im Hintergrund läuft.

Zusätzliche Ressourcen

1. CoinGecko — Marktkapitalisierung von KI-Agenten
2. QZ — Bots führen 90 % der Stablecoin-Transaktionen aus
3. Das neue Whitepaper von Turnkey
4. Offizielle Website von Turnkey
5. Kontaktiere uns, um die Bereitstellung verifizierbarer KI zu besprechen