recon-generate 0.0.20 → 0.0.22

package/dist/templateManager.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateManager = void 0;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs/promises"));
+const case_1 = require("case");
 const templates = __importStar(require("./templates"));
 const types_1 = require("./types");
 class TemplateManager {
@@ -209,7 +210,7 @@ class TemplateManager {
             [path.join(suiteTargetsDir, 'ManagersTargets.sol')]: templates.managersTargetsTemplate({}),
         };
         for (const [contractName, functions] of Object.entries(separatedByContract)) {
-            const targetPath = path.join(suiteTargetsDir, `${contractName}Targets.sol`);
+            const targetPath = path.join(suiteTargetsDir, `${(0, case_1.pascal)(contractName)}Targets.sol`);
             files[targetPath] = templates.targetsTemplate({
                 contractName,
                 path: functions.length > 0 ? functions[0].contractPath : '',

package/dist/templates/handlebars-helpers.js

@@ -9,6 +9,18 @@ function capitalizeFirstLetter(string) {
     }
     return string.charAt(0).toUpperCase() + string.slice(1);
 }
+/**
+ * Returns a safe instance name for a contract.
+ * If camelCase(name) equals the original name (e.g., "fB" -> "fB"),
+ * prefix with "_" to avoid type/variable name collision.
+ */
+function safeInstanceName(name) {
+    const camelName = (0, case_1.camel)(name);
+    if (camelName === name) {
+        return `_${camelName}`;
+    }
+    return camelName;
+}
 function getUsableInternalType(internalType) {
     if (internalType.split(" ").length > 1) {
         return internalType.split(" ")[1];
@@ -52,8 +64,12 @@ function registerHelpers(handlebars) {
     handlebars.registerHelper('pascal', function (str) {
         return (0, case_1.pascal)(str);
     });
+    handlebars.registerHelper('instanceName', function (str) {
+        return safeInstanceName(str);
+    });
     handlebars.registerHelper('functionDefinition', function ({ contractName, abi, actor, mode }) {
-        contractName = (0, case_1.camel)(contractName);
+        const funcPrefix = (0, case_1.camel)(contractName); // For function names: fB_method
+        const instanceVar = safeInstanceName(contractName); // For instance access: _fB.method
         let modifiers = [];
         if (abi.stateMutability === 'payable') {
             modifiers.push('payable');
@@ -97,32 +113,32 @@ function registerHelpers(handlebars) {
         });
         if (mode === types_1.Mode.NORMAL || mode === types_1.Mode.FAIL) {
             return `
-    function ${contractName}_${abi.name}(${abi.inputs
+    function ${funcPrefix}_${abi.name}(${abi.inputs
                 .map((input) => `${conditionallyAddMemoryLocation(input.type, extractType(input))} ${inputNames[abi.inputs.indexOf(input)]}`)
                 .join(", ")}) public ${modifiersStr}{
-        ${contractName}.${abi.name}${valueStr}(${abi.inputs
+        ${instanceVar}.${abi.name}${valueStr}(${abi.inputs
                 .map((input, index) => inputNames[index] || getDefaultValue(input.type))
                 .join(", ")});${mode === 'fail'
                 ? `
-        t(false, "${contractName}_${abi.name}");`
+        t(false, "${funcPrefix}_${abi.name}");`
                 : ""}
     }`;
         }
         else {
             return `
-    function ${contractName}_${abi.name}(${abi.inputs
+    function ${funcPrefix}_${abi.name}(${abi.inputs
                 .map((input) => `${conditionallyAddMemoryLocation(input.type, extractType(input))} ${inputNames[abi.inputs.indexOf(input)]}`)
                 .join(", ")}) public ${modifiersStr}{
         ${hasOutputs ? `${outputs}
-        try ${contractName}.${abi.name}${valueStr}(${abi.inputs
+        try ${instanceVar}.${abi.name}${valueStr}(${abi.inputs
                 .map((input, index) => inputNames[index] || getDefaultValue(input.type))
                 .join(", ")}) returns (${returnTypes}) {
             ${assignValues}
         }`
-                : `try ${contractName}.${abi.name}(${abi.inputs
+                : `try ${instanceVar}.${abi.name}(${abi.inputs
                     .map((input, index) => inputNames[index] || getDefaultValue(input.type))
                     .join(", ")}) {}`} catch {
-          ${hasOutputs ? "  " : "  "}t(false, "${contractName}_${abi.name}");
+          ${hasOutputs ? "  " : "  "}t(false, "${funcPrefix}_${abi.name}");
       ${hasOutputs ? "  " : "  "}}
     }`;
         }

package/dist/templates/setup.js

@@ -28,9 +28,9 @@ import "{{this.path}}";
 
 abstract contract Setup is BaseSetup, ActorManager, AssetManager, Utils {
 {{#each contracts}}
-    {{this.name}} {{camel this.name}};
+    {{this.name}} {{instanceName this.name}};
     {{#if this.isDynamic}}
-    address[] {{camel this.name}}_s;
+    address[] {{instanceName this.name}}_s;
     {{/if}}
 {{/each}}
     
@@ -38,9 +38,9 @@ abstract contract Setup is BaseSetup, ActorManager, AssetManager, Utils {
     /// This contains all calls to be performed in the tester constructor, both for Echidna and Foundry
     function setup() internal virtual override {
         {{#each contracts}}
-        {{camel this.name}} = new {{this.name}}(); // TODO: Add parameters here
+        {{instanceName this.name}} = new {{this.name}}(); // TODO: Add parameters here
         {{#if this.isDynamic}}
-        {{camel this.name}}_s.push(address({{camel this.name}}));
+        {{instanceName this.name}}_s.push(address({{instanceName this.name}}));
         {{/if}}
         {{/each}}
     }
@@ -49,7 +49,7 @@ abstract contract Setup is BaseSetup, ActorManager, AssetManager, Utils {
     {{#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];
+        return {{instanceName this.name}}_s[index % {{instanceName this.name}}_s.length];
     }
 
     {{/if}}

package/dist/templates/target-functions.js

@@ -42,7 +42,7 @@ abstract contract TargetFunctions is
     /// 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));
+        {{instanceName this.name}} = {{this.name}}(_getRandom{{pascal this.name}}(entropy));
     }
 
 {{/each}}

package/dist/templates/wake/handlebars_helpers.js

@@ -3,6 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerWakeHelpers = registerWakeHelpers;
 const case_1 = require("case");
 const types_1 = require("../../types"); // Keeping types for Actor/Mode
+/**
+ * Returns a safe instance name for a contract.
+ * If camelCase(name) equals the original name (e.g., "fB" -> "fB"),
+ * prefix with "_" to avoid type/variable name collision.
+ */
+function safeInstanceName(name) {
+    const camelName = (0, case_1.camel)(name);
+    if (camelName === name) {
+        return `_${camelName}`;
+    }
+    return camelName;
+}
 function registerWakeHelpers(handlebars) {
     handlebars.registerHelper('snake', function (str) {
         return (0, case_1.snake)(str);
@@ -13,6 +25,9 @@ function registerWakeHelpers(handlebars) {
     handlebars.registerHelper('pascal', function (str) {
         return (0, case_1.pascal)(str);
     });
+    handlebars.registerHelper('instanceName', function (str) {
+        return safeInstanceName(str);
+    });
     /**
      * Python default value based on type string.
      */
@@ -35,7 +50,7 @@ function registerWakeHelpers(handlebars) {
      * 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 instanceVar = safeInstanceName(contractName); // For instance access: self._fB.method
         const funcName = method.name;
         // Build parameter list
         const params = method.args.map((arg) => {
@@ -59,13 +74,13 @@ function registerWakeHelpers(handlebars) {
         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)`;
+        # self.${instanceVar}.${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)
+            self.${instanceVar}.${funcName}(${callArgsStr}from_=sender)
         except Exception:
             pass`;
         return `

package/dist/templates/wake/setup.js

@@ -23,7 +23,7 @@ class Setup(FuzzTest, ActorManager, AssetManager, Utils):
     admin: Account
     # Contracts
     {{#each contracts}}
-    {{camel name}}: {{name}}
+    {{instanceName name}}: {{name}}
     {{/each}}
 
     def setup(self):
@@ -40,7 +40,7 @@ class Setup(FuzzTest, ActorManager, AssetManager, Utils):
         {{#each contracts}}
         # Deploy {{name}}
         # Args: {{#each deploy_args}}{{name}}: {{type}}, {{/each}}
-        self.{{camel name}} = {{name}}.deploy(
+        self.{{instanceName name}} = {{name}}.deploy(
             {{#each deploy_args}}{{name}}={{pythonDefault type}}, {{/each}}
             from_=self.admin
         )

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

@@ -15,7 +15,7 @@ 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
+    # Assumes self.{{instanceName contract.name}} is available from Setup
 
 {{#each flows}}
 {{flowDefinition this}}

package/package.json

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