recon-generate 0.0.22 → 0.0.24

package/dist/dictionary.d.ts

@@ -0,0 +1,25 @@
+interface ConstructorParam {
+    name: string;
+    type: string;
+}
+interface ContractInfo {
+    constructor: ConstructorParam[];
+    state_variables: {
+        [variableName: string]: string;
+    };
+}
+interface FileContracts {
+    [contractName: string]: ContractInfo;
+}
+interface DictionaryOutput {
+    [filePath: string]: FileContracts;
+}
+/**
+ * Run the dictionary command
+ */
+export declare const runDictionary: (buildInfoPath: string, options?: {
+    outputPath?: string;
+    json?: boolean;
+    srcPrefix?: string;
+}) => Promise<DictionaryOutput>;
+export {};

package/dist/dictionary.js

@@ -0,0 +1,246 @@
+"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.runDictionary = void 0;
+const fs = __importStar(require("fs/promises"));
+const solc_typed_ast_1 = require("solc-typed-ast");
+const utils_1 = require("./utils");
+/**
+ * Load build-info from a JSON file
+ */
+const loadBuildInfo = async (buildInfoPath) => {
+    var _a;
+    const fileContent = await fs.readFile(buildInfoPath, '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 ${buildInfoPath} 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();
+    const sourceUnits = reader.read(filteredAstData);
+    return { sourceUnits };
+};
+/**
+ * Check if a type string represents an address, contract, or interface type
+ */
+const isRelevantType = (typeString) => {
+    return (typeString === 'address' ||
+        typeString === 'address payable' ||
+        typeString.startsWith('contract ') ||
+        typeString.startsWith('interface '));
+};
+/**
+ * Extract the type name from a typeString
+ * e.g., "contract IHub" -> "IHub", "address" -> "address"
+ */
+const extractTypeName = (typeString) => {
+    if (typeString.startsWith('contract ')) {
+        return typeString.slice('contract '.length);
+    }
+    if (typeString.startsWith('interface ')) {
+        return typeString.slice('interface '.length);
+    }
+    return typeString;
+};
+/**
+ * Get state variable map by ID for a contract (including inherited)
+ */
+const getStateVarMap = (contract) => {
+    const stateVars = (0, utils_1.getDefinitions)(contract, 'vStateVariables', true);
+    const varMap = new Map();
+    for (const stateVar of stateVars) {
+        varMap.set(stateVar.id, stateVar);
+    }
+    return varMap;
+};
+/**
+ * Check if an expression references a state variable and return the variable name
+ */
+const getReferencedStateVar = (node, stateVarIds) => {
+    const ref = node.vReferencedDeclaration;
+    if (ref instanceof solc_typed_ast_1.VariableDeclaration && stateVarIds.has(ref.id)) {
+        return ref.name;
+    }
+    return null;
+};
+/**
+ * Extract the casted type name from a type conversion call
+ * e.g., IERC20(token) -> "IERC20"
+ */
+const getCastedTypeName = (call) => {
+    if (call.kind !== solc_typed_ast_1.FunctionCallKind.TypeConversion) {
+        return null;
+    }
+    const expr = call.vExpression;
+    if (expr instanceof solc_typed_ast_1.Identifier) {
+        const ref = expr.vReferencedDeclaration;
+        if (ref instanceof solc_typed_ast_1.ContractDefinition) {
+            return ref.name;
+        }
+    }
+    return null;
+};
+/**
+ * Collect state variables that are address, contract, or interface types
+ */
+const collectRelevantStateVars = (stateVars) => {
+    const vars = new Map();
+    for (const stateVar of stateVars) {
+        const typeString = stateVar.typeString;
+        if (typeString && isRelevantType(typeString)) {
+            const typeName = extractTypeName(typeString);
+            vars.set(stateVar.name, typeName);
+        }
+    }
+    return vars;
+};
+/**
+ * Get constructor parameters for a contract
+ */
+const getConstructorParams = (contract) => {
+    const functions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true);
+    const constructor = functions.find(fn => fn.kind === solc_typed_ast_1.FunctionKind.Constructor);
+    if (!constructor) {
+        return [];
+    }
+    return constructor.vParameters.vParameters.map(param => ({
+        name: param.name,
+        type: extractTypeName(param.typeString),
+    }));
+};
+/**
+ * Find all state variable casts in a contract
+ * e.g., IFoo(stateVar) or Foo(stateVar)
+ */
+const findStateVarCasts = (contract, stateVarMap) => {
+    const casts = new Map();
+    for (const call of contract.getChildrenByType(solc_typed_ast_1.FunctionCall)) {
+        const castedType = getCastedTypeName(call);
+        if (!castedType)
+            continue;
+        for (const arg of call.vArguments) {
+            let stateVarName = null;
+            if (arg instanceof solc_typed_ast_1.Identifier) {
+                stateVarName = getReferencedStateVar(arg, stateVarMap);
+            }
+            else if (arg instanceof solc_typed_ast_1.MemberAccess) {
+                stateVarName = getReferencedStateVar(arg, stateVarMap);
+            }
+            if (stateVarName) {
+                if (!casts.has(stateVarName)) {
+                    casts.set(stateVarName, castedType);
+                }
+            }
+        }
+    }
+    return casts;
+};
+/**
+ * Run the dictionary command
+ */
+const runDictionary = async (buildInfoPath, options = {}) => {
+    var _a;
+    const log = options.json ? () => { } : console.log.bind(console);
+    const srcPrefix = (_a = options.srcPrefix) !== null && _a !== void 0 ? _a : 'src/';
+    log(`[recon-generate] Loading build-info from ${buildInfoPath}`);
+    const { sourceUnits } = await loadBuildInfo(buildInfoPath);
+    if (!sourceUnits || sourceUnits.length === 0) {
+        throw new Error('No source units were produced from the build-info; cannot generate dictionary.');
+    }
+    log(`[recon-generate] Found ${sourceUnits.length} source units`);
+    const output = {};
+    for (const unit of sourceUnits) {
+        const filePath = unit.absolutePath;
+        if (!filePath.startsWith(srcPrefix)) {
+            continue;
+        }
+        for (const contract of unit.getChildrenByType(solc_typed_ast_1.ContractDefinition)) {
+            // Skip interfaces, libraries, and abstract contracts
+            if (contract.kind !== solc_typed_ast_1.ContractKind.Contract) {
+                continue;
+            }
+            if (contract.abstract) {
+                continue;
+            }
+            // Get all state variables including inherited ones
+            const stateVars = (0, utils_1.getDefinitions)(contract, 'vStateVariables', true);
+            const stateVarMap = getStateVarMap(contract);
+            // 1. Get constructor parameters
+            const constructorParams = getConstructorParams(contract);
+            // 2. Collect state variables that are address/contract/interface types
+            const declaredVars = collectRelevantStateVars(stateVars);
+            // 3. Find all casts of state variables to contract/interface types
+            const casts = findStateVarCasts(contract, stateVarMap);
+            // Merge: casts override declared types
+            const mergedVars = {};
+            for (const [varName, typeName] of declaredVars) {
+                mergedVars[varName] = typeName;
+            }
+            for (const [varName, castedType] of casts) {
+                mergedVars[varName] = castedType;
+            }
+            // Include all implemented contracts
+            if (!output[filePath]) {
+                output[filePath] = {};
+            }
+            output[filePath][contract.name] = {
+                constructor: constructorParams,
+                state_variables: mergedVars,
+            };
+        }
+    }
+    const jsonOutput = JSON.stringify(output, null, 2);
+    if (options.json) {
+        console.log(jsonOutput);
+    }
+    if (options.outputPath || !options.json) {
+        const dictPath = options.outputPath || 'recon-dictionary.json';
+        await fs.writeFile(dictPath, jsonOutput);
+        log(`[recon-generate] Wrote dictionary file to ${dictPath}`);
+    }
+    return output;
+};
+exports.runDictionary = runDictionary;

