recon-generate 0.0.2 → 0.0.4

package/README.md

@@ -31,6 +31,7 @@ Key options:
 - `--exclude "A:{foo(uint256)},D"` — exclude these contracts/functions.
 - `--admin "A:{fnSig,fnSig}"` — mark listed functions as admin (`asAdmin`).
 - `--mock "A,B"` — generate mocks for the listed contracts (compiled ABIs required); mocks go under `recon[-name]/mocks` and are added to targets.
+- `--dynamic-deploy "Foo,Bar"` — keep dynamic lists for the listed contracts: deploys one instance, tracks addresses in an array, exposes `_getRandom<Contract>` and `switch<Contract>(entropy)` helpers to rotate among deployed instances.
 - `--name <suite>` — name the suite; affects folder (`recon-<name>`), config filenames (`echidna-<name>.yaml`, `medusa-<name>.json`, `halmos-<name>.toml`), and Crytic tester/runner names.
 - `--force` — replace existing generated suite output under `--output` (does **not** rebuild `.recon/out`).
 - `--force-build` — delete `.recon/out` to force a fresh compile before generation.
@@ -63,6 +64,9 @@ recon-generate --name foo --force
 
 # Generate mocks and include them in targets
 recon-generate --mock "Morpho,Other" --force
+
+# Enable dynamic deploy helpers for Foo and Bar
+recon-generate --dynamic-deploy "Foo,Bar" --force
 ```
 
 ### Behavior
@@ -71,6 +75,7 @@ recon-generate --mock "Morpho,Other" --force
 - `--force` replaces the suite output folder; it does **not** rebuild `.recon/out`.
 - `--force-build` deletes `.recon/out` to force a fresh compile before generation.
 - When `--mock` is used, a fresh build is triggered, mocks are generated under `recon[-name]/mocks`, and a second build picks them up into `.recon/out` and targets.
+- When `--dynamic-deploy` is used, generated `Setup.sol` keeps an `address[]` per listed contract, pushes the first deployment, and emits `_getRandom<Contract>` helper plus `switch<Contract>(entropy)` in `TargetFunctions.sol` to retarget to a previously deployed instance.
 - `recon.json` is regenerated every run from current filters/contracts.
 - Include/exclude/admin matching is tolerant of fully qualified struct names vs short names (e.g., `Morpho.MarketParams` vs `MarketParams`).
 - Admin list sets `actor: admin` for matched functions; others default to `actor`.

package/dist/generator.d.ts

@@ -13,6 +13,7 @@ export interface GeneratorOptions {
     forceBuild?: boolean;
     admin?: Map<string, Set<string>>;
     mocks?: Set<string>;
+    dynamicDeploy?: Set<string>;
     suiteNameSnake: string;
     suiteNamePascal: string;
 }
@@ -21,6 +22,7 @@ export declare class ReconGenerator {
     private options;
     private generatedMocks;
     private allowedMockNames;
+    private contractKindCache;
     constructor(foundryRoot: string, options: GeneratorOptions);
     private logDebug;
     private outDir;
@@ -33,6 +35,7 @@ export declare class ReconGenerator {
     private installSetupHelpers;
     private updateRemappings;
     private updateGitignore;
+    private getContractKind;
     private findSourceContracts;
     private matchesSignatureOrName;
     private paramType;

package/dist/generator.js

@@ -41,6 +41,7 @@ const child_process_1 = require("child_process");
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const abi_to_mock_1 = __importDefault(require("abi-to-mock"));
+const parser_1 = __importDefault(require("@solidity-parser/parser"));
 const templateManager_1 = require("./templateManager");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
@@ -50,6 +51,7 @@ class ReconGenerator {
         this.options = options;
         this.generatedMocks = new Set();
         this.allowedMockNames = new Set();
+        this.contractKindCache = new Map();
     }
     logDebug(message, obj) {
         if (!this.options.debug)
@@ -153,6 +155,45 @@ class ReconGenerator {
             await fs.writeFile(gitignorePath, content);
         }
     }
+    async getContractKind(sourcePath, contractName) {
+        const absPath = path.isAbsolute(sourcePath) ? sourcePath : path.join(this.foundryRoot, sourcePath);
+        let fileCache = this.contractKindCache.get(absPath);
+        if (fileCache && fileCache.has(contractName)) {
+            return fileCache.get(contractName);
+        }
+        let content;
+        try {
+            content = await fs.readFile(absPath, 'utf8');
+        }
+        catch (e) {
+            this.logDebug('Failed to read source when determining contract kind', { sourcePath, error: String(e) });
+            return 'unknown';
+        }
+        let ast;
+        try {
+            ast = parser_1.default.parse(content, { tolerant: true });
+        }
+        catch (e) {
+            this.logDebug('Failed to parse source when determining contract kind', { sourcePath, error: String(e) });
+            return 'unknown';
+        }
+        fileCache = fileCache !== null && fileCache !== void 0 ? fileCache : new Map();
+        let kind = 'unknown';
+        const children = ast === null || ast === void 0 ? void 0 : ast.children;
+        if (Array.isArray(children)) {
+            for (const node of children) {
+                if ((node === null || node === void 0 ? void 0 : node.type) === 'ContractDefinition' && node.name === contractName) {
+                    if (node.kind === 'contract' || node.kind === 'interface' || node.kind === 'library') {
+                        kind = node.kind;
+                    }
+                    break;
+                }
+            }
+        }
+        fileCache.set(contractName, kind);
+        this.contractKindCache.set(absPath, fileCache);
+        return kind;
+    }
     async findSourceContracts() {
         var _a;
         const contracts = [];
@@ -181,18 +222,14 @@ class ReconGenerator {
                             for (const [sourcePath, contractName] of Object.entries(metadata.settings.compilationTarget)) {
                                 const lowerPath = sourcePath.toLowerCase();
                                 const lowerName = String(contractName).toLowerCase();
-                                // Skip interfaces, libraries, and mocks by convention, unless explicitly allowed (generated mocks)
                                 const isGeneratedMock = this.generatedMocks.has(String(contractName));
-                                if (!isGeneratedMock) {
-                                    if (lowerPath.includes('/interface') ||
-                                        lowerPath.includes('/interfaces') ||
-                                        lowerPath.includes('/lib/') ||
-                                        lowerPath.includes('/libraries') ||
-                                        lowerPath.includes('/library') ||
-                                        lowerPath.includes('/mock') ||
-                                        lowerName.includes('mock')) {
-                                        continue;
-                                    }
+                                const contractKind = await this.getContractKind(sourcePath, String(contractName));
+                                if (contractKind === 'interface' || contractKind === 'library') {
+                                    this.logDebug('Skipping non-contract artifact', { contractName, sourcePath, contractKind });
+                                    continue;
+                                }
+                                if (!isGeneratedMock && (lowerPath.includes('/mock') || lowerName.includes('mock'))) {
+                                    continue;
                                 }
                                 const relativeJson = path.relative(this.foundryRoot, filePath);
                                 let displayedPath = sourcePath;
@@ -427,7 +464,7 @@ class ReconGenerator {
         return config;
     }
     async run() {
-        var _a;
+        var _a, _b;
         await this.ensureFoundryConfigExists();
         const outPath = this.outDir();
         const mockTargets = (_a = this.options.mocks) !== null && _a !== void 0 ? _a : new Set();
@@ -471,7 +508,7 @@ class ReconGenerator {
             this.logDebug('No contracts left after include/exclude filters');
         }
         const reconConfig = await this.loadReconConfig(filteredContracts);
-        const tm = new templateManager_1.TemplateManager(this.foundryRoot, this.options.suiteDir, this.options.suiteNameSnake, this.options.suiteNamePascal);
+        const tm = new templateManager_1.TemplateManager(this.foundryRoot, this.options.suiteDir, this.options.suiteNameSnake, this.options.suiteNamePascal, (_b = this.options.dynamicDeploy) !== null && _b !== void 0 ? _b : new Set());
         await tm.generateTemplates(filteredContracts, reconConfig);
     }
     async listAvailable() {

package/dist/index.js

@@ -114,6 +114,7 @@ async function main() {
         .option('--admin <spec>', 'Mark functions as admin: e.g. "A:{foo(uint256),bar()},B:{baz(address)}"')
         .option('--name <suite>', 'Suite name; affects folder (recon-name) and Crytic artifacts')
         .option('--mock <names>', 'Comma-separated contract names to generate mocks for')
+        .option('--dynamic-deploy <names>', 'Comma-separated contract names to enable dynamic deploy lists')
         .option('--debug', 'Print debug info about filters and selection')
         .option('--list', 'List available contracts/functions (after filters) and exit')
         .option('--force', 'Replace existing generated suite output (under --output). Does not rebuild .recon/out.')
@@ -130,6 +131,9 @@ async function main() {
     const mockSet = opts.mock
         ? new Set(String(opts.mock).split(',').map((s) => s.trim()).filter(Boolean))
         : undefined;
+    const dynamicDeploySet = opts.dynamicDeploy
+        ? new Set(String(opts.dynamicDeploy).split(',').map((s) => s.trim()).filter(Boolean))
+        : undefined;
     const suiteRaw = opts.name ? String(opts.name).trim() : '';
     const suiteSnake = suiteRaw ? (0, case_1.snake)(suiteRaw) : '';
     const suitePascal = suiteRaw ? (0, case_1.pascal)(suiteRaw) : '';
@@ -154,6 +158,7 @@ async function main() {
         force: !!opts.force,
         forceBuild: !!opts.forceBuild,
         mocks: mockSet,
+        dynamicDeploy: dynamicDeploySet,
         suiteNameSnake: suiteSnake,
         suiteNamePascal: suitePascal,
     });

package/dist/templateManager.d.ts

@@ -4,7 +4,8 @@ export declare class TemplateManager {
     private suiteDir;
     private suiteNameSnake;
     private suiteNamePascal;
-    constructor(foundryRoot: string, suiteDir: string, suiteNameSnake: string, suiteNamePascal: string);
+    private dynamicDeploy;
+    constructor(foundryRoot: string, suiteDir: string, suiteNameSnake: string, suiteNamePascal: string, dynamicDeploy?: Set<string>);
     private skipList;
     private shouldGenerateFile;
     private updateTargetFile;

package/dist/templateManager.js

@@ -39,11 +39,12 @@ const fs = __importStar(require("fs/promises"));
 const templates = __importStar(require("./templates"));
 const types_1 = require("./types");
 class TemplateManager {
-    constructor(foundryRoot, suiteDir, suiteNameSnake, suiteNamePascal) {
+    constructor(foundryRoot, suiteDir, suiteNameSnake, suiteNamePascal, dynamicDeploy = new Set()) {
         this.foundryRoot = foundryRoot;
         this.suiteDir = suiteDir;
         this.suiteNameSnake = suiteNameSnake;
         this.suiteNamePascal = suiteNamePascal;
+        this.dynamicDeploy = dynamicDeploy;
     }
     skipList() {
         const suiteRel = path.relative(this.foundryRoot, this.suiteDir);
@@ -180,6 +181,10 @@ class TemplateManager {
     }
     async generateTemplates(contracts, reconConfig) {
         const { enabledContracts, adminFunctions, nonSeparatedFunctions, separatedByContract, allContractNames, } = this.collectFunctions(contracts, reconConfig);
+        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 }));
         const suiteRel = path.relative(this.foundryRoot, this.suiteDir);
         const suffix = this.suiteNameSnake ? `-${this.suiteNameSnake}` : '';
         const cryticTesterName = `CryticTester${this.suiteNamePascal}`;
@@ -193,10 +198,11 @@ class TemplateManager {
             [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: enabledContracts }),
+            [path.join(suiteRel, 'Setup.sol')]: templates.setupTemplate({ contracts: contractsForSetup }),
             [path.join(suiteRel, 'TargetFunctions.sol')]: templates.targetFunctionsTemplate({
                 functions: nonSeparatedFunctions,
                 contracts: allContractNames,
+                dynamicContracts,
             }),
             [path.join(suiteTargetsDir, 'AdminTargets.sol')]: templates.adminTargetsTemplate({ functions: adminFunctions }),
             [path.join(suiteTargetsDir, 'DoomsdayTargets.sol')]: templates.doomsdayTargetsTemplate({}),

package/dist/templates/handlebars-helpers.js

@@ -86,13 +86,22 @@ function registerHelpers(handlebars) {
                 : `tempValue${index}`};`)
                 .join("\n            ")
             : "";
