Como criar um agente de IA seguro na Solana

O desafio de segurança: como agentes de IA podem acessar carteiras Solana com segurança?

Com o crescimento dos agentes de IA na Solana e em outros ecossistemas, surgiu um grande desafio de segurança: como sistemas autônomos podem acessar carteiras sem comprometer a segurança? 

Para executar ações onchain, um agente de IA precisa acessar uma carteira. Mas armazenar chaves privadas no código cria enormes vulnerabilidades: 

• Elas são alvos prioritários para invasores
• Estão sujeitas a erros de código que podem levar à perda de fundos 
• Desenvolvedores raramente as estruturam de modo a separar os fundos
• Podem abrir caminho para comportamentos indesejados da IA

Um exemplo real desses riscos ocorreu em setembro de 2024, quando invasores exploraram uma vulnerabilidade no Banana Gun, um bot de negociação baseado no Telegram. Uma falha em seu oráculo de mensagens permitiu que hackers drenassem US$ 3 milhões das carteiras dos usuários.

Um bot ou agente com acesso direto à carteira pode realizar transações indesejadas e irreversíveis, seja devido a uma exploração, um bug ou um ciclo de decisões sem supervisão.

Equilibrando segurança e autonomia 

As soluções tradicionais obrigam os desenvolvedores a escolher entre segurança e verdadeira autonomia dos agentes. As abordagens convencionais expõem chaves privadas ou exigem custódia centralizada. Nenhuma dessas opções é aceitável para sistemas em produção.

Uma solução é oferecida pela Turnkey, uma infraestrutura de gerenciamento de chaves altamente flexível, desenvolvida especificamente para segurança, escala e automação. Em vez de expor chaves privadas, a Turnkey permite que agentes de IA interajam com carteiras por meio de acesso à API com escopo definido e controlado por políticas.

Veja como funciona: 

Chaves de API com escopo definido

Os agentes de IA recebem credenciais de API limitadas, vinculadas a carteiras e ações específicas.

Políticas granulares

Os desenvolvedores podem definir exatamente o que um agente de IA pode fazer — seja assinar transações sob determinadas condições, interagir com contratos inteligentes específicos ou aplicar limites de frequência.

Controle do usuário

Usuários finais ou desenvolvedores podem manter o controle total das carteiras enquanto delegam ações específicas aos agentes de IA.

Por que isso funciona:

Essa abordagem garante que agentes de IA possam interagir de forma autônoma com ativos onchain sem nunca armazenar chaves privadas brutas. Isso resolve o problema de segurança e preserva a natureza trustless e sem permissão do setor cripto.

Além disso, o ambiente de computação verificável da Turnkey permite que as equipes implantem agentes de IA em um ambiente no qual qualquer pessoa pode verificar o código executado. Falaremos mais sobre isso adiante.

Vamos analisar um exemplo prático de provisionamento de uma chave de API com permissões de carteira para um bot simples. A partir daí, o desenvolvedor poderá dar o próximo passo: transformar o bot em um agente de IA totalmente autônomo.

Como criar um agente de IA na Solana

Vamos criar um bot de negociação seguro usando a Turnkey. Abordaremos:

• Configuração de uma carteira Solana com controles de política 
• Criação de um usuário exclusivo de API para o bot 
• Definição de políticas para restringir o comportamento do bot 
• Implementação de uma função de negociação simples usando a Jupiter Exchange

Pré-requisitos

Antes de começar a trabalhar com o código, você precisa ter o Node.js e o npm instalados.

Você também precisará de uma conta da Turnkey.

Crie uma carteira Solana na Turnkey

Entre no painel da Turnkey e siga estas etapas:

• Acesse Wallets
• Clique em Create New Wallet
• Selecione Solana e ED25519 nas configurações da carteira
• Adicione SOL à carteira para fazer negociações

Crie um usuário exclusivo de API para seu bot

Em seguida:

• Acesse a aba Users
• Clique em Add User
• Selecione API key nos tipos de acesso
• Dê um nome a ele (por exemplo, "Trading Bot Alpha")

Anote o ID do usuário e clique em aprovar. Você precisará dessa chave para configurar sua política.

Limite seu bot por meio de políticas

Primeiro, acesse a aba Policies e clique em Add new policy. Depois, configure uma política para limitar as ações que o bot pode realizar. Vamos definir uma política que garanta que o bot:

• Possa executar apenas transferências de tokens, sem outros tipos de transação
• Possa negociar apenas SOL e USDC
• Não possa executar transações 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)"
}

Configure seu projeto

Em seguida, crie seu projeto e instale as dependências.

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

Crie um arquivo .env para armazenar suas credenciais.

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"

Crie um bot simples

Agora, vamos escrever o código. Crie um arquivo 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();

Crie uma credencial controlada por política

Agora vem a parte interessante. Em vez de conceder ao seu agente de IA acesso total à carteira, criaremos uma credencial controlada por política: 

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

