recon-generate 0.0.2

package/dist/index.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+"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 });
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const case_1 = require("case");
+const generator_1 = require("./generator");
+const utils_1 = require("./utils");
+function parseFilter(input) {
+    if (!input)
+        return undefined;
+    const contractOnly = new Set();
+    const functions = new Map();
+    const splitTopLevel = (s) => {
+        const out = [];
+        let buf = '';
+        let depth = 0;
+        for (let i = 0; i < s.length; i++) {
+            const ch = s[i];
+            if (ch === '(')
+                depth++;
+            else if (ch === ')')
+                depth = Math.max(0, depth - 1);
+            if ((ch === ',' || ch === '|') && depth === 0) {
+                out.push(buf.trim());
+                buf = '';
+                continue;
+            }
+            buf += ch;
+        }
+        if (buf.trim())
+            out.push(buf.trim());
+        return out;
+    };
+    const addFn = (contract, fn) => {
+        const normalized = fn.replace(/^\{/, '').replace(/\}$/, '').trim();
+        if (!normalized)
+            return;
+        if (!functions.has(contract))
+            functions.set(contract, new Set());
+        functions.get(contract).add(normalized);
+    };
+    let currentContract;
+    for (const raw of splitTopLevel(String(input))) {
+        const token = raw.trim();
+        if (!token)
+            continue;
+        if (token.includes(':')) {
+            const [contractPart, fnPart] = token.split(':', 2);
+            const contract = contractPart.trim();
+            if (!contract)
+                continue;
+            currentContract = contract;
+            if (fnPart && fnPart.trim()) {
+                const pieces = splitTopLevel(fnPart);
+                for (const p of pieces)
+                    addFn(contract, p);
+            }
+            continue;
+        }
+        // Function token attached to last contract
+        if ((token.startsWith('{') || token.includes('(')) && currentContract) {
+            addFn(currentContract, token);
+            continue;
+        }
+        // Standalone contract
+        currentContract = token;
+        contractOnly.add(token);
+    }
+    return { contractOnly, functions };
+}
+async function main() {
+    const program = new commander_1.Command();
+    program
+        .name('recon-generate')
+        .description('Scaffold Recon fuzzing suite inside a Foundry project')
+        .option('-o, --output <path>', 'Custom output folder for tests (recon will be appended if missing)')
+        .option('-r, --recon <path>', 'Path to recon.json configuration')
+        .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 (recon-name) and Crytic artifacts')
+        .option('--mock <names>', 'Comma-separated contract names to generate mocks for')
+        .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 (under --output). Does not rebuild .recon/out.')
+        .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)')
+        .parse(process.argv);
+    const opts = program.opts();
+    const workspaceRoot = process.cwd();
+    const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
+    const foundryRoot = path.dirname(foundryConfig);
+    const includeFilter = parseFilter(opts.include);
+    const excludeFilter = parseFilter(opts.exclude);
+    const adminFilter = parseFilter(opts.admin);
+    const mockSet = opts.mock
+        ? new Set(String(opts.mock).split(',').map((s) => s.trim()).filter(Boolean))
+        : undefined;
+    const suiteRaw = opts.name ? String(opts.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) : await (0, utils_1.getTestFolder)(foundryRoot);
+    const baseOutPath = path.isAbsolute(baseOut) ? baseOut : path.join(foundryRoot, baseOut);
+    const suiteDir = path.join(baseOutPath, suiteFolderName);
+    const reconDefaultName = suiteSnake ? `recon-${suiteSnake}.json` : 'recon.json';
+    const reconPath = opts.recon
+        ? (path.isAbsolute(opts.recon) ? opts.recon : path.join(workspaceRoot, opts.recon))
+        : (await (0, utils_1.fileExists)(path.join(foundryRoot, reconDefaultName))
+            ? path.join(foundryRoot, reconDefaultName)
+            : path.join(foundryRoot, '.recon', reconDefaultName));
+    const generator = new generator_1.ReconGenerator(foundryRoot, {
+        suiteDir,
+        reconConfigPath: reconPath,
+        foundryConfigPath: foundryConfig,
+        include: includeFilter,
+        exclude: excludeFilter,
+        admin: adminFilter ? adminFilter.functions : undefined,
+        debug: !!opts.debug,
+        force: !!opts.force,
+        forceBuild: !!opts.forceBuild,
+        mocks: mockSet,
+        suiteNameSnake: suiteSnake,
+        suiteNamePascal: suitePascal,
+    });
+    if (opts.list) {
+        await generator.listAvailable();
+        return;
+    }
+    await generator.run();
+}
+main().catch(err => {
+    console.error('recon-generate failed:', err.message || err);
+    process.exit(1);
+});

