recon-generate 0.0.6 → 0.0.7

package/README.md

@@ -69,6 +69,9 @@ recon-generate --mock "Morpho,Other" --force
 # Enable dynamic deploy helpers for Foo and Bar
 recon-generate --dynamic-deploy "Foo,Bar" --force
 
+# Generate coverage JSON from a Crytic tester (no scaffolding)
+recon-generate coverage --crytic-name CryticTester --name foo
+
 # Link subcommand
 
 After generating a suite you can update Echidna and Medusa configs with detected Foundry libraries:

package/dist/coverage.d.ts

@@ -0,0 +1 @@
+export declare const runCoverage: (foundryRoot: string, foundryConfigPath: string, cryticName: string, suiteNameSnake?: string) => Promise<void>;

package/dist/coverage.js

@@ -0,0 +1,221 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCoverage = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const solc_typed_ast_1 = require("solc-typed-ast");
+const processor_1 = require("./processor");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const isSetupName = (name) => {
+    if (!name)
+        return false;
+    return name.toLowerCase() === 'setup';
+};
+const stripDataLocation = (raw) => {
+    if (!raw)
+        return '';
+    const noLocation = raw
+        .replace(/\s+(storage|memory|calldata)(\s+pointer)?/g, '')
+        .replace(/\s+pointer/g, '');
+    const noPrefix = noLocation
+        .replace(/^struct\s+/, '')
+        .replace(/^enum\s+/, '')
+        .replace(/^contract\s+/, '')
+        .trim();
+    return noPrefix;
+};
+const signatureFromFnDef = (fnDef) => {
+    const params = fnDef.vParameters.vParameters
+        .map((p) => { var _a; return stripDataLocation((_a = p.typeString) !== null && _a !== void 0 ? _a : ''); })
+        .join(',');
+    const name = fnDef.name
+        || (fnDef.kind === solc_typed_ast_1.FunctionKind.Constructor
+            ? 'constructor'
+            : fnDef.kind === solc_typed_ast_1.FunctionKind.Fallback
+                ? 'fallback'
+                : fnDef.kind === solc_typed_ast_1.FunctionKind.Receive
+                    ? 'receive'
+                    : '');
+    return `${name}(${params})`;
+};
+const runCmd = (cmd, cwd) => {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(cmd, { cwd, env: { ...process.env, PATH: (0, utils_1.getEnvPath)() } }, (err, _stdout, stderr) => {
+            if (err) {
+                reject(new Error(stderr || err.message));
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+};
+const loadLatestSourceUnits = async (foundryRoot) => {
+    var _a;
+    const outDir = path.join(foundryRoot, '.recon', 'out');
+    const buildInfoDir = path.join(outDir, 'build-info');
+    let files = [];
+    try {
+        const entries = await fs.readdir(buildInfoDir);
+        const jsonFiles = entries.filter((f) => f.endsWith('.json'));
+        files = await Promise.all(jsonFiles.map(async (f) => ({
+            name: f,
+            path: path.join(buildInfoDir, f),
+            mtime: (await fs.stat(path.join(buildInfoDir, f))).mtime,
+        })));
+    }
+    catch (e) {
+        throw new Error(`No build-info directory found at ${buildInfoDir}: ${e}`);
+    }
+    if (files.length === 0) {
+        throw new Error(`No build-info JSON files found in ${buildInfoDir}.`);
+    }
+    const latestFile = files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())[0].path;
+    const fileContent = await fs.readFile(latestFile, 'utf-8');
+    const buildInfo = JSON.parse(fileContent);
+    const buildOutput = (_a = buildInfo.output) !== null && _a !== void 0 ? _a : buildInfo;
+    if (!buildOutput) {
+        throw new Error(`Build-info file ${latestFile} is missing output data.`);
+    }
+    const filteredAstData = { ...buildOutput };
+    if (filteredAstData.sources) {
+        const validSources = {};
+        for (const [key, content] of Object.entries(filteredAstData.sources)) {
+            const ast = content.ast || content.legacyAST || content.AST;
+            if (ast && (ast.nodeType === 'SourceUnit' || ast.name === 'SourceUnit')) {
+                validSources[key] = content;
+            }
+        }
+        filteredAstData.sources = validSources;
+    }
+    const reader = new solc_typed_ast_1.ASTReader();
+    return reader.read(filteredAstData);
+};
+const shouldIncludeFunction = (fnDef) => {
+    if (!fnDef.implemented)
+        return false;
+    if (isSetupName(fnDef.name))
+        return false;
+    if (fnDef.kind !== solc_typed_ast_1.FunctionKind.Function)
+        return false;
+    if (fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.External &&
+        fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.Public) {
+        return false;
+    }
+    if (fnDef.stateMutability === solc_typed_ast_1.FunctionStateMutability.View ||
+        fnDef.stateMutability === solc_typed_ast_1.FunctionStateMutability.Pure) {
+        return false;
+    }
+    return true;
+};
+const addFunction = (map, contractName, fnDef) => {
+    var _a;
+    const sig = signatureFromFnDef(fnDef);
+    if (!sig)
+        return;
+    const existing = (_a = map.get(contractName)) !== null && _a !== void 0 ? _a : new Set();
+    existing.add(sig);
+    map.set(contractName, existing);
+};
+const collectContractFunctions = (sourceUnits, cryticName) => {
+    var _a;
+    const functionsByContract = new Map();
+    const contracts = [];
+    for (const unit of sourceUnits) {
+        for (const contract of unit.getChildrenByType(solc_typed_ast_1.ContractDefinition)) {
+            if (contract.name === cryticName) {
+                contracts.push(contract);
+            }
+        }
+    }
+    if (contracts.length === 0) {
+        throw new Error(`Contract ${cryticName} not found in build output.`);
+    }
+    const contract = contracts[0];
+    const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true).reverse();
+    for (const fnDef of allFunctions) {
+        if (!shouldIncludeFunction(fnDef)) {
+            continue;
+        }
+        addFunction(functionsByContract, contract.name, fnDef);
+        for (const call of fnDef.getChildrenByType(solc_typed_ast_1.FunctionCall)) {
+            const callType = (0, utils_1.getCallType)(call);
+            if (callType === types_1.CallType.Internal) {
+                continue;
+            }
+            const ref = (_a = call.vExpression.vReferencedDeclaration) !== null && _a !== void 0 ? _a : call.vReferencedDeclaration;
+            if (!(ref instanceof solc_typed_ast_1.FunctionDefinition)) {
+                continue;
+            }
+            const targetContract = ref.getClosestParentByType(solc_typed_ast_1.ContractDefinition);
+            if (!targetContract) {
+                continue;
+            }
+            if (ref.stateMutability === solc_typed_ast_1.FunctionStateMutability.View ||
+                ref.stateMutability === solc_typed_ast_1.FunctionStateMutability.Pure) {
+                continue;
+            }
+            if (ref.kind === solc_typed_ast_1.FunctionKind.Constructor ||
+                ref.kind === solc_typed_ast_1.FunctionKind.Fallback ||
+                ref.kind === solc_typed_ast_1.FunctionKind.Receive) {
+                continue;
+            }
+            addFunction(functionsByContract, targetContract.name, ref);
+        }
+    }
+    return functionsByContract;
+};
+const runCoverage = async (foundryRoot, foundryConfigPath, cryticName, suiteNameSnake) => {
+    const outDir = path.join(foundryRoot, '.recon', 'out');
+    const buildCmd = `forge build --contracts ${cryticName} --build-info --out .recon/out`.replace(/\s+/g, ' ').trim();
+    await runCmd(buildCmd, foundryRoot);
+    const sourceUnits = await loadLatestSourceUnits(foundryRoot);
+    if (!sourceUnits || sourceUnits.length === 0) {
+        throw new Error('No source units were produced from the Crytic build; cannot generate coverage.');
+    }
+    const contractFunctions = collectContractFunctions(sourceUnits, cryticName);
+    if (contractFunctions.size === 0) {
+        throw new Error('No eligible functions found to include in coverage.');
+    }
+    const coverage = await (0, processor_1.buildCoverageMap)(sourceUnits, foundryRoot, contractFunctions);
+    const coverageName = suiteNameSnake ? `recon-${suiteNameSnake}-coverage.json` : 'recon-coverage.json';
+    const coveragePath = path.join(foundryRoot, coverageName);
+    await fs.writeFile(coveragePath, JSON.stringify(coverage, null, 2));
+    console.log(`[recon-generate] Wrote coverage file to ${coveragePath}`);
+};
+exports.runCoverage = runCoverage;

package/dist/generator.js

@@ -111,14 +111,14 @@ class ReconGenerator {
         if (await (0, utils_1.fileExists)(chimeraPath)) {
             return;
         }
-        await this.runCmd('forge install Recon-Fuzz/chimera --no-git', this.foundryRoot);
+        await this.runCmd('forge install Recon-Fuzz/chimera', this.foundryRoot);
     }
     async installSetupHelpers() {
         const setupPath = path.join(this.foundryRoot, 'lib', 'setup-helpers');
         if (await (0, utils_1.fileExists)(setupPath)) {
             return;
         }
-        await this.runCmd('forge install Recon-Fuzz/setup-helpers --no-git', this.foundryRoot);
+        await this.runCmd('forge install Recon-Fuzz/setup-helpers', this.foundryRoot);
     }
     async updateRemappings() {
         const remappingsPath = path.join(this.foundryRoot, 'remappings.txt');

package/dist/index.js

@@ -38,6 +38,7 @@ const commander_1 = require("commander");
 const path = __importStar(require("path"));
 const case_1 = require("case");
 const generator_1 = require("./generator");
+const coverage_1 = require("./coverage");
 const utils_1 = require("./utils");
 const link_1 = require("./link");
 function parseFilter(input) {
@@ -122,6 +123,20 @@ async function main() {
         .option('--force', 'Replace existing generated suite output (under --output). Does not rebuild .recon/out.')
         .option('--force-build', 'Delete .recon/out to force a fresh forge build before generating')
         .option('--foundry-config <path>', 'Path to foundry.toml (defaults to ./foundry.toml)');
+    program
+        .command('coverage')
+        .description('Generate recon-coverage.json from a Crytic tester contract without scaffolding tests')
+        .option('--crytic-name <name>', 'Name of the Crytic tester contract to compile', 'CryticTester')
+        .option('--name <suite>', 'Suite name; affects coverage filename (recon-<name>-coverage.json)')
+        .option('--foundry-config <path>', 'Path to foundry.toml (defaults to ./foundry.toml)')
+        .action(async (opts) => {
+        const workspaceRoot = process.cwd();
+        const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
+        const foundryRoot = path.dirname(foundryConfig);
+        const suiteRaw = opts.name ? String(opts.name).trim() : '';
+        const suiteSnake = suiteRaw ? (0, case_1.snake)(suiteRaw) : '';
+        await (0, coverage_1.runCoverage)(foundryRoot, foundryConfig, opts.cryticName || 'CryticTester', suiteSnake);
+    });
     program
         .command('link')
         .description('Link library addresses into echidna/medusa configs via crytic-compile')

package/dist/processor.js

@@ -153,11 +153,26 @@ const processContract = (contract) => {
     return result;
 };
 exports.processContract = processContract;
+const skipPatterns = [
+    'test/',
+    'tests/',
+    'script/',
+    'scripts/',
+    'contracts/test/',
+    'contracts/script/',
+    'contracts/scripts/',
+    'lib/forge-std/',
+    'lib/chimera/',
+    'lib/setup-helpers/',
+];
 async function buildCoverageMap(asts, foundryRoot, contractFunctions) {
     const coverage = new Map();
     const fileCache = new Map();
     let nodesVisited = 0;
     let nodesAdded = 0;
+    const shouldSkipPath = (relPath) => {
+        return skipPatterns.some((p) => relPath.includes(p));
+    };
     const addNodeRange = async (node) => {
         var _a;
         nodesVisited++;
@@ -224,6 +239,9 @@ async function buildCoverageMap(asts, foundryRoot, contractFunctions) {
     }
     const normalized = {};
     for (const [relPath, ranges] of coverage.entries()) {
+        if (shouldSkipPath(relPath)) {
+            continue; // skip test/script/lib files at the final emission step only
+        }
         const sorted = Array.from(ranges).sort((a, b) => {
             const start = (val) => parseInt(val.split('-')[0], 10);
             return start(a) - start(b);

package/dist/utils.js

@@ -284,11 +284,27 @@ function getDeepRef(node) {
     }
 }
 function getDefinitions(contract, kind, inclusion = true) {
-    let defs = inclusion ? contract[kind] : [];
-    for (const child of contract.vLinearizedBaseContracts.filter((x) => x !== contract)) {
-        defs = getDefinitions(child, kind).concat(defs.filter((x) => !getDefinitions(child, kind).includes(x)));
-    }
-    return defs;
+    const visited = new Set();
+    const gather = (c) => {
+        if (visited.has(c)) {
+            return [];
+        }
+        visited.add(c);
+        const own = inclusion ? c[kind] : [];
+        const defs = [...(own || [])];
+        for (const base of c.vLinearizedBaseContracts) {
+            if (base === c) {
+                continue;
+            }
+            for (const def of gather(base)) {
+                if (!defs.includes(def)) {
+                    defs.push(def);
+                }
+            }
+        }
+        return defs;
+    };
+    return gather(contract);
 }
 function toSource(node, version) {
     const formatter = new solc_typed_ast_1.PrettyFormatter(4, 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recon-generate",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "CLI to scaffold Recon fuzzing suite inside Foundry projects",
   "main": "dist/index.js",
   "bin": {