Cómo crear un agente de IA seguro en Solana

El desafío de seguridad: ¿cómo pueden los agentes de IA acceder de forma segura a las billeteras de Solana?

Con el auge de los agentes de IA en Solana y otros ecosistemas, ha surgido un importante desafío de seguridad: ¿cómo pueden los sistemas autónomos acceder a las billeteras sin comprometer la seguridad? 

Para ejecutar acciones en cadena, un agente de IA necesita acceso a una billetera. Pero almacenar claves privadas en el código crea enormes vulnerabilidades: 

• Son objetivos prioritarios para los atacantes
• Son susceptibles a errores de código que podrían causar la pérdida de fondos 
• Los desarrolladores rara vez las estructuran de forma que separen los fondos
• Podrían abrir la puerta a comportamientos descontrolados de la IA

Un ejemplo real de estos riesgos ocurrió en septiembre de 2024, cuando unos atacantes explotaron una vulnerabilidad en Banana Gun, un bot de trading basado en Telegram. Una falla en su oráculo de mensajes permitió a los hackers extraer $3 millones de las billeteras de los usuarios.

Un bot o agente con acceso directo a una billetera puede realizar transacciones involuntarias e irreversibles debido a un exploit, un error o un ciclo de decisiones sin supervisión.

Equilibrio entre seguridad y autonomía 

Las soluciones tradicionales obligan a los desarrolladores a elegir entre seguridad y verdadera autonomía del agente. Los enfoques tradicionales exponen las claves privadas o requieren custodia centralizada. Ninguna opción es aceptable para sistemas en producción.

Una solución es Turnkey, una infraestructura de administración de claves muy flexible y diseñada específicamente para ofrecer seguridad, escalabilidad y automatización. En lugar de exponer claves privadas, Turnkey permite que los agentes de IA interactúen con billeteras mediante acceso por API limitado y controlado por políticas.

Así funciona: 

Claves de API con alcance limitado

Los agentes de IA reciben credenciales de API limitadas y vinculadas a billeteras y acciones específicas.

Políticas detalladas

Los desarrolladores pueden definir exactamente qué puede hacer un agente de IA, ya sea firmar transacciones bajo ciertas condiciones, interactuar con contratos inteligentes específicos o aplicar límites de solicitudes.

Control del usuario

Los usuarios finales o desarrolladores pueden conservar el control total de las billeteras mientras delegan acciones específicas a los agentes de IA.

Por qué funciona:

Este enfoque garantiza que los agentes de IA puedan interactuar de forma autónoma con activos en cadena sin poseer claves privadas sin procesar. Así resuelve el problema de seguridad y conserva la naturaleza sin confianza ni permisos del sector cripto.

Además, el entorno de computación verificable de Turnkey permite que los equipos implementen agentes de IA en un entorno donde cualquiera puede verificar el código que se ejecuta. Más adelante veremos esto en detalle.

Veamos un ejemplo práctico de cómo aprovisionar una clave de API con permisos de billetera para un bot sencillo. A partir de ahí, el desarrollador puede dar el siguiente paso: convertir el bot en un agente de IA completamente autónomo.

Cómo crear un agente de IA en Solana

Creemos un bot de trading seguro con Turnkey. Veremos cómo:

• Configurar una billetera de Solana con controles basados en políticas 
• Crear un usuario exclusivo de API para el bot 
• Definir políticas que restrinjan el comportamiento del bot 
• Implementar una función de trading sencilla con Jupiter Exchange

Requisitos previos

Antes de comenzar con el código, debes tener instalados Node.js y npm.

También necesitarás una cuenta de Turnkey.

Crea una billetera de Solana en Turnkey

Inicia sesión en tu panel de Turnkey y luego:

• Ve a Wallets
• Haz clic en Create New Wallet
• Selecciona Solana y ED25519 en la configuración de tu billetera
• Deposita algunos SOL en esta billetera para hacer trading

Crea un usuario exclusivo de API para tu bot

A continuación:

• Ve a la pestaña Users
• Haz clic en Add User
• Selecciona API key en los tipos de acceso
• Asígnale un nombre (por ejemplo, "Trading Bot Alpha")

Anota el ID de usuario y haz clic en aprobar. Necesitarás esta clave para configurar tu política.

Limita tu bot mediante políticas

Primero, ve a la pestaña Policies y haz clic en Add new policy. Luego, configura una política para limitar las acciones que puede realizar el bot. Definamos una política que garantice que el bot:

• Solo pueda ejecutar transferencias de tokens, sin otros tipos de transacciones
• Solo pueda operar con SOL y USDC
• No pueda ejecutar transacciones superiores a 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)"
}

Configura tu proyecto

A continuación, crea tu proyecto e instala las dependencias.

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

Crea un archivo .env para almacenar tus credenciales.

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"

Crea un bot sencillo

Ahora escribamos el código. Crea un archivo 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();

Crea una credencial controlada por políticas

Ahora viene la parte interesante. En lugar de darle a tu agente de IA acceso completo a la billetera, crearemos una credencial controlada por políticas: 

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

Implementa la función de trading del bot

