recon-generate 0.0.10 → 0.0.11

package/dist/templates/wake/helpers/actor_manager.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actorManagerTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+exports.actorManagerTemplate = handlebars_1.default.compile(`
+from typing import List, Optional
+from wake.testing import *
+
+class ActorManager:
+    _actors: List[Account]
+    _actor: Optional[Account]
+    
+    # Expected to be mixed in with a class having 'admin'
+    
+    def __init_actors__(self):
+        self._actors = []
+        self._actor = None
+
+    @property
+    def current_actor(self) -> Account:
+        return self._get_actor()
+
+    def _get_actor(self) -> Account:
+        if not self._actor:
+             # Fallback to admin if available in self (Setup/FuzzTest)
+             if hasattr(self, 'admin') and self.admin:
+                 return self.admin
+             from wake.testing import default_chain
+             return default_chain.accounts[0]
+        return self._actor
+
+    def _add_actor(self, actor: Account) -> None:
+        if actor not in self._actors:
+            self._actors.append(actor)
+        if not self._actor:
+            self._actor = actor
+
+    def _switch_actor(self, entropy: int) -> None:
+        if self._actors:
+            self._actor = self._actors[entropy % len(self._actors)]
+`);

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

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

package/dist/templates/wake/helpers/asset_manager.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assetManagerTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+exports.assetManagerTemplate = handlebars_1.default.compile(`
+from typing import List, Optional
+from wake.testing import *
+from pytypes.recon.MockERC20 import MockERC20
+
+class AssetManager:
+    _assets: List[Address]
+    _asset: Optional[Address]
+
+    def __init_assets__(self):
+        self._assets = []
+        self._asset = None
+
+    def _get_asset(self) -> Address:
+        if self._asset:
+            return self._asset
+        if self._assets:
+            return self._assets[0]
+        return Address(0)
+
+    def _new_asset(self, decimals: int) -> Address:
+        # Assuming admin is available via self.admin
+        if not hasattr(self, 'admin'):
+             from wake.testing import default_chain
+             admin = default_chain.accounts[0]
+        else:
+             admin = self.admin
+
+        token = MockERC20.deploy("Test Token", "TST", decimals, from_=admin)
+        self._assets.append(token.address)
+        self._asset = token.address
+        return token.address
+
+    def _switch_asset(self, entropy: int) -> None:
+        if self._assets:
+            self._asset = self._assets[entropy % len(self._assets)]
+`);

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

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

package/dist/templates/wake/helpers/utils.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utilsTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+exports.utilsTemplate = handlebars_1.default.compile(`
+class Utils:
+    pass
+`);

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

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

package/dist/templates/wake/helpers.js

