recon-generate 0.0.10 → 0.0.11

package/dist/generator.d.ts

@@ -24,6 +24,7 @@ export declare class ReconGenerator {
     private generatedMocks;
     private allowedMockNames;
     private contractKindCache;
+    private abstractContractCache;
     constructor(foundryRoot: string, options: GeneratorOptions);
     private logDebug;
     private outDir;
@@ -37,6 +38,7 @@ export declare class ReconGenerator {
     private updateRemappings;
     private updateGitignore;
     private getContractKind;
+    private isAbstractContract;
     private findSourceContracts;
     private matchesSignatureOrName;
     private paramType;

package/dist/generator.js

@@ -54,6 +54,7 @@ class ReconGenerator {
         this.generatedMocks = new Set();
         this.allowedMockNames = new Set();
         this.contractKindCache = new Map();
+        this.abstractContractCache = new Map();
     }
     logDebug(message, obj) {
         if (!this.options.debug)
@@ -196,6 +197,53 @@ class ReconGenerator {
         this.contractKindCache.set(absPath, fileCache);
         return kind;
     }
+    async isAbstractContract(sourcePath, contractName) {
+        const absPath = path.isAbsolute(sourcePath) ? sourcePath : path.join(this.foundryRoot, sourcePath);
+        let fileCache = this.abstractContractCache.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 abstract contract', { sourcePath, error: String(e) });
+            return false;
+        }
+        let ast;
+        try {
+            ast = parser_1.default.parse(content, { tolerant: true });
+        }
+        catch (e) {
+            this.logDebug('Failed to parse source when determining abstract contract', { sourcePath, error: String(e) });
+            ast = null;
+        }
+        fileCache = fileCache !== null && fileCache !== void 0 ? fileCache : new Map();
+        let isAbstract = false;
+        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.abstract === true) {
+                        isAbstract = true;
+                    }
+                    break;
+                }
+            }
+        }
+        if (!isAbstract) {
+            // Fallback: text search for `abstract contract <Name>` to cover parser misses
+            const stripped = content.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
+            const pattern = new RegExp(`\\babstract\\s+contract\\s+${contractName}\\b`);
+            if (pattern.test(stripped)) {
+                isAbstract = true;
+            }
+        }
+        fileCache.set(contractName, isAbstract);
+        this.abstractContractCache.set(absPath, fileCache);
+        return isAbstract;
+    }
     async findSourceContracts() {
         var _a, _b;
         const contracts = [];
@@ -226,11 +274,34 @@ class ReconGenerator {
                                 const lowerName = String(contractName).toLowerCase();
                                 const isGeneratedMock = this.generatedMocks.has(String(contractName));
                                 const contractKind = await this.getContractKind(sourcePath, String(contractName));
+                                const isAbstract = await this.isAbstractContract(sourcePath, String(contractName));
+                                const absSourcePath = path.isAbsolute(sourcePath)
+                                    ? sourcePath
+                                    : path.join(this.foundryRoot, sourcePath);
+                                const relSourcePath = path.relative(this.foundryRoot, absSourcePath).replace(/\\/g, '/').toLowerCase();
+                                const skipPrefixes = [
+                                    'test/',
+                                    'tests/',
+                                    'script/',
+                                    'scripts/',
+                                    'contracts/test/',
+                                    'contracts/tests/',
+                                    'lib/',
+                                ];
                                 // 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));
+                                const inSkipDir = skipPrefixes.some(prefix => relSourcePath.startsWith(prefix));
+                                if (!isGeneratedMock && inSkipDir && !isExplicitlyIncluded && !isExplicitlyMocked) {
+                                    this.logDebug('Skipping artifact from non-source directory', { contractName, sourcePath });
+                                    continue;
+                                }
+                                if (isAbstract && !isExplicitlyIncluded && !isExplicitlyMocked) {
+                                    this.logDebug('Skipping abstract contract', { contractName, sourcePath });
+                                    continue;
+                                }
                                 if ((contractKind === 'interface' || contractKind === 'library') && !isExplicitlyIncluded && !isExplicitlyMocked) {
                                     this.logDebug('Skipping non-contract artifact', { contractName, sourcePath, contractKind });
                                     continue;

package/dist/index.js

@@ -38,6 +38,7 @@ const commander_1 = require("commander");
 const path = __importStar(require("path"));
 const case_1 = require("case");
 const generator_1 = require("./generator");
+const wakeGenerator_1 = require("./wakeGenerator");
 const coverage_1 = require("./coverage");
 const pathsGenerator_1 = require("./pathsGenerator");
 const utils_1 = require("./utils");
@@ -146,6 +147,8 @@ async function main() {
         .option('--crytic-name <name>', 'Name of the Crytic tester contract to compile', 'CryticTester')
         .option('--name <suite>', 'Suite name; affects paths filename (recon-<name>-paths.json)')
         .option('--foundry-config <path>', 'Path to foundry.toml (defaults to ./foundry.toml)')
+        .option('--dry-run', 'Do not enumerate paths; only report which functions/external calls would be processed')
+        .option('--max-paths <n>', 'Cap path enumeration per function to avoid OOM (default: 5000)')
         .action(async (opts, cmd) => {
         var _a;
         const workspaceRoot = process.cwd();
@@ -154,7 +157,11 @@ async function main() {
         const parentOpts = ((_a = cmd.parent) === null || _a === void 0 ? void 0 : _a.opts()) || {};
         const suiteRaw = opts.name || parentOpts.name ? String(opts.name || parentOpts.name).trim() : '';
         const suiteSnake = suiteRaw ? (0, case_1.snake)(suiteRaw) : '';
-        await (0, pathsGenerator_1.runPaths)(foundryRoot, opts.cryticName || 'CryticTester', suiteSnake);
+        const maxPaths = opts.maxPaths ? parseInt(String(opts.maxPaths), 10) : 5000;
+        await (0, pathsGenerator_1.runPaths)(foundryRoot, opts.cryticName || 'CryticTester', suiteSnake, {
+            dryRun: !!opts.dryRun,
+            maxPaths: Number.isFinite(maxPaths) && maxPaths > 0 ? maxPaths : undefined,
+        });
     });
     program
         .command('link')
@@ -185,6 +192,53 @@ async function main() {
             : path.join(foundryRoot, medusaConfigOpt);
         await (0, link_1.runLink)(foundryRoot, echidnaConfigPath, medusaConfigPath, !!opts.verbose);
     });
+    program
+        .command('wake')
+        .description('Generate Python fuzzing suite using Wake framework')
+        .option('--include <spec>', 'Include filter: e.g. "A,B:{foo(uint256)|bar(address)},C"')
+        .option('--exclude <spec>', 'Exclude filter: e.g. "A:{foo(uint256)},D" or just "B"')
+        .option('--admin <spec>', 'Mark functions as admin: e.g. "A:{foo(uint256),bar()},B:{baz(address)}"')
+        .option('--name <suite>', 'Suite name; affects folder (tests/recon-name)')
+        .option('-o, --output <path>', 'Custom output folder for tests')
+        .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')
+        .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)')
+        .action(async (opts, cmd) => {
+        var _a;
+        const workspaceRoot = process.cwd();
+        const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
+        const foundryRoot = path.dirname(foundryConfig);
+        const parentOpts = ((_a = cmd.parent) === null || _a === void 0 ? void 0 : _a.opts()) || {};
+        const includeFilter = parseFilter(opts.include);
+        const excludeFilter = parseFilter(opts.exclude);
+        const adminFilter = parseFilter(opts.admin);
+        const suiteRaw = opts.name || parentOpts.name ? String(opts.name || parentOpts.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) : 'tests';
+        const baseOutPath = path.isAbsolute(baseOut) ? baseOut : path.resolve(foundryRoot, baseOut);
+        const suiteDir = path.resolve(baseOutPath, suiteFolderName);
+        const generator = new wakeGenerator_1.WakeGenerator(foundryRoot, {
+            suiteDir,
+            foundryConfigPath: foundryConfig,
+            include: includeFilter,
+            exclude: excludeFilter,
+            admin: adminFilter ? adminFilter.functions : undefined,
+            debug: !!opts.debug || !!parentOpts.debug,
+            force: Boolean(opts.force || parentOpts.force),
+            forceBuild: !!opts.forceBuild || !!parentOpts.forceBuild,
+            suiteNameSnake: suiteSnake,
+            suiteNamePascal: suitePascal,
+        });
+        if (opts.list) {
+            await generator.listAvailable();
+            return;
+        }
+        await generator.run();
+    });
     program
         .action(async (opts) => {
         const workspaceRoot = process.cwd();

package/dist/pathsGenerator.d.ts

@@ -4,6 +4,10 @@
  * Generates minimal paths needed for 100% branch coverage.
  * Output is optimized for LLM consumption.
  */
+export interface RunPathsOptions {
+    dryRun?: boolean;
+    maxPaths?: number;
+}
 /** Simple output: function name -> array of path condition strings */
 export type PathOutput = Record<string, string[]>;
-export declare const runPaths: (foundryRoot: string, cryticName: string, suiteNameSnake?: string) => Promise<void>;
+export declare const runPaths: (foundryRoot: string, cryticName: string, suiteNameSnake?: string, options?: RunPathsOptions) => Promise<void>;

package/dist/pathsGenerator.js

@@ -103,7 +103,7 @@ const loadLatestSourceUnits = async (foundryRoot) => {
     return reader.read(filteredAstData);
 };
 // ==================== Main Entry ====================
-const runPaths = async (foundryRoot, cryticName, suiteNameSnake) => {
+const runPaths = async (foundryRoot, cryticName, suiteNameSnake, options = {}) => {
     const buildCmd = `forge build --contracts ${cryticName} --build-info --out .recon/out`.replace(/\s+/g, ' ').trim();
     await runCmd(buildCmd, foundryRoot);
     const sourceUnits = await loadLatestSourceUnits(foundryRoot);
@@ -123,6 +123,18 @@ const runPaths = async (foundryRoot, cryticName, suiteNameSnake) => {
     // Process each function
     const output = {};
     let totalPaths = 0;
+    if (options.dryRun) {
+        console.log(`[dry-run] Crytic contract: ${cryticName}`);
+        console.log(`[dry-run] Target functions (${targetFunctions.length}):`);
+        for (const func of targetFunctions) {
+            const externalCall = findExternalCall(func);
+            const extLabel = externalCall ? `${externalCall.contract}.${externalCall.function}` : 'none';
+            console.log(`  - ${func.name} -> external call: ${extLabel}`);
+        }
+        console.log('[dry-run] Skipping path enumeration.');
+        return;
+    }
+    const maxPaths = options.maxPaths && options.maxPaths > 0 ? options.maxPaths : undefined;
     for (const func of targetFunctions) {
         // Find external call
         const externalCall = findExternalCall(func);
@@ -145,8 +157,8 @@ const runPaths = async (foundryRoot, cryticName, suiteNameSnake) => {
         const callTree = (0, call_tree_builder_1.buildCallTree)(extFunc, [], undefined, undefined, context);
         // Build param mapping
         const paramMapping = buildParamMapping(func, externalCall);
-        // Enumerate paths
-        const enumerator = new PathEnumerator(sourceUnits, paramMapping);
+        // Enumerate paths with optional cap
+        const enumerator = new PathEnumerator(sourceUnits, paramMapping, maxPaths);
         const paths = enumerator.enumerate(callTree);
         if (paths.length === 0)
             continue;
@@ -157,11 +169,14 @@ const runPaths = async (foundryRoot, cryticName, suiteNameSnake) => {
             continue;
         output[func.name] = simplified;
         totalPaths += simplified.length;
+        if (enumerator.wasTruncated()) {
+            console.warn(`[recon-generate] Warning: Path enumeration for ${func.name} reached the max limit${maxPaths ? ` (${maxPaths})` : ''} and was truncated.`);
+        }
     }
     const pathsName = suiteNameSnake ? `recon-${suiteNameSnake}-paths.json` : 'recon-paths.json';
     const pathsFilePath = path.join(foundryRoot, pathsName);
     await fs.writeFile(pathsFilePath, JSON.stringify(output, null, 2));
-    console.log(`[recon-generate] Wrote paths file to ${pathsFilePath}`);
+    console.log(`[recon-generate] Wrote paths file to ${pathsFilePath} (total paths: ${totalPaths})`);
 };
 exports.runPaths = runPaths;
 // ==================== Source Helpers ====================
@@ -224,20 +239,26 @@ function buildParamMapping(func, extCall) {
 }
 // ==================== Path Enumeration ====================
 class PathEnumerator {
-    constructor(sourceUnits, paramMap) {
+    constructor(sourceUnits, paramMap, maxPaths) {
         this.pathIdCounter = 0;
         this.branchPoints = 0;
+        this.truncated = false;
         this.sourceUnits = sourceUnits;
         this.paramMap = new Map(paramMap);
+        this.maxPaths = maxPaths;
     }
     enumerate(callTree) {
         this.pathIdCounter = 0;
         this.branchPoints = 0;
+        this.truncated = false;
         const paths = this.processCallTree(callTree);
         return paths
             .filter(p => p.result === 'success')
             .map(p => ({ id: p.id, conditions: p.conditions, requires: p.requires, result: p.result }));
     }
+    wasTruncated() {
+        return this.truncated;
+    }
     processCallTree(node) {
         const def = node.definition;
         // Process children first (leaf to root)
@@ -252,8 +273,13 @@ class PathEnumerator {
             this.paramMap = savedMap;
         }
         // Process function body
+        const firstId = ++this.pathIdCounter;
+        if (this.maxPaths && firstId > this.maxPaths) {
+            this.truncated = true;
+            return [];
+        }
         let activePaths = [{
-                id: ++this.pathIdCounter,
+                id: firstId,
                 conditions: [],
                 requires: [],
                 terminated: false
@@ -336,8 +362,13 @@ class PathEnumerator {
             for (const clause of stmt.vClauses) {
                 if (clause.errorName === '') {
                     // Success clause (try block) - external call succeeds
+                    const nextId = ++this.pathIdCounter;
+                    if (this.maxPaths && nextId > this.maxPaths) {
+                        this.truncated = true;
+                        continue;
+                    }
                     const successPath = {
-                        id: ++this.pathIdCounter,
+                        id: nextId,
                         conditions: [...path.conditions, {
                                 original: callExpr,
                                 resolved: callExpr,
@@ -351,8 +382,13 @@ class PathEnumerator {
                 }
                 else {
                     // Catch clause - external call fails
+                    const nextCatchId = ++this.pathIdCounter;
+                    if (this.maxPaths && nextCatchId > this.maxPaths) {
+                        this.truncated = true;
+                        continue;
+                    }
                     const catchPath = {
-                        id: ++this.pathIdCounter,
+                        id: nextCatchId,
                         conditions: [...path.conditions, {
                                 original: callExpr,
                                 resolved: callExpr,
@@ -411,8 +447,13 @@ class PathEnumerator {
                 continue;
             }
             // True branch
+            const nextIdTrue = ++this.pathIdCounter;
+            if (this.maxPaths && nextIdTrue > this.maxPaths) {
+                this.truncated = true;
+                break;
+            }
             const truePath = {
-                id: ++this.pathIdCounter,
+                id: nextIdTrue,
                 conditions: [...path.conditions, { original: condOrig, resolved: condResolved, mustBeTrue: true }],
                 requires: [...path.requires],
                 terminated: false
@@ -427,8 +468,13 @@ class PathEnumerator {
                 results.push(truePath);
             }
             // False branch
+            const nextIdFalse = ++this.pathIdCounter;
+            if (this.maxPaths && nextIdFalse > this.maxPaths) {
+                this.truncated = true;
+                break;
+            }
             const falsePath = {
-                id: ++this.pathIdCounter,
+                id: nextIdFalse,
                 conditions: [...path.conditions, { original: condOrig, resolved: condResolved, mustBeTrue: false }],
                 requires: [...path.requires],
                 terminated: false
@@ -483,8 +529,13 @@ class PathEnumerator {
                         for (const cp of cPaths) {
                             if (cp.result === 'revert')
                                 continue;
+                            const nextId = ++this.pathIdCounter;
+                            if (this.maxPaths && nextId > this.maxPaths) {
+                                this.truncated = true;
+                                continue;
+                            }
                             merged.push({
-                                id: ++this.pathIdCounter,
+                                id: nextId,
                                 conditions: [...p.conditions, ...cp.conditions],
                                 requires: [...p.requires, ...cp.requires],
                                 terminated: false

package/dist/templates/setup.js

@@ -27,11 +27,12 @@ import "{{this.path}}";
 {{/each}}
 
 abstract contract Setup is BaseSetup, ActorManager, AssetManager, Utils {
-    {{#each contracts}}
+{{#each contracts}}
     {{this.name}} {{camel this.name}};
-    {{#if this.isDynamic}}address[] {{camel this.name}}_s;
+    {{#if this.isDynamic}}
+    address[] {{camel this.name}}_s;
     {{/if}}
-    {{/each}}
+{{/each}}
     
     /// === Setup === ///
     /// This contains all calls to be performed in the tester constructor, both for Echidna and Foundry

package/dist/templates/wake/before_after.d.ts

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

package/dist/templates/wake/before_after.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beforeAfterTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+exports.beforeAfterTemplate = handlebars_1.default.compile(`
+from wake.testing import *
+from wake.testing.fuzzing import *
+from .setup import Setup
+from dataclasses import dataclass
+
+@dataclass
+class Vars:
+    # Example ghost variables for tracking state
+    # total_assets: int = 0
+    pass
+
+class BeforeAfter(Setup):
+    _before: Vars
+    _after: Vars
+
+    def pre_flow(self, flow: Callable) -> None:
+        # Called before each flow
+        # self._before = Vars(total_assets=self.complexVault.totalAssets())
+        pass
+
+    def post_flow(self, flow: Callable) -> None:
+        # Called after each flow
+        # self._after = Vars(total_assets=self.complexVault.totalAssets())
+        pass
+`, { noEscape: true });

package/dist/templates/wake/conftest.d.ts

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

package/dist/templates/wake/conftest.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conftestTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars_helpers");
+(0, handlebars_helpers_1.registerWakeHelpers)(handlebars_1.default);
+exports.conftestTemplate = handlebars_1.default.compile(`import pytest
+from wake.testing import chain
+
+@pytest.fixture(scope="module", autouse=True)
+def chain_connection():
+    """Connect to a local chain for all tests in this module."""
+    with chain.connect():
+        yield
+`, { noEscape: true });

package/dist/templates/wake/crytic_tester.d.ts

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

package/dist/templates/wake/crytic_tester.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cryticTesterTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+exports.cryticTesterTemplate = handlebars_1.default.compile(`
+from wake.testing import *
+from wake.testing.fuzzing import FuzzTest, flow, invariant
+from .target_functions import TargetFunctions
+
+class TestCrytic(TargetFunctions):
+    def pre_sequence(self):
+        self.setup()
+
+@chain.connect()
+def test_recon_fuzz():
+    TestCrytic().run(sequences_count=30, flows_count=100)
+`);

package/dist/templates/wake/flows.d.ts

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

package/dist/templates/wake/flows.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flowsTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const helpers_1 = require("./helpers");
+(0, helpers_1.registerWakeHelpers)(handlebars_1.default);
+exports.flowsTemplate = handlebars_1.default.compile(`
+from wake.testing import *
+from wake.testing.fuzzing import *
+
+class Flows:
+{{#each flows}}
+{{flowDefinition this}}
+{{/each}}
+`, { noEscape: true });

package/dist/templates/wake/fuzz-test.d.ts

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

package/dist/templates/wake/fuzz-test.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fuzzTestTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const helpers_1 = require("./helpers");
+(0, helpers_1.registerWakeHelpers)(handlebars_1.default);
+exports.fuzzTestTemplate = handlebars_1.default.compile(`"""
+{{pascal suiteName}} Fuzz Test
+"""
+from wake.testing import *
+from wake.testing.fuzzing import *
+import random
+
+# Import pytypes
+{{#each contracts}}
+from {{module}} import {{name}}
+{{/each}}
+
+from .flows import Flows
+from .invariants import Invariants
+
+class {{pascal suiteName}}FuzzTest(FuzzTest, Flows, Invariants):
+    # Contract instances
+    {{#each contracts}}
+    {{camel name}}: {{name}}
+    {{/each}}
+    
+    # Actors
+    actors: list[Account]
+    admin: Account
+
+    def pre_sequence(self) -> None:
+        # Setup actors
+        self.admin = default_chain.accounts[0]
+        self.actors = [Account.new() for _ in range(3)]
+
+        # Deploy contracts
+        {{#each contracts}}
+        # Deploy {{name}}
+        # Args: {{#each deploy_args}}{{name}}: {{type}}, {{/each}}
+        self.{{camel name}} = {{name}}.deploy(
+            {{#each deploy_args}}{{name}}={{pythonDefault type}}, {{/each}}
+            from_=self.admin
+        )
+        {{/each}}
+
+
+    def _get_actor(self) -> Account:
+        return self.actors[0] if self.actors else self.admin
+
+    @flow()
+    def flow_switch_actor(self, entropy: uint8) -> None:
+        if self.actors:
+            idx = entropy % len(self.actors)
+            self.actors = self.actors[idx:] + self.actors[:idx]
+
+def test_{{snake suiteName}}_fuzz():
+    {{pascal suiteName}}FuzzTest().run(sequences_count=10, flows_count=100)
+`, { noEscape: true });

package/dist/templates/wake/handlebars_helpers.d.ts

@@ -0,0 +1,2 @@
+import Handlebars from "handlebars";
+export declare function registerWakeHelpers(handlebars: typeof Handlebars): void;

package/dist/templates/wake/handlebars_helpers.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWakeHelpers = registerWakeHelpers;
+const case_1 = require("case");
+const types_1 = require("../../types"); // Keeping types for Actor/Mode
+function registerWakeHelpers(handlebars) {
+    handlebars.registerHelper('snake', function (str) {
+        return (0, case_1.snake)(str);
+    });
+    handlebars.registerHelper('camel', function (str) {
+        return (0, case_1.camel)(str);
+    });
+    handlebars.registerHelper('pascal', function (str) {
+        return (0, case_1.pascal)(str);
+    });
+    /**
+     * Python default value based on type string.
+     */
+    function pythonDefault(type) {
+        if (type.includes("Address"))
+            return "Address(0)";
+        if (type.includes("int"))
+            return "0";
+        if (type === "bool")
+            return "False";
+        if (type.includes("bytes"))
+            return 'b""';
+        if (type.includes("list") || type.includes("List"))
+            return "[]";
+        return "()";
+    }
+    handlebars.registerHelper('pythonDefault', pythonDefault);
+    /**
+     * Generate a @flow decorated method definition for Wake FuzzTest.
+     * Expects: { contractName, method: { name, args: [{name, type}] }, actor, mode }
+     */
+    handlebars.registerHelper('flowDefinition', function ({ contractName, method, actor, mode }) {
+        const contractVar = (0, case_1.camel)(contractName);
+        const funcName = method.name;
+        // Build parameter list
+        const params = method.args.map((arg) => {
+            let typeStr = arg.type;
+            // Fix imported types if needed? Usually they are unqualified if imported, or fully qualified.
+            // Pytypes usually gives "ComplexVault.Status" or "Address".
+            return `${arg.name}: ${typeStr}`;
+        });
+        // Add self as first parameter
+        const paramStr = params.length > 0 ? `self, ${params.join(', ')}` : 'self';
+        // Determine sender based on actor type
+        let senderLine;
+        if (actor === types_1.Actor.ADMIN) {
+            senderLine = '        sender = default_chain.accounts[0]  # Admin';
+        }
+        else {
+            senderLine = '        sender = self._get_actor()';
+        }
+        // Build argument list for the contract call
+        const callArgs = method.args.map((arg) => arg.name);
+        const callArgsStr = callArgs.length > 0 ? `${callArgs.join(', ')}, ` : '';
+        // Handle different modes (using existing logic, though pytypes inspection doesn't perfectly enable this yet)
+        let methodBody = `${senderLine}
+        # self.${contractVar}.${funcName}(${callArgsStr}from_=sender)`;
+        // We wrap in try-except by default per "identical suite" robustness usually found in these tools
+        // But user said "user only need to fix the setup and add invariants" implies flows should work or fail?
+        // Let's assume standard basic call.
+        methodBody = `${senderLine}
+        try:
+            self.${contractVar}.${funcName}(${callArgsStr}from_=sender)
+        except Exception:
+            pass`;
+        return `
+    @flow()
+    def flow_${(0, case_1.snake)(contractName)}_${(0, case_1.snake)(funcName)}(${paramStr}) -> None:
+        """Call ${contractName}.${funcName}"""
+${methodBody}
+`;
+    });
+    handlebars.registerHelper('hasItems', function (arr, options) {
+        if (arr && arr.length > 0) {
+            return options.fn(this);
+        }
+        return options.inverse(this);
+    });
+}

package/dist/templates/wake/helpers/actor_manager.d.ts

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