Segurança para Agentes de Trading com LLM

O que Segurança para Agentes de Trading com LLM faz?

Agentes de trading autônomos têm um modelo de ameaça mais severo do que aplicativos LLM normais: uma injeção ou caminho de ferramenta incorreto pode se transformar diretamente em perda de ativos.

Quando Usar

• Construindo um agente de IA que assina e envia transações
• Auditando um robô de trading ou assistente de execução on-chain
• Projetando gerenciamento de chaves de carteira para um agente
• Dando a um LLM acesso a colocação de ordens, swaps ou operações de tesouraria

Como Funciona

Camadas de defesa. Nenhuma verificação isolada é suficiente. Trate higiene de prompt, política de gastos, simulação, limites de execução e isolamento de carteira como controles independentes.

Exemplos

Trate injeção de prompt como um ataque financeiro

import re

INJECTION_PATTERNS = [
    r'ignore (previous|all) instructions',
    r'new (task|directive|instruction)',
    r'system prompt',
    r'send .{0,50} to 0x[0-9a-fA-F]{40}',
    r'transfer .{0,50} to',
    r'approve .{0,50} for',
]

def sanitize_onchain_data(text: str) -> str:
    for pattern in INJECTION_PATTERNS:
        if re.search(pattern, text, re.IGNORECASE):
            raise ValueError(f"Potencial injeção de prompt: {text[:100]}")
    return text

Não injete cegamente nomes de tokens, rótulos de pares, webhooks ou feeds de mídia social em um prompt com capacidade de execução.

Limites de gastos rígidos

from decimal import Decimal

MAX_SINGLE_TX_USD = Decimal("500")
MAX_DAILY_SPEND_USD = Decimal("2000")

class SpendLimitError(Exception):
    pass

class SpendLimitGuard:
    def check_and_record(self, usd_amount: Decimal) -> None:
        if usd_amount > MAX_SINGLE_TX_USD:
            raise SpendLimitError(f"Tx única ${usd_amount} excede max ${MAX_SINGLE_TX_USD}")

        daily = self._get_24h_spend()
        if daily + usd_amount > MAX_DAILY_SPEND_USD:
            raise SpendLimitError(f"Limite diário: ${daily} + ${usd_amount} > ${MAX_DAILY_SPEND_USD}")

        self._record_spend(usd_amount)

Simule antes de enviar

class SlippageError(Exception):
    pass

async def safe_execute(self, tx: dict, expected_min_out: int | None = None) -> str:
    sim_result = await self.w3.eth.call(tx)

    if expected_min_out is None:
        raise ValueError("min_amount_out é obrigatório antes do envio")

    actual_out = decode_uint256(sim_result)
    if actual_out < expected_min_out:
        raise SlippageError(f"Simulação: {actual_out} < {expected_min_out}")

    signed = self.account.sign_transaction(tx)
    return await self.w3.eth.send_raw_transaction(signed.raw_transaction)

Disjuntor

class TradingCircuitBreaker:
    MAX_CONSECUTIVE_LOSSES = 3
    MAX_HOURLY_LOSS_PCT = 0.05

    def check(self, portfolio_value: float) -> None:
        if self.consecutive_losses >= self.MAX_CONSECUTIVE_LOSSES:
            self.halt("Muitas perdas consecutivas")

        if self.hour_start_value <= 0:
            self.halt("hour_start_value inválido")
            return

        hourly_pnl = (portfolio_value - self.hour_start_value) / self.hour_start_value
        if hourly_pnl < -self.MAX_HOURLY_LOSS_PCT:
            self.halt(f"PnL horário {hourly_pnl:.1%} abaixo do limite")

Isolamento de carteira

import os
from eth_account import Account

private_key = os.environ.get("TRADING_WALLET_PRIVATE_KEY")
if not private_key:
    raise EnvironmentError("TRADING_WALLET_PRIVATE_KEY não definido")

account = Account.from_key(private_key)

Use uma carteira quente dedicada com apenas os fundos de sessão necessários. Nunca aponte o agente para uma carteira de tesouraria primária.

Proteção MEV e de prazo

import time

PRIVATE_RPC = "https://rpc.flashbots.net"
MAX_SLIPPAGE_BPS = {"stable": 10, "volatile": 50}
deadline = int(time.time()) + 60

Lista de Verificação Pré-Implantação

• Dados externos são higienizados antes de entrar no contexto do LLM
• Limites de gastos são aplicados independentemente da saída do modelo
• Transações são simuladas antes do envio
• min_amount_out é obrigatório
• Disjuntores param em caso de drawdown ou estado inválido
• Chaves vêm de env ou de um gerenciador de segredos, nunca de código ou logs
• Mempool privado ou roteamento protegido é usado quando apropriado
• Slippage e prazos são definidos por estratégia
• Todas as decisões do agente são registradas em auditoria, não apenas envios bem-sucedidos