recon-generate 0.0.2

package/dist/templates/handlebars-helpers.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerHelpers = registerHelpers;
+const case_1 = require("case");
+const types_1 = require("../types");
+function capitalizeFirstLetter(string) {
+    if (string.length === 0) {
+        return string;
+    }
+    return string.charAt(0).toUpperCase() + string.slice(1);
+}
+function getUsableInternalType(internalType) {
+    if (internalType.split(" ").length > 1) {
+        return internalType.split(" ")[1];
+    }
+    else {
+        return internalType;
+    }
+}
+function conditionallyAddMemoryLocation(type, internalType) {
+    if (type.indexOf("[") !== -1) {
+        if (internalType.startsWith("struct ") || internalType.startsWith("enum ") || internalType.startsWith("contract ")) {
+            const usable = getUsableInternalType(internalType);
+            return `${usable} memory`;
+        }
+        return `${type} memory`;
+    }
+    if (internalType.startsWith("struct ") || internalType.startsWith("enum ") || internalType.startsWith("contract ")) {
+        return `${getUsableInternalType(internalType)}${internalType.startsWith("struct ") ? " memory" : ""}`;
+    }
+    if (type === "bytes" || type === "string") {
+        return `${type} memory`;
+    }
+    return internalType || type;
+}
+function extractType(inputOrOutput) {
+    if (inputOrOutput.internalType) {
+        return inputOrOutput.internalType;
+    }
+    return inputOrOutput.type;
+}
+function registerHelpers(handlebars) {
+    handlebars.registerHelper('snake', function (str) {
+        return (0, case_1.snake)(str);
+    });
+    handlebars.registerHelper('scream', function (str) {
+        return (0, case_1.snake)(str).toUpperCase();
+    });
+    handlebars.registerHelper('camel', function (str) {
+        return (0, case_1.camel)(str);
+    });
+    handlebars.registerHelper('pascal', function (str) {
+        return (0, case_1.pascal)(str);
+    });
+    handlebars.registerHelper('functionDefinition', function ({ contractName, abi, actor, mode }) {
+        contractName = (0, case_1.camel)(contractName);
+        let modifiers = [];
+        if (abi.stateMutability === 'payable') {
+            modifiers.push('payable');
+        }
+        if (actor === types_1.Actor.ADMIN) {
+            modifiers.push('asAdmin');
+        }
+        else if (actor === types_1.Actor.ACTOR) {
+            modifiers.push('asActor');
+        }
+        const valueStr = abi.stateMutability === 'payable' ? '{value: msg.value}' : '';
+        const modifiersStr = modifiers.length ? modifiers.join(' ') + ' ' : '';
+        const hasOutputs = abi.outputs && abi.outputs.length > 0;
+        const outputs = abi.outputs && abi.outputs.length > 0
+            ? abi.outputs
+                .map((output, index) => `${conditionallyAddMemoryLocation(output.type, extractType(output))} ${output.name !== "" ? output.name : `value${index}`};`)
+                .join("\n        ")
+            : "";
+        const returnTypes = abi.outputs && abi.outputs.length > 0
+            ? abi.outputs
+                .map((output, index) => `${conditionallyAddMemoryLocation(output.type, extractType(output))} ${output.name !== ""
+                ? `temp${capitalizeFirstLetter(output.name)}`
+                : `tempValue${index}`}`)
+                .join(", ")
+            : "";
+        const assignValues = abi.outputs && abi.outputs.length > 0
+            ? abi.outputs
+                .map((output, index) => `${output.name !== "" ? output.name : `value${index}`} = ${output.name !== ""
+                ? `temp${capitalizeFirstLetter(output.name)}`
+                : `tempValue${index}`};`)
+                .join("\n            ")
+            : "";
+        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}`)
+                .join(", ")}) public ${modifiersStr}{
+        ${contractName}.${abi.name}${valueStr}(${abi.inputs
+                .map((input) => input.name ? input.name : getDefaultValue(input.type))
+                .join(", ")});${mode === 'fail'
+                ? `
+        t(false, "${contractName}_${abi.name}");`
+                : ""}
+    }`;
+        }
+        else {
+            return `
+    function ${contractName}_${abi.name}(${abi.inputs
+                .map((input) => `${conditionallyAddMemoryLocation(input.type, extractType(input))} ${input.name}`)
+                .join(", ")}) public ${modifiersStr}{
+        ${hasOutputs ? `${outputs}
+        try ${contractName}.${abi.name}${valueStr}(${abi.inputs
+                .map((input) => input.name ? input.name : getDefaultValue(input.type))
+                .join(", ")}) returns (${returnTypes}) {
+            ${assignValues}
+        }`
+                : `try ${contractName}.${abi.name}(${abi.inputs
+                    .map((input) => input.name ? input.name : getDefaultValue(input.type))
+                    .join(", ")}) {}`} catch {
+          ${hasOutputs ? "  " : "  "}t(false, "${contractName}_${abi.name}");
+      ${hasOutputs ? "  " : "  "}}
+    }`;
+        }
+    });
+}
+function getDefaultValue(type) {
+    if (type === "address") {
+        return "address(0)";
+    }
+    else if (type.startsWith("uint") || type.startsWith("int")) {
+        return "0";
+    }
+    else if (type === "bool") {
+        return "false";
+    }
+    else if (type === "string") {
+        return '""';
+    }
+    else if (type === "bytes") {
+        return 'bytes("")';
+    }
+    else if (type.startsWith("bytes")) {
+        return `${type}("")`;
+    }
+    return '"__HandleMe__"';
+}

