Construire des bots de trading crypto autonomes avec ElizaOS : le guide technique complet

22 juillet 2025

Justin Olivier

Comment nous avons construit un agent de trading IA entièrement autonome, capable d'analyser les données de marché, de traiter le sentiment des actualités et d'exécuter des ordres automatiquement, le tout dans un environnement d'exécution de confiance.

Le défi : du trading manuel à l'intelligence autonome

Les marchés crypto ne dorment jamais. Là où les traders traditionnels peinent avec la surveillance 24/7, les décisions émotionnelles et la surcharge d'information, l'avenir appartient aux agents autonomes capables de traiter d'énormes volumes de données et d'exécuter des ordres avec une précision de machine.

Chez Etherwave Labs, nous explorons comment les agents IA peuvent révolutionner la finance décentralisée (DeFAI). Notre dernière preuve de concept montre quelque chose de remarquable : un bot de trading entièrement autonome propulsé par ElizaOS, qui combine grands modèles de langage et analyse de marché en temps réel.

Ce n'est pas un script de trading de plus : c'est un agent intelligent qui lit l'actualité crypto, analyse les indicateurs techniques, prend des décisions stratégiques et exécute des ordres automatiquement. Voici comment nous l'avons construit.

Qu'est-ce qu'ElizaOS ? Le socle des agents autonomes

ElizaOS représente une avancée majeure dans le développement d'agents IA. Incubé par a16z, ce framework open source permet de construire des agents autonomes capables d'analyser, de planifier et d'agir dans des environnements complexes.

Sa force tient à son architecture modulaire :

Intégration LLM : prise en charge de GPT-4, Claude, LLaMA et d'autres modèles via Ollama
Système de plugins : Actions et Providers extensibles pour vos besoins spécifiques
Multi-environnement : fonctionne sur le web, la blockchain et les API tierces
Décision autonome : les agents traitent le contexte et font leurs propres choix

Notre bot de trading : l'intelligence au service de l'exécution

Notre preuve de concept montre un agent ElizaOS qui opère comme un système de trading complet :

Analyse des données de marché : récupération des prix en temps réel, des indicateurs techniques (MACD, RSI) et des données de sentiment
Traitement de l'actualité : analyse des news crypto de CoinDesk pour évaluer le sentiment de marché
Décision stratégique : raisonnement du LLM pour déterminer une position longue, courte, ou l'attente
Exécution automatisée : passage d'ordres automatique sur l'exchange Hyperliquid
Gestion du risque : suivi du solde du portefeuille et des positions ouvertes

L'ensemble fonctionne en autonomie, le LLM jouant le rôle de « cerveau » qui traite toutes les entrées et prend les décisions de trading.

Mise en œuvre technique : construire l'agent de trading

Prérequis et préparation de l'environnement

Avant de plonger dans le développement, assurez-vous de disposer des outils nécessaires :

Variables d'environnement essentielles :

.env

# Trading platform credentials
HYPERLIQUID_PRIVKEY=your_private_key_here

# AI model configuration  
OLLAMA_EMBEDDING_MODEL=nomic-embed-text

# Market data APIs
COINGECKO_API_KEY=your_coingecko_api_key
COINDESK_API_KEY=your_coindesk_api_key
TAAPI_API_KEY=your_taapi_api_key

Installation rapide :


# Step 1: Initialize the embedding server
ollama pull nomic-embed-text && ollama serve

# Step 2: Clone and setup the project
git clone https://github.com/etherwave-labs/ai-agent-playground.git
cd ai-agent-playground/trading-ai
bun install && bun run dev

# Step 3: Start the trading scheduler (executes every 15 minutes)
cd ../workflowTradingAi
bun run workflow.ts

L'architecture en plugins : les briques de base

Le système de plugins d'ElizaOS permet d'étendre les capacités de l'agent via deux types de composants :

architecture du projet — *Architecture d'un projet ElizaOS*

1. Les Actions : ce que l'agent peut faire

Opérations de marché :

placeOrder.ts : exécute les ordres via l'API Hyperliquid, avec une gestion du risque appropriée
log.ts : enregistre tous les raisonnements du LLM pour la traçabilité
rag.ts : conserve l'historique des transactions (implémentation historique)

2. Les Providers : les sources d'information

Providers de données de marché :

fetchBTCPrice.ts : prix spot du Bitcoin en temps réel et historique 7 jours via CoinGecko
getDataMarket.ts : indicateurs d'analyse technique (RSI, MACD) depuis TAAPI.io
fetchNewsCoindesk.ts : analyse du sentiment des actualités crypto de CoinDesk

Providers de gestion de portefeuille :

getBalanceHyperLiquid.ts : solde du wallet en temps réel, via signatures EIP-712
getOpenOrder.ts : suivi des positions de trading actives
getPnL.ts : suivi des gains et pertes sur plusieurs horizons (1 j, 1 sem., 1 mois, depuis le début)