package/dist/generator.d.ts

@@ -17,6 +17,7 @@ export interface GeneratorOptions {
     suiteNameSnake: string;
     suiteNamePascal: string;
     coverage?: boolean;
+    params?: boolean;
 }
 export declare class ReconGenerator {
     private foundryRoot;

package/dist/generator.js

@@ -47,6 +47,7 @@ const processor_1 = require("./processor");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
 const solc_typed_ast_1 = require("solc-typed-ast");
+const inputParams_1 = require("./inputParams");
 class ReconGenerator {
     constructor(foundryRoot, options) {
         this.foundryRoot = foundryRoot;
@@ -707,8 +708,23 @@ class ReconGenerator {
                 }
             }
         }
+        const collected = (0, processor_1.collectFunctions)(filteredContracts, reconConfig);
+        if (this.options.params) {
+            if (!sourceUnits || sourceUnits.length === 0) {
+                console.warn('Input params map requested but no source units were available; skipping params file.');
+            }
+            else {
+                const inputParamsMap = (0, inputParams_1.buildInputParamsMap)(sourceUnits, collected.adminFunctions, collected.constructors, collected.otherFunctions);
+                const paramName = this.options.suiteNameSnake
+                    ? `recon-${this.options.suiteNameSnake}-params.json`
+                    : 'recon-params.json';
+                const paramPath = path.join(this.foundryRoot, paramName);
+                await fs.writeFile(paramPath, JSON.stringify(inputParamsMap, null, 2));
+                this.logDebug('Wrote parameter file', { paramPath });
+            }
+        }
         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);
+        await tm.generateTemplates(collected.enabledContracts, collected.adminFunctions, collected.nonSeparatedFunctions, collected.separatedByContract, collected.allContractNames);
     }
     async listAvailable() {
         var _a;

package/dist/index.js

@@ -46,6 +46,7 @@ const utils_1 = require("./utils");
 const link_1 = require("./link");
 const link2_1 = require("./link2");
 const sourcemap_1 = require("./sourcemap");
+const dictionary_1 = require("./dictionary");
 function parseFilter(input) {
     if (!input)
         return undefined;
@@ -124,6 +125,7 @@ async function main() {
         .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('--params', 'Generate input parameters mapping to recon-params.json (or recon-<name>-params.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')
@@ -242,6 +244,27 @@ async function main() {
             verbose: !!opts.verbose,
         });
     });