package/dist/templates/index.d.ts

@@ -0,0 +1,14 @@
+import { echidnaConfigTemplate } from './echidna-config';
+import { halmosConfigTemplate } from './halmos-config';
+import { medusaConfigTemplate } from './medusa-config';
+import { beforeAfterTemplate } from './before-after';
+import { cryticTesterTemplate } from './crytic-tester';
+import { cryticToFoundryTemplate } from './crytic-to-foundry';
+import { propertiesTemplate } from './properties';
+import { setupTemplate } from './setup';
+import { targetFunctionsTemplate } from './target-functions';
+import { adminTargetsTemplate } from './targets/admin-targets';
+import { doomsdayTargetsTemplate } from './targets/doomsday-targets';
+import { managersTargetsTemplate } from './targets/managers-targets';
+import { targetsTemplate } from './targets/targets';
+export { echidnaConfigTemplate, halmosConfigTemplate, medusaConfigTemplate, beforeAfterTemplate, cryticTesterTemplate, cryticToFoundryTemplate, propertiesTemplate, setupTemplate, targetFunctionsTemplate, adminTargetsTemplate, doomsdayTargetsTemplate, managersTargetsTemplate, targetsTemplate, };

package/dist/templates/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetsTemplate = exports.managersTargetsTemplate = exports.doomsdayTargetsTemplate = exports.adminTargetsTemplate = exports.targetFunctionsTemplate = exports.setupTemplate = exports.propertiesTemplate = exports.cryticToFoundryTemplate = exports.cryticTesterTemplate = exports.beforeAfterTemplate = exports.medusaConfigTemplate = exports.halmosConfigTemplate = exports.echidnaConfigTemplate = void 0;
+const echidna_config_1 = require("./echidna-config");
+Object.defineProperty(exports, "echidnaConfigTemplate", { enumerable: true, get: function () { return echidna_config_1.echidnaConfigTemplate; } });
+const halmos_config_1 = require("./halmos-config");
+Object.defineProperty(exports, "halmosConfigTemplate", { enumerable: true, get: function () { return halmos_config_1.halmosConfigTemplate; } });
+const medusa_config_1 = require("./medusa-config");
+Object.defineProperty(exports, "medusaConfigTemplate", { enumerable: true, get: function () { return medusa_config_1.medusaConfigTemplate; } });
+const before_after_1 = require("./before-after");
+Object.defineProperty(exports, "beforeAfterTemplate", { enumerable: true, get: function () { return before_after_1.beforeAfterTemplate; } });
+const crytic_tester_1 = require("./crytic-tester");
+Object.defineProperty(exports, "cryticTesterTemplate", { enumerable: true, get: function () { return crytic_tester_1.cryticTesterTemplate; } });
+const crytic_to_foundry_1 = require("./crytic-to-foundry");
+Object.defineProperty(exports, "cryticToFoundryTemplate", { enumerable: true, get: function () { return crytic_to_foundry_1.cryticToFoundryTemplate; } });
+const properties_1 = require("./properties");
+Object.defineProperty(exports, "propertiesTemplate", { enumerable: true, get: function () { return properties_1.propertiesTemplate; } });
+const setup_1 = require("./setup");
+Object.defineProperty(exports, "setupTemplate", { enumerable: true, get: function () { return setup_1.setupTemplate; } });
+const target_functions_1 = require("./target-functions");
+Object.defineProperty(exports, "targetFunctionsTemplate", { enumerable: true, get: function () { return target_functions_1.targetFunctionsTemplate; } });
+const admin_targets_1 = require("./targets/admin-targets");
+Object.defineProperty(exports, "adminTargetsTemplate", { enumerable: true, get: function () { return admin_targets_1.adminTargetsTemplate; } });
+const doomsday_targets_1 = require("./targets/doomsday-targets");
+Object.defineProperty(exports, "doomsdayTargetsTemplate", { enumerable: true, get: function () { return doomsday_targets_1.doomsdayTargetsTemplate; } });
+const managers_targets_1 = require("./targets/managers-targets");
+Object.defineProperty(exports, "managersTargetsTemplate", { enumerable: true, get: function () { return managers_targets_1.managersTargetsTemplate; } });
+const targets_1 = require("./targets/targets");
+Object.defineProperty(exports, "targetsTemplate", { enumerable: true, get: function () { return targets_1.targetsTemplate; } });