package/dist/templateManager.d.ts

@@ -0,0 +1,14 @@
+import { ContractMetadata } from './types';
+export declare class TemplateManager {
+    private foundryRoot;
+    private suiteDir;
+    private suiteNameSnake;
+    private suiteNamePascal;
+    constructor(foundryRoot: string, suiteDir: string, suiteNameSnake: string, suiteNamePascal: string);
+    private skipList;
+    private shouldGenerateFile;
+    private updateTargetFile;
+    private collectFunctions;
+    private defaultFunctionsFromAbi;
+    generateTemplates(contracts: ContractMetadata[], reconConfig: Record<string, any>): Promise<void>;
+}

package/dist/templateManager.js

@@ -0,0 +1,236 @@
+"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.TemplateManager = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const templates = __importStar(require("./templates"));
+const types_1 = require("./types");
+class TemplateManager {
+    constructor(foundryRoot, suiteDir, suiteNameSnake, suiteNamePascal) {
+        this.foundryRoot = foundryRoot;
+        this.suiteDir = suiteDir;
+        this.suiteNameSnake = suiteNameSnake;
+        this.suiteNamePascal = suiteNamePascal;
+    }
+    skipList() {
+        const suiteRel = path.relative(this.foundryRoot, this.suiteDir);
+        const suffix = this.suiteNameSnake ? `-${this.suiteNameSnake}` : '';
+        const cryticTesterName = `CryticTester${this.suiteNamePascal}`;
+        const cryticToFoundryName = `CryticToFoundry${this.suiteNamePascal}`;
+        return [
+            `echidna${suffix}.yaml`,
+            `medusa${suffix}.json`,
+            `halmos${suffix}.toml`,
+            path.join(suiteRel, 'BeforeAfter.sol'),
+            path.join(suiteRel, `${cryticTesterName}.sol`),
+            path.join(suiteRel, `${cryticToFoundryName}.sol`),
+            path.join(suiteRel, 'Properties.sol'),
+            path.join(suiteRel, 'helpers/Utils.sol'),
+            path.join(suiteRel, 'helpers/Panic.sol'),
+            path.join(suiteRel, 'managers/ActorManager.sol'),
+            path.join(suiteRel, 'managers/AssetManager.sol'),
+            path.join(suiteRel, 'managers/utils/EnumerableSet.sol'),
+            path.join(suiteRel, 'mocks/MockERC20.sol'),
+            path.join(suiteRel, 'targets/DoomsdayTargets.sol'),
+            path.join(suiteRel, 'targets/ManagersTargets.sol'),
+        ];
+    }
+    async shouldGenerateFile(filePath) {
+        if (!this.skipList().includes(filePath)) {
+            return true;
+        }
+        try {
+            const targetPath = path.isAbsolute(filePath) ? filePath : path.join(this.foundryRoot, filePath);
+            await fs.access(targetPath);
+            return false;
+        }
+        catch {
+            return true;
+        }
+    }
+    async updateTargetFile(filepath, newContent) {
+        try {
+            const existingContent = await fs.readFile(filepath, 'utf8');
+            if (existingContent.includes('/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///')) {
+                const [beforeMarker, afterMarker] = existingContent.split('/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///');
+                const [, newAutoGenerated] = newContent.split('/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///');
+                return beforeMarker + '/// AUTO GENERATED TARGET FUNCTIONS - WARNING: DO NOT DELETE OR MODIFY THIS LINE ///' + newAutoGenerated;
+            }
+            return newContent;
+        }
+        catch {
+            return newContent;
+        }
+    }
+    collectFunctions(contracts, reconConfig) {
+        const enabledContracts = [];
+        const adminFunctions = [];
+        const otherFunctions = [];
+        const nonSeparatedFunctions = [];
+        const separatedByContract = {};
+        for (const contract of contracts) {
+            const cfg = reconConfig[contract.jsonPath] || { enabled: true, functions: [], separated: true };
+            if (cfg.enabled === false) {
+                continue;
+            }
+            enabledContracts.push(contract);
+            const separated = cfg.separated !== false;
+            const functionsConfig = Array.isArray(cfg.functions) ? cfg.functions : [];
+            const functionList = functionsConfig.length > 0 ? functionsConfig : this.defaultFunctionsFromAbi(contract);
+            for (const fnCfg of functionList) {
+                const fnName = fnCfg.signature.split('(')[0];
+                const fnAbi = contract.abi.find((item) => {
+                    if (item.type !== 'function' || item.name !== fnName) {
+                        return false;
+                    }
+                    const sig = `${item.name}(${item.inputs.map((i) => i.internalType && i.internalType.startsWith('struct ')
+                        ? i.internalType.replace(/^struct\s+/, '')
+                        : i.type).join(',')})`;
+                    return sig === fnCfg.signature;
+                });
+                if (!fnAbi) {
+                    continue;
+                }
+                const fnInfo = {
+                    contractName: contract.name,
+                    contractPath: contract.path,
+                    functionName: fnAbi.name,
+                    abi: fnAbi,
+                    actor: fnCfg.actor || types_1.Actor.ACTOR,
+                    mode: fnCfg.mode || types_1.Mode.NORMAL,
+                    separated,
+                };
+                if (fnCfg.actor === types_1.Actor.ADMIN) {
+                    adminFunctions.push(fnInfo);
+                }
+                else {
+                    otherFunctions.push(fnInfo);
+                    if (separated) {
+                        if (!separatedByContract[contract.name]) {
+                            separatedByContract[contract.name] = [];
+                        }
+                        separatedByContract[contract.name].push(fnInfo);
+                    }
+                    else {
+                        nonSeparatedFunctions.push(fnInfo);
+                    }
+                }
+            }
+        }
+        const allContractNames = [
+            'Admin',
+            'Doomsday',
+            'Managers',
+            ...Object.keys(separatedByContract)
+        ].sort();
+        return {
+            enabledContracts,
+            adminFunctions,
+            otherFunctions,
+            nonSeparatedFunctions,
+            separatedByContract,
+            allContractNames,
+        };
+    }
+    defaultFunctionsFromAbi(contract) {
+        var _a;
+        const functions = [];
+        for (const item of contract.abi) {
+            if (item.type === 'function' && !((_a = item.stateMutability) === null || _a === void 0 ? void 0 : _a.match(/^(view|pure)$/))) {
+                const sig = `${item.name}(${item.inputs.map((i) => i.internalType && i.internalType.startsWith('struct ')
+                    ? i.internalType.replace(/^struct\s+/, '')
+                    : i.type).join(',')})`;
+                functions.push({ signature: sig, actor: types_1.Actor.ACTOR, mode: types_1.Mode.NORMAL });
+            }
+        }
+        return functions;
+    }
+    async generateTemplates(contracts, reconConfig) {
+        const { enabledContracts, adminFunctions, nonSeparatedFunctions, separatedByContract, allContractNames, } = this.collectFunctions(contracts, reconConfig);
+        const suiteRel = path.relative(this.foundryRoot, this.suiteDir);
+        const suffix = this.suiteNameSnake ? `-${this.suiteNameSnake}` : '';
+        const cryticTesterName = `CryticTester${this.suiteNamePascal}`;
+        const cryticToFoundryName = `CryticToFoundry${this.suiteNamePascal}`;
+        const suiteTargetsDir = path.join(suiteRel, 'targets');
+        const files = {
+            [`echidna${suffix}.yaml`]: templates.echidnaConfigTemplate({ corpusDir: `echidna${suffix}` }),
+            [`medusa${suffix}.json`]: templates.medusaConfigTemplate({ cryticTesterName }),
+            [`halmos${suffix}.toml`]: templates.halmosConfigTemplate({ cryticToFoundryName }),
+            [path.join(suiteRel, 'BeforeAfter.sol')]: templates.beforeAfterTemplate({}),
+            [path.join(suiteRel, `${cryticTesterName}.sol`)]: templates.cryticTesterTemplate({ cryticTesterName, suiteNameSuffix: suffix }),
+            [path.join(suiteRel, `${cryticToFoundryName}.sol`)]: templates.cryticToFoundryTemplate({ cryticToFoundryName }),
+            [path.join(suiteRel, 'Properties.sol')]: templates.propertiesTemplate({}),
+            [path.join(suiteRel, 'Setup.sol')]: templates.setupTemplate({ contracts: enabledContracts }),
+            [path.join(suiteRel, 'TargetFunctions.sol')]: templates.targetFunctionsTemplate({
+                functions: nonSeparatedFunctions,
+                contracts: allContractNames,
+            }),
+            [path.join(suiteTargetsDir, 'AdminTargets.sol')]: templates.adminTargetsTemplate({ functions: adminFunctions }),
+            [path.join(suiteTargetsDir, 'DoomsdayTargets.sol')]: templates.doomsdayTargetsTemplate({}),
+            [path.join(suiteTargetsDir, 'ManagersTargets.sol')]: templates.managersTargetsTemplate({}),
+        };
+        for (const [contractName, functions] of Object.entries(separatedByContract)) {
+            const targetPath = path.join(suiteTargetsDir, `${contractName}Targets.sol`);
+            files[targetPath] = templates.targetsTemplate({
+                contractName,
+                path: functions.length > 0 ? functions[0].contractPath : '',
+                functions,
+            });
+        }
+        for (const [name, content] of Object.entries(files)) {
+            const outputPath = path.isAbsolute(name) ? name : path.join(this.foundryRoot, name);
+            if (!(await this.shouldGenerateFile(name))) {
+                continue;
+            }
+            await fs.mkdir(path.dirname(outputPath), { recursive: true });
+            if (name.endsWith('Setup.sol')) {
+                try {
+                    await fs.access(outputPath);
+                    continue; // do not overwrite user setup
+                }
+                catch { }
+            }
+            if (name.includes('targets/') && name.endsWith('Targets.sol')) {
+                const finalContent = await this.updateTargetFile(outputPath, content);
+                await fs.writeFile(outputPath, finalContent);
+            }
+            else {
+                await fs.writeFile(outputPath, content);
+            }
+        }
+    }
+}
+exports.TemplateManager = TemplateManager;

