recon-generate 0.0.4 → 0.0.6

package/README.md

@@ -32,6 +32,7 @@ Key options:
 - `--admin "A:{fnSig,fnSig}"` — mark listed functions as admin (`asAdmin`).
 - `--mock "A,B"` — generate mocks for the listed contracts (compiled ABIs required); mocks go under `recon[-name]/mocks` and are added to targets.
 - `--dynamic-deploy "Foo,Bar"` — keep dynamic lists for the listed contracts: deploys one instance, tracks addresses in an array, exposes `_getRandom<Contract>` and `switch<Contract>(entropy)` helpers to rotate among deployed instances.
+- `--coverage` — emit `recon[-name]-coverage.json` with source line ranges for included contract functions.
 - `--name <suite>` — name the suite; affects folder (`recon-<name>`), config filenames (`echidna-<name>.yaml`, `medusa-<name>.json`, `halmos-<name>.toml`), and Crytic tester/runner names.
 - `--force` — replace existing generated suite output under `--output` (does **not** rebuild `.recon/out`).
 - `--force-build` — delete `.recon/out` to force a fresh compile before generation.
@@ -67,6 +68,19 @@ recon-generate --mock "Morpho,Other" --force
 
 # Enable dynamic deploy helpers for Foo and Bar
 recon-generate --dynamic-deploy "Foo,Bar" --force