+    program
+        .command('dictionary <buildInfo>')
+        .description('Extract storage variables with contract/interface types from build-info')
+        .option('-o, --output <path>', 'Custom output path for the dictionary JSON file')
+        .option('--json', 'Output JSON to terminal (also saves to file if -o is specified)')
+        .option('--src-prefix <prefix>', 'Source directory prefix to filter (default: "src/")', 'src/')
+        .action(async function (buildInfoPath) {
+        // @ts-ignore - Commander types are complex
+        const opts = this.opts();
+        const resolvedBuildInfo = path.isAbsolute(buildInfoPath)
+            ? buildInfoPath
+            : path.resolve(process.cwd(), buildInfoPath);
+        const outputPath = opts.output
+            ? (path.isAbsolute(opts.output) ? opts.output : path.resolve(process.cwd(), opts.output))
+            : undefined;
+        await (0, dictionary_1.runDictionary)(resolvedBuildInfo, {
+            outputPath,
+            json: !!opts.json,
+            srcPrefix: opts.srcPrefix,
+        });
+    });
     program
         .command('info <contractName>')
         .description('Generate contract info JSON (payable, constants, function relations, etc.)')
@@ -353,6 +376,7 @@ async function main() {
             suiteNameSnake: suiteSnake,
             suiteNamePascal: suitePascal,
             coverage: !!opts.coverage,
+            params: !!opts.params,
         });
         if (opts.list) {
             await generator.listAvailable();

package/dist/inputParams.d.ts

@@ -0,0 +1,3 @@
+import { FunctionDefinitionParams, InputParamsMap } from './types';
+import { SourceUnit } from 'solc-typed-ast';
+export declare function buildInputParamsMap(sourceUnits: SourceUnit[], adminFunctions: FunctionDefinitionParams[], constructors: FunctionDefinitionParams[], otherFunctions: FunctionDefinitionParams[]): InputParamsMap;

package/dist/inputParams.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInputParamsMap = buildInputParamsMap;
+const solc_typed_ast_1 = require("solc-typed-ast");
+const processor_1 = require("./processor");
+function buildInputParamsMap(sourceUnits, adminFunctions, constructors, otherFunctions) {
+    const formatter = new solc_typed_ast_1.PrettyFormatter(4, 0);
+    for (const source of sourceUnits) {
+        const pragmas = source.vPragmaDirectives;
+        const solidityPragma = pragmas.find(p => p.vIdentifier === 'solidity');
+        const compilerVersion = solidityPragma ? solidityPragma.vValue : solc_typed_ast_1.LatestCompilerVersion;
+        const writer = new solc_typed_ast_1.ASTWriter(solc_typed_ast_1.DefaultASTWriterMapping, formatter, compilerVersion);
+        const contracts = source.getChildrenByType(solc_typed_ast_1.ContractDefinition);
+        for (const contract of contracts) {
+            if (contract.kind === 'interface')
+                continue;
+            const allowedFunctions = adminFunctions.filter(fn => fn.contractName === contract.name);
+            constructors.filter(fn => fn.contractName === contract.name).forEach(fn => allowedFunctions.push(fn));
+            otherFunctions.filter(fn => fn.contractName === contract.name).forEach(fn => allowedFunctions.push(fn));
+            if (allowedFunctions.length === 0)
+                continue;
+            const processed = (0, processor_1.processContract)(contract);
+            const recs = processed['vFunctions'] || [];
+            if (recs.length === 0) {
+                continue;
+            }
+            for (const rec of recs) {
+                const sig = (0, processor_1.signatureFromFnDef)(rec.ast);
+                const match = allowedFunctions.find(fn => fn.sig === sig);
+                if (match) {
+                    const code = writer.write(rec.ast);
+                    match.ast = rec.ast;
+                    match.code = code;
+                }
+            }
+        }
+    }
+    const data = {
+        version: '0.0.1',
+        contracts: {},
+    };
+    if (adminFunctions.length > 0) {
+        adminFunctions.forEach(fn => {
+            var _a, _b;
+            if (!fn.code)
+                return;
+            (_a = data.contracts)[_b = fn.contractName] || (_a[_b] = {
+                struct_params: {},
+                input_params: {},
+                functions_code: {},
+            });
+            const contractData = data.contracts[fn.contractName];
+            contractData.functions_code[fn.sig] = fn.code;
+            fn.abi.inputs.forEach(input => {
+                var _a;
+                const key = inputKey(input);
+                if (input.type === 'tuple')
+                    recursiveStructHandler(input, contractData.struct_params);
+                (_a = contractData.input_params)[key] || (_a[key] = { dependent_function_signatures: [], labels: [] });
+                contractData.input_params[key].dependent_function_signatures.push(fn.sig);
+            });
+        });
+    }
+    if (constructors.length > 0) {
+        constructors.forEach(fn => {
+            var _a, _b;
+            if (!fn.code)
+                return;
+            (_a = data.contracts)[_b = fn.contractName] || (_a[_b] = {
+                struct_params: {},
+                input_params: {},
+                functions_code: {},
+            });
+            const contractData = data.contracts[fn.contractName];
+            contractData.functions_code[fn.sig] = fn.code;
+            fn.abi.inputs.forEach(input => {
+                var _a;
+                const key = inputKey(input);
+                if (input.type === 'tuple')
+                    recursiveStructHandler(input, contractData.struct_params);
+                (_a = contractData.input_params)[key] || (_a[key] = { dependent_function_signatures: [], labels: [] });
+                contractData.input_params[key].dependent_function_signatures.push(fn.sig);
+            });
+        });
+    }
+    if (otherFunctions.length > 0) {
+        otherFunctions.forEach(fn => {
+            var _a, _b;
+            if (!fn.code)
+                return;
+            (_a = data.contracts)[_b = fn.contractName] || (_a[_b] = {
+                struct_params: {},
+                input_params: {},
+                functions_code: {},
+            });
+            const contractData = data.contracts[fn.contractName];
+            contractData.functions_code[fn.sig] = fn.code;
+            fn.abi.inputs.forEach(input => {
+                var _a;
+                const key = inputKey(input);
+                if (input.type === 'tuple')
+                    recursiveStructHandler(input, contractData.struct_params);
+                (_a = contractData.input_params)[key] || (_a[key] = { dependent_function_signatures: [], labels: [] });
+                contractData.input_params[key].dependent_function_signatures.push(fn.sig);
+            });
+        });
+    }
+    return data;
+}
+function inputKey(param) {
+    if (param.type === 'tuple') {
+        return `${param.internalType.replace(/^struct\s+/, '')} ${param.name}`;
+    }
+    return `${param.type} ${param.name}`;
+}
+function recursiveStructHandler(struct, struct_params) {
+    const key = inputKey(struct);
+    const childVars = struct.components.map(c => inputKey(c));
+    struct_params[key] = childVars;
+    for (const comp of struct.components) {
+        if (comp.type === 'tuple') {
+            recursiveStructHandler(comp, struct_params);
+        }
+    }
+}

package/dist/processor.d.ts

@@ -1,3 +1,14 @@
 import * as $ from 'solc-typed-ast';
-export declare const processContract: (contract: $.ContractDefinition) => Record<string, any>;
+import { ContractMetadata, FunctionDefinitionParams, ReconConfigContract, RecordItem } from './types';
+export declare const signatureFromFnDef: (fnDef: $.FunctionDefinition) => string;
+export declare const processContract: (contract: $.ContractDefinition) => Record<string, RecordItem[]>;
 export declare function buildCoverageMap(asts: $.SourceUnit[], foundryRoot: string, contractFunctions: Map<string, Set<string>>): Promise<Record<string, string[]>>;
+export declare function collectFunctions(contracts: ContractMetadata[], reconConfig: Record<string, ReconConfigContract>): {
+    enabledContracts: ContractMetadata[];
+    adminFunctions: FunctionDefinitionParams[];
+    constructors: FunctionDefinitionParams[];
+    otherFunctions: FunctionDefinitionParams[];
+    nonSeparatedFunctions: FunctionDefinitionParams[];
+    separatedByContract: Record<string, FunctionDefinitionParams[]>;
+    allContractNames: string[];
+};

package/dist/processor.js

@@ -33,8 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processContract = void 0;
+exports.processContract = exports.signatureFromFnDef = void 0;
 exports.buildCoverageMap = buildCoverageMap;
+exports.collectFunctions = collectFunctions;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const $ = __importStar(require("solc-typed-ast"));
@@ -90,6 +91,7 @@ const signatureFromFnDef = (fnDef) => {
                     : '');
     return `${name}(${params})`;
 };