package/dist/templates/before-after.d.ts

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

package/dist/templates/before-after.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.beforeAfterTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.beforeAfterTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+import {Setup} from "./Setup.sol";
+
+// ghost variables for tracking state variable values before and after function calls
+abstract contract BeforeAfter is Setup {
+    struct Vars {
+        uint256 __ignore__;
+    }
+
+    Vars internal _before;
+    Vars internal _after;
+
+    modifier updateGhosts {
+        __before();
+        _;
+        __after();
+    }
+
+    function __before() internal {
+
+    }
+
+    function __after() internal {
+
+    }
+}`, { noEscape: true });

package/dist/templates/crytic-tester.d.ts

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

package/dist/templates/crytic-tester.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.cryticTesterTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.cryticTesterTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+import {CryticAsserts} from "@chimera/CryticAsserts.sol";
+
+import {TargetFunctions} from "./TargetFunctions.sol";
+
+// echidna . --contract {{cryticTesterName}} --config echidna{{#if suiteNameSuffix}}{{suiteNameSuffix}}{{/if}}.yaml --format text --workers 16 --test-limit 1000000
+// medusa fuzz
+contract {{cryticTesterName}} is TargetFunctions, CryticAsserts {
+    constructor() payable {
+        setup();
+    }
+}`, { noEscape: true });