Créer des plugins sur mesure : étendre les capacités de l'agent

La conception modulaire rend l'ajout de fonctionnalités très simple. Voici comment construire vos propres composants.

Exemple de Provider – données de marché :

bitcoinPriceProvider.ts

import { Provider } from 'elizaos'

export const btcPriceProvider: Provider = {
  name: 'btc-price',
  description: 'Fetches current BTC spot price from CoinGecko',
  position: 2, // Execution priority
  get: async () => {
    const apiKey = process.env.COINGECKO_API_KEY
    const response = await fetch(
      `https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd&x_cg_pro_api_key=${apiKey}`
    )
    const { bitcoin } = await response.json()
    
    return { 
      price: bitcoin.usd,
      timestamp: Date.now(),
      source: 'coingecko'
    }
  },
}

Exemple d'Action – exécution d'ordre :

placeOrderAction.ts

import { Action } from 'elizaos'

export const placeOrderAction: Action = {
  name: 'PLACE_ORDER',
  description: 'Executes trading orders on Hyperliquid exchange',
  handler: async (runtime, message, state, parameters, callback) => {
    try {
      // Validate order parameters
      const { side, size, price, symbol } = parameters
      
      // Execute trade via Hyperliquid API
      const transactionId = await hyperLiquid.placeOrder({
        side,
        size, 
        price,
        symbol,
        timestamp: Date.now()
      })
      
      // Confirm execution
      await callback({ 
        text: `Order executed successfully. Transaction ID: ${transactionId}`, 
        actions: ['PLACE_ORDER'] 
      })
      
      return true
    } catch (error) {
      console.error('Order execution failed:', error)
      return false
    }
  }
}

Étapes d'intégration :

Créez le fichier de votre plugin dans le dossier src/plugins/
Exportez l'objet Provider ou Action correctement typé
Enregistrez le plugin dans la configuration index.ts

Le moteur de décision : comment l'IA choisit ses positions

Le processus de décision de l'agent combine plusieurs sources de données en une stratégie de trading cohérente.

La synthèse des données

Analyse technique : les indicateurs RSI et MACD donnent des signaux de momentum et de tendance
Analyse du sentiment des actualités : les articles de CoinDesk sont traités pour en dégager un sentiment haussier ou baissier
Contexte de prix : le prix courant est comparé aux plus hauts et plus bas récents et aux niveaux de support et de résistance
Évaluation du risque : solde du portefeuille, positions ouvertes et performance historique

L'algorithme de score de sentiment

L'agent convertit toutes ces entrées en un score de sentiment unifié (0-100 %) :

algorithme de sentiment — *Le processus de décision, à partir du score de sentiment de marché*

Le raisonnement du LLM

Le modèle de langage reçoit un contexte structuré qui comprend :

Le score de sentiment de marché courant
Les valeurs des indicateurs techniques
Un résumé de l'analyse des actualités récentes
L'état du portefeuille et les métriques de risque
Les données de performance historique

Le LLM raisonne alors sur ces données et prend une décision stratégique, transmise à l'action PLACE_ORDER pour exécution.

Sécurité avancée : l'intégration d'un Trusted Execution Environment (TEE)

Pour un bot de trading en production manipulant de vrais fonds, la sécurité devient primordiale. Nous avons exploré la protection par Trusted Execution Environment (TEE) avec Intel SGX, afin que le code et les données restent protégés même dans un environnement compromis.

Pourquoi le TEE compte pour un bot de trading

Isolation matérielle : le code s'exécute dans des enclaves chiffrées
Résistance à la falsification : même une attaque au niveau du noyau ne peut atteindre les secrets
Informatique confidentielle : clés privées et logique de trading restent chiffrées
Attestation à distance : une preuve cryptographique de l'intégrité du code

Mise en œuvre avec Gramine et Azure

Étape 1 : conteneurisation

dockerfile

FROM ubuntu:22.04

# Install system dependencies
RUN apt-get update && apt-get install -y curl git build-essential

# Install Bun runtime
RUN curl -fsSL https://bun.sh/install | bash

# Install Ollama for local LLM inference
RUN curl -L https://ollama.com/download/linux | tar -xz && \
    mv ollama /usr/local/bin

WORKDIR /app
COPY . .
RUN bun install --production

# Entry point for the trading agent
CMD ["bun", "run", "workflow.ts"]

Étape 2 : génération de l'enclave SGX


# Create manifest for Gramine SGX
gramine-manifest -Dlog_level=error Dockerfile.manifest

# Sign the enclave with your SGX key
gramine-sgx-sign \
  --manifest Dockerfile.manifest \
  --output Dockerfile.sig \
  --key sgx.key

# Extract MRENCLAVE and MRSIGNER for attestation
gramine-sgx-get-token --output enclave.token