package/dist/templates/medusa-config.d.ts

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

package/dist/templates/medusa-config.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.medusaConfigTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.medusaConfigTemplate = handlebars_1.default.compile(`{
+  "fuzzing": {
+    "workers": 16,
+    "workerResetLimit": 50,
+    "timeout": 0,
+    "testLimit": 0,
+    "callSequenceLength": 100,
+    "corpusDirectory": "medusa",
+    "coverageEnabled": true,
+    "deploymentOrder": [
+
+    ],
+    "targetContracts": [
+      "{{cryticTesterName}}"
+    ],
+    "targetContractsBalances": [
+      "0x27b46536c66c8e3000000"
+    ],
+    "predeployedContracts": {
+      "{{cryticTesterName}}": "0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496"
+    },
+    "constructorArgs": {},
+    "deployerAddress": "0xf5e4fFeB7d2183B61753AA4074d72E51873C1D0a",
+    "senderAddresses": [
+      "0x10000",
+      "0x20000",
+      "0x30000"
+    ],
+    "blockNumberDelayMax": 60480,
+    "blockTimestampDelayMax": 604800,
+    "blockGasLimit": 125000000,
+    "transactionGasLimit": 12500000,
+    "testing": {
+      "stopOnFailedTest": false,
+      "stopOnFailedContractMatching": false,
+      "stopOnNoTests": true,
+      "testAllContracts": false,
+      "traceAll": false,
+      "assertionTesting": {
+        "enabled": true,
+        "testViewMethods": true,
+        "panicCodeConfig": {
+          "failOnCompilerInsertedPanic": false,
+          "failOnAssertion": true,
+          "failOnArithmeticUnderflow": false,
+          "failOnDivideByZero": false,
+          "failOnEnumTypeConversionOutOfBounds": false,
+          "failOnIncorrectStorageAccess": false,
+          "failOnPopEmptyArray": false,
+          "failOnOutOfBoundsArrayAccess": false,
+          "failOnAllocateTooMuchMemory": false,
+          "failOnCallUninitializedVariable": false
+        }
+      },
+      "propertyTesting": {
+        "enabled": true,
+        "testPrefixes": [
+          "echidna_"
+        ]
+      },
+      "optimizationTesting": {
+        "enabled": false,
+        "testPrefixes": [
+          "optimize_"
+        ]
+      }
+    },
+    "chainConfig": {
+      "codeSizeCheckDisabled": true,
+      "cheatCodes": {
+        "cheatCodesEnabled": true,
+        "enableFFI": false
+      },
+      "skipAccountChecks": true,
+			"forkConfig": {
+				"forkModeEnabled": false,
+				"rpcUrl": "",
+				"rpcBlock": 1,
+				"poolSize": 20
+			}
+    }
+  },
+  "compilation": {
+    "platform": "crytic-compile",
+    "platformConfig": {
+      "target": ".",
+      "solcVersion": "",
+      "exportDirectory": "",
+      "args": [
+        "--foundry-compile-all"
+      ]
+    }
+  },
+  "slither": {
+		"useSlither": true,
+		"cachePath": "slither_results.json",
+		"args": []
+	},
+  "logging": {
+    "level": "info",
+    "logDirectory": ""
+  }
+}`, { noEscape: true });

