segurança-para-agente-de-trading-llm

Segurança para Agentes de Trading com LLM

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

Quando Usar

• Construindo um agente de IA que assina e envia transações
• Auditando um bot de trading ou assistente de execução on-chain
• Projetando o 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

Camada as defesas. Nenhuma verificação única é suficiente. Trate a higiene de prompt, política de gastos, simulação, limites de execução e isolamento de carteira como controles independentes.

Exemplos

Trate a 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 sociais em um prompt com capacidade de execução.

Limites rígidos de gasto

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 o máximo ${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 definida")

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 principal.

Proteção MEV e prazo

import time

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

Checklist Pré-Implantação

• Dados externos são sanitizados antes de entrar no contexto do LLM
• Limites de gasto 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 queda ou estado inválido
• Chaves vêm de env ou de um gerenciador de segredos, nunca de código ou logs
• Mempool privada 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 log de auditoria, não apenas os envios bem-sucedidos