feat: Validated Implementation with Centrifuge Case

SYSTEM_PROMPT: Updated with expert guidelines (explainability, quality,
iterative refinement)

scripts/setup-sandbox.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+set -e
+
+SANDBOX="/tmp/poc-sandbox"
+FORGE_BIN="$HOME/.foundry/bin/forge"
+
+echo "Inicializando sandbox Foundry em $SANDBOX..."
+rm -rf "$SANDBOX"
+mkdir -p "$SANDBOX"
+cd "$SANDBOX"
+
+# Iniciar projeto forge mínimo sem git
+"$FORGE_BIN" init --no-git --quiet
+
+# Limpar arquivos padrão que causam erros de importação se deletados parcialmente
+rm -rf src/*
+rm -rf test/*
+rm -rf script/*
+
+# Criar foundry.toml configurado
+cat > foundry.toml << 'EOF'
+[profile.default]
+src = "src"
+test = "test"
+script = "script"
+out = "out"
+libs = ["lib"]
+solc-version = "0.8.20"
+optimizer = true
+optimizer_runs = 200
+EOF
+
+echo "Sandbox pronto. Testando com forge build..."
+"$FORGE_BIN" build
+echo "OK — sandbox funcionando em $SANDBOX"

src/agents/tester/agent.ts

@@ -1,7 +1,21 @@
+import "dotenv/config";
 import { StateGraph, END, START } from "@langchain/langgraph";
 import { PoCStateAnnotation, PoCState } from "./state.js";
 import { generateLocalScaffold } from "./tools/scaffoldGenerator.js";
 import { OracleContext } from "./types.js";
+import { ChatOpenRouter } from "@langchain/openrouter";
+import { SYSTEM_PROMPT } from "./prompts/system.js";
+import { extractSolidity } from "./utils/extractSolidity.js";
+import { runFoundry } from "./tools/foundryRunner.js";
+import { analyzeFoundryLog } from "./utils/logAnalyzer.js";
+
+const MAX_ITERATIONS = 5;
+
+const llm = new ChatOpenRouter({
+  model: "deepseek/deepseek-v4-flash",
+  temperature: 0.2,
+  apiKey: process.env.OPENROUTER_API_KEY,
+});
 
 async function oracleNode(state: PoCState): Promise<Partial<PoCState>> {
   console.log("[oracleNode] gerando scaffold para:", state.report.title);
@@ -14,18 +28,93 @@ async function oracleNode(state: PoCState): Promise<Partial<PoCState>> {
 }
 
 async function generatePoCNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[generatePoCNode] stub — iteração:", state.iterations);
-  return { iterations: 1 };
+  const { report, oracleContext, executionLogs, pocCode, iterations, lastError } = state;
+  const isRetry = iterations > 0;
+
+  const userMessage = isRetry
+    ? `O seguinte exploit FALHOU no Foundry.
+
+Código anterior:
+\`\`\`solidity
+${pocCode}
+\`\`\`
+
+Output do Forge (última execução):
+${executionLogs[executionLogs.length - 1]?.slice(0, 3000) ?? "sem logs"}
+
+Análise do erro: ${lastError ?? "desconhecido"}
+
+Corrija o código. Retorne o arquivo Solidity completo corrigido.`
+    : `Relatório de Vulnerabilidade:
+- Título: ${report.title}
+- Tipo: ${report.type}
+- Descrição: ${report.description}
+- Vetor de Ataque: ${report.attackVector}
+${report.exploitablePaths ? `- Caminhos de Exploração:\n  * ${report.exploitablePaths.join("\n  * ")}` : ""}
+
+Scaffold (complete APENAS test_Exploit):
+\`\`\`solidity
+${oracleContext!.solidityScaffold}
+\`\`\``;
+
+  console.log(`[generatePoCNode] iteração ${iterations + 1}, isRetry=${isRetry}`);
+
+  try {
+    const response = await llm.invoke([
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: userMessage },
+    ]);
+    const solidityCode = extractSolidity(response.content as string);
+    console.log("[generatePoCNode] Solidity extraído, tamanho:", solidityCode.length);
+    return { pocCode: solidityCode, iterations: 1 };
+  } catch (err) {
+    console.error("[generatePoCNode] falha:", (err as Error).message);
+    return { iterations: 1, lastError: `Erro na geração/extração: ${(err as Error).message}` };
+  }
 }
 
 async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[runFoundryNode] stub");
-  return { status: "success" };
+  const result   = await runFoundry(state.pocCode);
+  const analysis = analyzeFoundryLog(result);
+  const passed   = result.exitCode === 0 && result.stdout.includes("ok");
+
+  console.log(`[runFoundryNode] exitCode=${result.exitCode}, passed=${passed}`);
+
+  return {
+    executionLogs: [result.combined],   // reducer append
+    lastError: analysis.summary,
+    status: passed          ? "success"
+          : result.timedOut ? "timeout"
+          : "running",
+  };
 }
 
 async function reflectNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[reflectNode] stub");
-  return {};
+  const lastLog = state.executionLogs[state.executionLogs.length - 1];
+  if (!lastLog) {
+    return { lastError: "Sem logs disponíveis para análise." };
+  }
+
+  const mockResult = {
+    exitCode: 1, timedOut: lastLog.includes("TIMEOUT"),
+    stdout: "", stderr: "", combined: lastLog,
+  };
+
+  const analysis = analyzeFoundryLog(mockResult as any);
+
+  console.log(`[reflectNode] categoria: ${analysis.category}`);
+  console.log(`[reflectNode] resumo: ${analysis.summary}`);
+
+  return {
+    lastError: `[${analysis.category.toUpperCase()}] ${analysis.summary}\n\nLinhas relevantes:\n${analysis.relevantLines.join("\n")}`,
+  };
+}
+
+function routeAfterFoundry(state: PoCState): "reflectNode" | typeof END {
+  if (state.status === "success") return END;
+  if (state.status === "timeout") return END;
+  if (state.iterations >= MAX_ITERATIONS) return END;
+  return "reflectNode";
 }
 
 const graph = new StateGraph(PoCStateAnnotation)
@@ -36,7 +125,10 @@ const graph = new StateGraph(PoCStateAnnotation)
   .addEdge(START, "oracleNode")
   .addEdge("oracleNode", "generatePoCNode")
   .addEdge("generatePoCNode", "runFoundryNode")
-  .addEdge("runFoundryNode", "reflectNode")
-  .addEdge("reflectNode", END);
+  .addConditionalEdges("runFoundryNode", routeAfterFoundry, {
+    reflectNode: "reflectNode",
+    [END]: END,
+  })
+  .addEdge("reflectNode", "generatePoCNode");
 
 export const testerAgent = graph.compile();

src/agents/tester/data/input_centrifuge.json

@@ -0,0 +1,16 @@
+{
+  "title": "Escrow mismatch in LiquidityPool due to price changes during epoch execution",
+  "description": "The LiquidityPool contract relies on an external InvestmentManager to process deposits and mints. When an investor requests a deposit, their assets are locked. During the epoch execution, if the tranche token price changes significantly, the amount of shares to be minted (TokenShares) may exceed the available balance in the Escrow contract, causing subsequent collection transactions (mint/deposit) to revert for some users while others succeed.",
+  "recommendation": "Ensure the Escrow contract is always sufficiently funded by validating price impacts before final execution or implement a more robust collection mechanism that handles partial fills or explicit failure states when Escrow is empty.",
+  "severity": "high",
+  "codeSnippet": "function deposit(uint256 assets, address receiver) public withApproval(receiver) returns (uint256 shares) {\n    shares = investmentManager.processDeposit(receiver, assets);\n    emit Deposit(address(this), receiver, assets, shares);\n}",
+  "location": "L148-L151",
+  "path": "contracts/LiquidityPool.sol",
+  "judgeReview": {
+    "review": "Confirmed valid finding. The vulnerability occurs when multiple investors deposit at different prices within the same logic flow. If the price in the second epoch is higher/lower than expected, the calculation of total shares needed in Escrow might be incorrect, leading to a denial of service (revert) for users trying to collect their shares after the price update.",
+    "confidence": 0.95,
+    "exploitablePaths": [
+      "User A deposits 100 assets at price 1.25 -> User B deposits 100 assets at price 2.0 -> Price updates -> User A collects successfully -> User B tries to collect but Escrow is empty -> Transaction reverts."
+    ]
+  }
+}

src/agents/tester/prompts/system.ts

@@ -0,0 +1,30 @@
+export const SYSTEM_PROMPT = `Você é um Especialista em Testes de Segurança de Smart Contracts. Sua missão é gerar exploits Proof-of-Concept (PoC) executáveis que demonstrem vulnerabilidades usando Foundry.
+
+## DIRETRIZES DE EXPLICABILIDADE
+- Escreva exploits que provem claramente a vulnerabilidade.
+- Inclua comentários detalhados documentando cada passo do ataque.
+- O PoC deve ser autoexplicativo para auditores de segurança.
+
+## DIRETRIZES TÉCNICAS (FOUNDRY)
+- Use o framework Foundry exclusivamente.
+- NÃO modifique o contrato original ou o bloco "setUp()" fornecido no scaffold.
+- Utilize cheatcodes de forma apropriada: vm.prank(), vm.deal(), vm.warp(), vm.expectRevert().
+- A assertion final DEVE usar assertTrue(), assertGt() ou assertEq() para provar o sucesso do exploit.
+
+## EXECUTABILIDADE E QUALIDADE
+- Garanta que o código compila com a versão de Solidity especificada.
+- Mantenha o PoC minimalista e focado apenas na vulnerabilidade descrita.
+- Se necessário, crie contratos auxiliares (ex: atacante malicioso) ANTES do contrato ExploitTest.
+- Preserve a lógica original do contrato sem modificações.
+
+## REFINAMENTO ITERATIVO
+- Se o código falhar, analise os logs do Foundry para identificar se o erro é de COMPILAÇÃO ou de LÓGICA (revert inesperado, assertion falhou).
+- Para erros de importação, use apenas os arquivos já presentes no projeto.
+- Se travar no mesmo erro por >3 iterações, tente uma abordagem mais simples que ainda prove o ponto.
+
+## FORMATO DE OUTPUT
+Retorne APENAS um bloco de código Solidity completo:
+\`\`\`solidity
+// Código aqui
+\`\`\`
+`.trim();

src/agents/tester/tools/foundryRunner.ts

@@ -0,0 +1,53 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import { writeFile } from "fs/promises";
+
+const execAsync  = promisify(exec);
+const SANDBOX    = "/tmp/poc-sandbox";
+const TIMEOUT_MS = 60_000;
+
+export interface FoundryResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  combined: string;
+  timedOut: boolean;
+}
+
+export async function runFoundry(solidityCode: string): Promise<FoundryResult> {
+  // Escrever o arquivo no sandbox
+  await writeFile(`${SANDBOX}/test/Exploit.t.sol`, solidityCode, "utf-8");
+
+  try {
+    const { stdout, stderr } = await execAsync(
+      "forge test --match-contract ExploitTest -vvvv",
+      { 
+        cwd: SANDBOX, 
+        timeout: TIMEOUT_MS, 
+        env: { ...process.env, PATH: `${process.env.HOME}/.foundry/bin:${process.env.PATH}` } 
+      }
+    );
+    return {
+      exitCode: 0,
+      stdout,
+      stderr,
+      combined: `STDOUT:\n${stdout}\nSTDERR:\n${stderr}`,
+      timedOut: false,
+    };
+  } catch (err: any) {
+    if (err.killed || err.signal === "SIGTERM") {
+      return {
+        exitCode: -1, stdout: "", stderr: "Forge timed out",
+        combined: `TIMEOUT após ${TIMEOUT_MS / 1000}s`,
+        timedOut: true,
+      };
+    }
+    return {
+      exitCode: err.code ?? 1,
+      stdout: err.stdout ?? "",
+      stderr: err.stderr ?? "",
+      combined: `STDOUT:\n${err.stdout ?? ""}\nSTDERR:\n${err.stderr ?? ""}`,
+      timedOut: false,
+    };
+  }
+}

src/agents/tester/utils/extractSolidity.ts

@@ -0,0 +1,16 @@
+export function extractSolidity(llmOutput: string): string {
+  // Caso 1: bloco ```solidity ... ``` padrão
+  const match = llmOutput.match(/```solidity\s*([\s\S]*?)```/);
+  if (match) return match[1].trim();
+
+  // Caso 2: LLM omitiu backticks mas começa com pragma/SPDX
+  const trimmed = llmOutput.trim();
+  if (trimmed.startsWith("// SPDX") || trimmed.startsWith("pragma")) {
+    return trimmed;
+  }
+
+  // Caso 3: output inválido — lançar erro descritivo
+  throw new Error(
+    `LLM output não contém bloco Solidity válido. Preview: "${llmOutput.slice(0, 200)}"`
+  );
+}

src/agents/tester/utils/logAnalyzer.ts

@@ -0,0 +1,65 @@
+import { FoundryResult } from "../tools/foundryRunner.js";
+
+export type ErrorCategory =
+  | "compiler_error"
+  | "revert_no_message"
+  | "revert_with_message"
+  | "assertion_failed"
+  | "timeout"
+  | "unknown";
+
+export interface LogAnalysis {
+  category: ErrorCategory;
+  summary: string;          // 1-2 frases em linguagem natural para o LLM
+  relevantLines: string[];  // máx 10 linhas do log original
+}
+
+export function analyzeFoundryLog(result: FoundryResult): LogAnalysis {
+  if (result.timedOut) return {
+    category: "timeout",
+    summary: "Forge excedeu 60s. O exploit pode ter entrado em loop infinito ou a lógica está bloqueante.",
+    relevantLines: [],
+  };
+
+  if (result.combined.includes("Compiler run failed")) {
+    const lines = result.combined.split("\n")
+      .filter(l => l.includes("Error") || l.includes("error") || l.includes("-->"))
+      .slice(0, 10);
+    return {
+      category: "compiler_error",
+      summary: "Erro de compilação Solidity. Verifique: interfaces faltando, assinaturas incorretas, tipos incompatíveis.",
+      relevantLines: lines,
+    };
+  }
+
+  if (result.combined.includes("FAIL")) {
+    const revertReason  = result.combined.match(/revert: (.+)/)?.[1];
+    const assertionFail = result.combined.includes("Assertion Failed") || result.combined.includes("assertion failed");
+
+    if (assertionFail) return {
+      category: "assertion_failed",
+      summary: "O exploit executou mas a assertion final falhou — o atacante não obteve o resultado esperado.",
+      relevantLines: result.combined.split("\n")
+        .filter(l => l.includes("assertion") || l.includes("FAIL")).slice(0, 10),
+    };
+
+    if (revertReason) return {
+      category: "revert_with_message",
+      summary: `Transação reverteu com: "${revertReason}". O contrato rejeitou a operação.`,
+      relevantLines: [revertReason],
+    };
+
+    return {
+      category: "revert_no_message",
+      summary: "Transação reverteu sem mensagem. Verifique a ordem das chamadas, permissões e estado do contrato.",
+      relevantLines: result.combined.split("\n")
+        .filter(l => l.includes("revert") || l.includes("FAIL")).slice(0, 5),
+    };
+  }
+
+  return {
+    category: "unknown",
+    summary: "Erro desconhecido. Revisar output completo do forge.",
+    relevantLines: result.combined.split("\n").slice(0, 10),
+  };
+}

tests/centrifuge_flat.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity 0.8.21;
+
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+}
+
+interface IERC4626 is IERC20 {
+    function asset() external view returns (address);
+}
+
+interface InvestmentManagerLike {
+    function processDeposit(address receiver, uint256 assets) external returns (uint256);
+    function processMint(address receiver, uint256 shares) external returns (uint256);
+    function maxDeposit(address user, address _tranche) external view returns (uint256);
+    function maxMint(address user, address _tranche) external view returns (uint256);
+    function requestDeposit(uint256 assets, address receiver) external;
+}
+
+contract Auth {
+    mapping (address => uint) public wards;
+    function rely(address usr) external auth { wards[usr] = 1; }
+    function deny(address usr) external auth { wards[usr] = 0; }
+    modifier auth {
+        require(wards[msg.sender] == 1, "not-authorized");
+        _;
+    }
+}
+
+contract LiquidityPool is Auth {
+    uint64 public poolId;
+    bytes16 public trancheId;
+    address public immutable asset;
+    address public immutable share;
+    InvestmentManagerLike public investmentManager;
+
+    constructor(uint64 poolId_, bytes16 trancheId_, address asset_, address share_, address investmentManager_) {
+        poolId = poolId_;
+        trancheId = trancheId_;
+        asset = asset_;
+        share = share_;
+        investmentManager = InvestmentManagerLike(investmentManager_);
+        wards[msg.sender] = 1;
+    }
+
+    modifier withApproval(address owner) {
+        require(msg.sender == owner, "LiquidityPool/no-approval");
+        _;
+    }
+
+    function deposit(uint256 assets, address receiver) public withApproval(receiver) returns (uint256 shares) {
+        shares = investmentManager.processDeposit(receiver, assets);
+    }
+
+    function mint(uint256 shares, address receiver) public withApproval(receiver) returns (uint256 assets) {
+        assets = investmentManager.processMint(receiver, shares);
+    }
+
+    function maxDeposit(address receiver) public view returns (uint256) {
+        return investmentManager.maxDeposit(receiver, address(this));
+    }
+
+    function maxMint(address receiver) external view returns (uint256 maxShares) {
+        return investmentManager.maxMint(receiver, address(this));
+    }
+}

tests/run-centrifuge-test.ts

@@ -0,0 +1,44 @@
+import { testerAgent } from "../src/agents/tester/agent.js";
+import { Finding, VulnerabilityReport } from "../src/agents/tester/types.js";
+import { readFileSync } from "fs";
+
+function mapFindingToReport(finding: Finding, sourceCode: string): VulnerabilityReport {
+  const nameMatch = finding.path.match(/([^\/]+)\.sol$/);
+  const contractName = nameMatch ? nameMatch[1] : "TargetContract";
+
+  return {
+    id: finding.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50),
+    severity: finding.severity === "high" ? "high" : finding.severity === "medium" ? "medium" : "low",
+    type: "custom",
+    title: finding.title,
+    description: finding.description,
+    affectedContract: {
+      name: contractName,
+      sourceCode: sourceCode,
+    },
+    attackVector: finding.judgeReview.exploitablePaths[0] || "Unknown vector",
+    exploitablePaths: finding.judgeReview.exploitablePaths,
+    codeSnippet: finding.codeSnippet,
+    location: finding.location
+  };
+}
+
+async function main() {
+  const input = JSON.parse(readFileSync("src/agents/tester/data/input_centrifuge.json", "utf-8"));
+  const sourceCode = readFileSync("tests/centrifuge_flat.sol", "utf-8");
+
+  const report = mapFindingToReport(input, sourceCode);
+
+  console.log("Iniciando execução do Agente Tester com Centrifuge Trajectory 008...");
+  const result = await testerAgent.invoke({ report });
+
+  console.log("\n======= Resultado =======");
+  console.log("Status Final:", result.status);
+  console.log("Iterações:", result.iterations);
+  if (result.lastError) console.log("Último Erro:", result.lastError);
+  
+  console.log("\n======= Código Gerado =======");
+  console.log(result.pocCode);
+}
+
+main().catch(console.error);

tests/run-input-test.ts

@@ -0,0 +1,67 @@
+import { testerAgent } from "../src/agents/tester/agent.js";
+import { Finding, VulnerabilityReport } from "../src/agents/tester/types.js";
+import { readFileSync } from "fs";
+
+function mapFindingToReport(finding: Finding, sourceCode: string): VulnerabilityReport {
+  const nameMatch = finding.path.match(/([^\/]+)\.sol$/);
+  const contractName = nameMatch ? nameMatch[1] : "TargetContract";
+
+  return {
+    id: finding.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50),
+    severity: finding.severity === "high" ? "high" : finding.severity === "medium" ? "medium" : "low",
+    type: "custom",
+    title: finding.title,
+    description: finding.description,
+    affectedContract: {
+      name: contractName,
+      sourceCode: sourceCode,
+    },
+    attackVector: finding.judgeReview.exploitablePaths[0] || "Unknown vector",
+    exploitablePaths: finding.judgeReview.exploitablePaths,
+    codeSnippet: finding.codeSnippet,
+    location: finding.location
+  };
+}
+
+async function main() {
+  const input = JSON.parse(readFileSync("src/agents/tester/data/input.json", "utf-8"));
+  
+  // O Finding do auditor já tem o 'codeSnippet', mas para o Oracle precisamos do 'sourceCode' completo.
+  // Como não temos o repositório do coder aqui, vamos usar o codeSnippet envolto em um contrato mínimo
+  // ou assumir que o codeSnippet é representativo para o teste.
+  // Na vida real, o index.ts passa o coderResult.contract.
+  
+  // Vamos criar um sourceCode fake que contém o snippet para testar o fluxo.
+  const fakeSourceCode = `
+pragma solidity ^0.8.20;
+contract CafeToken {
+    mapping(address => uint256) public balances;
+    event RewardRedeemed(address indexed user, uint256 amount, string recompensa);
+    function _burn(address account, uint256 amount) internal {
+        balances[account] -= amount;
+    }
+    function balanceOf(address account) public view returns (uint256) {
+        return balances[account];
+    }
+    function mint(address account, uint256 amount) public {
+        balances[account] += amount;
+    }
+    ${input.codeSnippet}
+}
+  `;
+
+  const report = mapFindingToReport(input, fakeSourceCode);
+
+  console.log("Iniciando execução do Agente Tester com input.json...");
+  const result = await testerAgent.invoke({ report });
+
+  console.log("\n======= Resultado =======");
+  console.log("Status Final:", result.status);
+  console.log("Iterações:", result.iterations);
+  if (result.lastError) console.log("Último Erro:", result.lastError);
+  
+  console.log("\n======= Código Gerado =======");
+  console.log(result.pocCode);
+}
+
+main().catch(console.error);