Comment créer un agent d’IA sécurisé sur Solana

Le défi de la sécurité : comment permettre aux agents d’IA d’accéder aux portefeuilles Solana en toute sécurité ?

Avec l’essor des agents d’IA sur Solana et au-delà, un défi majeur de sécurité se pose : comment des systèmes autonomes peuvent-ils accéder aux portefeuilles sans compromettre leur sécurité ? 

Pour exécuter des actions on-chain, un agent d’IA doit accéder à un portefeuille. Mais stocker des clés privées dans le code crée d’importantes vulnérabilités : 

• Elles constituent des cibles privilégiées pour les attaquants
• Elles sont exposées aux erreurs de code susceptibles d’entraîner une perte de fonds 
• Les développeurs les structurent rarement de manière à séparer les fonds
• Elles peuvent ouvrir la voie à des comportements déviants de l’IA

Un exemple concret de ces risques s’est produit en septembre 2024, lorsque des attaquants ont exploité une vulnérabilité dans Banana Gun, un bot de trading basé sur Telegram. Une faille dans son oracle de messages a permis aux pirates de dérober 3 millions de dollars dans les portefeuilles des utilisateurs.

Un bot ou un agent disposant d’un accès direct à un portefeuille peut effectuer des transactions involontaires et irréversibles, que ce soit en raison d’une faille, d’un bug ou d’une boucle de décision non contrôlée.

Trouver l’équilibre entre sécurité et autonomie 

Les solutions traditionnelles obligent les développeurs à choisir entre sécurité et véritable autonomie des agents. Elles exposent les clés privées ou imposent une conservation centralisée, deux approches inacceptables pour les systèmes en production.

Une solution est proposée par Turnkey, une infrastructure de gestion de clés très flexible, spécialement conçue pour la sécurité, le passage à l’échelle et l’automatisation. Au lieu d’exposer les clés privées, Turnkey permet aux agents d’IA d’interagir avec des portefeuilles grâce à un accès API limité et régi par des politiques.

Voici comment cela fonctionne : 

Clés API à portée limitée

Les agents d’IA reçoivent des identifiants API limités, associés à des portefeuilles et à des actions spécifiques.

Politiques granulaires

Les développeurs peuvent définir précisément ce qu’un agent d’IA est autorisé à faire : signer des transactions sous certaines conditions, interagir avec des smart contracts spécifiques ou appliquer des limites de débit.

Contrôle par l’utilisateur

Les utilisateurs finaux ou les développeurs peuvent conserver un contrôle total sur les portefeuilles tout en déléguant des actions spécifiques aux agents d’IA.

Pourquoi cette approche fonctionne :

Cette approche garantit que les agents d’IA peuvent interagir de manière autonome avec des actifs on-chain sans jamais détenir de clés privées brutes. Elle résout ainsi le problème de sécurité tout en préservant la nature sans confiance et sans autorisation de la crypto.

De plus, l’environnement informatique vérifiable de Turnkey permet aux équipes de déployer des agents d’IA dans un environnement où chacun peut vérifier le code exécuté. Nous y reviendrons plus loin.

Examinons un exemple pratique de configuration d’une clé API donnant à un bot des autorisations sur un portefeuille. Le développeur pourra ensuite passer à l’étape suivante : faire évoluer le bot en un agent d’IA entièrement autonome.

Comment créer un agent d’IA sur Solana

Créons un bot de trading sécurisé avec Turnkey. Nous verrons comment :

• Configurer un portefeuille Solana avec des contrôles basés sur des politiques 
• Créer pour le bot un utilisateur disposant uniquement d’un accès API 
• Définir des politiques limitant le comportement du bot 
• Implémenter une fonction de trading simple avec Jupiter Exchange

Prérequis

Avant de passer au code, vous devez avoir installé Node.js et npm.

Vous aurez également besoin d’un compte Turnkey.

Créer un portefeuille Solana dans Turnkey

Connectez-vous à votre tableau de bord Turnkey, puis :

• Accédez à Portefeuilles
• Cliquez sur Créer un portefeuille
• Sélectionnez Solana et ED25519 dans les paramètres du portefeuille
• Alimentez ce portefeuille avec quelques SOL pour effectuer des transactions

Créer pour votre bot un utilisateur disposant uniquement d’un accès API

Ensuite :

• Accédez à l’onglet Utilisateurs
• Cliquez sur Ajouter un utilisateur
• Sélectionnez Clé API dans les types d’accès
• Donnez-lui un nom (par exemple, « Trading Bot Alpha »)

Notez l’identifiant utilisateur, puis cliquez sur Approuver. Vous aurez besoin de cette clé pour configurer votre politique.

Limiter votre bot à l’aide de politiques

Commencez par accéder à l’onglet Politiques, puis cliquez sur Ajouter une politique. Configurez ensuite une politique pour limiter les actions que le bot peut effectuer. Définissons une politique garantissant que le bot :

• Peut uniquement exécuter des transferts de tokens, sans autre type de transaction
• Peut uniquement échanger SOL et USDC
• Ne peut pas exécuter de transactions supérieures à 1 SOL

{
  "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)"
}

Configurer votre projet

Créez ensuite votre projet et installez les dépendances.

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

Créez un fichier .env pour stocker vos identifiants.

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"

Créer un bot simple

Écrivons maintenant le code. Créez un fichier index.js :

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

Créer un identifiant régi par une politique

C’est ici que les choses deviennent intéressantes. Au lieu de donner à votre agent d’IA un accès complet au portefeuille, nous allons créer un identifiant régi par une politique : 

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

