recon-generate 0.0.15 → 0.0.17

package/dist/info.js

@@ -0,0 +1,1017 @@
+"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.runInfo = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const solc_typed_ast_1 = require("solc-typed-ast");
+const utils_1 = require("./utils");
+const z3Solver_1 = require("./z3Solver");
+const call_tree_builder_1 = require("./analyzer/call-tree-builder");
+const runCmd = (cmd, cwd) => {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(cmd, { cwd, env: { ...process.env, PATH: (0, utils_1.getEnvPath)() } }, (err, _stdout, stderr) => {
+            if (err) {
+                reject(new Error(stderr || err.message));
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+};
+const loadLatestBuildInfo = async (foundryRoot) => {
+    var _a;
+    const outDir = path.join(foundryRoot, 'out');
+    const buildInfoDir = path.join(outDir, 'build-info');
+    let files = [];
+    try {
+        const entries = await fs.readdir(buildInfoDir);
+        const jsonFiles = entries.filter((f) => f.endsWith('.json'));
+        files = await Promise.all(jsonFiles.map(async (f) => ({
+            name: f,
+            path: path.join(buildInfoDir, f),
+            mtime: (await fs.stat(path.join(buildInfoDir, f))).mtime,
+        })));
+    }
+    catch (e) {
+        throw new Error(`No build-info directory found at ${buildInfoDir}: ${e}`);
+    }
+    if (files.length === 0) {
+        throw new Error(`No build-info JSON files found in ${buildInfoDir}.`);
+    }
+    const latestFile = files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())[0].path;
+    const fileContent = await fs.readFile(latestFile, 'utf-8');
+    const buildInfo = JSON.parse(fileContent);
+    const buildOutput = (_a = buildInfo.output) !== null && _a !== void 0 ? _a : buildInfo;
+    if (!buildOutput) {
+        throw new Error(`Build-info file ${latestFile} is missing output data.`);
+    }
+    // Extract ABIs from contracts
+    const contractAbis = new Map();
+    if (buildOutput.contracts) {
+        for (const [_filePath, contracts] of Object.entries(buildOutput.contracts)) {
+            for (const [contractName, contractData] of Object.entries(contracts)) {
+                if (contractData.abi) {
+                    contractAbis.set(contractName, contractData.abi);
+                }
+            }
+        }
+    }
+    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, contractAbis };
+};
+const stripDataLocation = (raw) => {
+    if (!raw)
+        return '';
+    const noLocation = raw
+        .replace(/\s+(storage|memory|calldata)(\s+pointer)?/g, '')
+        .replace(/\s+pointer/g, '');
+    const noPrefix = noLocation
+        .replace(/^struct\s+/, '')
+        .replace(/^enum\s+/, '')
+        .replace(/^contract\s+/, '')
+        .trim();
+    return noPrefix;
+};
+const signatureFromFnDef = (fnDef) => {
+    const params = fnDef.vParameters.vParameters
+        .map((p) => { var _a; return stripDataLocation((_a = p.typeString) !== null && _a !== void 0 ? _a : ''); })
+        .join(',');
+    const name = fnDef.name
+        || (fnDef.kind === solc_typed_ast_1.FunctionKind.Constructor
+            ? 'constructor'
+            : fnDef.kind === solc_typed_ast_1.FunctionKind.Fallback
+                ? 'fallback'
+                : fnDef.kind === solc_typed_ast_1.FunctionKind.Receive
+                    ? 'receive'
+                    : '');
+    return `${name}(${params})`;
+};
+/**
+ * Convert typeString to actual Solidity type
+ * e.g. "int_const 42" -> "uint256", "bool" -> "bool", etc.
+ */
+const typeStringToSolidityType = (typeString, value) => {
+    if (!typeString)
+        return 'unknown';
+    // Handle int_const and rational_const
+    if (typeString.startsWith('int_const')) {
+        // Check if the value is negative
+        if (value && value.startsWith('-')) {
+            return 'int256';
+        }
+        return 'uint256';
+    }
+    if (typeString.startsWith('rational_const')) {
+        return 'uint256';
+    }
+    // Handle literal_string
+    if (typeString.startsWith('literal_string')) {
+        return 'string';
+    }
+    // Handle basic types
+    const basicTypes = [
+        'bool', 'address', 'bytes', 'string',
+        'uint8', 'uint16', 'uint32', 'uint64', 'uint128', 'uint256',
+        'int8', 'int16', 'int32', 'int64', 'int128', 'int256',
+        'bytes1', 'bytes2', 'bytes4', 'bytes8', 'bytes16', 'bytes32',
+    ];
+    for (const t of basicTypes) {
+        if (typeString === t || typeString.startsWith(t + ' ')) {
+            return t;
+        }
+    }
+    // Default fallback
+    return typeString;
+};
+/**
+ * Convert literal value for display
+ */
+const formatLiteralValue = (lit) => {
+    var _a;
+    if (lit.kind === 'bool') {
+        return lit.value === 'true' ? 'True' : 'False';
+    }
+    return (_a = lit.value) !== null && _a !== void 0 ? _a : '';
+};
+const getAllContracts = (sourceUnits) => {
+    const contracts = new Map();
+    for (const unit of sourceUnits) {
+        for (const contract of unit.getChildrenByType(solc_typed_ast_1.ContractDefinition)) {
+            contracts.set(contract.name, contract);
+        }
+    }
+    return contracts;
+};
+/**
+ * Recursively collect all contracts related to the target contract:
+ * - Base contracts (inheritance chain)
+ * - Contracts referenced in state variables
+ * - Contracts called in functions
+ */
+const collectRelatedContracts = (targetContract, allContracts) => {
+    const visited = new Set();
+    const queue = [targetContract];
+    while (queue.length > 0) {
+        const contract = queue.shift();
+        if (visited.has(contract))
+            continue;
+        visited.add(contract);
+        // 1. Collect from linearized base contracts (inheritance)
+        for (const baseContract of contract.vLinearizedBaseContracts) {
+            if (!visited.has(baseContract)) {
+                queue.push(baseContract);
+            }
+        }
+        // 2. Collect from state variable types (contract references)
+        const stateVars = (0, utils_1.getDefinitions)(contract, 'vStateVariables', true);
+        for (const stateVar of stateVars) {
+            // Check if the type references a contract
+            const typeNode = stateVar.vType;
+            if (typeNode instanceof solc_typed_ast_1.UserDefinedTypeName) {
+                const ref = typeNode.vReferencedDeclaration;
+                if (ref instanceof solc_typed_ast_1.ContractDefinition && !visited.has(ref)) {
+                    queue.push(ref);
+                }
+            }
+            // Also check typeString for contract types
+            const typeString = stateVar.typeString;
+            if (typeString === null || typeString === void 0 ? void 0 : typeString.startsWith('contract ')) {
+                const contractName = typeString.replace('contract ', '');
+                const refContract = allContracts.get(contractName);
+                if (refContract && !visited.has(refContract)) {
+                    queue.push(refContract);
+                }
+            }
+        }
+        // 3. Collect from function calls to other contracts
+        const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true);
+        for (const fnDef of allFunctions) {
+            for (const call of fnDef.getChildrenByType(solc_typed_ast_1.FunctionCall)) {
+                // Check if call target is on another contract
+                const expr = call.vExpression;
+                if (expr instanceof solc_typed_ast_1.MemberAccess) {
+                    const baseExpr = expr.vExpression;
+                    // Check typeString for contract type
+                    const typeString = baseExpr.typeString;
+                    if (typeString === null || typeString === void 0 ? void 0 : typeString.startsWith('contract ')) {
+                        const contractName = typeString.replace('contract ', '');
+                        const refContract = allContracts.get(contractName);
+                        if (refContract && !visited.has(refContract)) {
+                            queue.push(refContract);
+                        }
+                    }
+                    // Also check the referenced declaration
+                    const ref = expr.vReferencedDeclaration;
+                    if (ref instanceof solc_typed_ast_1.FunctionDefinition) {
+                        const parentContract = ref.vScope;
+                        if (parentContract instanceof solc_typed_ast_1.ContractDefinition && !visited.has(parentContract)) {
+                            queue.push(parentContract);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return visited;
+};
+/**
+ * Recursively collect all inherited contracts for a given contract
+ * Uses a visited set to avoid infinite loops
+ */
+const collectAllInheritances = (contract, visited = new Set()) => {
+    const inheritedNames = [];
+    // Get direct base contracts
+    const directBases = contract.vLinearizedBaseContracts.filter(base => base.id !== contract.id);
+    for (const base of directBases) {
+        // Skip if already visited (avoid infinite loops)
+        if (visited.has(base.id))
+            continue;
+        visited.add(base.id);
+        // Add this base contract
+        if (!inheritedNames.includes(base.name)) {
+            inheritedNames.push(base.name);
+        }
+        // Recursively collect inheritances from this base
+        const baseInheritances = collectAllInheritances(base, visited);
+        for (const name of baseInheritances) {
+            if (!inheritedNames.includes(name)) {
+                inheritedNames.push(name);
+            }
+        }
+    }
+    return inheritedNames;
+};
+const collectPayableFunctions = (contract) => {
+    const payable = [];
+    const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true).reverse();
+    for (const fnDef of allFunctions) {
+        if (fnDef.stateMutability === solc_typed_ast_1.FunctionStateMutability.Payable) {
+            if (fnDef.kind === solc_typed_ast_1.FunctionKind.Receive) {
+                payable.push('()');
+            }
+            else if (fnDef.kind === solc_typed_ast_1.FunctionKind.Fallback) {
+                payable.push('fallback()');
+            }
+            else {
+                payable.push(signatureFromFnDef(fnDef));
+            }
+        }
+    }
+    return payable;
+};
+/**
+ * Collect constant functions from ABI (view/pure functions)
+ * This is more reliable than AST for complex types
+ */
+const collectConstantFunctionsFromAbi = (contractName, contractAbis) => {
+    const abi = contractAbis.get(contractName);
+    if (!abi)
+        return [];
+    const constants = [];
+    for (const entry of abi) {
+        if (entry.type === 'function' &&
+            (entry.stateMutability === 'view' || entry.stateMutability === 'pure')) {
+            const params = (entry.inputs || []).map(inp => inp.type).join(',');
+            const sig = `${entry.name}(${params})`;
+            constants.push(sig);
+        }
+    }
+    return constants;
+};
+/**
+ * Collect constant functions including:
+ * - view/pure functions
+ * - public state variable getters
+ */
+const collectConstantFunctions = (contract) => {
+    const constants = [];
+    const seen = new Set();
+    // 1. Collect view/pure functions
+    const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true).reverse();
+    for (const fnDef of allFunctions) {
+        if (fnDef.visibility === solc_typed_ast_1.FunctionVisibility.External || fnDef.visibility === solc_typed_ast_1.FunctionVisibility.Public) {
+            const sig = signatureFromFnDef(fnDef);
+            if (!seen.has(sig)) {
+                seen.add(sig);
+                constants.push(sig);
+            }
+        }
+    }
+    // 2. Collect public state variable auto-generated getters
+    const stateVars = (0, utils_1.getDefinitions)(contract, 'vStateVariables', true);
+    for (const stateVar of stateVars) {
+        if (stateVar.visibility === 'public') {
+            // Generate getter signature based on type
+            const sig = generateGetterSignature(stateVar);
+            if (sig && !seen.has(sig)) {
+                seen.add(sig);
+                constants.push(sig);
+            }
+        }
+    }
+    return constants;
+};
+/**
+ * Generate getter function signature for public state variables
+ */
+const generateGetterSignature = (stateVar) => {
+    const name = stateVar.name;
+    const typeString = stateVar.typeString;
+    if (!typeString)
+        return null;
+    // Handle mappings - generate signature with key type
+    if (typeString.startsWith('mapping(')) {
+        const keyType = extractMappingKeyType(typeString);
+        if (keyType) {
+            return `${name}(${keyType})`;
+        }
+        return null;
+    }
+    // Handle arrays - generate signature with uint256 index
+    if (typeString.endsWith('[]') || typeString.match(/\[\d+\]$/)) {
+        return `${name}(uint256)`;
+    }
+    // Simple variables - no parameters
+    return `${name}()`;
+};
+/**
+ * Extract the key type from a mapping type string
+ */
+const extractMappingKeyType = (typeString) => {
+    // mapping(address => uint256) -> address
+    // mapping(uint256 => mapping(address => bool)) -> uint256
+    const match = typeString.match(/^mapping\((\w+)\s*=>/);
+    if (match) {
+        return match[1];
+    }
+    return null;
+};
+/**
+ * Collect assert statements with source location info
+ */
+const collectAssertStatements = (contract, foundryRoot, sourceContents) => {
+    const asserts = {};
+    const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true).reverse();
+    for (const fnDef of allFunctions) {
+        if (fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.External && fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.Public) {
+            continue;
+        }
+        if (fnDef.kind !== solc_typed_ast_1.FunctionKind.Function && fnDef.kind !== solc_typed_ast_1.FunctionKind.Constructor) {
+            continue;
+        }
+        const sig = signatureFromFnDef(fnDef);
+        const assertInfos = [];
+        for (const call of fnDef.getChildrenByType(solc_typed_ast_1.FunctionCall)) {
+            const expr = call.vExpression;
+            if (expr instanceof solc_typed_ast_1.Identifier && expr.name === 'assert') {
+                // Get source location
+                const src = call.src;
+                if (src) {
+                    const [startStr, lengthStr, fileIdStr] = src.split(':');
+                    const start = parseInt(startStr, 10);
+                    const length = parseInt(lengthStr, 10);
+                    // Get the source file path
+                    const sourceUnit = call.getClosestParentByType(solc_typed_ast_1.SourceUnit);
+                    let filePath = (sourceUnit === null || sourceUnit === void 0 ? void 0 : sourceUnit.absolutePath) || '';
+                    // Make path relative to foundry root
+                    let relPath = filePath;
+                    if (filePath.startsWith(foundryRoot)) {
+                        relPath = filePath.slice(foundryRoot.length + 1);
+                    }
+                    // Get line info from source content
+                    const content = sourceContents.get(filePath) || '';
+                    let lines = [];
+                    let startingColumn = 1;
+                    let endingColumn = 1;
+                    if (content) {
+                        const lineInfo = (0, utils_1.getLines)(content, src);
+                        lines = [];
+                        for (let i = lineInfo.start; i <= lineInfo.end; i++) {
+                            lines.push(i);
+                        }
+                        // Calculate columns
+                        const beforeStart = content.substring(0, start);
+                        const lastNewline = beforeStart.lastIndexOf('\n');
+                        startingColumn = start - lastNewline;
+                        endingColumn = startingColumn + length;
+                    }
+                    assertInfos.push({
+                        start,
+                        length,
+                        filename_relative: relPath,
+                        filename_absolute: filePath,
+                        filename_short: relPath,
+                        is_dependency: filePath.includes('lib/') || filePath.includes('node_modules/'),
+                        lines,
+                        starting_column: startingColumn,
+                        ending_column: endingColumn,
+                    });
+                }
+            }
+        }
+        // Only include functions that have asserts
+        if (assertInfos.length > 0) {
+            asserts[sig] = assertInfos;
+        }
+    }
+    return asserts;
+};
+/**
+ * Collect constants used in functions with proper type formatting
+ * Also includes Z3-solved values from constraint expressions
+ */
+const collectConstantsUsed = async (contract) => {
+    var _a;
+    const constantsUsed = {};
+    const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true).reverse();
+    for (const fnDef of allFunctions) {
+        if (fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.External && fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.Public) {
+            continue;
+        }
+        const sig = signatureFromFnDef(fnDef);
+        const literals = [];
+        // Collect literal constants
+        for (const lit of fnDef.getChildrenByType(solc_typed_ast_1.Literal)) {
+            const value = formatLiteralValue(lit);
+            const type = typeStringToSolidityType((_a = lit.typeString) !== null && _a !== void 0 ? _a : '', value);
+            // Each constant is wrapped in an array (matching slither format)
+            literals.push([{ value, type }]);
+        }
+        // Collect Z3-solved constants from constraint expressions
+        try {
+            const z3Solutions = await (0, z3Solver_1.findZ3Solutions)(fnDef);
+            for (const solution of z3Solutions) {
+                // Add Z3 solution as a special constant with metadata
+                literals.push([{
+                        value: solution.value,
+                        type: solution.type,
+                    }]);
+            }
+        }
+        catch (e) {
+            // Z3 errors are non-fatal, continue without Z3 solutions
+        }
+        // Only include functions that have constants
+        if (literals.length > 0) {
+            constantsUsed[sig] = literals;
+        }
+    }
+    return constantsUsed;
+};
+const collectFunctionsRelations = (contract) => {
+    const relations = {};
+    const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true).reverse();
+    const stateVars = (0, utils_1.getDefinitions)(contract, 'vStateVariables', true);
+    // Build a map of state variable IDs for faster lookup
+    const stateVarIds = new Set(stateVars.map(v => v.id));
+    const stateVarNames = new Set(stateVars.map(v => v.name));
+    const fnWritesVar = new Map();
+    const fnReadsVar = new Map();
+    // Helper to check if a node is part of assignment left-hand side
+    const isInAssignmentLHS = (node) => {
+        const parentAssignment = node.getClosestParentByType(solc_typed_ast_1.Assignment);
+        if (!parentAssignment)
+            return false;
+        // Walk up from the node to see if it's under the LHS
+        let current = node;
+        while (current && current !== parentAssignment) {
+            if (current === parentAssignment.vLeftHandSide) {
+                return true;
+            }
+            current = current.parent;
+        }
+        return false;
+    };
+    for (const fnDef of allFunctions) {
+        if (fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.External && fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.Public) {
+            continue;
+        }
+        const sig = signatureFromFnDef(fnDef);
+        const writes = new Set();
+        const reads = new Set();
+        // Collect writes (assignments to state variables)
+        for (const assignment of fnDef.getChildrenByType(solc_typed_ast_1.Assignment)) {
+            if ((0, utils_1.isStateVarAssignment)(assignment)) {
+                const varDecl = (0, utils_1.getStateVarAssignment)(assignment);
+                if (varDecl && stateVarNames.has(varDecl.name)) {
+                    writes.add(varDecl.name);
+                    // Compound assignments (+=, -=, etc.) also read
+                    if (assignment.operator !== '=') {
+                        reads.add(varDecl.name);
+                    }
+                }
+            }
+        }
+        // Collect reads (identifiers referencing state variables)
+        for (const id of fnDef.getChildrenByType(solc_typed_ast_1.Identifier)) {
+            const ref = id.vReferencedDeclaration;
+            if (ref instanceof solc_typed_ast_1.VariableDeclaration && stateVarIds.has(ref.id)) {
+                // Check if this identifier is in an assignment LHS
+                if (!isInAssignmentLHS(id)) {
+                    reads.add(ref.name);
+                }
+                else {
+                    // Even in LHS, compound assignments read
+                    const parentAssignment = id.getClosestParentByType(solc_typed_ast_1.Assignment);
+                    if (parentAssignment && parentAssignment.operator !== '=') {
+                        reads.add(ref.name);
+                    }
+                }
+            }
+        }
+        // Collect reads from member accesses (for struct fields, mapping accesses)
+        for (const ma of fnDef.getChildrenByType(solc_typed_ast_1.MemberAccess)) {
+            const ref = ma.vReferencedDeclaration;
+            if (ref instanceof solc_typed_ast_1.VariableDeclaration && stateVarIds.has(ref.id)) {
+                if (!isInAssignmentLHS(ma)) {
+                    reads.add(ref.name);
+                }
+                else {
+                    const parentAssignment = ma.getClosestParentByType(solc_typed_ast_1.Assignment);
+                    if (parentAssignment && parentAssignment.operator !== '=') {
+                        reads.add(ref.name);
+                    }
+                }
+            }
+        }
+        fnWritesVar.set(sig, writes);
+        fnReadsVar.set(sig, reads);
+    }
+    // Build relations
+    for (const fnDef of allFunctions) {
+        if (fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.External && fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.Public) {
+            continue;
+        }
+        const sig = signatureFromFnDef(fnDef);
+        const writes = fnWritesVar.get(sig) || new Set();
+        const reads = fnReadsVar.get(sig) || new Set();
+        const impacts = [];
+        const isImpactedBy = [];
+        // This function impacts others (including itself) that read variables this function writes
+        for (const [otherSig, otherReads] of fnReadsVar) {
+            for (const w of writes) {
+                if (otherReads.has(w)) {
+                    if (!impacts.includes(otherSig)) {
+                        impacts.push(otherSig);
+                    }
+                    break;
+                }
+            }
+        }
+        // This function is impacted by others (including itself) that write variables this function reads
+        for (const [otherSig, otherWrites] of fnWritesVar) {
+            for (const r of reads) {
+                if (otherWrites.has(r)) {
+                    if (!isImpactedBy.includes(otherSig)) {
+                        isImpactedBy.push(otherSig);
+                    }
+                    break;
+                }
+            }
+        }
+        // Check for single external call (harness wrapper pattern)
+        let externalCall;
+        const functionCalls = fnDef.getChildrenByType(solc_typed_ast_1.FunctionCall).filter(call => {
+            // Only consider regular function calls (not type conversions, struct constructors, etc.)
+            if (call.kind !== solc_typed_ast_1.FunctionCallKind.FunctionCall)
+                return false;
+            // Must be a member access (e.g., foo.bar())
+            if (!(call.vExpression instanceof solc_typed_ast_1.MemberAccess))
+                return false;
+            const memberAccess = call.vExpression;
+            const referencedDecl = memberAccess.vReferencedDeclaration;
+            // Must reference a function
+            if (!(referencedDecl instanceof solc_typed_ast_1.FunctionDefinition))
+                return false;
+            // The function must be external or public
+            if (referencedDecl.visibility !== solc_typed_ast_1.FunctionVisibility.External &&
+                referencedDecl.visibility !== solc_typed_ast_1.FunctionVisibility.Public)
+                return false;
+            // Must be on a contract (not an interface)
+            const parentContract = referencedDecl.vScope;
+            if (!(parentContract instanceof solc_typed_ast_1.ContractDefinition))
+                return false;
+            if (parentContract.kind !== solc_typed_ast_1.ContractKind.Contract)
+                return false;
+            return true;
+        });
+        // If exactly one external call to a contract, record it
+        if (functionCalls.length === 1) {
+            const call = functionCalls[0];
+            const memberAccess = call.vExpression;
+            const referencedFn = memberAccess.vReferencedDeclaration;
+            const parentContract = referencedFn.vScope;
+            const fnSig = signatureFromFnDef(referencedFn);
+            externalCall = `${parentContract.name}::${fnSig}`;
+        }
+        const relation = {
+            impacts,
+            is_impacted_by: isImpactedBy
+        };
+        if (externalCall) {
+            relation.external = externalCall;
+        }
+        relations[sig] = relation;
+    }
+    return relations;
+};
+/**
+ * Get line number from an AST node's src attribute
+ */
+const getLineFromSrc = (src, sourceContents, absolutePath) => {
+    const content = sourceContents.get(absolutePath);
+    if (!content || !src)
+        return null;
+    const lineInfo = (0, utils_1.getLines)(content, src);
+    return lineInfo.start;
+};
+/**
+ * Check if a function call is an external/high-level call (not internal)
+ */
+const isExternalCall = (call) => {
+    // High-level calls to external contracts
+    if ((0, utils_1.highLevelCall)(call))
+        return true;
+    // Member access calls like contract.function()
+    if (call.vExpression instanceof solc_typed_ast_1.MemberAccess) {
+        const memberAccess = call.vExpression;
+        const baseType = memberAccess.vExpression.typeString;
+        // If base is a contract type, it's external
+        if (baseType === null || baseType === void 0 ? void 0 : baseType.startsWith('contract '))
+            return true;
+    }
+    return false;
+};
+/**
+ * Collect external call lines from a list of statements
+ */
+const collectExternalCallLines = (statements, sourceContents, absolutePath) => {
+    const lines = [];
+    for (const stmt of statements) {
+        const calls = stmt.getChildrenByType(solc_typed_ast_1.FunctionCall);
+        for (const call of calls) {
+            if (call.kind === solc_typed_ast_1.FunctionCallKind.FunctionCall && isExternalCall(call)) {
+                const line = getLineFromSrc(call.src, sourceContents, absolutePath);
+                if (line !== null) {
+                    const lineStr = line.toString();
+                    if (!lines.includes(lineStr)) {
+                        lines.push(lineStr);
+                    }
+                }
+            }
+        }
+    }
+    return lines;
+};
+/**
+ * Build coverage block from a function/modifier body
+ */
+const buildCoverageBlockFromBody = (definition, sourceContents, contract, callTree, visited = new Set()) => {
+    const sourceUnit = definition.getClosestParentByType(solc_typed_ast_1.SourceUnit);
+    const absolutePath = (sourceUnit === null || sourceUnit === void 0 ? void 0 : sourceUnit.absolutePath) || '';
+    const content = sourceContents.get(absolutePath) || '';
+    const lines = [];
+    const children = [];
+    if (!definition.vBody || definition.vBody.vStatements.length === 0) {
+        return { lines, absolutePath, children };
+    }
+    const statements = definition.vBody.vStatements;
+    // Add first statement line
+    const firstStmt = statements[0];
+    if (firstStmt.src && content) {
+        const lineInfo = (0, utils_1.getLines)(content, firstStmt.src);
+        lines.push(lineInfo.start.toString());
+    }
+    // Add last statement line (if different from first)
+    const lastStmt = statements[statements.length - 1];
+    if (lastStmt.src && content && statements.length > 1) {
+        const lineInfo = (0, utils_1.getLines)(content, lastStmt.src);
+        const lastLine = lineInfo.end.toString();
+        if (!lines.includes(lastLine)) {
+            lines.push(lastLine);
+        }
+    }
+    // Add external call lines
+    const externalLines = collectExternalCallLines(statements, sourceContents, absolutePath);
+    for (const line of externalLines) {
+        if (!lines.includes(line)) {
+            lines.push(line);
+        }
+    }
+    // Process nested blocks (if statements, try/catch, etc.)
+    for (const stmt of statements) {
+        // Handle if statements
+        if (stmt instanceof solc_typed_ast_1.IfStatement) {
+            const ifChildren = buildCoverageBlockFromIfStatement(stmt, sourceContents, absolutePath);
+            children.push(...ifChildren);
+        }
+        // Handle try statements
+        if (stmt instanceof solc_typed_ast_1.TryStatement) {
+            const tryChildren = buildCoverageBlockFromTryStatement(stmt, sourceContents, absolutePath);
+            children.push(...tryChildren);
+        }
+    }
+    // Process children from call tree (internal/modifier calls)
+    for (const child of callTree.children) {
+        // Skip if already visited (recursive call)
+        if (child.isRecursive || visited.has(child.nodeId)) {
+            continue;
+        }
+        visited.add(child.nodeId);
+        const childBlock = buildCoverageBlockFromBody(child.definition, sourceContents, contract, child, visited);
+        if (childBlock.lines.length > 0 || childBlock.children.length > 0) {
+            children.push(childBlock);
+        }
+    }
+    return { lines, absolutePath, children };
+};
+/**
+ * Build coverage blocks from an if statement
+ */
+const buildCoverageBlockFromIfStatement = (ifStmt, sourceContents, absolutePath) => {
+    const blocks = [];
+    const content = sourceContents.get(absolutePath) || '';
+    // True branch
+    if (ifStmt.vTrueBody) {
+        const trueBranch = buildCoverageBlockFromStatementOrBlock(ifStmt.vTrueBody, sourceContents, absolutePath);
+        if (trueBranch.lines.length > 0) {
+            blocks.push(trueBranch);
+        }
+    }
+    // False branch (else)
+    if (ifStmt.vFalseBody) {
+        const falseBranch = buildCoverageBlockFromStatementOrBlock(ifStmt.vFalseBody, sourceContents, absolutePath);
+        if (falseBranch.lines.length > 0) {
+            blocks.push(falseBranch);
+        }
+    }
+    return blocks;
+};
+/**
+ * Build coverage blocks from a try statement
+ */
+const buildCoverageBlockFromTryStatement = (tryStmt, sourceContents, absolutePath) => {
+    const blocks = [];
+    // Process each catch clause
+    for (const clause of tryStmt.vClauses) {
+        if (clause.vBlock) {
+            const clauseBlock = buildCoverageBlockFromStatementOrBlock(clause.vBlock, sourceContents, absolutePath);
+            if (clauseBlock.lines.length > 0) {
+                blocks.push(clauseBlock);
+            }
+        }
+    }
+    return blocks;
+};
+/**
+ * Build coverage block from a statement or block
+ */
+const buildCoverageBlockFromStatementOrBlock = (node, sourceContents, absolutePath) => {
+    const content = sourceContents.get(absolutePath) || '';
+    const lines = [];
+    const children = [];
+    let statements = [];
+    if (node instanceof solc_typed_ast_1.Block) {
+        statements = node.vStatements;
+    }
+    else {
+        statements = [node];
+    }
+    if (statements.length === 0) {
+        return { lines, absolutePath, children };
+    }
+    // Add first statement line
+    const firstStmt = statements[0];
+    if (firstStmt.src && content) {
+        const lineInfo = (0, utils_1.getLines)(content, firstStmt.src);
+        lines.push(lineInfo.start.toString());
+    }
+    // Add last statement line
+    const lastStmt = statements[statements.length - 1];
+    if (lastStmt.src && content && statements.length > 1) {
+        const lineInfo = (0, utils_1.getLines)(content, lastStmt.src);
+        const lastLine = lineInfo.end.toString();
+        if (!lines.includes(lastLine)) {
+            lines.push(lastLine);
+        }
+    }
+    // Add external call lines
+    const externalLines = collectExternalCallLines(statements, sourceContents, absolutePath);
+    for (const line of externalLines) {
+        if (!lines.includes(line)) {
+            lines.push(line);
+        }
+    }
+    // Process nested blocks
+    for (const stmt of statements) {
+        if (stmt instanceof solc_typed_ast_1.IfStatement) {
+            const ifChildren = buildCoverageBlockFromIfStatement(stmt, sourceContents, absolutePath);
+            children.push(...ifChildren);
+        }
+        if (stmt instanceof solc_typed_ast_1.TryStatement) {
+            const tryChildren = buildCoverageBlockFromTryStatement(stmt, sourceContents, absolutePath);
+            children.push(...tryChildren);
+        }
+    }
+    return { lines, absolutePath, children };
+};
+/**
+ * Collect coverage map for a contract
+ */
+const collectCoverageMap = (contract, sourceContents) => {
+    const coverageMap = {};
+    const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true).reverse();
+    for (const fnDef of allFunctions) {
+        // Only include external/public functions
+        if (fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.External && fnDef.visibility !== solc_typed_ast_1.FunctionVisibility.Public) {
+            continue;
+        }
+        const sig = signatureFromFnDef(fnDef);
+        // Build call tree context
+        const context = {
+            nodeCounter: { value: 0 },
+            contract: contract,
+            callStack: [],
+            activeNodes: new Map()
+        };
+        // Build call tree for this function
+        const callTree = (0, call_tree_builder_1.buildCallTree)(fnDef, [], undefined, undefined, context);
+        // Build coverage block from call tree
+        const coverageBlock = buildCoverageBlockFromBody(fnDef, sourceContents, contract, callTree);
+        coverageMap[sig] = coverageBlock;
+    }
+    return coverageMap;
+};
+const hasFallback = (contract) => {
+    const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true);
+    return allFunctions.some(fn => fn.kind === solc_typed_ast_1.FunctionKind.Fallback);
+};
+const hasReceive = (contract) => {
+    const allFunctions = (0, utils_1.getDefinitions)(contract, 'vFunctions', true);
+    return allFunctions.some(fn => fn.kind === solc_typed_ast_1.FunctionKind.Receive);
+};
+/**
+ * Load source file contents for source location info
+ */
+const loadSourceContents = async (sourceUnits) => {
+    const contents = new Map();
+    for (const unit of sourceUnits) {
+        const filePath = unit.absolutePath;
+        if (filePath) {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                contents.set(filePath, content);
+            }
+            catch {
+                // File might not exist or not accessible
+            }
+        }
+    }
+    return contents;
+};
+const runInfo = async (foundryRoot, contractName, options = {}) => {
+    const log = options.json ? () => { } : console.log.bind(console);
+    // Set Z3 to silent mode if --json is used
+    if (options.json) {
+        (0, z3Solver_1.setZ3Silent)(true);
+    }
+    const { sourceUnits, contractAbis } = await loadLatestBuildInfo(foundryRoot);
+    if (!sourceUnits || sourceUnits.length === 0) {
+        throw new Error('No source units were produced from the build; cannot generate info.');
+    }
+    // Load source file contents for assert info
+    const sourceContents = await loadSourceContents(sourceUnits);
+    const allContracts = getAllContracts(sourceUnits);
+    const targetContract = allContracts.get(contractName);
+    if (!targetContract) {
+        throw new Error(`Contract ${contractName} not found in build output.`);
+    }
+    // Recursively collect all related contracts
+    const relatedContracts = collectRelatedContracts(targetContract, allContracts);
+    log(`[recon-generate] Found ${relatedContracts.size} related contracts`);
+    const output = {
+        payable: {},
+        assert: {},
+        constant_functions: {},
+        constants_used: {},
+        inheritances: {},
+        functions_relations: {},
+        with_fallback: [],
+        with_receive: [],
+        coverage_map: {},
+    };
+    // Collect info for all related contracts
+    for (const contract of relatedContracts) {
+        // Skip abstract contracts (their functions are inherited by concrete contracts)
+        // But include libraries (ContractKind.Library) since they contain important logic
+        if (contract.abstract) {
+            continue;
+        }
+        if (contract.kind !== solc_typed_ast_1.ContractKind.Contract && contract.kind !== solc_typed_ast_1.ContractKind.Library) {
+            continue;
+        }
+        // Payable functions
+        const payable = collectPayableFunctions(contract);
+        if (payable.length > 0) {
+            output.payable[contract.name] = payable;
+        }
+        // Constant functions from ABI (more reliable for complex types)
+        const constantFns = collectConstantFunctionsFromAbi(contract.name, contractAbis);
+        if (constantFns.length > 0) {
+            output.constant_functions[contract.name] = constantFns;
+        }
+        // Assert statements (only include contracts with asserts)
+        const asserts = collectAssertStatements(contract, foundryRoot, sourceContents);
+        if (Object.keys(asserts).length > 0) {
+            output.assert[contract.name] = asserts;
+        }
+        // Constants used (only include contracts/functions with constants)
+        // Also includes Z3-solved values from constraint expressions
+        const constants = await collectConstantsUsed(contract);
+        if (Object.keys(constants).length > 0) {
+            output.constants_used[contract.name] = constants;
+        }
+        // Functions relations
+        const relations = collectFunctionsRelations(contract);
+        output.functions_relations[contract.name] = relations;
+        // Coverage map
+        const coverage = collectCoverageMap(contract, sourceContents);
+        if (Object.keys(coverage).length > 0) {
+            output.coverage_map[contract.name] = coverage;
+        }
+        // Fallback and receive
+        if (hasFallback(contract)) {
+            output.with_fallback.push(contract.name);
+        }
+        if (hasReceive(contract)) {
+            output.with_receive.push(contract.name);
+        }
+        // Inheritances (all base contracts recursively, excluding self)
+        const inheritedContracts = collectAllInheritances(contract);
+        if (inheritedContracts.length > 0) {
+            output.inheritances[contract.name] = inheritedContracts;
+        }
+    }
+    const jsonOutput = JSON.stringify(output, null, 2);
+    // Cleanup Z3 context
+    await (0, z3Solver_1.cleanupZ3)();
+    // Output to terminal if --json flag is set
+    if (options.json) {
+        console.log(jsonOutput);
+    }
+    // Write to file if outputPath is provided or --json is not set
+    if (options.outputPath || !options.json) {
+        const infoPath = options.outputPath || path.join(foundryRoot, `recon-info-${contractName}.json`);
+        await fs.writeFile(infoPath, jsonOutput);
+        log(`[recon-generate] Wrote info file to ${infoPath}`);
+    }
+    return output;
+};
+exports.runInfo = runInfo;