@@ -0,0 +1,81 @@
+"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 "None";
+    }
+    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}
+        self.${contractVar}.${funcName}(${callArgsStr}from_=sender)`;
+        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/index.d.ts

@@ -0,0 +1,10 @@
+export * from './crytic_tester';
+export * from './setup';
+export * from './target_functions';
+export * from './properties';
+export * from './before_after';
+export * from './helpers/actor_manager';
+export * from './helpers/asset_manager';
+export * from './helpers/utils';
+export * from './targets/managers_targets';
+export * from './targets/contract_targets';

package/dist/templates/wake/index.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./crytic_tester"), exports);
+__exportStar(require("./setup"), exports);
+__exportStar(require("./target_functions"), exports);
+__exportStar(require("./properties"), exports);
+__exportStar(require("./before_after"), exports);
+__exportStar(require("./helpers/actor_manager"), exports);
+__exportStar(require("./helpers/asset_manager"), exports);
+__exportStar(require("./helpers/utils"), exports);
+__exportStar(require("./targets/managers_targets"), exports);
+__exportStar(require("./targets/contract_targets"), exports);

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

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

package/dist/templates/wake/invariants.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invariantsTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const helpers_1 = require("./helpers");
+(0, helpers_1.registerWakeHelpers)(handlebars_1.default);
+exports.invariantsTemplate = handlebars_1.default.compile(`
+from wake.testing import *
+from wake.testing.fuzzing import *
+
+class Invariants:
+    @invariant()
+    def invariant_placeholder(self) -> None:
+        """
+        Placeholder invariant - replace with your actual property checks.
+        """
+        pass
+`, { noEscape: true });

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

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

package/dist/templates/wake/properties.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.propertiesTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+exports.propertiesTemplate = handlebars_1.default.compile(`
+from wake.testing import *
+from wake.testing.fuzzing import *
+from .setup import Setup
+
+class Properties(Setup):
+    @invariant()
+    def check_invariants(self):
+        # Example invariant:
+        # assert self.complexVault.totalAssets() >= 0
+        pass
+`, { noEscape: true });

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

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

package/dist/templates/wake/setup.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars_helpers");
+(0, handlebars_helpers_1.registerWakeHelpers)(handlebars_1.default);
+exports.setupTemplate = handlebars_1.default.compile(`
+from typing import List, Optional, Union
+from .helpers.actor_manager import ActorManager
+from .helpers.asset_manager import AssetManager
+from .helpers.utils import Utils
+from wake.testing import *
+from wake.testing.fuzzing import FuzzTest
+# Import contracts for setup
+{{#each contracts}}
+from {{module}} import {{name}}
+{{/each}}
+
+class Setup(FuzzTest, ActorManager, AssetManager, Utils):
+    admin: Account
+    # Contracts
+    {{#each contracts}}
+    {{camel name}}: {{name}}
+    {{/each}}
+
+    def setup(self):
+        self.admin = default_chain.accounts[0]
+        self.__init_actors__() 
+        self.__init_assets__()
+        
+        self._add_actor(self.admin) 
+        # Add a few more actors for better fuzzing coverage
+        for i in range(1, 5):
+            self._add_actor(default_chain.accounts[i])
+        
+        # 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}}
+`, { noEscape: true });

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

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

package/dist/templates/wake/target_functions.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetFunctionsTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars_helpers");
+(0, handlebars_helpers_1.registerWakeHelpers)(handlebars_1.default);
+exports.targetFunctionsTemplate = handlebars_1.default.compile(`
+# imports
+{{#each contracts}}
+from .targets.{{snake name}}_targets import {{pascal name}}Targets
+{{/each}}
+from .targets.managers_targets import ManagersTargets
+
+class TargetFunctions(
+    ManagersTargets,
+    {{#each contracts}}
+    {{pascal name}}Targets,
+    {{/each}}
+):
+    pass
+`);

package/dist/templates/wake/targets/contract_targets.d.ts

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

package/dist/templates/wake/targets/contract_targets.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractTargetsTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("../handlebars_helpers");
+(0, handlebars_helpers_1.registerWakeHelpers)(handlebars_1.default);
+exports.contractTargetsTemplate = handlebars_1.default.compile(`
+from typing import List, Optional, Union
+from wake.testing import *
+from wake.testing.fuzzing import *
+from {{contract.module}} import {{contract.name}}
+from ..properties import Properties
+
+class {{pascal contract.name}}Targets(Properties):
+    # Assumes self.{{camel contract.name}} is available from Setup
+
+{{#each flows}}
+{{flowDefinition this}}
+{{/each}}
+`, { noEscape: true });

package/dist/templates/wake/targets/managers_targets.d.ts

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

package/dist/templates/wake/targets/managers_targets.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.managersTargetsTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+exports.managersTargetsTemplate = handlebars_1.default.compile(`
+from typing import List, Optional, Union
+from wake.testing import *
+from wake.testing.fuzzing import *
+from ..properties import Properties
+
+class ManagersTargets(Properties):
+    @flow()
+    def flow_switch_actor(self, entropy: uint256) -> None:
+        self._switch_actor(entropy)
+
+    @flow()
+    def flow_switch_asset(self, entropy: uint256) -> None:
+        self._switch_asset(entropy)
+        
+    @flow()
+    def flow_add_new_asset(self, decimals: uint8) -> None:
+        self._new_asset(decimals)
+`);

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

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

package/dist/templates/wake/test_fuzz.js

@@ -0,0 +1,27 @@
+"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 handlebars_helpers_1 = require("./handlebars_helpers");
+(0, handlebars_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 *
+
+from .setup import Setup
+from .target_functions import TargetFunctions
+from .properties import Properties
+from .before_after import BeforeAfter
+
+class {{pascal suiteName}}FuzzTest(FuzzTest, Setup, TargetFunctions, Properties, BeforeAfter):
+    def pre_sequence(self) -> None:
+        self.setup()
+
+def test_{{snake suiteName}}_fuzz():
+    {{pascal suiteName}}FuzzTest().run(sequences_count=10, flows_count=100)
+`);

package/dist/wakeGenerator.d.ts

@@ -0,0 +1,32 @@
+export type FilterSpec = {
+    contractOnly: Set<string>;
+    functions: Map<string, Set<string>>;
+};
+export interface WakeGeneratorOptions {
+    suiteDir: string;
+    foundryConfigPath: string;
+    include?: FilterSpec;
+    exclude?: FilterSpec;
+    debug?: boolean;
+    force?: boolean;
+    forceBuild?: boolean;
+    admin?: Map<string, Set<string>>;
+    suiteNameSnake: string;
+    suiteNamePascal: string;
+}
+export declare class WakeGenerator {
+    private foundryRoot;
+    private options;
+    constructor(foundryRoot: string, options: WakeGeneratorOptions);
+    private logDebug;
+    private runCmd;
+    private ensureBuild;
+    private runWakeUp;
+    private copyBuiltins;
+    private inspectPytypes;
+    private matchesSignatureOrName;
+    private isContractAllowed;
+    private isFunctionIncluded;
+    run(): Promise<void>;
+    listAvailable(): Promise<void>;
+}