recon-generate 0.0.10 → 0.0.11

package/dist/wakeGenerator.js

@@ -0,0 +1,447 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WakeGenerator = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const wakeTemplates = __importStar(require("./templates/wake"));
+const case_1 = require("case");
+// Embed the Python introspection script
+const INSPECT_SCRIPT = `
+import inspect
+import json
+import sys
+import os
+from pathlib import Path
+import importlib.util
+
+# Ensure we can import from current directory
+sys.path.insert(0, os.getcwd())
+
+def format_annotation(annotation):
+    if annotation == inspect.Parameter.empty:
+        return "Any"
+    
+    # Get string representation
+    s = str(annotation)
+    
+    # Simplify Union and Optional for Wake generators
+    # We recursively flatten until we find a concrete type
+    # This prevents the TypeError: issubclass() arg 1 must be a class in Wake generators
+    import re
+    
+    def simplify(type_str):
+        while "Union" in type_str or "Optional" in type_str:
+            # Find the innermost Union[...] or Optional[...]
+            m = re.search(r"(Union|Optional)\[([^\[\]]+)\]", type_str)
+            if not m: break
+            content = m.group(2)
+            parts = [p.strip() for p in content.split(",")]
+            # Pick first non-None
+            best = parts[0]
+            for p in parts:
+                if p not in ("None", "NoneType"):
+                    best = p
+                    break
+            
+            # Special case: if Address or Account is present, use Address for Wake compatibility
+            if any("Address" in p or "Account" in p for p in parts):
+                best = "Address"
+                
+            type_str = type_str[:m.start()] + best + type_str[m.end():]
+        return type_str
+
+    s = simplify(s)
+    s = s.replace("typing.", "").replace("wake.testing.core.", "")
+    s = s.replace("<class '", "").replace("'>", "")
+    return s
+
+def inspect_pytypes():
+    contracts = []
+    mock_erc20 = None
+    target_dir = Path("pytypes")
+    
+    if not target_dir.exists():
+        return { "contracts": [], "mock_erc20_module": None }
+
+    for root, dirs, files in os.walk(target_dir):
+        for file in files:
+            if file.endswith(".py") and file != "__init__.py":
+                rel_path = Path(root) / file
+                module_path = str(rel_path).replace(os.sep, ".").replace(".py", "")
+                
+                try:
+                    module = importlib.import_module(module_path)
+                    
+                    for name, obj in inspect.getmembers(module):
+                        if inspect.isclass(obj) and hasattr(obj, "deploy") and obj.__module__ == module_path:
+                            # Check for MockERC20 globally
+                            if name == "MockERC20":
+                                mock_erc20 = module_path
+
+                            # STRICT FILTER: Only include contracts from src folder
+                            if not module_path.startswith("pytypes.src"):
+                                continue
+
+                            # Determine mutable functions from _abi
+                            mutable_functions = set()
+                            if hasattr(obj, "_abi"):
+                                try:
+                                    # _abi is dict: selector -> item
+                                    for item in obj._abi.values():
+                                        if item.get("type") == "function" and item.get("stateMutability") not in ["view", "pure"]:
+                                            mutable_functions.add(item.get("name"))
+                                except Exception:
+                                    pass
+                            
+                            contract_info = {
+                                "name": name,
+                                "module": module_path,
+                                "methods": [],
+                                "deploy_args": []
+                            }
+                            
+                            try:
+                                deploy_method = getattr(obj, "deploy")
+                                sig = inspect.signature(deploy_method)
+                                for param_name, param in sig.parameters.items():
+                                    if param_name in ["cls", "return_tx", "request_type", "chain", "from_", "value", "gas_limit", "gas_price", "max_fee_per_gas", "max_priority_fee_per_gas", "access_list", "type", "block", "confirmations", "to"]:
+                                        continue
+                                    
+                                    contract_info["deploy_args"].append({
+                                        "name": param_name,
+                                        "type": format_annotation(param.annotation),
+                                        "default": str(param.default) if param.default != inspect.Parameter.empty else None
+                                    })
+                            except Exception:
+                                pass
+
+                            for method_name, method in inspect.getmembers(obj):
+                                if method_name.startswith("_") or method_name in ["deploy", "address", "balance", "code", "chain"]:
+                                    continue
+                                
+                                if not inspect.isfunction(method):
+                                    continue
+
+                                # Filter: Must be mutable
+                                if method_name not in mutable_functions:
+                                    continue
+
+                                try:
+                                    sig = inspect.signature(method)
+                                    args = []
+                                    for param_name, param in sig.parameters.items():
+                                        if param_name == "self": continue
+                                        if param_name in ["from_", "value", "gas_limit", "gas_price", "max_fee_per_gas", "max_priority_fee_per_gas", "access_list", "type", "block", "confirmations", "return_tx", "request_type", "to"]:
+                                            continue
+                                        
+                                        args.append({
+                                            "name": param_name,
+                                            "type": format_annotation(param.annotation)
+                                        })
+                                    
+                                    contract_info["methods"].append({
+                                        "name": method_name,
+                                        "args": args
+                                    })
+                                except Exception:
+                                    continue
+
+                            contracts.append(contract_info)
+                except Exception as e:
+                    pass
+
+    return { "contracts": contracts, "mock_erc20_module": mock_erc20 }
+
+if __name__ == "__main__":
+    print(json.dumps(inspect_pytypes(), indent=2))
+`;
+class WakeGenerator {
+    constructor(foundryRoot, options) {
+        this.foundryRoot = foundryRoot;
+        this.options = options;
+    }
+    logDebug(message, obj) {
+        if (!this.options.debug)
+            return;
+        if (obj !== undefined) {
+            console.info(`[recon-generate wake] ${message}`, obj);
+        }
+        else {
+            console.info(`[recon-generate wake] ${message}`);
+        }
+    }
+    runCmd(cmd, cwd) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(cmd, { cwd, env: { ...process.env, PATH: (0, utils_1.getEnvPath)() } }, (err, stdout, stderr) => {
+                if (err) {
+                    reject(new Error(stderr || err.message));
+                }
+                else {
+                    resolve(stdout);
+                }
+            });
+        });
+    }
+    async ensureBuild() {
+        const outDir = path.join(this.foundryRoot, '.recon', 'out');
+        if (await (0, utils_1.fileExists)(outDir) && !this.options.forceBuild) {
+            return;
+        }
+        console.log('Building project...');
+        await fs.mkdir(path.join(this.foundryRoot, '.recon'), { recursive: true });
+        const skipPaths = [
+            'test',
+            'tests',
+            'script',
+            'scripts',
+            'contracts/test',
+            'contracts/tests',
+            'lib/**/test/**',
+            'lib/**/tests/**'
+        ];
+        const skipArg = skipPaths.map(p => `--skip ${p}`).join(' ');
+        const cmd = `forge build --build-info ${skipArg} --out .recon/out`.replace(/\s+/g, ' ').trim();
+        await this.runCmd(cmd, this.foundryRoot);
+    }
+    async runWakeUp() {
+        console.log('Running wake up to generate pytypes...');
+        try {
+            await this.runCmd('wake up', this.foundryRoot);
+            console.log('✓ pytypes generated');
+        }
+        catch (e) {
+            console.warn('⚠ wake up failed - ensure wake is installed and configured:', e);
+            throw e;
+        }
+    }
+    async copyBuiltins() {
+        const reconPytypesDir = path.join(this.foundryRoot, 'pytypes', 'recon');
+        await fs.mkdir(reconPytypesDir, { recursive: true });
+        // locate builtins directory relative to dist/
+        const candidates = [
+            path.resolve(__dirname, '..', 'src', 'templates', 'wake', 'builtins'),
+            path.resolve(__dirname, '../../src/templates/wake/builtins'),
+            path.resolve(__dirname, 'templates/wake/builtins')
+        ];
+        let builtinsDir;
+        for (const p of candidates) {
+            if (await (0, utils_1.fileExists)(p)) {
+                builtinsDir = p;
+                break;
+            }
+        }
+        if (!builtinsDir) {
+            console.warn("⚠ Could not find builtin templates directory. AssetManager might fail.");
+            console.warn("Checked paths:", candidates);
+            return;
+        }
+        await fs.writeFile(path.join(reconPytypesDir, '__init__.py'), '');
+        const files = await fs.readdir(builtinsDir);
+        for (const file of files) {
+            if (file.endsWith('.py')) {
+                const content = await fs.readFile(path.join(builtinsDir, file), 'utf8');
+                await fs.writeFile(path.join(reconPytypesDir, file), content);
+                console.log(`✓ Copied builtin ${file} to ${path.join(reconPytypesDir, file)}`);
+            }
+        }
+    }
+    async inspectPytypes() {
+        const tempScript = path.join(this.foundryRoot, '.recon', 'inspect_wake.py');
+        await fs.mkdir(path.dirname(tempScript), { recursive: true });
+        await fs.writeFile(tempScript, INSPECT_SCRIPT);
+        try {
+            const output = await this.runCmd(`python3 ${tempScript}`, this.foundryRoot);
+            return JSON.parse(output);
+        }
+        catch (e) {
+            // Fallback to python
+            try {
+                const output = await this.runCmd(`python ${tempScript}`, this.foundryRoot);
+                return JSON.parse(output);
+            }
+            catch (e2) {
+                throw new Error(`Failed to run introspection script: ${String(e2)}`);
+            }
+        }
+    }
+    matchesSignatureOrName(signature, set) {
+        if (!set || set.size === 0) {
+            return false;
+        }
+        const nameOnly = signature.split('(')[0];
+        if (set.has(signature) || set.has(nameOnly)) {
+            return true;
+        }
+        return false;
+    }
+    isContractAllowed(name) {
+        const { include, exclude } = this.options;
+        if (include && (include.contractOnly.size > 0 || include.functions.size > 0)) {
+            const inInclude = include.contractOnly.has(name) || include.functions.has(name);
+            if (!inInclude)
+                return false;
+        }
+        if (exclude && exclude.contractOnly.has(name)) {
+            return false;
+        }
+        return true;
+    }
+    isFunctionIncluded(contractName, method) {
+        const sig = `${method.name}(${method.args.map(a => a.type).join(',')})`;
+        const { include, exclude } = this.options;
+        if (include && include.functions.size > 0) {
+            const fnSet = include.functions.get(contractName);
+            if (fnSet) {
+                if (!this.matchesSignatureOrName(sig, fnSet)) {
+                    return false;
+                }
+            }
+        }
+        if (exclude && exclude.functions.size > 0) {
+            const fnSet = exclude.functions.get(contractName);
+            if (fnSet && this.matchesSignatureOrName(sig, fnSet)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async run() {
+        if (!this.options.force && await (0, utils_1.fileExists)(this.options.suiteDir)) {
+            throw new Error(`${this.options.suiteDir} exists. Use --force.`);
+        }
+        await this.ensureBuild();
+        try {
+            await this.runWakeUp();
+        }
+        catch (e) {
+            console.warn('Wake up warning (continuing):', e);
+        }
+        // Setup builtin mock
+        await this.copyBuiltins();
+        const introspection = await this.inspectPytypes();
+        const contracts = introspection.contracts;
+        this.logDebug('Discovered contracts from pytypes', contracts.map(c => c.name));
+        const filteredContracts = contracts.filter(c => this.isContractAllowed(c.name));
+        const contractFlows = new Map();
+        for (const contract of filteredContracts) {
+            const flows = [];
+            for (const method of contract.methods) {
+                if (this.isFunctionIncluded(contract.name, method)) {
+                    // Check admin
+                    const sig = `${method.name}(${method.args.map(a => a.type).join(',')})`;
+                    let actor = types_1.Actor.ACTOR;
+                    if (this.options.admin && this.options.admin.has(contract.name)) {
+                        const adminSet = this.options.admin.get(contract.name);
+                        if (this.matchesSignatureOrName(sig, adminSet)) {
+                            actor = types_1.Actor.ADMIN;
+                        }
+                    }
+                    flows.push({
+                        contractName: contract.name,
+                        method: method,
+                        actor: actor,
+                        mode: types_1.Mode.NORMAL
+                    });
+                }
+            }
+            if (flows.length > 0) {
+                contractFlows.set(contract.name, flows);
+            }
+        }
+        if (await (0, utils_1.fileExists)(this.options.suiteDir)) {
+            await fs.rm(this.options.suiteDir, { recursive: true, force: true });
+        }
+        await fs.mkdir(this.options.suiteDir, { recursive: true });
+        // Create directories
+        const helpersDir = path.join(this.options.suiteDir, 'helpers');
+        const targetsDir = path.join(this.options.suiteDir, 'targets');
+        await fs.mkdir(helpersDir, { recursive: true });
+        await fs.mkdir(targetsDir, { recursive: true });
+        // __init__.py files
+        await fs.writeFile(path.join(this.options.suiteDir, '__init__.py'), '');
+        await fs.writeFile(path.join(helpersDir, '__init__.py'), '');
+        await fs.writeFile(path.join(targetsDir, '__init__.py'), '');
+        // Helpers
+        await fs.writeFile(path.join(helpersDir, 'actor_manager.py'), wakeTemplates.actorManagerTemplate({}));
+        await fs.writeFile(path.join(helpersDir, 'asset_manager.py'), wakeTemplates.assetManagerTemplate({}));
+        await fs.writeFile(path.join(helpersDir, 'utils.py'), wakeTemplates.utilsTemplate({}));
+        // targets/managers_targets.py
+        await fs.writeFile(path.join(targetsDir, 'managers_targets.py'), wakeTemplates.managersTargetsTemplate({}));
+        // targets/{contract}_targets.py
+        for (const contract of filteredContracts) {
+            const flows = contractFlows.get(contract.name) || [];
+            // Even if no flows, we might want the class? Usually yes.
+            const content = wakeTemplates.contractTargetsTemplate({
+                contract,
+                flows
+            });
+            const filename = `${(0, case_1.snake)(contract.name)}_targets.py`;
+            await fs.writeFile(path.join(targetsDir, filename), content);
+        }
+        // setup.py
+        await fs.writeFile(path.join(this.options.suiteDir, 'setup.py'), wakeTemplates.setupTemplate({ contracts: filteredContracts }));
+        // target_functions.py
+        await fs.writeFile(path.join(this.options.suiteDir, 'target_functions.py'), wakeTemplates.targetFunctionsTemplate({ contracts: filteredContracts }));
+        // properties.py
+        await fs.writeFile(path.join(this.options.suiteDir, 'properties.py'), wakeTemplates.propertiesTemplate({}));
+        // before_after.py
+        await fs.writeFile(path.join(this.options.suiteDir, 'before_after.py'), wakeTemplates.beforeAfterTemplate({}));
+        // test_crytic.py
+        const testContent = wakeTemplates.cryticTesterTemplate({});
+        await fs.writeFile(path.join(this.options.suiteDir, 'test_crytic.py'), testContent);
+        console.log(`✓ Generated Wake suite at ${this.options.suiteDir}`);
+    }
+    async listAvailable() {
+        await this.ensureBuild();
+        await this.runWakeUp();
+        const introspection = await this.inspectPytypes();
+        const filtered = introspection.contracts.filter(c => this.isContractAllowed(c.name));
+        console.log('Available contracts/functions (Wake):');
+        for (const c of filtered) {
+            console.log(`- ${c.name} (${c.module})`);
+            for (const m of c.methods) {
+                const sig = `${m.name}(${m.args.map(a => a.type).join(',')})`;
+                if (this.isFunctionIncluded(c.name, m)) {
+                    console.log(`   • ${sig}`);
+                }
+            }
+        }
+    }
+}
+exports.WakeGenerator = WakeGenerator;

package/package.json

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