Implemente a função de negociação do bot

Com as restrições configuradas, você pode implementar sua função de negociação: 

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

E pronto!

Ele ainda não é um agente de IA completo, mas esse bot simples e controlado por políticas estabelece a base. 

A partir daqui, você pode ampliar sua autonomia, adicionar lógica de tomada de decisão e transformá-lo em um agente mais sofisticado.

Você também pode continuar aprimorando a segurança exigindo aprovações multiassinatura para transações de alto valor ou concedendo aos agentes acesso a carteiras controladas por usuários finais.

Além das carteiras seguras: como ambientes verificáveis viabilizam agentes de IA seguros

Garantir que agentes de IA realizem transações com segurança não se resume a proteger o acesso à carteira. Também é preciso verificar se o agente está executando o código que afirma executar.

Imagine um mundo no qual agentes de IA realizam transações com segurança e operam em um ambiente totalmente verificável. Nesse ambiente, qualquer pessoa pode confirmar de forma independente exatamente qual código um agente executa.

A infraestrutura de computação verificável da Turnkey permite que qualquer pessoa verifique qual software está sendo executado dentro de um enclave seguro, solucionando um dos maiores desafios atuais do software confiável.

Em sua essência, a Turnkey utiliza Ambientes de Execução Confiáveis (TEEs), especificamente o AWS Nitro Enclaves, para oferecer um ambiente inviolável para a execução de operações sensíveis. Esses enclaves funcionam como máquinas virtuais isoladas, sem armazenamento persistente, acesso a redes externas ou possibilidade de modificação após a inicialização. Isso garante que, depois de provisionado, o código e os dados de um enclave permaneçam protegidos contra interferências externas, inclusive do próprio provedor de infraestrutura.

No entanto, apenas a execução segura não é suficiente — o que importa é a verificabilidade. A Turnkey consegue isso por meio de três inovações principais:

1. Atestações remotas

Cada enclave da Turnkey gera uma prova criptográfica que certifica precisamente qual código está sendo executado. Essa atestação inclui um hash do sistema operacional e do binário da aplicação do enclave, assinado pelo Nitro Secure Module (NSM) da AWS. Em breve, qualquer pessoa poderá verificar essa prova de forma independente para confirmar que o enclave executa o software esperado.

2. QuorumOS (QOS)

Um sistema operacional mínimo e de código aberto, desenvolvido especificamente para verificabilidade. O QOS garante que cada enclave execute apenas código aprovado e auditável, além de fornecer QOS Manifests — provas legíveis por máquina que vinculam a execução de um enclave a uma impressão digital de software verificável publicamente.

3. StageX e builds reproduzíveis

Para eliminar o risco de ataques à cadeia de suprimentos, a Turnkey exige builds reproduzíveis. Qualquer binário executado dentro de um enclave pode ser recompilado de forma independente a partir de código-fonte legível por humanos para verificar se não foi alterado. Isso garante uma correspondência individual entre o código revisado pelos desenvolvedores e o software executado em um ambiente seguro.

Ao combinar TEEs, atestações remotas e builds reproduzíveis, a Turnkey permite executar aplicações com verificabilidade absoluta, seja para proteger carteiras, realizar assinaturas criptográficas ou executar agentes de IA. Essa arquitetura vai além dos modelos tradicionais de segurança em nuvem, nos quais a confiança é presumida, e avança para um novo paradigma no qual a segurança é comprovável, transparente e descentralizada.

Por que isso é importante para agentes de IA

Um ambiente de execução verificável aumenta a segurança e amplia as possibilidades de design para sistemas autônomos, aplicações financeiras e qualquer serviço que exija confiança comprovável. 

Quando os usuários podem verificar de forma independente o software executado em um enclave, surgem novas possibilidades, como a execução trustless de IA, na qual desenvolvedores e usuários podem evitar com segurança agentes “Mágico de Oz”, ou seja, pessoas fingindo ser agentes de IA reais.

Além da IA verificável, as equipes podem implantar desde coprocessadores offchain até oráculos confiáveis e mecanismos de inferência de IA. Tudo isso com prova criptográfica de que estão executando exatamente o que foi prometido e não podem ser atualizados unilateralmente. Alguns exemplos de cargas de trabalho sensíveis que poderiam se beneficiar da migração para ambientes atestáveis estão na tabela abaixo:

Quer participar e executar suas próprias aplicações críticas de forma verificável?

A equipe da Turnkey está formando parcerias com equipes selecionadas para implantar agentes de IA e outras aplicações em um ambiente de execução totalmente verificável, no qual qualquer pessoa pode validar o código exato executado nos bastidores.

Recursos adicionais

1. CoinGecko — Capitalização de mercado dos agentes de IA
2. QZ — Bots realizam 90% das transações com stablecoins
3. Novo whitepaper da Turnkey
4. Site oficial da Turnkey
5. Entre em contato para explorar a implantação de IA verificável