Étape 3 : déploiement sur Azure Confidential Computing


# Create SGX-enabled VM on Azure
az vm create \
  --resource-group rg-trading-bot \
  --name trading-bot-sgx \
  --image Canonical:0001-com-ubuntu-confidential-vm-focal:22_04-lts-cvm:latest \
  --size Standard_DC4s_v3 \
  --admin-username azureuser \
  --generate-ssh-keys \
  --enable-sgx

Étape 4 : gestion sécurisée des clés


# Encrypt sensitive environment variables
az keyvault secret set \
  --vault-name trading-bot-vault \
  --name hyperliquid-privkey \
  --value "encrypted_private_key"

# Keys are only decrypted inside the verified enclave
gramine-sgx-get-quote -m Dockerfile.manifest -o attestation.bin

Alternative : les preuves à divulgation nulle avec Risc0

Si vous avez besoin d'une preuve cryptographique d'exécution sans dépendance matérielle, envisagez la zkVM Risc0 :

guest_main

#[no_mangle] 
pub extern "C" fn guest_main() {
    let market_data: MarketData = env::read();
    let trading_decision = analyze_market(market_data);
    env::commit(&trading_decision);
}

Cette approche génère des preuves à divulgation nulle de connaissance attestant d'une exécution correcte, avec la garantie cryptographique que les ordres ont bien suivi la logique prévue.

Les enseignements clés

Ce qui a bien fonctionné :

Le raisonnement du LLM a produit une lecture nuancée du marché
La fusion de plusieurs sources de données a amélioré la justesse des décisions
L'exécution automatisée a supprimé le trading émotionnel
La mise en œuvre du TEE a garanti la conformité en matière de sécurité

Les axes d'amélioration :

La volatilité du marché a parfois déclenché de faux signaux
L'analyse du sentiment des actualités demande un affinage pour le vocabulaire propre à la crypto
La gestion du risque pourrait être plus sophistiquée

Conclusion

Ce projet démontre que la convergence de l'IA et de la blockchain peut donner naissance à de véritables agents financiers autonomes. En associant la souplesse du framework ElizaOS à des mesures de sécurité avancées comme le TEE, nous avons construit un système capable de :

Traiter l'information plus vite qu'un trader humain
Décider à partir d'une analyse de données complète
Exécuter des ordres avec une précision de machine
Fonctionner en sécurité dans un environnement de production
Passer à l'échelle sur plusieurs marchés et actifs

À retenir pour les développeurs

Commencez simple : partez de données de marché de base et de stratégies simples
La sécurité d'abord : mettez en place une vraie gestion des clés et sécurisez l'environnement d'exécution
Testez abondamment : backtestez sérieusement avant d'engager du capital réel
Surveillez en continu : automatisé ne veut pas dire laissé sans surveillance
Itérez vite : le marché crypto évolue rapidement, vos stratégies aussi

L'impact plus large

Les agents de trading autonomes ne sont que le début de la DeFAI, la DeFi propulsée par l'IA. À mesure que ces systèmes mûriront, on peut s'attendre à :

Un accès démocratisé : des stratégies sophistiquées à la portée des particuliers
Moins d'inefficiences de marché : les agents IA arbitreront rapidement les écarts de prix
De nouveaux produits financiers : des protocoles hybrides IA-DeFi encore inimaginés
Une meilleure stabilité de marché : moins de trading émotionnel et une découverte des prix améliorée

Les outils et techniques présentés ici posent les fondations de la prochaine génération d'applications financières décentralisées. Chez Etherwave Labs, nous sommes enthousiastes à l'idée de continuer à repousser les limites de ce que permet la rencontre de l'IA et de la blockchain.

Références

*ElizaOS – GitHub : *https://github.com/elizaOS/eliza

*Runtime Bun : *https://bun.com

*Ollama – nomic‑embed‑text : *https://ollama.com/library/nomic-embed-text

*API Hyperliquid : *https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api

*API CoinGecko : *https://docs.coingecko.com/reference/introduction

*API News CoinDesk : *https://developers.coindesk.com/documentation/data-api/news

TAAPI.io* : *https://taapi.io

*Gramine SGX : *https://gramine.readthedocs.io

*Risc0 zkVM : *https://github.com/risc0/risc0

À propos d'Etherwave Labs

Etherwave Labs est une agence de développement blockchain et une société de venture building spécialisée dans les innovations Web3. Nous aidons les entreprises à exploiter des technologies de pointe, agents IA, protocoles DeFi et preuves à divulgation nulle de connaissance, pour construire l'avenir des applications décentralisées.

Restons en contact :

Site : etherwavelabs.com
Suivez nos travaux de recherche et développement
Explorons ensemble les opportunités de partenariat pour vos projets Web3

Prêt à construire votre propre système de trading autonome ? Contactez notre équipe pour un accompagnement ou un développement sur mesure.

Suivez-nous