package/dist/templates/properties.d.ts

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

package/dist/templates/properties.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.propertiesTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.propertiesTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+import {Asserts} from "@chimera/Asserts.sol";
+import {BeforeAfter} from "./BeforeAfter.sol";
+
+abstract contract Properties is BeforeAfter, Asserts {
+
+}`, { noEscape: true });

package/dist/templates/setup.d.ts

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

package/dist/templates/setup.js

@@ -0,0 +1,55 @@
+"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.registerHelpers)(handlebars_1.default);
+exports.setupTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+// Chimera deps
+import {BaseSetup} from "@chimera/BaseSetup.sol";
+import {vm} from "@chimera/Hevm.sol";
+
+// Managers
+import {ActorManager} from "@recon/ActorManager.sol";
+import {AssetManager} from "@recon/AssetManager.sol";
+
+// Helpers
+import {Utils} from "@recon/Utils.sol";
+
+// Your deps
+{{#each contracts}}
+import "{{this.path}}";
+{{/each}}
+
+abstract contract Setup is BaseSetup, ActorManager, AssetManager, Utils {
+    {{#each contracts}}
+    {{this.name}} {{camel this.name}};
+    {{/each}}
+    
+    /// === Setup === ///
+    /// 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
+        {{/each}}
+    }
+
+    /// === MODIFIERS === ///
+    /// Prank admin and actor
+    
+    modifier asAdmin {
+        vm.prank(address(this));
+        _;
+    }
+
+    modifier asActor {
+        vm.prank(address(_getActor()));
+        _;
+    }
+}
+`, { noEscape: true });

package/dist/templates/target-functions.d.ts

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

package/dist/templates/target-functions.js

