recon-generate 0.0.3 → 0.0.5

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;
 }

package/dist/generator.js

@@ -195,7 +195,7 @@ class ReconGenerator {
         return kind;
     }
     async findSourceContracts() {
-        var _a;
+        var _a, _b;
         const contracts = [];
         const outDir = this.outDir();
         try {
@@ -224,7 +224,12 @@ class ReconGenerator {
                                 const lowerName = String(contractName).toLowerCase();
                                 const isGeneratedMock = this.generatedMocks.has(String(contractName));
                                 const contractKind = await this.getContractKind(sourcePath, String(contractName));
-                                if (contractKind === 'interface' || contractKind === 'library') {
+                                // Check if contract is explicitly included or mocked - if so, don't filter by kind
+                                const isExplicitlyIncluded = this.options.include &&
+                                    (this.options.include.contractOnly.has(String(contractName)) ||
+                                        this.options.include.functions.has(String(contractName)));
+                                const isExplicitlyMocked = (_b = this.options.mocks) === null || _b === void 0 ? void 0 : _b.has(String(contractName));
+                                if ((contractKind === 'interface' || contractKind === 'library') && !isExplicitlyIncluded && !isExplicitlyMocked) {
                                     this.logDebug('Skipping non-contract artifact', { contractName, sourcePath, contractKind });
                                     continue;
                                 }
@@ -388,7 +393,10 @@ class ReconGenerator {
         if (!tempSrc) {
             return;
         }
-        const mocksDir = path.join(this.options.suiteDir, 'mocks');
+        const suiteDirAbs = path.isAbsolute(this.options.suiteDir)
+            ? this.options.suiteDir
+            : path.join(this.foundryRoot, this.options.suiteDir);
+        const mocksDir = path.join(suiteDirAbs, 'mocks');
         await fs.mkdir(mocksDir, { recursive: true });
         const tempFiles = await fs.readdir(tempSrc);
         for (const f of tempFiles) {
@@ -464,7 +472,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();
@@ -508,7 +516,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

@@ -39,6 +39,7 @@ const path = __importStar(require("path"));
 const case_1 = require("case");
 const generator_1 = require("./generator");
 const utils_1 = require("./utils");
+const link_1 = require("./link");
 function parseFilter(input) {
     if (!input)
         return undefined;
@@ -114,54 +115,92 @@ 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.')
         .option('--force-build', 'Delete .recon/out to force a fresh forge build before generating')
+        .option('--foundry-config <path>', 'Path to foundry.toml (defaults to ./foundry.toml)');
+    program
+        .command('link')
+        .description('Link library addresses into echidna/medusa configs via crytic-compile')
+        .option('--echidna-config <path>', 'Path to echidna yaml (defaults based on --name)')
+        .option('--medusa-config <path>', 'Path to medusa json (defaults based on --name)')
+        .option('--name <suite>', 'Suite name to pick config defaults (echidna-<name>.yaml / medusa-<name>.json)')
         .option('--foundry-config <path>', 'Path to foundry.toml (defaults to ./foundry.toml)')
-        .parse(process.argv);
-    const opts = program.opts();
-    const workspaceRoot = process.cwd();
-    const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
-    const foundryRoot = path.dirname(foundryConfig);
-    const includeFilter = parseFilter(opts.include);
-    const excludeFilter = parseFilter(opts.exclude);
-    const adminFilter = parseFilter(opts.admin);
-    const mockSet = opts.mock
-        ? new Set(String(opts.mock).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) : '';
-    const suiteFolderName = suiteSnake ? `recon-${suiteSnake}` : 'recon';
-    const baseOut = opts.output ? String(opts.output) : await (0, utils_1.getTestFolder)(foundryRoot);
-    const baseOutPath = path.isAbsolute(baseOut) ? baseOut : path.join(foundryRoot, baseOut);
-    const suiteDir = path.join(baseOutPath, suiteFolderName);
-    const reconDefaultName = suiteSnake ? `recon-${suiteSnake}.json` : 'recon.json';
-    const reconPath = opts.recon
-        ? (path.isAbsolute(opts.recon) ? opts.recon : path.join(workspaceRoot, opts.recon))
-        : (await (0, utils_1.fileExists)(path.join(foundryRoot, reconDefaultName))
-            ? path.join(foundryRoot, reconDefaultName)
-            : path.join(foundryRoot, '.recon', reconDefaultName));
-    const generator = new generator_1.ReconGenerator(foundryRoot, {
-        suiteDir,
-        reconConfigPath: reconPath,
-        foundryConfigPath: foundryConfig,
-        include: includeFilter,
-        exclude: excludeFilter,
-        admin: adminFilter ? adminFilter.functions : undefined,
-        debug: !!opts.debug,
-        force: !!opts.force,
-        forceBuild: !!opts.forceBuild,
-        mocks: mockSet,
-        suiteNameSnake: suiteSnake,
-        suiteNamePascal: suitePascal,
+        .action(async (opts) => {
+        const workspaceRoot = process.cwd();
+        const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
+        const foundryRoot = path.dirname(foundryConfig);
+        const suiteRaw = opts.name ? String(opts.name).trim() : '';
+        const suiteSnake = suiteRaw ? (0, case_1.snake)(suiteRaw) : '';
+        const suffix = suiteSnake ? `-${suiteSnake}` : '';
+        const echidnaDefault = `echidna${suffix}.yaml`;
+        const medusaDefault = `medusa${suffix}.json`;
+        const echidnaConfigOpt = opts.echidnaConfig || echidnaDefault;
+        const medusaConfigOpt = opts.medusaConfig || medusaDefault;
+        const echidnaConfigPath = path.isAbsolute(echidnaConfigOpt)
+            ? echidnaConfigOpt
+            : path.join(foundryRoot, echidnaConfigOpt);
+        const medusaConfigPath = path.isAbsolute(medusaConfigOpt)
+            ? medusaConfigOpt
+            : path.join(foundryRoot, medusaConfigOpt);
+        await (0, link_1.runLink)(foundryRoot, echidnaConfigPath, medusaConfigPath);
     });
-    if (opts.list) {
-        await generator.listAvailable();
-        return;
-    }
-    await generator.run();
+    program
+        .action(async (opts) => {
+        const workspaceRoot = process.cwd();
+        const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
+        const foundryRoot = path.dirname(foundryConfig);
+        const includeFilter = parseFilter(opts.include);
+        const excludeFilter = parseFilter(opts.exclude);
+        const adminFilter = parseFilter(opts.admin);
+        const mockSet = opts.mock
+            ? new Set(String(opts.mock).split(',').map((s) => s.trim()).filter(Boolean))
+            : undefined;
+        if (includeFilter && mockSet && mockSet.size > 0) {
+            for (const m of mockSet) {
+                includeFilter.contractOnly.add(`${m}Mock`);
+            }
+        }
+        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) : '';
+        const suiteFolderName = suiteSnake ? `recon-${suiteSnake}` : 'recon';
+        const baseOut = opts.output ? String(opts.output) : await (0, utils_1.getTestFolder)(foundryRoot);
+        const baseOutPath = path.isAbsolute(baseOut) ? baseOut : path.join(foundryRoot, baseOut);
+        const suiteDir = path.join(baseOutPath, suiteFolderName);
+        const reconDefaultName = suiteSnake ? `recon-${suiteSnake}.json` : 'recon.json';
+        const reconPath = opts.recon
+            ? (path.isAbsolute(opts.recon) ? opts.recon : path.join(workspaceRoot, opts.recon))
+            : (await (0, utils_1.fileExists)(path.join(foundryRoot, reconDefaultName))
+                ? path.join(foundryRoot, reconDefaultName)
+                : path.join(foundryRoot, '.recon', reconDefaultName));
+        const generator = new generator_1.ReconGenerator(foundryRoot, {
+            suiteDir,
+            reconConfigPath: reconPath,
+            foundryConfigPath: foundryConfig,
+            include: includeFilter,
+            exclude: excludeFilter,
+            admin: adminFilter ? adminFilter.functions : undefined,
+            debug: !!opts.debug,
+            force: !!opts.force,
+            forceBuild: !!opts.forceBuild,
+            mocks: mockSet,
+            dynamicDeploy: dynamicDeploySet,
+            suiteNameSnake: suiteSnake,
+            suiteNamePascal: suitePascal,
+        });
+        if (opts.list) {
+            await generator.listAvailable();
+            return;
+        }
+        await generator.run();
+    });
+    await program.parseAsync(process.argv);
 }
 main().catch(err => {
     console.error('recon-generate failed:', err.message || err);

package/dist/link.d.ts

@@ -0,0 +1 @@
+export declare function runLink(foundryRoot: string, echidnaConfigPath: string, medusaConfigPath: string): Promise<void>;

package/dist/link.js

@@ -0,0 +1,137 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLink = runLink;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const yaml_1 = __importDefault(require("yaml"));
+const utils_1 = require("./utils");
+const generateHexAddress = (index) => {
+    return `0xf${(index + 1).toString().padStart(2, '0')}`;
+};
+const parseLibrariesFromOutput = (output) => {
+    const usesPattern = /^\s+uses: \[(.*?)\]/gm;
+    const matches = [...(0, utils_1.stripAnsiCodes)(output).matchAll(usesPattern)];
+    const allLibraries = [];
+    for (const match of matches) {
+        if (match[1]) {
+            const libs = match[1]
+                .split(',')
+                .map(lib => lib.trim().replace(/["'\s]/g, ''))
+                .filter(lib => lib.length > 0);
+            for (const lib of libs) {
+                if (!allLibraries.includes(lib)) {
+                    allLibraries.push(lib);
+                }
+            }
+        }
+    }
+    return allLibraries;
+};
+const runCryticCompile = (cwd) => {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)('crytic-compile . --foundry-compile-all --print-libraries', { cwd, env: { ...process.env, PATH: (0, utils_1.getEnvPath)() } }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(stderr || error.message));
+                return;
+            }
+            resolve(stdout || '');
+        });
+    });
+};
+const formatEchidnaYaml = (config, libraries) => {
+    const cfg = { ...config };
+    delete cfg.cryticArgs;
+    delete cfg.deployContracts;
+    let out = yaml_1.default.stringify(cfg, { indent: 2 });
+    if (libraries.length === 0) {
+        out += 'cryticArgs: []\n';
+        out += 'deployContracts: []\n';
+        return out;
+    }
+    const libraryArgs = libraries.map((lib, index) => `(${lib},${generateHexAddress(index)})`).join(',');
+    out += `cryticArgs: ["--compile-libraries=${libraryArgs}","--foundry-compile-all"]\n`;
+    out += 'deployContracts:\n';
+    libraries.forEach((lib, index) => {
+        out += `  - ["${generateHexAddress(index)}", "${lib}"]\n`;
+    });
+    return out;
+};
+const updateEchidnaConfig = async (configPath, libraries) => {
+    const content = await fs.readFile(configPath, 'utf8');
+    const parsed = yaml_1.default.parse(content) || {};
+    const updated = formatEchidnaYaml(parsed, libraries);
+    await fs.writeFile(configPath, updated, 'utf8');
+};
+const updateMedusaConfig = async (configPath, libraries) => {
+    const content = await fs.readFile(configPath, 'utf8');
+    const parsed = JSON.parse(content);
+    if (!parsed.compilation)
+        parsed.compilation = {};
+    if (!parsed.compilation.platformConfig)
+        parsed.compilation.platformConfig = {};
+    if (libraries.length > 0) {
+        const libraryArgs = libraries.map((lib, index) => `(${lib},${generateHexAddress(index)})`).join(',');
+        parsed.compilation.platformConfig.args = ['--compile-libraries', libraryArgs, '--foundry-compile-all'];
+    }
+    else {
+        delete parsed.compilation.platformConfig.args;
+    }
+    await fs.writeFile(configPath, JSON.stringify(parsed, null, 2), 'utf8');
+};
+async function runLink(foundryRoot, echidnaConfigPath, medusaConfigPath) {
+    const output = await runCryticCompile(foundryRoot);
+    const libraries = parseLibrariesFromOutput(output);
+    console.log('Detected libraries:', libraries.length ? libraries.join(', ') : '(none)');
+    try {
+        await fs.access(echidnaConfigPath);
+        await updateEchidnaConfig(echidnaConfigPath, libraries);
+        console.log(`Updated echidna config at ${echidnaConfigPath}`);
+    }
+    catch (e) {
+        throw new Error(`Failed to update echidna config: ${e}`);
+    }
+    try {
+        await fs.access(medusaConfigPath);
+        await updateMedusaConfig(medusaConfigPath, libraries);
+        console.log(`Updated medusa config at ${medusaConfigPath}`);
+    }
+    catch (e) {
+        throw new Error(`Failed to update medusa config: ${e}`);
+    }
+}

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.3",
+  "version": "0.0.5",
   "description": "CLI to scaffold Recon fuzzing suite inside Foundry projects",
   "main": "dist/index.js",
   "bin": {
@@ -22,7 +22,8 @@
     "abi-to-mock": "^1.0.4",
     "case": "^1.6.3",
     "commander": "^14.0.2",
-    "handlebars": "^4.7.8"
+    "handlebars": "^4.7.8",
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@types/node": "^24.0.4",