+exports.signatureFromFnDef = signatureFromFnDef;
 const matchesSignature = (sig, allowed) => {
     if (allowed.has(sig))
         return true;
@@ -149,7 +151,7 @@ const processContract = (contract) => {
             fnDef.stateMutability === $.FunctionStateMutability.View)) {
             continue;
         }
-        if (!result['vFunctions'].some((x) => (0, utils_1.signatureEquals)(x, fnDef))) {
+        if (!result['vFunctions'].some((x) => (0, utils_1.signatureEquals)(x.ast, fnDef))) {
             const rec = {
                 ast: fnDef,
                 children: processFunction(fnDef),
@@ -347,12 +349,12 @@ async function buildCoverageMap(asts, foundryRoot, contractFunctions) {
                 continue;
             }
             const processed = (0, exports.processContract)(contract);
-            const recs = (processed['vFunctions'] || []);
+            const recs = processed['vFunctions'] || [];
             if (recs.length === 0) {
                 continue;
             }
             for (const rec of recs) {
-                const sig = signatureFromFnDef(rec.ast);
+                const sig = (0, exports.signatureFromFnDef)(rec.ast);
                 if (!matchesSignature(sig, allowedFns)) {
                     continue;
                 }
@@ -416,3 +418,106 @@ async function buildCoverageMap(asts, foundryRoot, contractFunctions) {
     }
     return normalized;
 }
+function computeSignature(item) {
+    var _a;
+    const inputs = item.inputs.map(i => i.internalType && i.internalType.startsWith('struct ')
+        ? i.internalType.replace(/^struct\s+/, '')
+        : i.type);
+    return `${(_a = item.name) !== null && _a !== void 0 ? _a : 'constructor'}(${inputs.join(',')})`;
+}
+function defaultFunctionsFromAbi(contract) {
+    var _a;
+    const functions = [];
+    for (const item of contract.abi) {
+        if (['constructor', 'function'].includes(item.type) && !((_a = item.stateMutability) === null || _a === void 0 ? void 0 : _a.match(/^(view|pure)$/))) {
+            const sig = computeSignature(item);
+            functions.push({ signature: sig, actor: types_1.Actor.ACTOR, mode: types_1.Mode.NORMAL });
+        }
+    }
+    return functions;
+}
+function collectFunctions(contracts, reconConfig) {
+    const enabledContracts = [];
+    const adminFunctions = [];
+    const constructors = [];
+    const otherFunctions = [];
+    const nonSeparatedFunctions = [];
+    const separatedByContract = {};
+    for (const contract of contracts) {
+        const cfg = reconConfig[contract.jsonPath] || { enabled: true, functions: [], separated: true };
+        if (cfg.enabled === false) {
+            continue;
+        }
+        enabledContracts.push(contract);
+        const separated = cfg.separated !== false;
+        const functionsConfig = Array.isArray(cfg.functions) ? cfg.functions : [];
+        const functionList = functionsConfig.length > 0 ? functionsConfig : defaultFunctionsFromAbi(contract);
+        for (const fnCfg of functionList) {
+            const fnName = fnCfg.signature.split('(')[0];
+            const fnAbi = contract.abi.find((item) => {
+                if (item.type !== 'function' || item.name !== fnName) {
+                    return false;
+                }
+                const sig = computeSignature(item);
+                return sig === fnCfg.signature;
+            });
+            if (!fnAbi) {
+                continue;
+            }
+            const fnInfo = {
+                contractName: contract.name,
+                contractPath: contract.path,
+                functionName: fnAbi.name,
+                abi: fnAbi,
+                actor: fnCfg.actor || types_1.Actor.ACTOR,
+                mode: fnCfg.mode || types_1.Mode.NORMAL,
+                separated,
+                sig: fnCfg.signature,
+            };
+            if (fnCfg.actor === types_1.Actor.ADMIN) {
+                adminFunctions.push(fnInfo);
+            }
+            else {
+                otherFunctions.push(fnInfo);
+                if (separated) {
+                    if (!separatedByContract[contract.name]) {
+                        separatedByContract[contract.name] = [];
+                    }
+                    separatedByContract[contract.name].push(fnInfo);
+                }
+                else {
+                    nonSeparatedFunctions.push(fnInfo);
+                }
+            }
+        }
+        const constructorAbi = contract.abi.find(item => item.type === 'constructor');
+        if (constructorAbi) {
+            const constructorInfo = {
+                contractName: contract.name,
+                contractPath: contract.path,
+                functionName: 'constructor',
+                abi: constructorAbi,
+                actor: types_1.Actor.ACTOR,
+                mode: types_1.Mode.NORMAL,
+                separated: false,
+                sig: computeSignature(constructorAbi),
+            };
+            constructors.push(constructorInfo);
+        }
+    }
+    const allContractNames = [
+        'Admin',
+        'Doomsday',
+        'Managers',
+        ...Object.keys(separatedByContract)
+    ].sort();
+    return {
+        enabledContracts,
+        adminFunctions,
+        constructors,
+        otherFunctions,
+        nonSeparatedFunctions,
+        separatedByContract,
+        allContractNames,
+    };
+}

package/dist/templateManager.d.ts

@@ -1,4 +1,4 @@
-import { ContractMetadata } from './types';
+import { FunctionDefinitionParams, ContractMetadata } from './types';
 export declare class TemplateManager {
     private foundryRoot;
     private suiteDir;
@@ -9,7 +9,5 @@ export declare class TemplateManager {
     private skipList;
     private shouldGenerateFile;
     private updateTargetFile;
-    private collectFunctions;
-    private defaultFunctionsFromAbi;
-    generateTemplates(contracts: ContractMetadata[], reconConfig: Record<string, any>): Promise<void>;
+    generateTemplates(enabledContracts: ContractMetadata[], adminFunctions: FunctionDefinitionParams[], nonSeparatedFunctions: FunctionDefinitionParams[], separatedByContract: Record<string, FunctionDefinitionParams[]>, allContractNames: string[]): Promise<void>;
 }

package/dist/templateManager.js

@@ -38,7 +38,6 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs/promises"));
 const case_1 = require("case");
 const templates = __importStar(require("./templates"));
-const types_1 = require("./types");
 class TemplateManager {
     constructor(foundryRoot, suiteDir, suiteNameSnake, suiteNamePascal, dynamicDeploy = new Set()) {
         this.foundryRoot = foundryRoot;
@@ -97,91 +96,7 @@ class TemplateManager {
             return newContent;
         }
     }
-    collectFunctions(contracts, reconConfig) {
-        const enabledContracts = [];
-        const adminFunctions = [];
-        const otherFunctions = [];
-        const nonSeparatedFunctions = [];
-        const separatedByContract = {};
-        for (const contract of contracts) {
-            const cfg = reconConfig[contract.jsonPath] || { enabled: true, functions: [], separated: true };
-            if (cfg.enabled === false) {
-                continue;
-            }
-            enabledContracts.push(contract);
-            const separated = cfg.separated !== false;
-            const functionsConfig = Array.isArray(cfg.functions) ? cfg.functions : [];
-            const functionList = functionsConfig.length > 0 ? functionsConfig : this.defaultFunctionsFromAbi(contract);
-            for (const fnCfg of functionList) {
-                const fnName = fnCfg.signature.split('(')[0];
-                const fnAbi = contract.abi.find((item) => {
-                    if (item.type !== 'function' || item.name !== fnName) {
-                        return false;
-                    }
-                    const sig = `${item.name}(${item.inputs.map((i) => i.internalType && i.internalType.startsWith('struct ')
-                        ? i.internalType.replace(/^struct\s+/, '')
-                        : i.type).join(',')})`;
-                    return sig === fnCfg.signature;
-                });
-                if (!fnAbi) {
-                    continue;
-                }
-                const fnInfo = {
-                    contractName: contract.name,
-                    contractPath: contract.path,
-                    functionName: fnAbi.name,
-                    abi: fnAbi,
-                    actor: fnCfg.actor || types_1.Actor.ACTOR,
-                    mode: fnCfg.mode || types_1.Mode.NORMAL,
-                    separated,
-                };
-                if (fnCfg.actor === types_1.Actor.ADMIN) {
-                    adminFunctions.push(fnInfo);
-                }
-                else {
-                    otherFunctions.push(fnInfo);
-                    if (separated) {
-                        if (!separatedByContract[contract.name]) {
-                            separatedByContract[contract.name] = [];
-                        }
-                        separatedByContract[contract.name].push(fnInfo);
-                    }
-                    else {
-                        nonSeparatedFunctions.push(fnInfo);
-                    }
-                }
-            }
-        }
-        const allContractNames = [
-            'Admin',
-            'Doomsday',
-            'Managers',
-            ...Object.keys(separatedByContract)
-        ].sort();
-        return {
-            enabledContracts,
-            adminFunctions,
-            otherFunctions,
-            nonSeparatedFunctions,
-            separatedByContract,
-            allContractNames,
-        };
-    }
-    defaultFunctionsFromAbi(contract) {
-        var _a;
-        const functions = [];
-        for (const item of contract.abi) {
-            if (item.type === 'function' && !((_a = item.stateMutability) === null || _a === void 0 ? void 0 : _a.match(/^(view|pure)$/))) {
-                const sig = `${item.name}(${item.inputs.map((i) => i.internalType && i.internalType.startsWith('struct ')
-                    ? i.internalType.replace(/^struct\s+/, '')
-                    : i.type).join(',')})`;
-                functions.push({ signature: sig, actor: types_1.Actor.ACTOR, mode: types_1.Mode.NORMAL });
-            }
-        }
-        return functions;
-    }
-    async generateTemplates(contracts, reconConfig) {
-        const { enabledContracts, adminFunctions, nonSeparatedFunctions, separatedByContract, allContractNames, } = this.collectFunctions(contracts, reconConfig);
+    async generateTemplates(enabledContracts, adminFunctions, nonSeparatedFunctions, separatedByContract, allContractNames) {
         const contractsForSetup = enabledContracts.map(contract => ({ ...contract, isDynamic: this.dynamicDeploy.has(contract.name) }));
         const dynamicContracts = enabledContracts
             .filter(contract => this.dynamicDeploy.has(contract.name))

package/dist/templates/echidna-config.js

@@ -17,4 +17,5 @@ filterFunctions: []
 cryticArgs: ["--foundry-compile-all"]
 deployer: "0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38"
 contractAddr: "0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496"
-shrinkLimit: 100000`, { noEscape: true });
+shrinkLimit: 100000
+symExec: true`, { noEscape: true });

package/dist/types.d.ts

@@ -43,6 +43,9 @@ export interface FunctionDefinitionParams {
     actor: Actor;
     mode: Mode;
     separated?: boolean;
+    sig: string;
+    ast?: ASTNode;
+    code?: string;
 }
 export declare enum CallType {
     Internal = "internal",
@@ -64,6 +67,32 @@ export type CallTree = {
     isRecursive?: boolean;
     recursiveTargetNodeId?: number;
 };
+export interface ReconConfigFunction {
+    signature: string;
+    actor: Actor;
+    mode: Mode;
+}
+export interface ReconConfigContract {
+    enabled: boolean;
+    functions: ReconConfigFunction[];
+    separated: boolean;
+}
+export interface InputParam {
+    dependent_function_signatures: string[];
+    labels: {
+        label: string;
+        reason: string;
+    }[];
+}
+export interface InputVariablesConfig {
+    struct_params: Record<string, string[]>;
+    input_params: Record<string, InputParam>;
+    functions_code: Record<string, string>;
+}
+export interface InputParamsMap {
+    version: string;
+    contracts: Record<string, InputVariablesConfig>;
+}
 export type CallTreeData = {
     contract: string;
     function: FunctionDefinition;

package/dist/types.js

@@ -18,3 +18,5 @@ var CallType;
     CallType["HighLevel"] = "high-level";
     CallType["LowLevel"] = "low-level";
 })(CallType || (exports.CallType = CallType = {}));
+;
+;

package/dist/unpack.d.ts

@@ -0,0 +1,3 @@
+export interface UnpackOptions {
+}
+export declare function unpackBuildInfo(inputPath: string, outputDir: string, _options?: UnpackOptions): Promise<void>;

package/dist/unpack.js

@@ -0,0 +1,276 @@
+"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.unpackBuildInfo = unpackBuildInfo;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Load a single build-info JSON file
+ */
+async function loadBuildInfo(filePath) {
+    const content = await fs.promises.readFile(filePath, 'utf8');
+    return JSON.parse(content);
+}
+/**
+ * Load all build-info files from a path (file or directory)
+ */
+async function loadAllBuildInfos(inputPath) {
+    const stat = await fs.promises.stat(inputPath);
+    if (stat.isFile()) {
+        const buildInfo = await loadBuildInfo(inputPath);
+        return [buildInfo];
+    }
+    else if (stat.isDirectory()) {
+        const entries = await fs.promises.readdir(inputPath);
+        const jsonFiles = entries.filter(f => f.endsWith('.json'));
+        if (jsonFiles.length === 0) {
+            throw new Error(`No JSON files found in directory: ${inputPath}`);
+        }
+        console.log(`Found ${jsonFiles.length} build-info files in directory`);
+        const buildInfos = [];
+        for (const file of jsonFiles) {
+            const filePath = path.join(inputPath, file);
+            console.log(`  Loading: ${file}`);
+            const buildInfo = await loadBuildInfo(filePath);
+            buildInfos.push(buildInfo);
+        }
+        return buildInfos;
+    }
+    else {
+        throw new Error(`Invalid input path: ${inputPath}`);
+    }
+}
+/**
+ * Merge multiple build-info files into a single structure
+ */
+function mergeBuildInfos(buildInfos) {
+    var _a, _b, _c;
+    const merged = {
+        sources: {},
+        remappings: new Set(),
+        includePaths: new Set(),
+        basePath: undefined,
+        solcVersions: new Set(),
+        optimizer: undefined,
+        viaIR: false,
+    };
+    for (const buildInfo of buildInfos) {
+        merged.solcVersions.add(buildInfo.solcVersion);
+        for (const [sourcePath, sourceData] of Object.entries(buildInfo.input.sources)) {
+            if (!merged.sources[sourcePath]) {
+                merged.sources[sourcePath] = sourceData;
+            }
+        }
+        if ((_a = buildInfo.input.settings) === null || _a === void 0 ? void 0 : _a.remappings) {
+            for (const remap of buildInfo.input.settings.remappings) {
+                merged.remappings.add(remap);
+            }
+        }
+        if (buildInfo.input.includePaths) {
+            for (const includePath of buildInfo.input.includePaths) {
+                merged.includePaths.add(includePath);
+            }
+        }
+        if (!merged.basePath && buildInfo.input.basePath) {
+            merged.basePath = buildInfo.input.basePath;
+        }
+        if (!merged.optimizer && ((_b = buildInfo.input.settings) === null || _b === void 0 ? void 0 : _b.optimizer)) {
+            merged.optimizer = buildInfo.input.settings.optimizer;
+        }
+        if ((_c = buildInfo.input.settings) === null || _c === void 0 ? void 0 : _c.viaIR) {
+            merged.viaIR = true;
+        }
+    }
+    return merged;
+}
+/**
+ * Normalize a source path: contracts/ -> src/
+ */
+function normalizePath(sourcePath) {
+    if (sourcePath.startsWith('contracts/')) {
+        return 'src/' + sourcePath.slice('contracts/'.length);
+    }
+    return sourcePath;
+}
+/**
+ * Rewrite imports in source content:
+ * - contracts/ -> src/
+ * - Handle includePath-based src/ imports
+ */
+function rewriteImports(sourcePath, content, includePaths, basePath) {
+    let result = content;
+    // Rewrite contracts/ imports to src/
+    result = result.replace(/(import\s+(?:{[^}]+}\s+from\s+)?["'])contracts\//g, '$1src/');
+    // Handle includePath-based src/ imports (for libraries with self-referential imports)
+    if (includePaths.size > 0) {
+        let relativeIncludePath;
+        for (const includePath of includePaths) {
+            let relative;
+            if (basePath && includePath.startsWith(basePath)) {
+                relative = includePath.slice(basePath.length).replace(/^\//, '');
+            }
+            else {
+                continue;
+            }
+            // Normalize the path for comparison
+            const normalizedSourcePath = normalizePath(sourcePath);
+            const normalizedRelative = normalizePath(relative);
+            if (normalizedRelative && normalizedSourcePath.startsWith(`${normalizedRelative}/`)) {
+                relativeIncludePath = normalizedRelative;
+                break;
+            }
+        }
+        if (relativeIncludePath) {
+            const importRegex = /import\s+(?:{[^}]+}\s+from\s+)?["']src\/([^"']+)["']/g;
+            result = result.replace(importRegex, (match, importPath) => {
+                const currentDir = path.dirname(normalizePath(sourcePath));
+                const targetPath = `${relativeIncludePath}/src/${importPath}`;
+                let relativeTo = path.relative(currentDir, path.dirname(targetPath));
+                if (!relativeTo) {
+                    relativeTo = '.';
+                }
+                else if (!relativeTo.startsWith('.')) {
+                    relativeTo = './' + relativeTo;
+                }
+                let newImport = path.posix.join(relativeTo, path.basename(targetPath));
+                if (!newImport.startsWith('.')) {
+                    newImport = './' + newImport;
+                }
+                return match.replace(`"src/${importPath}"`, `"${newImport}"`).replace(`'src/${importPath}'`, `'${newImport}'`);
+            });
+        }
+    }
+    return result;
+}
+/**
+ * Detect remappings needed based on source paths (for Hardhat-style @scope/ imports)
+ */
+function detectRemappings(sources) {
+    const remappings = new Set();
+    const scopedDirs = new Set();
+    // Find all @scope/ style directories
+    for (const sourcePath of Object.keys(sources)) {
+        if (sourcePath.startsWith('@')) {
+            const parts = sourcePath.split('/');
+            if (parts.length >= 2) {
+                const scopeDir = parts[0] + '/';
+                scopedDirs.add(scopeDir);
+            }
+        }
+    }
+    // Create remappings for each scoped directory
+    for (const scopeDir of scopedDirs) {
+        remappings.add(`${scopeDir}=${scopeDir}`);
+    }
+    return remappings;
+}
+async function unpackBuildInfo(inputPath, outputDir, _options = {}) {
+    var _a;
+    console.log(`Reading build-info from: ${inputPath}`);
+    const buildInfos = await loadAllBuildInfos(inputPath);
+    const merged = mergeBuildInfos(buildInfos);
+    const solcVersionsArray = Array.from(merged.solcVersions);
+    console.log(`Solc Version(s): ${solcVersionsArray.join(', ')}`);
+    const sourceCount = Object.keys(merged.sources).length;
+    console.log(`Found ${sourceCount} unique source files`);
+    if (merged.includePaths.size > 0) {
+        console.log(`Found ${merged.includePaths.size} include paths`);
+    }
+    await fs.promises.mkdir(outputDir, { recursive: true });
+    // Write each source file
+    let written = 0;
+    for (const [sourcePath, sourceData] of Object.entries(merged.sources)) {
+        // Normalize path: contracts/ -> src/
+        const normalizedPath = normalizePath(sourcePath);
+        const fullPath = path.join(outputDir, normalizedPath);
+        const dir = path.dirname(fullPath);
+        await fs.promises.mkdir(dir, { recursive: true });
+        // Rewrite imports
+        const content = rewriteImports(sourcePath, sourceData.content, merged.includePaths, merged.basePath);
+        await fs.promises.writeFile(fullPath, content);
+        written++;
+        if (written % 50 === 0) {
+            console.log(`  Written ${written}/${sourceCount} files...`);
+        }
+    }
+    console.log(`Written ${written} source files to ${outputDir}`);
+    // Detect if this is a Hardhat-style project (has @scope/ directories)
+    const hasNodeModulesStyle = Array.from(Object.keys(merged.sources)).some(p => p.startsWith('@'));
+    const libsDir = hasNodeModulesStyle ? '.' : 'lib';
+    // Generate foundry.toml - no solc version specified, let auto_detect handle it
+    let foundryToml = `[profile.default]\nsrc = "src"\nout = "out"\nlibs = ["${libsDir}"]\nauto_detect_solc = true\n`;
+    if ((_a = merged.optimizer) === null || _a === void 0 ? void 0 : _a.enabled) {
+        foundryToml += `optimizer = true\noptimizer_runs = ${merged.optimizer.runs}\n`;
+    }
+    if (merged.viaIR) {
+        foundryToml += `via_ir = true\n`;
+    }
+    // Collect remappings: from build-info + auto-detected @scope/ dirs
+    const allRemappings = new Set();
+    for (const remap of merged.remappings) {
+        // Also normalize contracts/ -> src/ in remappings
+        allRemappings.add(remap.replace(/contracts\//g, 'src/'));
+    }
+    const detectedRemappings = detectRemappings(merged.sources);
+    for (const remap of detectedRemappings) {
+        allRemappings.add(remap);
+    }
+    if (allRemappings.size > 0) {
+        foundryToml += `\nremappings = [\n`;
+        for (const remap of allRemappings) {
+            foundryToml += `    "${remap}",\n`;
+        }
+        foundryToml += `]\n`;
+    }
+    const foundryTomlPath = path.join(outputDir, 'foundry.toml');
+    await fs.promises.writeFile(foundryTomlPath, foundryToml);
+    console.log(`Generated ${foundryTomlPath}`);
+    console.log('\nDone! To build the project:');
+    console.log(`  cd ${outputDir}`);
+    console.log('  forge build');
+}
+// CLI entry point
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    if (args.length < 2) {
+        console.error('Usage: npx ts-node src/unpack.ts <build-info.json|build-info-dir> <output-dir>');
+        process.exit(1);
+    }
+    const [inputPath, outputDir] = args;
+    unpackBuildInfo(inputPath, outputDir).catch(err => {
+        console.error('Failed:', err.message);
+        process.exit(1);
+    });
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "recon-generate",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "CLI to scaffold Recon fuzzing suite inside Foundry projects",
   "main": "dist/index.js",
   "bin": {
     "recon-generate": "dist/index.js"
   },
   "scripts": {
+    "dev": "tsc -p . --watch",
     "build": "tsc -p .",
     "postbuild": "node scripts/copy-builtins.js",
     "prepare": "npm run build"
@@ -25,7 +26,7 @@
     "commander": "^14.0.2",
     "ethers": "^6.16.0",
     "handlebars": "^4.7.8",
-    "solc-typed-ast": "^19.1.0",
+    "solc-typed-ast": "^8.0.1",
     "src-location": "^1.1.0",
     "yaml": "^2.8.2",
     "z3-solver": "^4.15.4"