@@ -0,0 +1,37 @@
+"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.registerHelpers)(handlebars_1.default);
+exports.targetFunctionsTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+// Chimera deps
+import {vm} from "@chimera/Hevm.sol";
+
+// Helpers
+import {Panic} from "@recon/Panic.sol";
+
+// Targets
+// NOTE: Always import and apply them in alphabetical order, so much easier to debug!
+{{#each contracts}}
+import { {{pascal this}}Targets } from "./targets/{{pascal this}}Targets.sol";
+{{/each}}
+
+abstract contract TargetFunctions is
+    {{#each contracts}}{{pascal this}}Targets{{#unless @last}},
+    {{/unless}}{{/each}}
+{
+    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///
+
+
+    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///
+{{#each functions}}
+{{functionDefinition this}}
+{{/each}}
+}
+`, { noEscape: true });

package/dist/templates/targets/admin-targets.d.ts

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

package/dist/templates/targets/admin-targets.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.adminTargetsTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("../handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.adminTargetsTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
+import {BeforeAfter} from "../BeforeAfter.sol";
+import {Properties} from "../Properties.sol";
+// Chimera deps
+import {vm} from "@chimera/Hevm.sol";
+
+// Helpers
+import {Panic} from "@recon/Panic.sol";
+
+abstract contract AdminTargets is
+    BaseTargetFunctions,
+    Properties
+{
+    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///
+
+
+    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///
+{{#each functions}}
+{{functionDefinition this}}
+{{/each}}
+}`, { noEscape: true });

package/dist/templates/targets/doomsday-targets.d.ts

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

package/dist/templates/targets/doomsday-targets.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.doomsdayTargetsTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("../handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.doomsdayTargetsTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
+import {BeforeAfter} from "../BeforeAfter.sol";
+import {Properties} from "../Properties.sol";
+// Chimera deps
+import {vm} from "@chimera/Hevm.sol";
+
+// Helpers
+import {Panic} from "@recon/Panic.sol";
+
+abstract contract DoomsdayTargets is
+    BaseTargetFunctions,
+    Properties
+{
+    /// Makes a handler have no side effects
+    /// The fuzzer will call this anyway, and because it reverts it will be removed from shrinking
+    /// Replace the "withGhosts" with "stateless" to make the code clean
+    modifier stateless() {
+        _;
+        revert("stateless");
+    }
+}`, { noEscape: true });

package/dist/templates/targets/managers-targets.d.ts

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

package/dist/templates/targets/managers-targets.js

@@ -0,0 +1,61 @@
+"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"));
+const handlebars_helpers_1 = require("../handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.managersTargetsTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
+import {BeforeAfter} from "../BeforeAfter.sol";
+import {Properties} from "../Properties.sol";
+import {vm} from "@chimera/Hevm.sol";
+
+import {MockERC20} from "@recon/MockERC20.sol";
+
+
+// Target functions that are effectively inherited from the Actor and AssetManagers
+// Once properly standardized, managers will expose these by default
+// Keeping them out makes your project more custom
+abstract contract ManagersTargets is
+    BaseTargetFunctions,
+    Properties
+{
+    // == ACTOR HANDLERS == //
+    
+    /// @dev Start acting as another actor
+    function switchActor(uint256 entropy) public {
+        _switchActor(entropy);
+    }
+
+
+    /// @dev Starts using a new asset
+    function switch_asset(uint256 entropy) public {
+        _switchAsset(entropy);
+    }
+
+    /// @dev Deploy a new token and add it to the list of assets, then set it as the current asset
+    function add_new_asset(uint8 decimals) public returns (address) {
+        address newAsset = _newAsset(decimals);
+        return newAsset;
+    }
+
+    /// === GHOST UPDATING HANDLERS ===///
+    /// We updateGhosts cause you never know (e.g. donations)
+    /// If you don't want to track donations, remove the updateGhosts
+
+    /// @dev Approve to arbitrary address, uses Actor by default
+    /// NOTE: You're almost always better off setting approvals in Setup
+    function asset_approve(address to, uint128 amt) public updateGhosts asActor {
+        MockERC20(_getAsset()).approve(to, amt);
+    }
+
+    /// @dev Mint to arbitrary address, uses owner by default, even though MockERC20 doesn't check
+    function asset_mint(address to, uint128 amt) public updateGhosts asAdmin {
+        MockERC20(_getAsset()).mint(to, amt);
+    }
+}`, { noEscape: true });

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

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

package/dist/templates/targets/targets.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetsTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("../handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.targetsTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
+import {BeforeAfter} from "../BeforeAfter.sol";
+import {Properties} from "../Properties.sol";
+// Chimera deps
+import {vm} from "@chimera/Hevm.sol";
+
+// Helpers
+import {Panic} from "@recon/Panic.sol";
+
+{{#if path}}import "{{path}}";{{/if}}
+
+abstract contract {{pascal contractName}}Targets is
+    BaseTargetFunctions,
+    Properties
+{
+    /// CUSTOM TARGET FUNCTIONS - Add your own target functions here ///
+
+
+    /// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///
+{{#each functions}}
+{{functionDefinition this}}
+{{/each}}
+}`, { noEscape: true });

package/dist/types.d.ts

@@ -0,0 +1,45 @@
+export declare enum Actor {
+    ACTOR = "actor",
+    ADMIN = "admin"
+}
+export declare enum Mode {
+    NORMAL = "normal",
+    FAIL = "fail",
+    CATCH = "catch"
+}
+export type ParamDefinition = {
+    name: string;
+    type: string;
+    internalType: string;
+    components?: ParamDefinition[];
+};
+export type Abi = {
+    type: string;
+    name?: string;
+    inputs: ParamDefinition[];
+    outputs: ParamDefinition[];
+    stateMutability?: string;
+};
+export type ContractMetadata = {
+    name: string;
+    jsonPath: string;
+    path: string;
+    abi: Abi[];
+    enabled: boolean;
+    functionConfigs?: FunctionConfig[];
+    separated?: boolean;
+};
+export type FunctionConfig = {
+    signature: string;
+    actor: Actor;
+    mode: Mode;
+};
+export interface FunctionDefinitionParams {
+    contractName: string;
+    contractPath: string;
+    functionName: string;
+    abi: Abi;
+    actor: Actor;
+    mode: Mode;
+    separated?: boolean;
+}

package/dist/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mode = exports.Actor = void 0;
+var Actor;
+(function (Actor) {
+    Actor["ACTOR"] = "actor";
+    Actor["ADMIN"] = "admin";
+})(Actor || (exports.Actor = Actor = {}));
+var Mode;
+(function (Mode) {
+    Mode["NORMAL"] = "normal";
+    Mode["FAIL"] = "fail";
+    Mode["CATCH"] = "catch";
+})(Mode || (exports.Mode = Mode = {}));