+        const inputNames = abi.inputs.map((input, index) => {
+            if (input.name && input.name.trim() !== "") {
+                return input.name;
+            }
+            if (input.type === "tuple") {
+                return `empty${index}`;
+            }
+            return `arg${index}`;
+        });
         if (mode === types_1.Mode.NORMAL || mode === types_1.Mode.FAIL) {
             return `
     function ${contractName}_${abi.name}(${abi.inputs
-                .map((input) => `${conditionallyAddMemoryLocation(input.type, extractType(input))} ${input.name}`)
+                .map((input) => `${conditionallyAddMemoryLocation(input.type, extractType(input))} ${inputNames[abi.inputs.indexOf(input)]}`)
                 .join(", ")}) public ${modifiersStr}{
         ${contractName}.${abi.name}${valueStr}(${abi.inputs
-                .map((input) => input.name ? input.name : getDefaultValue(input.type))
+                .map((input, index) => inputNames[index] || getDefaultValue(input.type))
                 .join(", ")});${mode === 'fail'
                 ? `
         t(false, "${contractName}_${abi.name}");`
@@ -102,16 +111,16 @@ function registerHelpers(handlebars) {
         else {
             return `
     function ${contractName}_${abi.name}(${abi.inputs
-                .map((input) => `${conditionallyAddMemoryLocation(input.type, extractType(input))} ${input.name}`)
+                .map((input) => `${conditionallyAddMemoryLocation(input.type, extractType(input))} ${inputNames[abi.inputs.indexOf(input)]}`)
                 .join(", ")}) public ${modifiersStr}{
         ${hasOutputs ? `${outputs}
         try ${contractName}.${abi.name}${valueStr}(${abi.inputs
-                .map((input) => input.name ? input.name : getDefaultValue(input.type))
+                .map((input, index) => inputNames[index] || getDefaultValue(input.type))
                 .join(", ")}) returns (${returnTypes}) {
             ${assignValues}
         }`
                 : `try ${contractName}.${abi.name}(${abi.inputs
-                    .map((input) => input.name ? input.name : getDefaultValue(input.type))
+                    .map((input, index) => inputNames[index] || getDefaultValue(input.type))
                     .join(", ")}) {}`} catch {
           ${hasOutputs ? "  " : "  "}t(false, "${contractName}_${abi.name}");
       ${hasOutputs ? "  " : "  "}}

package/dist/templates/setup.js

@@ -29,6 +29,8 @@ import "{{this.path}}";
 abstract contract Setup is BaseSetup, ActorManager, AssetManager, Utils {
     {{#each contracts}}
     {{this.name}} {{camel this.name}};
+    {{#if this.isDynamic}}address[] {{camel this.name}}_s;
+    {{/if}}
     {{/each}}
     
     /// === Setup === ///
@@ -36,9 +38,22 @@ abstract contract Setup is BaseSetup, ActorManager, AssetManager, Utils {
     function setup() internal virtual override {
         {{#each contracts}}
         {{camel this.name}} = new {{this.name}}(); // TODO: Add parameters here
+        {{#if this.isDynamic}}
+        {{camel this.name}}_s.push(address({{camel this.name}}));
+        {{/if}}
         {{/each}}
     }
 
+    /// === Dynamic deploy helpers === ///
+    {{#each contracts}}
+    {{#if this.isDynamic}}
+    function _getRandom{{pascal this.name}}(uint8 index) internal view returns (address) {
+        return {{camel this.name}}_s[index % {{camel this.name}}_s.length];
+    }
+
+    {{/if}}
+    {{/each}}
+
     /// === MODIFIERS === ///
     /// Prank admin and actor
     

package/dist/templates/target-functions.js

@@ -22,6 +22,11 @@ import {Panic} from "@recon/Panic.sol";
 import { {{pascal this}}Targets } from "./targets/{{pascal this}}Targets.sol";
 {{/each}}
 
+// Dynamic deploy contract types
+{{#each dynamicContracts}}
+import "{{this.path}}";
+{{/each}}
+
 abstract contract TargetFunctions is
     {{#each contracts}}{{pascal this}}Targets{{#unless @last}},
     {{/unless}}{{/each}}
@@ -32,6 +37,14 @@ abstract contract TargetFunctions is
     /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///
 {{#each functions}}
 {{functionDefinition this}}
+{{/each}}
+
+    /// AUTO GENERATED DYNAMIC DEPLOY SWITCHES ///
+{{#each dynamicContracts}}
+    function switch{{pascal this.name}}(uint8 entropy) public {
+        {{camel this.name}} = {{this.name}}(_getRandom{{pascal this.name}}(entropy));
+    }
+
 {{/each}}
 }
 `, { noEscape: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recon-generate",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "CLI to scaffold Recon fuzzing suite inside Foundry projects",
   "main": "dist/index.js",
   "bin": {
@@ -18,9 +18,10 @@
     "package.json"
   ],
   "dependencies": {
+    "@solidity-parser/parser": "^0.20.2",
     "abi-to-mock": "^1.0.4",
     "case": "^1.6.3",
-    "commander": "^12.1.0",
+    "commander": "^14.0.2",
     "handlebars": "^4.7.8"
   },
   "devDependencies": {