Con las restricciones establecidas, puedes implementar tu función 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();

¡Y listo!

Todavía no es un agente de IA completo, pero este bot sencillo y controlado por políticas establece las bases. 

A partir de aquí, puedes ampliar su autonomía, agregar lógica para la toma de decisiones y convertirlo en un agente más sofisticado.

También puedes seguir mejorando la seguridad mediante aprobaciones multifirma para transacciones de alto valor o concediendo a los agentes acceso a billeteras controladas por usuarios finales.

Más allá de las billeteras seguras: cómo los entornos verificables permiten crear agentes de IA seguros

Garantizar que los agentes de IA realicen transacciones de forma segura no consiste solo en proteger el acceso a la billetera, sino también en verificar que el agente ejecute el código que afirma ejecutar.

Imagina un mundo donde los agentes de IA realicen transacciones de forma segura y operen en un entorno completamente verificable. En este entorno, cualquiera puede confirmar de manera independiente exactamente qué código ejecuta un agente.

La infraestructura de computación verificable de Turnkey permite que cualquiera verifique qué software se ejecuta dentro de un enclave seguro. Así resuelve uno de los mayores desafíos actuales del software confiable.

En esencia, Turnkey aprovecha los entornos de ejecución confiables (TEE), específicamente AWS Nitro Enclaves, para proporcionar un entorno a prueba de manipulaciones donde ejecutar operaciones confidenciales. Estos enclaves funcionan como máquinas virtuales aisladas, sin almacenamiento persistente, acceso a redes externas ni posibilidad de modificación después de iniciarse. Esto garantiza que, una vez aprovisionado un enclave, su código y sus datos permanezcan protegidos contra interferencias externas, incluso las del propio proveedor de infraestructura.

Sin embargo, la ejecución segura por sí sola no es suficiente: lo que importa es la verificabilidad. Turnkey la consigue mediante tres innovaciones clave:

1. Atestaciones remotas

Cada enclave de Turnkey genera una prueba criptográfica que certifica con precisión qué código ejecuta. Esta atestación incluye un hash del sistema operativo y del binario de la aplicación del enclave, firmado por el Nitro Secure Module (NSM) de AWS. Pronto, cualquiera podrá verificar esta prueba de manera independiente para confirmar que el enclave ejecuta el software previsto.

2. QuorumOS (QOS)

Un sistema operativo mínimo y de código abierto diseñado específicamente para la verificabilidad. QOS garantiza que cada enclave ejecute únicamente código aprobado y auditable. También proporciona manifiestos de QOS: pruebas legibles por máquinas que vinculan la ejecución de un enclave con una huella de software verificable públicamente.

3. StageX y compilaciones reproducibles

Para eliminar el riesgo de ataques a la cadena de suministro, Turnkey exige compilaciones reproducibles. Cualquier binario que se ejecute dentro de un enclave puede volver a compilarse de forma independiente a partir de código fuente legible por humanos para verificar que no haya sido alterado. Esto garantiza una correspondencia 1:1 entre el código revisado por los desarrolladores y el software que se ejecuta en un entorno seguro.

Al combinar TEE, atestaciones remotas y compilaciones reproducibles, Turnkey permite ejecutar aplicaciones con verificabilidad absoluta, ya sea para la seguridad de billeteras, la firma criptográfica o la ejecución de agentes de IA. Esta arquitectura supera los modelos tradicionales de seguridad en la nube, donde se presupone la confianza, y adopta un nuevo paradigma en el que la seguridad es demostrable, transparente y descentralizada.

Por qué esto es importante para los agentes de IA

Un entorno de ejecución verificable mejora la seguridad y amplía las posibilidades de diseño para sistemas autónomos, aplicaciones financieras y cualquier servicio que requiera confianza demostrable. 

Cuando los usuarios pueden verificar de forma independiente el software que se ejecuta en un enclave, surgen nuevas posibilidades. Por ejemplo, una ejecución de IA sin confianza donde desarrolladores y usuarios puedan evitar con seguridad a los agentes del “Mago de OZ”, es decir, personas que fingen ser agentes de IA reales.

Además de la IA verificable, los equipos pueden implementar desde coprocesadores fuera de la cadena hasta oráculos confiables y motores de inferencia de IA. Todo con pruebas criptográficas de que se ejecutan exactamente como se prometió y no pueden actualizarse de forma unilateral. La siguiente tabla incluye algunos ejemplos de cargas de trabajo confidenciales que podrían beneficiarse al trasladarse a entornos con atestación:

¿Quieres participar y ejecutar tus propias aplicaciones críticas de forma verificable?

El equipo de Turnkey ahora colabora con equipos seleccionados para implementar agentes de IA y otras aplicaciones en un entorno de ejecución completamente verificable, donde cualquiera puede validar el código exacto que se ejecuta tras bambalinas.

Recursos adicionales

1. CoinGecko — Capitalización de mercado de los agentes de IA
2. QZ — Los bots realizan el 90 % de las transacciones con stablecoins
3. Nuevo documento técnico de Turnkey
4. Sitio oficial de Turnkey
5. Contáctanos para explorar la implementación de IA verificable