package/dist/templates/crytic-to-foundry.d.ts

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

package/dist/templates/crytic-to-foundry.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cryticToFoundryTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.cryticToFoundryTemplate = handlebars_1.default.compile(`// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+import {FoundryAsserts} from "@chimera/FoundryAsserts.sol";
+
+import "forge-std/console2.sol";
+
+import {Test} from "forge-std/Test.sol";
+import {TargetFunctions} from "./TargetFunctions.sol";
+
+// forge test --match-contract CryticToFoundry -vv
+contract {{cryticToFoundryName}} is Test, TargetFunctions, FoundryAsserts {
+    function setUp() public {
+        setup();
+
+        targetContract(address(this));
+    }
+
+    // forge test --match-test test_crytic -vvv
+    function test_crytic() public {
+        // TODO: add failing property tests here for debugging
+    }
+}`, { noEscape: true });

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

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

package/dist/templates/echidna-config.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.echidnaConfigTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.echidnaConfigTemplate = handlebars_1.default.compile(`testMode: "assertion"
+prefix: "echidna_"
+coverage: true
+corpusDir: "{{corpusDir}}"
+balanceAddr: 0x1043561a8829300000
+balanceContract: 0x1043561a8829300000
+filterFunctions: []
+cryticArgs: ["--foundry-compile-all"]
+deployer: "0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38"
+contractAddr: "0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496"
+shrinkLimit: 100000`, { noEscape: true });

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

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

package/dist/templates/halmos-config.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.halmosConfigTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const handlebars_helpers_1 = require("./handlebars-helpers");
+(0, handlebars_helpers_1.registerHelpers)(handlebars_1.default);
+exports.halmosConfigTemplate = handlebars_1.default.compile(`[global]
+# match tests with the invariant_ prefix
+function = "(check|invariant)_"
+
+contract = "{{cryticToFoundryName}}"`, { noEscape: true });

package/dist/templates/handlebars-helpers.d.ts

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