recon-generate 0.0.21 → 0.0.23

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/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;
@@ -242,6 +243,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.)')

package/dist/templateManager.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateManager = void 0;
 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 {
@@ -209,7 +210,7 @@ class TemplateManager {
             [path.join(suiteTargetsDir, 'ManagersTargets.sol')]: templates.managersTargetsTemplate({}),
         };
         for (const [contractName, functions] of Object.entries(separatedByContract)) {
-            const targetPath = path.join(suiteTargetsDir, `${contractName}Targets.sol`);
+            const targetPath = path.join(suiteTargetsDir, `${(0, case_1.pascal)(contractName)}Targets.sol`);
             files[targetPath] = templates.targetsTemplate({
                 contractName,
                 path: functions.length > 0 ? functions[0].contractPath : '',

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,6 +1,6 @@
 {
   "name": "recon-generate",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "CLI to scaffold Recon fuzzing suite inside Foundry projects",
   "main": "dist/index.js",
   "bin": {