Implémenter la fonction de trading du bot

Une fois ces contraintes en place, vous pouvez implémenter votre fonction de trading : 

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

Et voilà !

Ce n’est pas encore un agent d’IA complet, mais ce bot simple, régi par des politiques, en pose les fondations. 

Vous pouvez désormais étendre son autonomie, ajouter une logique de prise de décision et le faire évoluer vers un agent plus sophistiqué.

Vous pouvez aussi continuer à renforcer la sécurité en exigeant des approbations multisignatures pour les transactions à fort enjeu ou en donnant aux agents accès à des portefeuilles contrôlés par les utilisateurs finaux.

Au-delà des portefeuilles sécurisés : comment les environnements vérifiables rendent les agents d’IA plus sûrs

Pour garantir que les agents d’IA effectuent des transactions en toute sécurité, il ne suffit pas de protéger l’accès aux portefeuilles : il faut aussi vérifier qu’un agent exécute bien le code qu’il prétend exécuter.

Imaginez un monde où les agents d’IA effectuent des transactions en toute sécurité et fonctionnent dans un environnement entièrement vérifiable. Dans cet environnement, chacun peut confirmer de manière indépendante le code exact exécuté par un agent.

L’infrastructure informatique vérifiable de Turnkey permet à chacun de vérifier quels logiciels s’exécutent dans une enclave sécurisée, résolvant ainsi l’un des plus grands défis actuels des logiciels de confiance.

Turnkey s’appuie principalement sur des environnements d’exécution de confiance (TEE), notamment AWS Nitro Enclaves, pour fournir un environnement inviolable où exécuter des opérations sensibles. Ces enclaves fonctionnent comme des machines virtuelles isolées, sans stockage persistant, sans accès à un réseau externe et sans possibilité de modification après leur lancement. Cela garantit qu’une fois l’enclave provisionnée, son code et ses données restent protégés contre les interférences externes, y compris celles du fournisseur d’infrastructure lui-même.

Cependant, une exécution sécurisée ne suffit pas : c’est la vérifiabilité qui compte. Turnkey l’assure grâce à trois innovations majeures :

1. Attestations à distance

Chaque enclave Turnkey génère une preuve cryptographique qui certifie précisément le code qu’elle exécute. Cette attestation comprend un hash du système d’exploitation de l’enclave et du binaire de l’application, signé par le Nitro Secure Module (NSM) d’AWS. Bientôt, chacun pourra vérifier cette preuve de manière indépendante afin de confirmer que l’enclave exécute le logiciel attendu.

2. QuorumOS (QOS)

Un système d’exploitation minimal et open source spécialement conçu pour la vérifiabilité. QOS garantit que chaque enclave exécute uniquement du code approuvé et auditable. Il fournit également des manifestes QOS, des preuves lisibles par machine qui relient l’exécution d’une enclave à une empreinte logicielle vérifiable publiquement.

3. StageX et builds reproductibles

Pour éliminer le risque d’attaques de la chaîne d’approvisionnement, Turnkey impose des builds reproductibles. Tout binaire exécuté dans une enclave peut être recompilé de manière indépendante à partir d’un code source lisible par l’humain afin de vérifier qu’il n’a pas été altéré. Cela garantit une correspondance exacte entre le code examiné par les développeurs et le logiciel exécuté dans un environnement sécurisé.

En combinant les TEE, les attestations à distance et les builds reproductibles, Turnkey permet d’exécuter des applications avec une vérifiabilité absolue, qu’il s’agisse de sécuriser des portefeuilles, de réaliser des signatures cryptographiques ou d’exécuter des agents d’IA. Cette architecture dépasse les modèles traditionnels de sécurité cloud, fondés sur une confiance présumée, pour adopter un nouveau paradigme où la sécurité est démontrable, transparente et décentralisée.

Pourquoi est-ce important pour les agents d’IA ?

Un environnement d’exécution vérifiable renforce la sécurité et élargit les possibilités de conception pour les systèmes autonomes, les applications financières et tous les services nécessitant une confiance démontrable. 

Lorsque les utilisateurs peuvent vérifier de manière indépendante le logiciel exécuté dans une enclave, de nouvelles possibilités apparaissent, comme l’exécution d’IA sans confiance, qui permet aux développeurs et aux utilisateurs d’éviter avec certitude les agents « Wizard of OZ », c’est-à-dire des personnes se faisant passer pour de véritables agents d’IA.

Au-delà de l’IA vérifiable, les équipes peuvent déployer aussi bien des coprocesseurs off-chain que des oracles de confiance et des moteurs d’inférence d’IA. Le tout avec une preuve cryptographique qu’ils s’exécutent exactement comme prévu et ne peuvent pas être mis à jour unilatéralement. Le tableau ci-dessous présente quelques exemples de charges de travail sensibles qui pourraient bénéficier d’un transfert vers des environnements attestables :

Vous souhaitez participer et exécuter vos propres applications critiques de manière vérifiable ?

L’équipe Turnkey collabore désormais avec des équipes sélectionnées pour déployer des agents d’IA et d’autres applications dans un environnement d’exécution entièrement vérifiable, où chacun peut valider le code exact exécuté en arrière-plan.

Ressources supplémentaires

1. CoinGecko — Capitalisation boursière des agents d’IA
2. QZ — Les bots effectuent 90 % des transactions en stablecoins
3. Le nouveau livre blanc de Turnkey
4. Site officiel de Turnkey
5. Contactez-nous pour étudier le déploiement d’une IA vérifiable