+
+# Link subcommand
+
+After generating a suite you can update Echidna and Medusa configs with detected Foundry libraries:
+
+```bash
+recon-generate link
+```
+
+This runs `crytic-compile` with `--foundry-compile-all` to find linked libraries and rewrites:
+
+- Echidna YAML `cryticArgs` and `deployContracts` with deterministic placeholder addresses
+- Medusa `compilation.platformConfig.args` to include `--compile-libraries`
 ```
 
 ### Behavior

package/dist/generator.d.ts

@@ -16,6 +16,7 @@ export interface GeneratorOptions {
     dynamicDeploy?: Set<string>;
     suiteNameSnake: string;
     suiteNamePascal: string;
+    coverage?: boolean;
 }
 export declare class ReconGenerator {
     private foundryRoot;

package/dist/generator.js

@@ -43,8 +43,10 @@ const path = __importStar(require("path"));
 const abi_to_mock_1 = __importDefault(require("abi-to-mock"));
 const parser_1 = __importDefault(require("@solidity-parser/parser"));
 const templateManager_1 = require("./templateManager");
+const processor_1 = require("./processor");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
+const solc_typed_ast_1 = require("solc-typed-ast");
 class ReconGenerator {
     constructor(foundryRoot, options) {
         this.foundryRoot = foundryRoot;
@@ -195,7 +197,7 @@ class ReconGenerator {
         return kind;
     }
     async findSourceContracts() {
-        var _a;
+        var _a, _b;
         const contracts = [];
         const outDir = this.outDir();
         try {
@@ -224,7 +226,12 @@ class ReconGenerator {
                                 const lowerName = String(contractName).toLowerCase();
                                 const isGeneratedMock = this.generatedMocks.has(String(contractName));
                                 const contractKind = await this.getContractKind(sourcePath, String(contractName));
-                                if (contractKind === 'interface' || contractKind === 'library') {
+                                // Check if contract is explicitly included or mocked - if so, don't filter by kind
+                                const isExplicitlyIncluded = this.options.include &&
+                                    (this.options.include.contractOnly.has(String(contractName)) ||
+                                        this.options.include.functions.has(String(contractName)));
+                                const isExplicitlyMocked = (_b = this.options.mocks) === null || _b === void 0 ? void 0 : _b.has(String(contractName));
+                                if ((contractKind === 'interface' || contractKind === 'library') && !isExplicitlyIncluded && !isExplicitlyMocked) {
                                     this.logDebug('Skipping non-contract artifact', { contractName, sourcePath, contractKind });
                                     continue;
                                 }
@@ -388,7 +395,10 @@ class ReconGenerator {
         if (!tempSrc) {
             return;
         }
-        const mocksDir = path.join(this.options.suiteDir, 'mocks');
+        const suiteDirAbs = path.isAbsolute(this.options.suiteDir)
+            ? this.options.suiteDir
+            : path.join(this.foundryRoot, this.options.suiteDir);
+        const mocksDir = path.join(suiteDirAbs, 'mocks');
         await fs.mkdir(mocksDir, { recursive: true });
         const tempFiles = await fs.readdir(tempSrc);
         for (const f of tempFiles) {
@@ -464,7 +474,7 @@ class ReconGenerator {
         return config;
     }
     async run() {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         await this.ensureFoundryConfigExists();
         const outPath = this.outDir();
         const mockTargets = (_a = this.options.mocks) !== null && _a !== void 0 ? _a : new Set();
@@ -485,6 +495,73 @@ class ReconGenerator {
             }
             await this.ensureBuild(); // first build to get ABIs
         }
+        let sourceUnits = [];
+        const reader = new solc_typed_ast_1.ASTReader();
+        try {
+            const buildInfoDir = path.join(this.outDir(), 'build-info');
+            this.logDebug('Scanning build-info directory', { buildInfoDir });
+            const allFiles = await fs.readdir(buildInfoDir);
+            const jsonFiles = allFiles.filter(f => f.endsWith('.json'));
+            const filesWithStats = await Promise.all(jsonFiles.map(async (f) => ({
+                name: f,
+                path: path.join(buildInfoDir, f),
+                mtime: (await fs.stat(path.join(buildInfoDir, f))).mtime
+            })));
+            const files = filesWithStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+            if (files.length === 0) {
+                console.warn('❌ No build-info JSON files found');
+            }
+            const latestFile = (_b = files[0]) === null || _b === void 0 ? void 0 : _b.path;
+            if (latestFile) {
+                const fileContent = await fs.readFile(latestFile, 'utf-8');
+                const buildInfo = JSON.parse(fileContent);
+                const buildOutput = (_c = buildInfo.output) !== null && _c !== void 0 ? _c : buildInfo;
+                if (buildOutput) {
+                    const filteredAstData = { ...buildOutput };
+                    if (filteredAstData.sources) {
+                        const validSources = {};
+                        // Paths to skip - test and script directories
+                        const skipPatterns = [
+                            'test/',
+                            'tests/',
+                            'script/',
+                            'scripts/',
+                            'contracts/test/',
+                            'contracts/script/',
+                            'contracts/scripts/',
+                            'forge-std/'
+                        ];
+                        for (const [key, content] of Object.entries(filteredAstData.sources)) {
+                            // Skip test and script files
+                            const shouldSkip = skipPatterns.some(pattern => key.includes(pattern));
+                            if (shouldSkip) {
+                                this.logDebug('Skipping source (pattern match)', { key });
+                                continue;
+                            }
+                            const ast = content.ast || content.legacyAST || content.AST;
+                            if (ast && (ast.nodeType === "SourceUnit" || ast.name === "SourceUnit")) {
+                                validSources[key] = content;
+                            }
+                            else {
+                                this.logDebug('Skipping source (no source unit)', { key });
+                            }
+                        }
+                        filteredAstData.sources = validSources;
+                        this.logDebug('Filtered sources for AST read', { kept: Object.keys(validSources).length, keys: Object.keys(validSources) });
+                    }
+                    else {
+                        this.logDebug('No sources present in build output');
+                    }
+                    try {
+                        sourceUnits = reader.read(filteredAstData);
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+        }
+        catch (e) {
+        }
         // Generate mocks if requested, then rebuild to pick them up
         let tempMockSrc = null;
         if (mockTargets.size > 0) {
@@ -503,12 +580,63 @@ class ReconGenerator {
             await this.copyAndCleanupMocks(tempMockSrc);
         }
         const contracts = await this.findSourceContracts();
-        const filteredContracts = contracts.filter(c => this.isContractAllowed(c.name));
-        if (filteredContracts.length === 0) {
-            this.logDebug('No contracts left after include/exclude filters');
+        if (this.options.include) {
+            const requested = new Set([
+                ...this.options.include.contractOnly,
+                ...Array.from(this.options.include.functions.keys()),
+            ]);
+            const discovered = new Set(contracts.map(c => c.name));
+            const missing = Array.from(requested).filter((n) => !discovered.has(n));
+            if (missing.length > 0) {
+                console.warn('[recon-generate] Include requested contracts not found in build:', missing);
+            }
         }
+        const filteredContracts = [];
+        const skippedContracts = [];
+        for (const c of contracts) {
+            if (this.isContractAllowed(c.name)) {
+                filteredContracts.push(c);
+            }
+            else {
+                skippedContracts.push({ name: c.name, reason: 'filtered by include/exclude/mocks' });
+            }
+        }
+        this.logDebug('Contracts after filters', { count: filteredContracts.length });
         const reconConfig = await this.loadReconConfig(filteredContracts);
-        const tm = new templateManager_1.TemplateManager(this.foundryRoot, this.options.suiteDir, this.options.suiteNameSnake, this.options.suiteNamePascal, (_b = this.options.dynamicDeploy) !== null && _b !== void 0 ? _b : new Set());
+        if (this.options.coverage) {
+            if (!sourceUnits || sourceUnits.length === 0) {
+                console.warn('Coverage requested but no source units were available; skipping coverage file.');
+            }
+            else {
+                const contractFunctions = new Map();
+                for (const contract of filteredContracts) {
+                    const cfg = reconConfig[contract.jsonPath];
+                    if (!cfg || cfg.enabled === false) {
+                        continue;
+                    }
+                    const fnSet = new Set();
+                    for (const fn of (_d = cfg.functions) !== null && _d !== void 0 ? _d : []) {
+                        if (fn === null || fn === void 0 ? void 0 : fn.signature) {
+                            fnSet.add(String(fn.signature));
+                        }
+                    }
+                    if (fnSet.size > 0) {
+                        this.logDebug('Coverage: adding contract functions', { contract: contract.name, count: fnSet.size });
+                        contractFunctions.set(contract.name, fnSet);
+                    }
+                }
+                if (contractFunctions.size > 0) {
+                    const coverage = await (0, processor_1.buildCoverageMap)(sourceUnits, this.foundryRoot, contractFunctions);
+                    const coverageName = this.options.suiteNameSnake
+                        ? `recon-${this.options.suiteNameSnake}-coverage.json`
+                        : 'recon-coverage.json';
+                    const coveragePath = path.join(this.foundryRoot, coverageName);
+                    await fs.writeFile(coveragePath, JSON.stringify(coverage, null, 2));
+                    this.logDebug('Wrote coverage file', { coveragePath, files: Object.keys(coverage).length });
+                }
+            }
+        }
+        const tm = new templateManager_1.TemplateManager(this.foundryRoot, this.options.suiteDir, this.options.suiteNameSnake, this.options.suiteNamePascal, (_e = this.options.dynamicDeploy) !== null && _e !== void 0 ? _e : new Set());
         await tm.generateTemplates(filteredContracts, reconConfig);
     }
     async listAvailable() {
@@ -533,16 +661,16 @@ class ReconGenerator {
             if (fns.length > 0) {
                 filtered.push({ name: contract.name, path: contract.path, functions: fns });
             }
-        }
-        console.log('Available contracts and functions (after filters):');
-        for (const c of filtered) {
-            console.log(`- ${c.name} :: ${c.path}`);
-            for (const fn of c.functions) {
-                console.log(`    • ${fn}`);
+            console.log('Available contracts and functions (after filters):');
+            for (const c of filtered) {
+                console.log(`- ${c.name} :: ${c.path}`);
+                for (const fn of c.functions) {
+                    console.log(`    • ${fn}`);
+                }
+            }
+            if (filtered.length === 0) {
+                console.log('No contracts/functions match the current include/exclude filters.');
             }
-        }
-        if (filtered.length === 0) {
-            console.log('No contracts/functions match the current include/exclude filters.');
         }
     }
 }

package/dist/index.js

@@ -39,6 +39,7 @@ const path = __importStar(require("path"));
 const case_1 = require("case");
 const generator_1 = require("./generator");
 const utils_1 = require("./utils");
+const link_1 = require("./link");
 function parseFilter(input) {
     if (!input)
         return undefined;
@@ -116,57 +117,92 @@ async function main() {
         .option('--mock <names>', 'Comma-separated contract names to generate mocks for')
         .option('--dynamic-deploy <names>', 'Comma-separated contract names to enable dynamic deploy lists')
         .option('--debug', 'Print debug info about filters and selection')
+        .option('--coverage', 'Write coverage information to recon-coverage.json (or recon-<name>-coverage.json)')
         .option('--list', 'List available contracts/functions (after filters) and exit')
         .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('link')
+        .description('Link library addresses into echidna/medusa configs via crytic-compile')
+        .option('--echidna-config <path>', 'Path to echidna yaml (defaults based on --name)')
+        .option('--medusa-config <path>', 'Path to medusa json (defaults based on --name)')
+        .option('--name <suite>', 'Suite name to pick config defaults (echidna-<name>.yaml / medusa-<name>.json)')
         .option('--foundry-config <path>', 'Path to foundry.toml (defaults to ./foundry.toml)')
-        .parse(process.argv);
-    const opts = program.opts();
-    const workspaceRoot = process.cwd();
-    const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
-    const foundryRoot = path.dirname(foundryConfig);
-    const includeFilter = parseFilter(opts.include);
-    const excludeFilter = parseFilter(opts.exclude);
-    const adminFilter = parseFilter(opts.admin);
-    const mockSet = opts.mock
-        ? new Set(String(opts.mock).split(',').map((s) => s.trim()).filter(Boolean))
-        : undefined;
-    const dynamicDeploySet = opts.dynamicDeploy
-        ? new Set(String(opts.dynamicDeploy).split(',').map((s) => s.trim()).filter(Boolean))
-        : undefined;
-    const suiteRaw = opts.name ? String(opts.name).trim() : '';
-    const suiteSnake = suiteRaw ? (0, case_1.snake)(suiteRaw) : '';
-    const suitePascal = suiteRaw ? (0, case_1.pascal)(suiteRaw) : '';
-    const suiteFolderName = suiteSnake ? `recon-${suiteSnake}` : 'recon';
-    const baseOut = opts.output ? String(opts.output) : await (0, utils_1.getTestFolder)(foundryRoot);
-    const baseOutPath = path.isAbsolute(baseOut) ? baseOut : path.join(foundryRoot, baseOut);
-    const suiteDir = path.join(baseOutPath, suiteFolderName);
-    const reconDefaultName = suiteSnake ? `recon-${suiteSnake}.json` : 'recon.json';
-    const reconPath = opts.recon
-        ? (path.isAbsolute(opts.recon) ? opts.recon : path.join(workspaceRoot, opts.recon))
-        : (await (0, utils_1.fileExists)(path.join(foundryRoot, reconDefaultName))
-            ? path.join(foundryRoot, reconDefaultName)
-            : path.join(foundryRoot, '.recon', reconDefaultName));
-    const generator = new generator_1.ReconGenerator(foundryRoot, {
-        suiteDir,
-        reconConfigPath: reconPath,
-        foundryConfigPath: foundryConfig,
-        include: includeFilter,
-        exclude: excludeFilter,
-        admin: adminFilter ? adminFilter.functions : undefined,
-        debug: !!opts.debug,
-        force: !!opts.force,
-        forceBuild: !!opts.forceBuild,
-        mocks: mockSet,
-        dynamicDeploy: dynamicDeploySet,
-        suiteNameSnake: suiteSnake,
-        suiteNamePascal: suitePascal,
+        .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) : '';
+        const suffix = suiteSnake ? `-${suiteSnake}` : '';
+        const echidnaDefault = `echidna${suffix}.yaml`;
+        const medusaDefault = `medusa${suffix}.json`;
+        const echidnaConfigOpt = opts.echidnaConfig || echidnaDefault;
+        const medusaConfigOpt = opts.medusaConfig || medusaDefault;
+        const echidnaConfigPath = path.isAbsolute(echidnaConfigOpt)
+            ? echidnaConfigOpt
+            : path.join(foundryRoot, echidnaConfigOpt);
+        const medusaConfigPath = path.isAbsolute(medusaConfigOpt)
+            ? medusaConfigOpt
+            : path.join(foundryRoot, medusaConfigOpt);
+        await (0, link_1.runLink)(foundryRoot, echidnaConfigPath, medusaConfigPath);
     });
-    if (opts.list) {
-        await generator.listAvailable();
-        return;
-    }
-    await generator.run();
+    program
+        .action(async (opts) => {
+        const workspaceRoot = process.cwd();
+        const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
+        const foundryRoot = path.dirname(foundryConfig);
+        const includeFilter = parseFilter(opts.include);
+        const excludeFilter = parseFilter(opts.exclude);
+        const adminFilter = parseFilter(opts.admin);
+        const mockSet = opts.mock
+            ? new Set(String(opts.mock).split(',').map((s) => s.trim()).filter(Boolean))
+            : undefined;
+        if (includeFilter && mockSet && mockSet.size > 0) {
+            for (const m of mockSet) {
+                includeFilter.contractOnly.add(`${m}Mock`);
+            }
+        }
+        const dynamicDeploySet = opts.dynamicDeploy
+            ? new Set(String(opts.dynamicDeploy).split(',').map((s) => s.trim()).filter(Boolean))
+            : undefined;
+        const suiteRaw = opts.name ? String(opts.name).trim() : '';
+        const suiteSnake = suiteRaw ? (0, case_1.snake)(suiteRaw) : '';
+        const suitePascal = suiteRaw ? (0, case_1.pascal)(suiteRaw) : '';
+        const suiteFolderName = suiteSnake ? `recon-${suiteSnake}` : 'recon';
+        const baseOut = opts.output ? String(opts.output) : await (0, utils_1.getTestFolder)(foundryRoot);
+        const baseOutPath = path.isAbsolute(baseOut) ? baseOut : path.join(foundryRoot, baseOut);
+        const suiteDir = path.join(baseOutPath, suiteFolderName);
+        const reconDefaultName = suiteSnake ? `recon-${suiteSnake}.json` : 'recon.json';
+        const reconPath = opts.recon
+            ? (path.isAbsolute(opts.recon) ? opts.recon : path.join(workspaceRoot, opts.recon))
+            : (await (0, utils_1.fileExists)(path.join(foundryRoot, reconDefaultName))
+                ? path.join(foundryRoot, reconDefaultName)
+                : path.join(foundryRoot, '.recon', reconDefaultName));
+        const generator = new generator_1.ReconGenerator(foundryRoot, {
+            suiteDir,
+            reconConfigPath: reconPath,
+            foundryConfigPath: foundryConfig,
+            include: includeFilter,
+            exclude: excludeFilter,
+            admin: adminFilter ? adminFilter.functions : undefined,
+            debug: !!opts.debug,
+            force: !!opts.force,
+            forceBuild: !!opts.forceBuild,
+            mocks: mockSet,
+            dynamicDeploy: dynamicDeploySet,
+            suiteNameSnake: suiteSnake,
+            suiteNamePascal: suitePascal,
+            coverage: !!opts.coverage,
+        });
+        if (opts.list) {
+            await generator.listAvailable();
+            return;
+        }
+        await generator.run();
+    });
+    await program.parseAsync(process.argv);
 }
 main().catch(err => {
     console.error('recon-generate failed:', err.message || err);

package/dist/link.d.ts

@@ -0,0 +1 @@
+export declare function runLink(foundryRoot: string, echidnaConfigPath: string, medusaConfigPath: string): Promise<void>;

package/dist/link.js

@@ -0,0 +1,137 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLink = runLink;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const yaml_1 = __importDefault(require("yaml"));
+const utils_1 = require("./utils");
+const generateHexAddress = (index) => {
+    return `0xf${(index + 1).toString().padStart(2, '0')}`;
+};
+const parseLibrariesFromOutput = (output) => {
+    const usesPattern = /^\s+uses: \[(.*?)\]/gm;
+    const matches = [...(0, utils_1.stripAnsiCodes)(output).matchAll(usesPattern)];
+    const allLibraries = [];
+    for (const match of matches) {
+        if (match[1]) {
+            const libs = match[1]
+                .split(',')
+                .map(lib => lib.trim().replace(/["'\s]/g, ''))
+                .filter(lib => lib.length > 0);
+            for (const lib of libs) {
+                if (!allLibraries.includes(lib)) {
+                    allLibraries.push(lib);
+                }
+            }
+        }
+    }
+    return allLibraries;
+};
+const runCryticCompile = (cwd) => {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)('crytic-compile . --foundry-compile-all --print-libraries', { cwd, env: { ...process.env, PATH: (0, utils_1.getEnvPath)() } }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(stderr || error.message));
+                return;
+            }
+            resolve(stdout || '');
+        });
+    });
+};
+const formatEchidnaYaml = (config, libraries) => {
+    const cfg = { ...config };
+    delete cfg.cryticArgs;
+    delete cfg.deployContracts;
+    let out = yaml_1.default.stringify(cfg, { indent: 2 });
+    if (libraries.length === 0) {
+        out += 'cryticArgs: []\n';
+        out += 'deployContracts: []\n';
+        return out;
+    }
+    const libraryArgs = libraries.map((lib, index) => `(${lib},${generateHexAddress(index)})`).join(',');
+    out += `cryticArgs: ["--compile-libraries=${libraryArgs}","--foundry-compile-all"]\n`;
+    out += 'deployContracts:\n';
+    libraries.forEach((lib, index) => {
+        out += `  - ["${generateHexAddress(index)}", "${lib}"]\n`;
+    });
+    return out;
+};
+const updateEchidnaConfig = async (configPath, libraries) => {
+    const content = await fs.readFile(configPath, 'utf8');
+    const parsed = yaml_1.default.parse(content) || {};
+    const updated = formatEchidnaYaml(parsed, libraries);
+    await fs.writeFile(configPath, updated, 'utf8');
+};
+const updateMedusaConfig = async (configPath, libraries) => {
+    const content = await fs.readFile(configPath, 'utf8');
+    const parsed = JSON.parse(content);
+    if (!parsed.compilation)
+        parsed.compilation = {};
+    if (!parsed.compilation.platformConfig)
+        parsed.compilation.platformConfig = {};
+    if (libraries.length > 0) {
+        const libraryArgs = libraries.map((lib, index) => `(${lib},${generateHexAddress(index)})`).join(',');
+        parsed.compilation.platformConfig.args = ['--compile-libraries', libraryArgs, '--foundry-compile-all'];
+    }
+    else {
+        delete parsed.compilation.platformConfig.args;
+    }
+    await fs.writeFile(configPath, JSON.stringify(parsed, null, 2), 'utf8');
+};
+async function runLink(foundryRoot, echidnaConfigPath, medusaConfigPath) {
+    const output = await runCryticCompile(foundryRoot);
+    const libraries = parseLibrariesFromOutput(output);
+    console.log('Detected libraries:', libraries.length ? libraries.join(', ') : '(none)');
+    try {
+        await fs.access(echidnaConfigPath);
+        await updateEchidnaConfig(echidnaConfigPath, libraries);
+        console.log(`Updated echidna config at ${echidnaConfigPath}`);
+    }
+    catch (e) {
+        throw new Error(`Failed to update echidna config: ${e}`);
+    }
+    try {
+        await fs.access(medusaConfigPath);
+        await updateMedusaConfig(medusaConfigPath, libraries);
+        console.log(`Updated medusa config at ${medusaConfigPath}`);
+    }
+    catch (e) {
+        throw new Error(`Failed to update medusa config: ${e}`);
+    }
+}

package/dist/processor.d.ts

@@ -0,0 +1,3 @@
+import * as $ from 'solc-typed-ast';
+export declare const processContract: (contract: $.ContractDefinition) => Record<string, any>;
+export declare function buildCoverageMap(asts: $.SourceUnit[], foundryRoot: string, contractFunctions: Map<string, Set<string>>): Promise<Record<string, string[]>>;

package/dist/processor.js

@@ -0,0 +1,234 @@
+"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.processContract = void 0;
+exports.buildCoverageMap = buildCoverageMap;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const $ = __importStar(require("solc-typed-ast"));
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+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 simplifyParamType = (t) => {
+    const arraySuffixMatch = t.match(/(\[.*\])$/);
+    const arraySuffix = arraySuffixMatch ? arraySuffixMatch[1] : '';
+    const base = arraySuffix ? t.slice(0, -arraySuffix.length) : t;
+    const segments = base.split('.');
+    const simple = segments[segments.length - 1];
+    return `${simple}${arraySuffix}`;
+};
+const simplifySignature = (sig) => {
+    const match = sig.match(/^(.*?)\((.*)\)$/);
+    if (!match)
+        return sig;
+    const name = match[1];
+    const params = match[2];
+    if (!params)
+        return `${name}()`;
+    const simplifiedParams = params
+        .split(',')
+        .map((p) => simplifyParamType(p.trim()))
+        .join(',');
+    return `${name}(${simplifiedParams})`;
+};
+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 === $.FunctionKind.Constructor
+            ? 'constructor'
+            : fnDef.kind === $.FunctionKind.Fallback
+                ? 'fallback'
+                : fnDef.kind === $.FunctionKind.Receive
+                    ? 'receive'
+                    : '');
+    return `${name}(${params})`;
+};
+const matchesSignature = (sig, allowed) => {
+    if (allowed.has(sig))
+        return true;
+    const nameOnly = sig.split('(')[0];
+    if (allowed.has(nameOnly))
+        return true;
+    const simplifiedSig = simplifySignature(sig);
+    const simplifiedName = simplifiedSig.split('(')[0];
+    if (allowed.has(simplifiedSig) || allowed.has(simplifiedName))
+        return true;
+    const simplifiedAllowed = new Set(Array.from(allowed).map((s) => simplifySignature(s)));
+    if (simplifiedAllowed.has(sig) || simplifiedAllowed.has(nameOnly))
+        return true;
+    if (simplifiedAllowed.has(simplifiedSig) || simplifiedAllowed.has(simplifiedName))
+        return true;
+    return false;
+};
+const processFunction = (fnDef, includeDeps = false) => {
+    const result = [];
+    fnDef.walk((n) => {
+        if ('vReferencedDeclaration' in n &&
+            n.vReferencedDeclaration &&
+            n.vReferencedDeclaration !== fnDef) {
+            if (n.vReferencedDeclaration instanceof $.FunctionDefinition ||
+                n.vReferencedDeclaration instanceof $.ModifierDefinition) {
+                const refSourceUnit = n.vReferencedDeclaration.getClosestParentByType($.SourceUnit);
+                if (result.some((x) => x.ast === n.vReferencedDeclaration)) {
+                    return;
+                }
+                result.push({
+                    ast: n.vReferencedDeclaration,
+                    children: processFunction(n.vReferencedDeclaration, includeDeps),
+                    callType: n instanceof $.FunctionCall ? (0, utils_1.getCallType)(n) : types_1.CallType.Internal,
+                });
+            }
+        }
+    });
+    return result;
+};
+const processContract = (contract) => {
+    const result = {};
+    result['vFunctions'] = [];
+    const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true).reverse();
+    for (const fnDef of allFunctions.filter((x) => x.implemented)) {
+        if (fnDef.visibility !== $.FunctionVisibility.External &&
+            fnDef.visibility !== $.FunctionVisibility.Public) {
+            continue;
+        }
+        if ((fnDef.stateMutability === $.FunctionStateMutability.Pure ||
+            fnDef.stateMutability === $.FunctionStateMutability.View)) {
+            continue;
+        }
+        if (!result['vFunctions'].some((x) => (0, utils_1.signatureEquals)(x, fnDef))) {
+            const rec = {
+                ast: fnDef,
+                children: processFunction(fnDef),
+            };
+            result['vFunctions'].push(rec);
+        }
+    }
+    return result;
+};
+exports.processContract = processContract;
+async function buildCoverageMap(asts, foundryRoot, contractFunctions) {
+    const coverage = new Map();
+    const fileCache = new Map();
+    let nodesVisited = 0;
+    let nodesAdded = 0;
+    const addNodeRange = async (node) => {
+        var _a;
+        nodesVisited++;
+        const srcUnit = node.getClosestParentByType($.SourceUnit);
+        if (!srcUnit) {
+            return;
+        }
+        const parentContract = node.getClosestParentByType($.ContractDefinition);
+        if (parentContract && parentContract.kind === 'interface') {
+            return;
+        }
+        const absPath = path.isAbsolute(srcUnit.absolutePath)
+            ? srcUnit.absolutePath
+            : path.join(foundryRoot, srcUnit.absolutePath);
+        let content = fileCache.get(absPath);
+        if (!content) {
+            try {
+                content = await fs.readFile(absPath, 'utf8');
+                fileCache.set(absPath, content);
+            }
+            catch {
+                return;
+            }
+        }
+        const src = node.src;
+        if (!src) {
+            return;
+        }
+        const { start, end } = (0, utils_1.getLines)(content, src);
+        const key = path.relative(foundryRoot, absPath);
+        const entry = (_a = coverage.get(key)) !== null && _a !== void 0 ? _a : new Set();
+        entry.add(start === end ? `${start}` : `${start}-${end}`);
+        coverage.set(key, entry);
+        nodesAdded++;
+    };
+    const walkRecord = async (rec) => {
+        await addNodeRange(rec.ast);
+        for (const child of rec.children) {
+            await walkRecord(child);
+        }
+    };
+    for (const ast of asts) {
+        for (const contract of ast.getChildrenByType($.ContractDefinition)) {
+            if (contract.kind === 'interface') {
+                continue;
+            }
+            const allowedFns = contractFunctions.get(contract.name);
+            if (!allowedFns || allowedFns.size === 0) {
+                continue;
+            }
+            const processed = (0, exports.processContract)(contract);
+            const recs = (processed['vFunctions'] || []);
+            if (recs.length === 0) {
+                continue;
+            }
+            for (const rec of recs) {
+                const sig = signatureFromFnDef(rec.ast);
+                if (!matchesSignature(sig, allowedFns)) {
+                    continue;
+                }
+                await walkRecord(rec);
+            }
+        }
+    }
+    const normalized = {};
+    for (const [relPath, ranges] of coverage.entries()) {
+        const sorted = Array.from(ranges).sort((a, b) => {
+            const start = (val) => parseInt(val.split('-')[0], 10);
+            return start(a) - start(b);
+        });
+        normalized[relPath] = sorted;
+    }
+    return normalized;
+}

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { ASTNode } from "solc-typed-ast";
 export declare enum Actor {
     ACTOR = "actor",
     ADMIN = "admin"
@@ -43,3 +44,13 @@ export interface FunctionDefinitionParams {
     mode: Mode;
     separated?: boolean;
 }
+export declare enum CallType {
+    Internal = "internal",
+    HighLevel = "high-level",
+    LowLevel = "low-level"
+}
+export type RecordItem = {
+    ast: ASTNode;
+    children: RecordItem[];
+    callType?: CallType;
+};

package/dist/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mode = exports.Actor = void 0;
+exports.CallType = exports.Mode = exports.Actor = void 0;
 var Actor;
 (function (Actor) {
     Actor["ACTOR"] = "actor";
@@ -12,3 +12,9 @@ var Mode;
     Mode["FAIL"] = "fail";
     Mode["CATCH"] = "catch";
 })(Mode || (exports.Mode = Mode = {}));
+var CallType;
+(function (CallType) {
+    CallType["Internal"] = "internal";
+    CallType["HighLevel"] = "high-level";
+    CallType["LowLevel"] = "low-level";
+})(CallType || (exports.CallType = CallType = {}));

package/dist/utils.d.ts

@@ -1,3 +1,5 @@
+import { ASTNode, ContractDefinition, Assignment, FunctionCall, FunctionDefinition, VariableDeclaration } from 'solc-typed-ast';
+import { CallType } from './types';
 export declare function fileExists(p: string): Promise<boolean>;
 export declare function getFoundryConfigPath(workspaceRoot: string, override?: string): string;
 export declare function findOutputDirectory(workspaceRoot: string, foundryConfigPath: string): Promise<string>;
@@ -5,3 +7,25 @@ export declare function findSrcDirectory(workspaceRoot: string, foundryConfigPat
 export declare function getTestFolder(foundryRoot: string): Promise<string>;
 export declare function stripAnsiCodes(text: string): string;
 export declare function getEnvPath(): string;
+export declare const getLines: (content: string, src: string) => {
+    start: any;
+    end: any;
+};
+export declare const getSource: (content: string, src: string) => string;
+export declare const getIndex: (content: string, index: number) => number;
+export declare function highLevelCallWithOptions(fnCall: FunctionCall, noStatic?: boolean): boolean;
+export declare function highLevelCall(fnCall: FunctionCall, noStatic?: boolean): boolean;
+export declare function lowLevelCallWithOptions(fnCall: FunctionCall): boolean;
+export declare function lowLevelCall(fnCall: FunctionCall): boolean;
+export declare function lowLevelStaticCall(fnCall: FunctionCall): boolean;
+export declare function lowLevelDelegateCall(fnCall: FunctionCall): boolean;
+export declare function lowLevelSend(fnCall: FunctionCall): boolean;
+export declare function lowLevelTransfer(fnCall: FunctionCall): boolean;
+export declare function isStateVarAssignment(node: Assignment): boolean;
+export declare function getStateVarAssignment(node: Assignment): VariableDeclaration | null;
+export declare function getDeepRef(node: ASTNode): ASTNode | undefined;
+export declare function getDefinitions(contract: ContractDefinition, kind: string, inclusion?: boolean): ASTNode[];
+export declare function toSource(node: ASTNode, version?: string): string;
+export declare function getCallType(fnCall: FunctionCall): CallType;
+export declare const getFunctionName: (fnDef: FunctionDefinition) => string;
+export declare const signatureEquals: (a: FunctionDefinition, b: FunctionDefinition) => boolean;

package/dist/utils.js

@@ -32,7 +32,11 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.signatureEquals = exports.getFunctionName = exports.getIndex = exports.getSource = exports.getLines = void 0;
 exports.fileExists = fileExists;
 exports.getFoundryConfigPath = getFoundryConfigPath;
 exports.findOutputDirectory = findOutputDirectory;
@@ -40,8 +44,25 @@ exports.findSrcDirectory = findSrcDirectory;
 exports.getTestFolder = getTestFolder;
 exports.stripAnsiCodes = stripAnsiCodes;
 exports.getEnvPath = getEnvPath;
+exports.highLevelCallWithOptions = highLevelCallWithOptions;
+exports.highLevelCall = highLevelCall;
+exports.lowLevelCallWithOptions = lowLevelCallWithOptions;
+exports.lowLevelCall = lowLevelCall;
+exports.lowLevelStaticCall = lowLevelStaticCall;
+exports.lowLevelDelegateCall = lowLevelDelegateCall;
+exports.lowLevelSend = lowLevelSend;
+exports.lowLevelTransfer = lowLevelTransfer;
+exports.isStateVarAssignment = isStateVarAssignment;
+exports.getStateVarAssignment = getStateVarAssignment;
+exports.getDeepRef = getDeepRef;
+exports.getDefinitions = getDefinitions;
+exports.toSource = toSource;
+exports.getCallType = getCallType;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
+const solc_typed_ast_1 = require("solc-typed-ast");
+const src_location_1 = __importDefault(require("src-location"));
+const types_1 = require("./types");
 async function fileExists(p) {
     try {
         await fs.access(p);
@@ -104,3 +125,211 @@ function stripAnsiCodes(text) {
 function getEnvPath() {
     return process.env.PATH || '';
 }
+const getLines = (content, src) => {
+    let en = (0, exports.getIndex)(content, parseInt(src.split(':')[0]) + parseInt(src.split(':')[1]));
+    let { line: start } = src_location_1.default.indexToLocation(content, (0, exports.getIndex)(content, parseInt(src.split(':')[0])), true);
+    let { line: end } = src_location_1.default.indexToLocation(content, en, true);
+    return { start, end };
+};
+exports.getLines = getLines;
+const getSource = (content, src) => {
+    let en = (0, exports.getIndex)(content, parseInt(src.split(':')[0]) + parseInt(src.split(':')[1]));
+    return content.slice((0, exports.getIndex)(content, parseInt(src.split(':')[0])), en);
+};
+exports.getSource = getSource;
+const getIndex = (content, index) => {
+    const sourceBytes = (new TextEncoder).encode(content);
+    return new TextDecoder().decode(sourceBytes.slice(0, index)).length;
+};
+exports.getIndex = getIndex;
+function highLevelCallWithOptions(fnCall, noStatic = false) {
+    var _a, _b;
+    if (!(fnCall.vExpression instanceof solc_typed_ast_1.MemberAccess) ||
+        !(fnCall.vExpression.vExpression instanceof solc_typed_ast_1.MemberAccess))
+        return false;
+    const ref = (_a = fnCall.vExpression) === null || _a === void 0 ? void 0 : _a.vExpression.vReferencedDeclaration;
+    if (!(ref instanceof solc_typed_ast_1.FunctionDefinition))
+        return false;
+    if (noStatic) {
+        if (ref.stateMutability === solc_typed_ast_1.FunctionStateMutability.Pure ||
+            ref.stateMutability === solc_typed_ast_1.FunctionStateMutability.View ||
+            ref.stateMutability === solc_typed_ast_1.FunctionStateMutability.Constant) {
+            return false;
+        }
+    }
+    if (fnCall.vExpression.vExpression.vExpression.typeString.startsWith('type(library ')) {
+        if (!ref.vReturnParameters || ((_b = ref.vReturnParameters) === null || _b === void 0 ? void 0 : _b.vParameters.length) === 0)
+            return false;
+        for (const inFnCall of ref.getChildrenByType(solc_typed_ast_1.FunctionCall)) {
+            if (highLevelCall(inFnCall, noStatic))
+                return true;
+            if (highLevelCallWithOptions(inFnCall, noStatic))
+                return true;
+        }
+    }
+    return (fnCall.vExpression.vExpression.vExpression.typeString.startsWith('contract ') ||
+        fnCall.vExpression.vExpression.typeString === 'address');
+}
+function highLevelCall(fnCall, noStatic = false) {
+    var _a, _b, _c;
+    if (!(fnCall.vExpression instanceof solc_typed_ast_1.MemberAccess))
+        return false;
+    const ref = fnCall.vExpression.vReferencedDeclaration;
+    if (!(ref instanceof solc_typed_ast_1.FunctionDefinition))
+        return false;
+    if (noStatic) {
+        if (ref.stateMutability === solc_typed_ast_1.FunctionStateMutability.Pure ||
+            ref.stateMutability === solc_typed_ast_1.FunctionStateMutability.View ||
+            ref.stateMutability === solc_typed_ast_1.FunctionStateMutability.Constant) {
+            return false;
+        }
+    }
+    if (fnCall.vExpression.vExpression.typeString.startsWith('type(library ')) {
+        if (!ref.vReturnParameters || ((_a = ref.vReturnParameters) === null || _a === void 0 ? void 0 : _a.vParameters.length) === 0)
+            return false;
+        for (const inFnCall of ref.getChildrenByType(solc_typed_ast_1.FunctionCall)) {
+            if (highLevelCall(inFnCall, noStatic))
+                return true;
+            if (highLevelCallWithOptions(inFnCall, noStatic))
+                return true;
+        }
+    }
+    return (fnCall.vExpression.vExpression.typeString.startsWith('contract ') ||
+        ((_c = (_b = fnCall.vExpression) === null || _b === void 0 ? void 0 : _b.vExpression) === null || _c === void 0 ? void 0 : _c.typeString) === 'address');
+}
+function lowLevelCallWithOptions(fnCall) {
+    return (fnCall.vExpression instanceof solc_typed_ast_1.MemberAccess &&
+        fnCall.vExpression.vExpression instanceof solc_typed_ast_1.MemberAccess &&
+        fnCall.vExpression.vExpression.memberName === 'call');
+}
+function lowLevelCall(fnCall) {
+    if (fnCall.vExpression instanceof solc_typed_ast_1.MemberAccess && fnCall.vExpression.memberName === 'call') {
+        return true;
+    }
+    else if (lowLevelCallWithOptions(fnCall)) {
+        return true;
+    }
+    return false;
+}
+function lowLevelStaticCall(fnCall) {
+    if (fnCall.vExpression instanceof solc_typed_ast_1.MemberAccess &&
+        fnCall.vExpression.memberName === 'staticcall') {
+        return true;
+    }
+    else if (fnCall.vExpression instanceof solc_typed_ast_1.FunctionCall &&
+        fnCall.vExpression.vExpression instanceof solc_typed_ast_1.MemberAccess &&
+        fnCall.vExpression.vExpression.memberName === 'staticcall') {
+        return true;
+    }
+    return false;
+}
+function lowLevelDelegateCall(fnCall) {
+    if (fnCall.vExpression instanceof solc_typed_ast_1.MemberAccess &&
+        fnCall.vExpression.memberName === 'delegatecall') {
+        return true;
+    }
+    else if (fnCall.vExpression instanceof solc_typed_ast_1.FunctionCall &&
+        fnCall.vExpression.vExpression instanceof solc_typed_ast_1.MemberAccess &&
+        fnCall.vExpression.vExpression.memberName === 'delegatecall') {
+        return true;
+    }
+    return false;
+}
+function lowLevelSend(fnCall) {
+    if (fnCall.vExpression instanceof solc_typed_ast_1.MemberAccess && fnCall.vExpression.memberName === 'send') {
+        return true;
+    }
+    else if (fnCall.vExpression instanceof solc_typed_ast_1.FunctionCall &&
+        fnCall.vExpression.vExpression instanceof solc_typed_ast_1.MemberAccess &&
+        fnCall.vExpression.vExpression.memberName === 'send') {
+        return true;
+    }
+    return false;
+}
+function lowLevelTransfer(fnCall) {
+    if (fnCall.vExpression instanceof solc_typed_ast_1.MemberAccess && fnCall.vExpression.memberName === 'transfer') {
+        return true;
+    }
+    else if (fnCall.vExpression instanceof solc_typed_ast_1.FunctionCall &&
+        fnCall.vExpression.vExpression instanceof solc_typed_ast_1.MemberAccess &&
+        fnCall.vExpression.vExpression.memberName === 'transfer') {
+        return true;
+    }
+    return false;
+}
+function isStateVarAssignment(node) {
+    const decl = getStateVarAssignment(node);
+    if (!decl)
+        return false;
+    return decl && (decl.stateVariable || decl.storageLocation === solc_typed_ast_1.DataLocation.Storage);
+}
+function getStateVarAssignment(node) {
+    const decl = getDeepRef(node.vLeftHandSide);
+    if (!(decl instanceof solc_typed_ast_1.VariableDeclaration))
+        return null;
+    return decl;
+}
+function getDeepRef(node) {
+    if (node instanceof solc_typed_ast_1.Identifier) {
+        return node.vReferencedDeclaration;
+    }
+    else if (node instanceof solc_typed_ast_1.IndexAccess) {
+        return getDeepRef(node.vBaseExpression);
+    }
+    else if (node instanceof solc_typed_ast_1.MemberAccess) {
+        return getDeepRef(node.vExpression);
+    }
+    else {
+        return undefined;
+    }
+}
+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;
+}
+function toSource(node, version) {
+    const formatter = new solc_typed_ast_1.PrettyFormatter(4, 0);
+    const writer = new solc_typed_ast_1.ASTWriter(solc_typed_ast_1.DefaultASTWriterMapping, formatter, version ? version : solc_typed_ast_1.LatestCompilerVersion);
+    return writer.write(node);
+}
+function getCallType(fnCall) {
+    if (highLevelCall(fnCall)) {
+        return types_1.CallType.HighLevel;
+    }
+    else if (lowLevelCall(fnCall)) {
+        return types_1.CallType.LowLevel;
+    }
+    return types_1.CallType.Internal;
+}
+const getFunctionName = (fnDef) => {
+    if (fnDef.name) {
+        return fnDef.name;
+    }
+    if (fnDef.isConstructor || fnDef.kind === solc_typed_ast_1.FunctionKind.Constructor) {
+        return 'constructor';
+    }
+    if (fnDef.kind === solc_typed_ast_1.FunctionKind.Fallback) {
+        return 'fallback';
+    }
+    if (fnDef.kind === solc_typed_ast_1.FunctionKind.Receive) {
+        return 'receive';
+    }
+    return 'Unknown';
+};
+exports.getFunctionName = getFunctionName;
+const signatureEquals = (a, b) => {
+    if (!a.name || !b.name)
+        return false;
+    if (a.name !== b.name)
+        return false;
+    if (a.vParameters.vParameters.map((x) => x.type).join(',') !==
+        b.vParameters.vParameters.map((x) => x.type).join(','))
+        return false;
+    if (a.visibility !== b.visibility)
+        return false;
+    return a.stateMutability === b.stateMutability;
+};
+exports.signatureEquals = signatureEquals;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recon-generate",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "CLI to scaffold Recon fuzzing suite inside Foundry projects",
   "main": "dist/index.js",
   "bin": {
@@ -22,7 +22,10 @@
     "abi-to-mock": "^1.0.4",
     "case": "^1.6.3",
     "commander": "^14.0.2",
-    "handlebars": "^4.7.8"
+    "handlebars": "^4.7.8",
+    "solc-typed-ast": "^19.1.0",
+    "src-location": "^1.1.0",
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@types/node": "^24.0.4",