recon-generate 0.0.33 → 0.0.34

package/dist/dictionary.js

@@ -160,7 +160,8 @@ const runDictionary = async (foundryRoot, options = {}) => {
     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 ${foundryRoot}`);
-    const { sourceUnits } = await (0, utils_1.loadLatestBuildInfo)(foundryRoot);
+    const foundryConfig = await (0, utils_1.getFoundryConfig)(foundryRoot);
+    const { sourceUnits } = await (0, utils_1.loadLatestBuildInfo)(foundryRoot, foundryConfig.out || 'out');
     if (!sourceUnits || sourceUnits.length === 0) {
         throw new Error('No source units were produced from the build; cannot generate dictionary.');
     }

package/dist/info.js

@@ -922,7 +922,8 @@ const runInfo = async (foundryRoot, contractName, options = {}) => {
     if (options.json) {
         (0, z3Solver_1.setZ3Silent)(true);
     }
-    const { sourceUnits, buildOutput } = await (0, utils_1.loadLatestBuildInfo)(foundryRoot);
+    const foundryConfig = await (0, utils_1.getFoundryConfig)(foundryRoot);
+    const { sourceUnits, buildOutput } = await (0, utils_1.loadLatestBuildInfo)(foundryRoot, foundryConfig.out || 'out');
     if (!sourceUnits || sourceUnits.length === 0) {
         throw new Error('No source units were produced from the build; cannot generate info.');
     }

package/dist/link2.js

@@ -95,7 +95,8 @@ const runForgeBuild = async (cwd, verbose = false) => {
         });
     });
     // Find and read the most recent build-info JSON file
-    const buildInfoDir = path.join(cwd, 'out', 'build-info');
+    const foundryConfig = await (0, utils_1.getFoundryConfig)(cwd);
+    const buildInfoDir = path.join(cwd, foundryConfig.out, 'build-info');
     if (verbose) {
         console.log(`[VERBOSE] Looking for build-info files in: ${buildInfoDir}`);
     }

package/dist/sourcemap.js

@@ -70,8 +70,8 @@ function findFoundryProject(startDir = process.cwd()) {
     }
     return null;
 }
-function findBuildInfo(projectDir) {
-    const buildInfoDir = path.join(projectDir, 'out', 'build-info');
+function findBuildInfo(projectDir, outDir = 'out') {
+    const buildInfoDir = path.join(projectDir, outDir, 'build-info');
     if (!fs.existsSync(buildInfoDir))
         return null;
     const files = fs.readdirSync(buildInfoDir).filter(f => f.endsWith('.json'));
@@ -153,13 +153,15 @@ async function runSourcemap(foundryRoot, options = {}) {
         console.log(`[VERBOSE] Foundry root: ${foundryRoot}`);
         console.log(`[VERBOSE] Output dir: ${outputDir}`);
     }
+    const foundryConfig = await (0, utils_1.getFoundryConfig)(projectDir);
+    const forgeOutDir = foundryConfig.out || 'out';
     console.log(`📁 Project: ${projectDir}`);
     console.log(`📂 Output:  ${outputDir}`);
     const startTime = Date.now();
     // Find build info
-    const buildInfoPath = findBuildInfo(projectDir);
+    const buildInfoPath = findBuildInfo(projectDir, forgeOutDir);
     if (!buildInfoPath) {
-        throw new Error(`No build-info found in ${projectDir}/out/build-info/. Run "forge build" first to generate build artifacts.`);
+        throw new Error(`No build-info found in ${projectDir}/${forgeOutDir}/build-info/. Run "forge build" first to generate build artifacts.`);
     }
     console.log(`📂 Found build-info: ${path.basename(buildInfoPath)}`);
     // Load AST

package/dist/templateManager.d.ts

@@ -1,5 +1,5 @@
-import { FunctionDefinitionParams, ContractMetadata } from './types';
-import { SymbolsInfo } from './utils';
+import { FunctionDefinitionParams, ContractMetadata } from "./types";
+import { SymbolsInfo } from "./utils";
 export declare class TemplateManager {
     private foundryRoot;
     private suiteDir;

package/dist/templateManager.js

@@ -49,25 +49,26 @@ class TemplateManager {
     }
     skipList() {
         const suiteRel = path.relative(this.foundryRoot, this.suiteDir);
-        const suffix = this.suiteNameSnake ? `-${this.suiteNameSnake}` : '';
+        const suffix = this.suiteNameSnake ? `-${this.suiteNameSnake}` : "";
         const cryticTesterName = `CryticTester${this.suiteNamePascal}`;
         const cryticToFoundryName = `CryticToFoundry${this.suiteNamePascal}`;
         return [
             `echidna${suffix}.yaml`,
             `medusa${suffix}.json`,
             `halmos${suffix}.toml`,
-            path.join(suiteRel, 'BeforeAfter.sol'),
+            path.join(suiteRel, "BeforeAfter.sol"),
+            path.join(suiteRel, "SelectorStorage.sol"),
             path.join(suiteRel, `${cryticTesterName}.sol`),
             path.join(suiteRel, `${cryticToFoundryName}.sol`),
-            path.join(suiteRel, 'Properties.sol'),
-            path.join(suiteRel, 'helpers/Utils.sol'),
-            path.join(suiteRel, 'helpers/Panic.sol'),
-            path.join(suiteRel, 'managers/ActorManager.sol'),
-            path.join(suiteRel, 'managers/AssetManager.sol'),
-            path.join(suiteRel, 'managers/utils/EnumerableSet.sol'),
-            path.join(suiteRel, 'mocks/MockERC20.sol'),
-            path.join(suiteRel, 'targets/DoomsdayTargets.sol'),
-            path.join(suiteRel, 'targets/ManagersTargets.sol'),
+            path.join(suiteRel, "Properties.sol"),
+            path.join(suiteRel, "helpers/Utils.sol"),
+            path.join(suiteRel, "helpers/Panic.sol"),
+            path.join(suiteRel, "managers/ActorManager.sol"),
+            path.join(suiteRel, "managers/AssetManager.sol"),
+            path.join(suiteRel, "managers/utils/EnumerableSet.sol"),
+            path.join(suiteRel, "mocks/MockERC20.sol"),
+            path.join(suiteRel, "targets/DoomsdayTargets.sol"),
+            path.join(suiteRel, "targets/ManagersTargets.sol"),
         ];
     }
     async shouldGenerateFile(filePath) {
@@ -75,7 +76,9 @@ class TemplateManager {
             return true;
         }
         try {
-            const targetPath = path.isAbsolute(filePath) ? filePath : path.join(this.foundryRoot, filePath);
+            const targetPath = path.isAbsolute(filePath)
+                ? filePath
+                : path.join(this.foundryRoot, filePath);
             await fs.access(targetPath);
             return false;
         }
@@ -85,11 +88,13 @@ class TemplateManager {
     }
     async updateTargetFile(filepath, newContent) {
         try {
-            const existingContent = await fs.readFile(filepath, 'utf8');
-            if (existingContent.includes('/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///')) {
-                const [beforeMarker, afterMarker] = existingContent.split('/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///');
-                const [, newAutoGenerated] = newContent.split('/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///');
-                return beforeMarker + '/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///' + newAutoGenerated;
+            const existingContent = await fs.readFile(filepath, "utf8");
+            if (existingContent.includes("/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///")) {
+                const [beforeMarker, afterMarker] = existingContent.split("/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///");
+                const [, newAutoGenerated] = newContent.split("/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///");
+                return (beforeMarker +
+                    "/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///" +
+                    newAutoGenerated);
             }
             return newContent;
         }
@@ -98,39 +103,100 @@ class TemplateManager {
         }
     }
     async generateTemplates(enabledContracts, adminFunctions, nonSeparatedFunctions, separatedByContract, allContractNames, symbolsInfo) {
-        const contractsForSetup = enabledContracts.map(contract => ({ ...contract, isDynamic: this.dynamicDeploy.has(contract.name) }));
+        const contractsForSetup = enabledContracts.map((contract) => ({
+            ...contract,
+            isDynamic: this.dynamicDeploy.has(contract.name),
+        }));
         const dynamicContracts = enabledContracts
-            .filter(contract => this.dynamicDeploy.has(contract.name))
-            .map(c => ({ name: c.name, path: c.path }));
+            .filter((contract) => this.dynamicDeploy.has(contract.name))
+            .map((c) => ({ name: c.name, path: c.path }));
         const suiteRel = path.relative(this.foundryRoot, this.suiteDir);
-        const suffix = this.suiteNameSnake ? `-${this.suiteNameSnake}` : '';
+        const suffix = this.suiteNameSnake ? `-${this.suiteNameSnake}` : "";
         const cryticTesterName = `CryticTester${this.suiteNamePascal}`;
         const cryticToFoundryName = `CryticToFoundry${this.suiteNamePascal}`;
-        const suiteTargetsDir = path.join(suiteRel, 'targets');
+        const suiteTargetsDir = path.join(suiteRel, "targets");
+        // Collect all functions to count overloads
+        const allFunctionsRaw = [
+            ...adminFunctions,
+            ...nonSeparatedFunctions,
+            ...Object.values(separatedByContract).flat(),
+        ];
+        // Simple overload tracking with plain objects
+        const counts = {};
+        for (const fn of allFunctionsRaw) {
+            const key = `${fn.contractName}_${fn.abi.name}`;
+            counts[key] = (counts[key] || 0) + 1;
+        }
+        // Helper to add overloadIndex to a function array
+        const addOverloadIndices = (functions) => {
+            const indices = {};
+            return functions.map((fn) => {
+                const key = `${fn.contractName}_${fn.abi.name}`;
+                if (counts[key] > 1) {
+                    const idx = indices[key] || 0;
+                    indices[key] = idx + 1;
+                    return { ...fn, overloadIndex: idx };
+                }
+                return fn;
+            });
+        };
+        // Apply overload indexing to all function arrays
+        const indexedAdminFunctions = addOverloadIndices(adminFunctions);
+        const indexedNonSeparatedFunctions = addOverloadIndices(nonSeparatedFunctions);
+        const indexedSeparatedByContract = {};
+        for (const [contractName, functions] of Object.entries(separatedByContract)) {
+            indexedSeparatedByContract[contractName] = addOverloadIndices(functions);
+        }
+        // All functions with overload indices for SelectorStorage
+        const allFunctions = [
+            ...indexedAdminFunctions,
+            ...indexedNonSeparatedFunctions,
+            ...Object.values(indexedSeparatedByContract).flat(),
+        ];
         const files = {
-            [`echidna${suffix}.yaml`]: templates.echidnaConfigTemplate({ corpusDir: `echidna${suffix}` }),
-            [`medusa${suffix}.json`]: templates.medusaConfigTemplate({ cryticTesterName }),
-            [`halmos${suffix}.toml`]: templates.halmosConfigTemplate({ cryticToFoundryName }),
-            [path.join(suiteRel, 'BeforeAfter.sol')]: templates.beforeAfterTemplate({}),
-            [path.join(suiteRel, `${cryticTesterName}.sol`)]: templates.cryticTesterTemplate({ cryticTesterName, suiteNameSuffix: suffix }),
+            [`echidna${suffix}.yaml`]: templates.echidnaConfigTemplate({
+                corpusDir: `echidna${suffix}`,
+            }),
+            [`medusa${suffix}.json`]: templates.medusaConfigTemplate({
+                cryticTesterName,
+            }),
+            [`halmos${suffix}.toml`]: templates.halmosConfigTemplate({
+                cryticToFoundryName,
+            }),
+            [path.join(suiteRel, "BeforeAfter.sol")]: templates.beforeAfterTemplate({}),
+            [path.join(suiteRel, "SelectorStorage.sol")]: templates.selectorStorageTemplate({
+                functions: allFunctions,
+            }),
+            [path.join(suiteRel, `${cryticTesterName}.sol`)]: templates.cryticTesterTemplate({
+                cryticTesterName,
+                suiteNameSuffix: suffix,
+            }),
             [path.join(suiteRel, `${cryticToFoundryName}.sol`)]: templates.cryticToFoundryTemplate({ cryticToFoundryName }),
-            [path.join(suiteRel, 'Properties.sol')]: templates.propertiesTemplate({}),
-            [path.join(suiteRel, 'Setup.sol')]: templates.setupTemplate({ contracts: contractsForSetup }),
-            [path.join(suiteRel, 'TargetFunctions.sol')]: templates.targetFunctionsTemplate({
-                functions: nonSeparatedFunctions,
+            [path.join(suiteRel, "Properties.sol")]: templates.propertiesTemplate({}),
+            [path.join(suiteRel, "Setup.sol")]: templates.setupTemplate({
+                contracts: contractsForSetup,
+            }),
+            [path.join(suiteRel, "TargetFunctions.sol")]: templates.targetFunctionsTemplate({
+                functions: indexedNonSeparatedFunctions,
                 contracts: allContractNames,
                 dynamicContracts,
             }),
-            [path.join(suiteTargetsDir, 'AdminTargets.sol')]: templates.adminTargetsTemplate({
-                functions: adminFunctions,
-                extraImports: symbolsInfo ? (0, utils_1.resolveExtraImports)([], adminFunctions, symbolsInfo) : [],
+            [path.join(suiteTargetsDir, "AdminTargets.sol")]: templates.adminTargetsTemplate({
+                functions: indexedAdminFunctions,
+                extraImports: symbolsInfo ? (0, utils_1.resolveExtraImports)([], indexedAdminFunctions, symbolsInfo) : [],
+            }),
+            [path.join(suiteTargetsDir, "DoomsdayTargets.sol")]: templates.doomsdayTargetsTemplate({}),
+            [path.join(suiteTargetsDir, "ManagersTargets.sol")]: templates.managersTargetsTemplate({}),
+            [path.join(suiteRel, "README.md")]: templates.readmeTemplate({
+                suiteFolder: path.basename(this.suiteDir),
+                cryticTesterName,
+                cryticToFoundryName,
+                configSuffix: suffix,
             }),
-            [path.join(suiteTargetsDir, 'DoomsdayTargets.sol')]: templates.doomsdayTargetsTemplate({}),
-            [path.join(suiteTargetsDir, 'ManagersTargets.sol')]: templates.managersTargetsTemplate({}),
         };
-        for (const [contractName, functions] of Object.entries(separatedByContract)) {
+        for (const [contractName, functions] of Object.entries(indexedSeparatedByContract)) {
             const targetPath = path.join(suiteTargetsDir, `${(0, case_1.pascal)(contractName)}Targets.sol`);
-            const contractPath = functions.length > 0 ? functions[0].contractPath : '';
+            const contractPath = functions.length > 0 ? functions[0].contractPath : "";
             const importedPaths = contractPath ? [contractPath] : [];
             files[targetPath] = templates.targetsTemplate({
                 contractName,
@@ -140,19 +206,21 @@ class TemplateManager {
             });
         }
         for (const [name, content] of Object.entries(files)) {
-            const outputPath = path.isAbsolute(name) ? name : path.join(this.foundryRoot, name);
+            const outputPath = path.isAbsolute(name)
+                ? name
+                : path.join(this.foundryRoot, name);
             if (!(await this.shouldGenerateFile(name))) {
                 continue;
             }
             await fs.mkdir(path.dirname(outputPath), { recursive: true });
-            if (name.endsWith('Setup.sol')) {
+            if (name.endsWith("Setup.sol")) {
                 try {
                     await fs.access(outputPath);
                     continue; // do not overwrite user setup
                 }
                 catch { }
             }
-            if (name.includes('targets/') && name.endsWith('Targets.sol')) {
+            if (name.includes("targets/") && name.endsWith("Targets.sol")) {
                 const finalContent = await this.updateTargetFile(outputPath, content);
                 await fs.writeFile(outputPath, finalContent);
             }

package/dist/templates/before-after.js

@@ -11,9 +11,15 @@ exports.beforeAfterTemplate = handlebars_1.default.compile(`// SPDX-License-Iden
 pragma solidity ^0.8.0;
 
 import {Setup} from "./Setup.sol";
+import {SelectorStorage} from "./SelectorStorage.sol";
 
 // ghost variables for tracking state variable values before and after function calls
 abstract contract BeforeAfter is Setup {
+
+   // Tracks which function selector is currently executing
+    // Using bytes4 selector instead of enum to avoid 256 member limit
+    bytes4 public currentOperation;
+
     struct Vars {
         uint256 __ignore__;
     }
@@ -27,6 +33,15 @@ abstract contract BeforeAfter is Setup {
         __after();
     }
 
+
+  // Sets currentOperation to the function selector before execution
+    modifier trackOp(bytes4 op) {
+        currentOperation = op;
+        __before();
+        _;
+        __after();
+    }
+
     function __before() internal {
 
     }

package/dist/templates/handlebars-helpers.js

@@ -31,13 +31,17 @@ function getUsableInternalType(internalType) {
 }
 function conditionallyAddMemoryLocation(type, internalType) {
     if (type.indexOf("[") !== -1) {
-        if (internalType.startsWith("struct ") || internalType.startsWith("enum ") || internalType.startsWith("contract ")) {
+        if (internalType.startsWith("struct ") ||
+            internalType.startsWith("enum ") ||
+            internalType.startsWith("contract ")) {
             const usable = getUsableInternalType(internalType);
             return `${usable} memory`;
         }
         return `${type} memory`;
     }
-    if (internalType.startsWith("struct ") || internalType.startsWith("enum ") || internalType.startsWith("contract ")) {
+    if (internalType.startsWith("struct ") ||
+        internalType.startsWith("enum ") ||
+        internalType.startsWith("contract ")) {
         return `${getUsableInternalType(internalType)}${internalType.startsWith("struct ") ? " memory" : ""}`;
     }
     if (type === "bytes" || type === "string") {
@@ -51,37 +55,69 @@ function extractType(inputOrOutput) {
     }
     return inputOrOutput.type;
 }
+/**
+ * Recursively expands a ParamDefinition to its canonical ABI type string.
+ * Tuple types (structs) are expanded to "(type1,type2,...)" using components.
+ * Array suffixes like "[]" or "[5]" are preserved.
+ */
+function canonicalParamType(param) {
+    if (!param.type.startsWith("tuple") || !param.components || param.components.length === 0) {
+        return param.type;
+    }
+    // Extract array suffix: "tuple[]" -> "[]", "tuple[5]" -> "[5]", "tuple" -> ""
+    const arraySuffix = param.type.slice("tuple".length);
+    const inner = param.components.map((c) => canonicalParamType(c)).join(",");
+    return `(${inner})${arraySuffix}`;
+}
 function registerHelpers(handlebars) {
-    handlebars.registerHelper('snake', function (str) {
+    handlebars.registerHelper("snake", function (str) {
         return (0, case_1.snake)(str);
     });
-    handlebars.registerHelper('scream', function (str) {
+    handlebars.registerHelper("scream", function (str) {
         return (0, case_1.snake)(str).toUpperCase();
     });
-    handlebars.registerHelper('camel', function (str) {
+    handlebars.registerHelper("camel", function (str) {
         return (0, case_1.camel)(str);
     });
-    handlebars.registerHelper('pascal', function (str) {
+    handlebars.registerHelper("pascal", function (str) {
         return (0, case_1.pascal)(str);
     });
-    handlebars.registerHelper('instanceName', function (str) {
+    handlebars.registerHelper("instanceName", function (str) {
         return safeInstanceName(str);
     });
-    handlebars.registerHelper('functionDefinition', function ({ contractName, abi, actor, mode }) {
+    // Selector constant name: CONTRACT_FUNCTION or CONTRACT_FUNCTION_0 for overloads
+    handlebars.registerHelper("selectorConstName", function (fn) {
+        const contract = (0, case_1.snake)(fn.contractName).toUpperCase();
+        const func = (0, case_1.snake)(fn.abi.name).toUpperCase();
+        const suffix = fn.overloadIndex !== undefined ? `_${fn.overloadIndex}` : "";
+        return `${contract}_${func}${suffix}`;
+    });
+    // Function signature: "functionName(type1,type2)"
+    // Recursively expands tuple types using components for correct keccak256 selectors
+    handlebars.registerHelper("functionSignature", function (fn) {
+        const paramTypes = fn.abi.inputs.map((input) => canonicalParamType(input)).join(",");
+        return `${fn.abi.name}(${paramTypes})`;
+    });
+    handlebars.registerHelper("functionDefinition", function ({ contractName, abi, actor, mode, overloadIndex }) {
         const funcPrefix = (0, case_1.camel)(contractName); // For function names: fB_method
         const instanceVar = safeInstanceName(contractName); // For instance access: _fB.method
         let modifiers = [];
-        if (abi.stateMutability === 'payable') {
-            modifiers.push('payable');
+        // Use constant from SelectorStorage
+        const contract = (0, case_1.snake)(contractName).toUpperCase();
+        const func = (0, case_1.snake)(abi.name).toUpperCase();
+        const suffix = overloadIndex !== undefined ? `_${overloadIndex}` : "";
+        modifiers.push(`trackOp(SelectorStorage.${contract}_${func}${suffix})`);
+        if (abi.stateMutability === "payable") {
+            modifiers.push("payable");
         }
         if (actor === types_1.Actor.ADMIN) {
-            modifiers.push('asAdmin');
+            modifiers.push("asAdmin");
         }
         else if (actor === types_1.Actor.ACTOR) {
-            modifiers.push('asActor');
+            modifiers.push("asActor");
         }
-        const valueStr = abi.stateMutability === 'payable' ? '{value: msg.value}' : '';
-        const modifiersStr = modifiers.length ? modifiers.join(' ') + ' ' : '';
+        const valueStr = abi.stateMutability === "payable" ? "{value: msg.value}" : "";
+        const modifiersStr = modifiers.length ? modifiers.join(" ") + " " : "";
         const hasOutputs = abi.outputs && abi.outputs.length > 0;
         const outputs = abi.outputs && abi.outputs.length > 0
             ? abi.outputs
@@ -118,7 +154,7 @@ function registerHelpers(handlebars) {
                 .join(", ")}) public ${modifiersStr}{
         ${instanceVar}.${abi.name}${valueStr}(${abi.inputs
                 .map((input, index) => inputNames[index] || getDefaultValue(input.type))
-                .join(", ")});${mode === 'fail'
+                .join(", ")});${mode === "fail"
                 ? `
         t(false, "${funcPrefix}_${abi.name}");`
                 : ""}
@@ -129,10 +165,11 @@ function registerHelpers(handlebars) {
     function ${funcPrefix}_${abi.name}(${abi.inputs
                 .map((input) => `${conditionallyAddMemoryLocation(input.type, extractType(input))} ${inputNames[abi.inputs.indexOf(input)]}`)
                 .join(", ")}) public ${modifiersStr}{
-        ${hasOutputs ? `${outputs}
+        ${hasOutputs
+                ? `${outputs}
         try ${instanceVar}.${abi.name}${valueStr}(${abi.inputs
-                .map((input, index) => inputNames[index] || getDefaultValue(input.type))
-                .join(", ")}) returns (${returnTypes}) {
+                    .map((input, index) => inputNames[index] || getDefaultValue(input.type))
+                    .join(", ")}) returns (${returnTypes}) {
             ${assignValues}
         }`
                 : `try ${instanceVar}.${abi.name}(${abi.inputs

package/dist/templates/index.d.ts

@@ -1,14 +1,16 @@
-import { echidnaConfigTemplate } from './echidna-config';
-import { halmosConfigTemplate } from './halmos-config';
-import { medusaConfigTemplate } from './medusa-config';
-import { beforeAfterTemplate } from './before-after';
-import { cryticTesterTemplate } from './crytic-tester';
-import { cryticToFoundryTemplate } from './crytic-to-foundry';
-import { propertiesTemplate } from './properties';
-import { setupTemplate } from './setup';
-import { targetFunctionsTemplate } from './target-functions';
-import { adminTargetsTemplate } from './targets/admin-targets';
-import { doomsdayTargetsTemplate } from './targets/doomsday-targets';
-import { managersTargetsTemplate } from './targets/managers-targets';
-import { targetsTemplate } from './targets/targets';
-export { echidnaConfigTemplate, halmosConfigTemplate, medusaConfigTemplate, beforeAfterTemplate, cryticTesterTemplate, cryticToFoundryTemplate, propertiesTemplate, setupTemplate, targetFunctionsTemplate, adminTargetsTemplate, doomsdayTargetsTemplate, managersTargetsTemplate, targetsTemplate, };
+import { echidnaConfigTemplate } from "./echidna-config";
+import { halmosConfigTemplate } from "./halmos-config";
+import { medusaConfigTemplate } from "./medusa-config";
+import { beforeAfterTemplate } from "./before-after";
+import { cryticTesterTemplate } from "./crytic-tester";
+import { cryticToFoundryTemplate } from "./crytic-to-foundry";
+import { propertiesTemplate } from "./properties";
+import { setupTemplate } from "./setup";
+import { targetFunctionsTemplate } from "./target-functions";
+import { adminTargetsTemplate } from "./targets/admin-targets";
+import { doomsdayTargetsTemplate } from "./targets/doomsday-targets";
+import { managersTargetsTemplate } from "./targets/managers-targets";
+import { targetsTemplate } from "./targets/targets";
+import { selectorStorageTemplate } from "./selector-storage";
+import { readmeTemplate } from "./readme";
+export { echidnaConfigTemplate, halmosConfigTemplate, medusaConfigTemplate, beforeAfterTemplate, cryticTesterTemplate, cryticToFoundryTemplate, propertiesTemplate, setupTemplate, targetFunctionsTemplate, adminTargetsTemplate, doomsdayTargetsTemplate, managersTargetsTemplate, targetsTemplate, selectorStorageTemplate, readmeTemplate, };

package/dist/templates/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.targetsTemplate = exports.managersTargetsTemplate = exports.doomsdayTargetsTemplate = exports.adminTargetsTemplate = exports.targetFunctionsTemplate = exports.setupTemplate = exports.propertiesTemplate = exports.cryticToFoundryTemplate = exports.cryticTesterTemplate = exports.beforeAfterTemplate = exports.medusaConfigTemplate = exports.halmosConfigTemplate = exports.echidnaConfigTemplate = void 0;
+exports.readmeTemplate = exports.selectorStorageTemplate = exports.targetsTemplate = exports.managersTargetsTemplate = exports.doomsdayTargetsTemplate = exports.adminTargetsTemplate = exports.targetFunctionsTemplate = exports.setupTemplate = exports.propertiesTemplate = exports.cryticToFoundryTemplate = exports.cryticTesterTemplate = exports.beforeAfterTemplate = exports.medusaConfigTemplate = exports.halmosConfigTemplate = exports.echidnaConfigTemplate = void 0;
 const echidna_config_1 = require("./echidna-config");
 Object.defineProperty(exports, "echidnaConfigTemplate", { enumerable: true, get: function () { return echidna_config_1.echidnaConfigTemplate; } });
 const halmos_config_1 = require("./halmos-config");
@@ -27,3 +27,7 @@ const managers_targets_1 = require("./targets/managers-targets");
 Object.defineProperty(exports, "managersTargetsTemplate", { enumerable: true, get: function () { return managers_targets_1.managersTargetsTemplate; } });
 const targets_1 = require("./targets/targets");
 Object.defineProperty(exports, "targetsTemplate", { enumerable: true, get: function () { return targets_1.targetsTemplate; } });
+const selector_storage_1 = require("./selector-storage");
+Object.defineProperty(exports, "selectorStorageTemplate", { enumerable: true, get: function () { return selector_storage_1.selectorStorageTemplate; } });
+const readme_1 = require("./readme");
+Object.defineProperty(exports, "readmeTemplate", { enumerable: true, get: function () { return readme_1.readmeTemplate; } });

package/dist/templates/readme.d.ts

@@ -0,0 +1 @@
+export declare const readmeTemplate: HandlebarsTemplateDelegate<any>;

package/dist/templates/readme.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readmeTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.readmeTemplate = handlebars_1.default.compile(`# Recon Fuzzing Suite
+
+This is an auto-generated fuzzing test suite created by [Recon](https://getrecon.xyz/).
+
+## File Structure
+
+\`\`\`
+{{suiteFolder}}/
+├── Setup.sol              # Contract deployment and initialization
+├── BeforeAfter.sol        # Ghost variables for state tracking
+├── SelectorStorage.sol    # Function selector constants
+├── Properties.sol         # YOUR INVARIANTS GO HERE
+├── TargetFunctions.sol    # Non-separated target functions
+├── {{cryticTesterName}}.sol      # Entry point for Echidna/Medusa
+├── {{cryticToFoundryName}}.sol   # Foundry test wrapper
+├── helpers/
+│   └── Utils.sol
+├── managers/
+│   ├── ActorManager.sol
+│   └── AssetManager.sol
+└── targets/
+    ├── AdminTargets.sol
+    └── *Targets.sol       # Per-contract targets
+\`\`\`
+
+## Key Concepts
+
+### Inheritance Chain
+
+\`\`\`
+Setup (deploys contracts)
+  └── BeforeAfter (ghost variables, trackOp)
+        └── Properties (YOUR invariants)
+              └── *Targets (function wrappers)
+                    └── TargetFunctions
+                          └── {{cryticTesterName}}
+\`\`\`
+
+### Operation Tracking
+
+Each target function uses \`trackOp(selector)\` which:
+1. Sets \`currentOperation\` to the function's selector
+2. Calls \`__before()\` to capture pre-state
+3. Executes the function
+4. Calls \`__after()\` to capture post-state
+
+Example property using operation tracking:
+
+\`\`\`solidity
+function property_deposit_increases_balance() public {
+    if (currentOperation == SelectorStorage.VAULT_DEPOSIT) {
+        gte(_after.vaultBalance, _before.vaultBalance, "deposit should increase balance");
+    }
+}
+\`\`\`
+
+### Ghost Variables
+
+In \`BeforeAfter.sol\`, the \`Vars\` struct captures state:
+
+\`\`\`solidity
+struct Vars {
+    uint256 vaultTotalAssets;
+    uint256 userBalance;
+}
+
+function __before() internal {
+    _before.vaultTotalAssets = vault.totalAssets();
+    _before.userBalance = token.balanceOf(actor);
+}
+
+function __after() internal {
+    _after.vaultTotalAssets = vault.totalAssets();
+    _after.userBalance = token.balanceOf(actor);
+}
+\`\`\`
+
+### SelectorStorage
+
+Contains named constants for function selectors:
+
+\`\`\`solidity
+bytes4 constant VAULT_DEPOSIT = bytes4(keccak256("deposit(uint256)"));
+bytes4 constant VAULT_WITHDRAW_0 = bytes4(keccak256("withdraw(uint256)"));
+bytes4 constant VAULT_WITHDRAW_1 = bytes4(keccak256("withdraw(uint256,address)"));
+\`\`\`
+
+Overloaded functions get \_0, \_1 suffixes.
+
+## Files to Edit
+
+| File | Purpose |
+|------|---------|
+| \`Setup.sol\` | Deploy contracts, set initial state, configure actors |
+| \`BeforeAfter.sol\` | Add variables to \`Vars\` struct, implement \`__before()\`/\`__after()\` |
+| \`Properties.sol\` | Write invariant functions (prefix with \`property_\`) |
+
+## Auto-Generated Files (Don't Edit Below Marker)
+
+- \`SelectorStorage.sol\` - Regenerated from ABIs
+- \`*Targets.sol\` - Code below \`/// AUTO GENERATED TARGET FUNCTIONS\` marker is regenerated
+
+## Writing Properties
+
+\`\`\`solidity
+// Global invariant - checked after every operation
+function property_solvent() public {
+    gte(vault.totalAssets(), vault.totalSupply(), "insolvent");
+}
+
+// Operation-specific invariant
+function property_withdraw_decreases_shares() public {
+    if (currentOperation == SelectorStorage.VAULT_WITHDRAW_0) {
+        lt(_after.userShares, _before.userShares, "shares should decrease");
+    }
+}
+\`\`\`
+
+### Assertion Helpers
+
+- \`t(bool, string)\` - assert true
+- \`eq(a, b, string)\` - equal
+- \`gt(a, b, string)\` - greater than
+- \`gte(a, b, string)\` - greater or equal
+- \`lt(a, b, string)\` - less than
+- \`lte(a, b, string)\` - less or equal
+
+## Running Fuzzers
+
+\`\`\`bash
+# Echidna
+echidna . --contract {{cryticTesterName}} --config echidna{{configSuffix}}.yaml
+
+# Medusa
+medusa fuzz --config medusa{{configSuffix}}.json
+
+# Halmos
+halmos --config halmos{{configSuffix}}.toml
+\`\`\`
+
+## Regenerating
+
+After contract changes:
+\`\`\`bash
+recon-generate --force
+\`\`\`
+
+This preserves Setup.sol, BeforeAfter.sol, Properties.sol, and config files.
+`, { noEscape: true });

package/dist/templates/selector-storage.d.ts

@@ -0,0 +1 @@
+export declare const selectorStorageTemplate: HandlebarsTemplateDelegate<any>;

package/dist/templates/selector-storage.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectorStorageTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.selectorStorageTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+/// @notice Auto-generated selector constants for operation tracking
+library SelectorStorage {
+{{#each functions}}
+    bytes4 constant {{selectorConstName this}} = bytes4(keccak256("{{functionSignature this}}"));
+{{/each}}
+}
+`, { noEscape: true });

package/dist/templates/target-functions.js

@@ -16,6 +16,8 @@ import {vm} from "@chimera/Hevm.sol";
 // Helpers
 import {Panic} from "@recon/Panic.sol";
 
+import {SelectorStorage} from "./SelectorStorage.sol";
+
 // Targets
 // NOTE: Always import and apply them in alphabetical order, so much easier to debug!
 {{#each contracts}}

package/dist/templates/targets/admin-targets.js

@@ -22,6 +22,8 @@ import {Panic} from "@recon/Panic.sol";
 import { {{this.name}} } from "{{this.path}}";
 {{/each}}
 
+import {SelectorStorage} from "../SelectorStorage.sol";
+
 abstract contract AdminTargets is
     BaseTargetFunctions,
     Properties

package/dist/templates/targets/targets.js

@@ -19,6 +19,8 @@ import {vm} from "@chimera/Hevm.sol";
 // Helpers
 import {Panic} from "@recon/Panic.sol";
 
+import {SelectorStorage} from "../SelectorStorage.sol";
+
 {{#if path}}import "{{path}}";{{/if}}
 {{#each extraImports}}
 import { {{this.name}} } from "{{this.path}}";

package/dist/types.d.ts

@@ -46,6 +46,7 @@ export interface FunctionDefinitionParams {
     sig: string;
     ast?: ASTNode;
     code?: string;
+    overloadIndex?: number;
 }
 export declare enum CallType {
     Internal = "internal",

package/dist/types.js

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

package/package.json

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