@stacks/rendezvous 0.1.2

package/dist/invariant.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeClarityContext = exports.initializeLocalContext = exports.checkInvariants = void 0;
+const shared_1 = require("./shared");
+const transactions_1 = require("@stacks/transactions");
+const heatstroke_1 = require("./heatstroke");
+const fast_check_1 = __importDefault(require("fast-check"));
+const ansicolor_1 = require("ansicolor");
+const checkInvariants = (simnet, sutContractName, rendezvousList, rendezvousAllFunctions, seed, path, runs, radio) => {
+    // A map where the keys are the Rendezvous identifiers and the values are
+    // arrays of their SUT (System Under Test) functions. This map will be used
+    // to access the SUT functions for each Rendezvous contract afterwards.
+    const rendezvousSutFunctions = filterSutFunctions(rendezvousAllFunctions);
+    // A map where the keys are the Rendezvous identifiers and the values are
+    // arrays of their invariant functions. This map will be used to access the
+    // invariant functions for each Rendezvous contract afterwards.
+    const rendezvousInvariantFunctions = filterInvariantFunctions(rendezvousAllFunctions);
+    // Set up local context to track SUT function call counts.
+    const localContext = (0, exports.initializeLocalContext)(rendezvousSutFunctions);
+    // Set up context in simnet by initializing state for SUT.
+    (0, exports.initializeClarityContext)(simnet, rendezvousSutFunctions);
+    radio.emit("logMessage", `\nStarting invariant testing type for the ${sutContractName} contract...\n`);
+    const simnetAccounts = simnet.getAccounts();
+    const eligibleAccounts = new Map([...simnetAccounts].filter(([key]) => key !== "faucet"));
+    const simnetAddresses = Array.from(simnetAccounts.values());
+    // The Rendezvous identifier is the first one in the list. Only one contract
+    // can be fuzzed at a time.
+    const rendezvousContractId = rendezvousList[0];
+    const functions = (0, shared_1.getFunctionsListForContract)(rendezvousSutFunctions, rendezvousContractId);
+    const invariantFunctions = (0, shared_1.getFunctionsListForContract)(rendezvousInvariantFunctions, rendezvousContractId);
+    if ((functions === null || functions === void 0 ? void 0 : functions.length) === 0) {
+        radio.emit("logMessage", (0, ansicolor_1.red)(`No public functions found for the "${sutContractName}" contract. Without public functions, no state transitions can happen inside the contract, and the invariant test is not meaningful.\n`));
+        return;
+    }
+    if ((invariantFunctions === null || invariantFunctions === void 0 ? void 0 : invariantFunctions.length) === 0) {
+        radio.emit("logMessage", (0, ansicolor_1.red)(`No invariant functions found for the "${sutContractName}" contract. Beware, for your contract may be exposed to unforeseen issues.\n`));
+        return;
+    }
+    const eligibleFunctions = functions.filter((fn) => !(0, shared_1.isTraitReferenceFunction)(fn));
+    const eligibleInvariants = invariantFunctions.filter((fn) => !(0, shared_1.isTraitReferenceFunction)(fn));
+    if (eligibleFunctions.length === 0) {
+        radio.emit("logMessage", (0, ansicolor_1.red)(`No eligible public functions found for the "${sutContractName}" contract. Note: trait references are not supported.\n`));
+        return;
+    }
+    if (eligibleInvariants.length === 0) {
+        radio.emit("logMessage", (0, ansicolor_1.red)(`No eligible invariant functions found for the "${sutContractName}" contract. Note: trait references are not supported.\n`));
+        return;
+    }
+    const radioReporter = (runDetails) => {
+        (0, heatstroke_1.reporter)(runDetails, radio, "invariant");
+    };
+    fast_check_1.default.assert(fast_check_1.default.property(fast_check_1.default
+        .record({
+        // The target contract identifier. It is a constant value equal
+        // to the first contract in the list. The arbitrary is still needed,
+        // being used for reporting purposes in `heatstroke.ts`.
+        rendezvousContractId: fast_check_1.default.constant(rendezvousContractId),
+        sutCaller: fast_check_1.default.constantFrom(...eligibleAccounts.entries()),
+        invariantCaller: fast_check_1.default.constantFrom(...eligibleAccounts.entries()),
+        canMineBlocks: fast_check_1.default.boolean(),
+    })
+        .chain((r) => fast_check_1.default
+        .record({
+        selectedFunction: fast_check_1.default.constantFrom(...eligibleFunctions),
+        selectedInvariant: fast_check_1.default.constantFrom(...eligibleInvariants),
+    })
+        .map((selectedFunctions) => (Object.assign(Object.assign({}, r), selectedFunctions))))
+        .chain((r) => fast_check_1.default
+        .record({
+        functionArgsArb: fast_check_1.default.tuple(...(0, shared_1.functionToArbitrary)(r.selectedFunction, simnetAddresses)),
+        invariantArgsArb: fast_check_1.default.tuple(...(0, shared_1.functionToArbitrary)(r.selectedInvariant, simnetAddresses)),
+    })
+        .map((args) => (Object.assign(Object.assign({}, r), args))))
+        .chain((r) => fast_check_1.default
+        .record({
+        burnBlocks: r.canMineBlocks
+            ? // This arbitrary produces integers with a maximum value
+                // inversely proportional to the number of runs:
+                // - Fewer runs result in a higher maximum burn blocks,
+                //   allowing more blocks to be mined.
+                // - More runs result in a lower maximum burn blocks, as more
+                //   blocks are mined overall.
+                fast_check_1.default.integer({
+                    min: 1,
+                    max: Math.ceil(100000 / (runs || 100)),
+                })
+            : fast_check_1.default.constant(0),
+    })
+        .map((burnBlocks) => (Object.assign(Object.assign({}, r), burnBlocks)))), (r) => {
+        const selectedFunctionArgs = (0, shared_1.argsToCV)(r.selectedFunction, r.functionArgsArb);
+        const selectedInvariantArgs = (0, shared_1.argsToCV)(r.selectedInvariant, r.invariantArgsArb);
+        const printedFunctionArgs = r.functionArgsArb
+            .map((arg) => {
+            try {
+                return typeof arg === "object"
+                    ? JSON.stringify(arg)
+                    : arg.toString();
+            }
+            catch (_a) {
+                return "[Circular]";
+            }
+        })
+            .join(" ");
+        const [sutCallerWallet, sutCallerAddress] = r.sutCaller;
+        try {
+            const { result: functionCallResult } = simnet.callPublicFn(r.rendezvousContractId, r.selectedFunction.name, selectedFunctionArgs, sutCallerAddress);
+            const functionCallResultJson = (0, transactions_1.cvToJSON)(functionCallResult);
+            if (functionCallResultJson.success) {
+                localContext[r.rendezvousContractId][r.selectedFunction.name]++;
+                simnet.callPublicFn(r.rendezvousContractId, "update-context", [
+                    transactions_1.Cl.stringAscii(r.selectedFunction.name),
+                    transactions_1.Cl.uint(localContext[r.rendezvousContractId][r.selectedFunction.name]),
+                ], simnet.deployer);
+                radio.emit("logMessage", `₿ ${simnet.burnBlockHeight.toString().padStart(8)} ` +
+                    `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
+                    (0, ansicolor_1.dim)(`${sutCallerWallet}        `) +
+                    `${sutContractName} ` +
+                    `${(0, ansicolor_1.underline)(r.selectedFunction.name)} ` +
+                    printedFunctionArgs);
+            }
+            else {
+                radio.emit("logMessage", (0, ansicolor_1.dim)(`₿ ${simnet.burnBlockHeight.toString().padStart(8)} ` +
+                    `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
+                    `${sutCallerWallet}        ` +
+                    `${sutContractName} ` +
+                    `${(0, ansicolor_1.underline)(r.selectedFunction.name)} ` +
+                    printedFunctionArgs));
+            }
+        }
+        catch (error) {
+            // If the function call fails with a runtime error, log a dimmed
+            // message. Since the public function result is ignored, there's
+            // no need to throw an error.
+            radio.emit("logMessage", (0, ansicolor_1.dim)(`₿ ${simnet.burnBlockHeight.toString().padStart(8)} ` +
+                `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
+                `${sutCallerWallet}        ` +
+                `${sutContractName} ` +
+                `${(0, ansicolor_1.underline)(r.selectedFunction.name)} ` +
+                printedFunctionArgs));
+        }
+        const printedInvariantArgs = r.invariantArgsArb
+            .map((arg) => {
+            try {
+                return typeof arg === "object"
+                    ? JSON.stringify(arg)
+                    : arg.toString();
+            }
+            catch (_a) {
+                return "[Circular]";
+            }
+        })
+            .join(" ");
+        const [invariantCallerWallet, invariantCallerAddress] = r.invariantCaller;
+        try {
+            const { result: invariantCallResult } = simnet.callReadOnlyFn(r.rendezvousContractId, r.selectedInvariant.name, selectedInvariantArgs, invariantCallerAddress);
+            const invariantCallResultJson = (0, transactions_1.cvToJSON)(invariantCallResult);
+            if (invariantCallResultJson.value === true) {
+                radio.emit("logMessage", `₿ ${simnet.burnBlockHeight.toString().padStart(8)} ` +
+                    `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
+                    `${(0, ansicolor_1.dim)(invariantCallerWallet)} ` +
+                    `${(0, ansicolor_1.green)("[PASS]")} ` +
+                    `${sutContractName} ` +
+                    `${(0, ansicolor_1.underline)(r.selectedInvariant.name)} ` +
+                    printedInvariantArgs);
+            }
+            if (!invariantCallResultJson.value) {
+                throw new Error(`Invariant failed for ${sutContractName} contract: "${r.selectedInvariant.name}" returned ${invariantCallResultJson.value}`);
+            }
+        }
+        catch (error) {
+            // Handle both negative results from the invariant function and
+            // general runtime failures. Focus is on capturing the invariant
+            // function's result, including any runtime errors it caused.
+            radio.emit("logMessage", (0, ansicolor_1.red)(`₿ ${simnet.burnBlockHeight.toString().padStart(8)} ` +
+                `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
+                `${invariantCallerWallet} ` +
+                `[FAIL] ` +
+                `${sutContractName} ` +
+                `${(0, ansicolor_1.underline)(r.selectedInvariant.name)} ` +
+                printedInvariantArgs));
+            // Re-throw the error for fast-check to catch and process.
+            throw error;
+        }
+        if (r.canMineBlocks) {
+            simnet.mineEmptyBurnBlocks(r.burnBlocks);
+        }
+    }), {
+        verbose: true,
+        reporter: radioReporter,
+        seed: seed,
+        path: path,
+        numRuns: runs,
+    });
+};
+exports.checkInvariants = checkInvariants;
+/**
+ * Initialize the local context, setting the number of times each function
+ * has been called to zero.
+ * @param rendezvousSutFunctions The Rendezvous functions.
+ * @returns The initialized local context.
+ */
+const initializeLocalContext = (rendezvousSutFunctions) => Object.fromEntries(Array.from(rendezvousSutFunctions.entries()).map(([contractId, functions]) => [
+    contractId,
+    Object.fromEntries(functions.map((f) => [f.name, 0])),
+]));
+exports.initializeLocalContext = initializeLocalContext;
+const initializeClarityContext = (simnet, rendezvousSutFunctions) => rendezvousSutFunctions.forEach((fns, contractId) => {
+    fns.forEach((fn) => {
+        const { result: initialize } = simnet.callPublicFn(contractId, "update-context", [transactions_1.Cl.stringAscii(fn.name), transactions_1.Cl.uint(0)], simnet.deployer);
+        const jsonResult = (0, transactions_1.cvToJSON)(initialize);
+        if (!jsonResult.value || !jsonResult.success) {
+            throw new Error(`Failed to initialize the context for function: ${fn.name}.`);
+        }
+    });
+});
+exports.initializeClarityContext = initializeClarityContext;
+/**
+ * Filter the System Under Test (`SUT`) functions from the map of all
+ * contract functions.
+ *
+ * The SUT functions are the ones that have `public` access since they are
+ * capable of changing the contract state, and they are not test functions.
+ * @param allFunctionsMap The map containing all the functions for each
+ * contract.
+ * @returns A map containing only the SUT functions for each contract.
+ */
+const filterSutFunctions = (allFunctionsMap) => new Map(Array.from(allFunctionsMap, ([contractId, functions]) => [
+    contractId,
+    functions.filter((f) => f.access === "public" &&
+        f.name !== "update-context" &&
+        !f.name.startsWith("test-")),
+]));
+const filterInvariantFunctions = (allFunctionsMap) => new Map(Array.from(allFunctionsMap, ([contractId, functions]) => [
+    contractId,
+    functions.filter((f) => f.access === "read_only" && f.name.startsWith("invariant-")),
+]));

package/dist/invariant.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "@stacks/rendezvous",
+    "version": "0.1.2",
+    "description": "Meet your contract's vulnerabilities head-on.",
+    "main": "app.js",
+    "bin": {
+        "rv": "./dist/app.js"
+    },
+    "scripts": {
+        "postinstall": "npx -p typescript tsc --project tsconfig.json && node -e \"if (process.platform !== 'win32') require('fs').chmodSync('./dist/app.js', 0o755);\"",
+        "test": "npx tsc --project tsconfig.json && npx jest",
+        "test:coverage": "npx tsc --project tsconfig.json && npx jest --coverage"
+    },
+    "keywords": [
+        "stacks",
+        "clarity",
+        "fuzz",
+        "testing"
+    ],
+    "author": "Radu Bahmata, Nikos Baxevanis",
+    "license": "GPL-3.0-only",
+    "files": [
+        "dist/",
+        "package.json",
+        "README.md",
+        "LICENSE"
+    ],
+    "dependencies": {
+        "@hirosystems/clarinet-sdk": "2.12.0",
+        "@stacks/transactions": "^6.16.1",
+        "ansicolor": "^2.0.3",
+        "fast-check": "^3.20.0",
+        "yaml": "^2.6.1"
+    },
+    "devDependencies": {
+        "@hirosystems/clarinet-sdk-wasm": "2.12.0",
+        "@types/jest": "^29.5.12",
+        "jest": "^29.7.0",
+        "ts-jest": "^29.2.3",
+        "typescript": "^5.5.4"
+    }
+}

package/dist/property.js

@@ -0,0 +1,247 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReturnTypeBoolean = exports.isParamsMatch = exports.isTestDiscardedInPlace = exports.checkProperties = void 0;
+const fast_check_1 = __importDefault(require("fast-check"));
+const transactions_1 = require("@stacks/transactions");
+const heatstroke_1 = require("./heatstroke");
+const shared_1 = require("./shared");
+const ansicolor_1 = require("ansicolor");
+const checkProperties = (simnet, sutContractName, rendezvousList, rendezvousAllFunctions, seed, path, runs, radio) => {
+    // A map where the keys are the test contract identifiers and the values are
+    // arrays of their test functions. This map will be used to access the test
+    // functions for each test contract in the property-based testing routine.
+    const testContractsTestFunctions = filterTestFunctions(rendezvousAllFunctions);
+    radio.emit("logMessage", `\nStarting property testing type for the ${sutContractName} contract...\n`);
+    // Search for discard functions, for each test function. This map will
+    // be used to pair the test functions with their corresponding discard
+    // functions.
+    const testContractsDiscardFunctions = new Map(Array.from(rendezvousAllFunctions, ([contractId, functions]) => [
+        contractId,
+        functions.filter((f) => f.access === "read_only" && f.name.startsWith("can-")),
+    ]));
+    // Pair each test function with its corresponding discard function. When a
+    // test function is selected, Rendezvous will first call its discard
+    // function, to allow or prevent the property test from running.
+    const testContractsPairedFunctions = new Map(Array.from(testContractsTestFunctions, ([contractId, functions]) => [
+        contractId,
+        new Map(functions.map((f) => {
+            var _a;
+            const discardFunction = (_a = testContractsDiscardFunctions
+                .get(contractId)) === null || _a === void 0 ? void 0 : _a.find((pf) => pf.name === `can-${f.name}`);
+            return [f.name, discardFunction === null || discardFunction === void 0 ? void 0 : discardFunction.name];
+        })),
+    ]));
+    const hasDiscardFunctionErrors = Array.from(testContractsPairedFunctions).some(([contractId, pairedMap]) => Array.from(pairedMap).some(([testFunctionName, discardFunctionName]) => discardFunctionName
+        ? !validateDiscardFunction(contractId, discardFunctionName, testFunctionName, testContractsDiscardFunctions, testContractsTestFunctions, radio)
+        : false));
+    if (hasDiscardFunctionErrors) {
+        return;
+    }
+    const simnetAccounts = simnet.getAccounts();
+    const eligibleAccounts = new Map([...simnetAccounts].filter(([key]) => key !== "faucet"));
+    const simnetAddresses = Array.from(simnetAccounts.values());
+    const testContractId = rendezvousList[0];
+    const testFunctions = (0, shared_1.getFunctionsListForContract)(testContractsTestFunctions, testContractId);
+    if ((testFunctions === null || testFunctions === void 0 ? void 0 : testFunctions.length) === 0) {
+        radio.emit("logMessage", (0, ansicolor_1.red)(`No test functions found for the "${sutContractName}" contract.\n`));
+        return;
+    }
+    const eligibleTestFunctions = testFunctions.filter((fn) => !(0, shared_1.isTraitReferenceFunction)(fn));
+    if (eligibleTestFunctions.length === 0) {
+        radio.emit("logMessage", (0, ansicolor_1.red)(`No eligible test functions found for the "${sutContractName}" contract. Note: trait references are not supported.\n`));
+        return;
+    }
+    const radioReporter = (runDetails) => {
+        (0, heatstroke_1.reporter)(runDetails, radio, "test");
+    };
+    fast_check_1.default.assert(fast_check_1.default.property(fast_check_1.default
+        .record({
+        testContractId: fast_check_1.default.constant(testContractId),
+        testCaller: fast_check_1.default.constantFrom(...eligibleAccounts.entries()),
+        canMineBlocks: fast_check_1.default.boolean(),
+    })
+        .chain((r) => fast_check_1.default
+        .record({
+        selectedTestFunction: fast_check_1.default.constantFrom(...eligibleTestFunctions),
+    })
+        .map((selectedTestFunction) => (Object.assign(Object.assign({}, r), selectedTestFunction))))
+        .chain((r) => fast_check_1.default
+        .record({
+        functionArgsArb: fast_check_1.default.tuple(...(0, shared_1.functionToArbitrary)(r.selectedTestFunction, simnetAddresses)),
+    })
+        .map((args) => (Object.assign(Object.assign({}, r), args))))
+        .chain((r) => fast_check_1.default
+        .record({
+        burnBlocks: r.canMineBlocks
+            ? // This arbitrary produces integers with a maximum value
+                // inversely proportional to the number of runs:
+                // - Fewer runs result in a higher maximum burn blocks,
+                //   allowing more blocks to be mined.
+                // - More runs result in a lower maximum burn blocks, as more
+                //   blocks are mined overall.
+                fast_check_1.default.integer({
+                    min: 1,
+                    max: Math.ceil(100000 / (runs || 100)),
+                })
+            : fast_check_1.default.constant(0),
+    })
+        .map((burnBlocks) => (Object.assign(Object.assign({}, r), burnBlocks)))), (r) => {
+        const selectedTestFunctionArgs = (0, shared_1.argsToCV)(r.selectedTestFunction, r.functionArgsArb);
+        const printedTestFunctionArgs = r.functionArgsArb
+            .map((arg) => {
+            try {
+                return typeof arg === "object"
+                    ? JSON.stringify(arg)
+                    : arg.toString();
+            }
+            catch (_a) {
+                return "[Circular]";
+            }
+        })
+            .join(" ");
+        const [testCallerWallet, testCallerAddress] = r.testCaller;
+        const discardFunctionName = testContractsPairedFunctions
+            .get(r.testContractId)
+            .get(r.selectedTestFunction.name);
+        const discarded = isTestDiscarded(discardFunctionName, selectedTestFunctionArgs, r.testContractId, simnet, testCallerAddress);
+        if (discarded) {
+            radio.emit("logMessage", `₿ ${simnet.burnBlockHeight.toString().padStart(8)} ` +
+                `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
+                `${(0, ansicolor_1.dim)(testCallerWallet)} ` +
+                `${(0, ansicolor_1.yellow)("[WARN]")} ` +
+                `${sutContractName} ` +
+                `${(0, ansicolor_1.underline)(r.selectedTestFunction.name)} ` +
+                (0, ansicolor_1.dim)(printedTestFunctionArgs));
+        }
+        else {
+            try {
+                // If the function call results in a runtime error, the error will
+                // be caught and logged as a test failure in the catch block.
+                const { result: testFunctionCallResult } = simnet.callPublicFn(r.testContractId, r.selectedTestFunction.name, selectedTestFunctionArgs, testCallerAddress);
+                const testFunctionCallResultJson = (0, transactions_1.cvToJSON)(testFunctionCallResult);
+                const discardedInPlace = (0, exports.isTestDiscardedInPlace)(testFunctionCallResultJson);
+                if (discardedInPlace) {
+                    radio.emit("logMessage", `₿ ${simnet.burnBlockHeight.toString().padStart(8)} ` +
+                        `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
+                        `${(0, ansicolor_1.dim)(testCallerWallet)} ` +
+                        `${(0, ansicolor_1.yellow)("[WARN]")} ` +
+                        `${sutContractName} ` +
+                        `${(0, ansicolor_1.underline)(r.selectedTestFunction.name)} ` +
+                        (0, ansicolor_1.dim)(printedTestFunctionArgs));
+                }
+                else if (!discardedInPlace &&
+                    testFunctionCallResultJson.success &&
+                    testFunctionCallResultJson.value.value === true) {
+                    radio.emit("logMessage", `₿ ${simnet.burnBlockHeight.toString().padStart(8)} ` +
+                        `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
+                        `${(0, ansicolor_1.dim)(testCallerWallet)} ` +
+                        `${(0, ansicolor_1.green)("[PASS]")} ` +
+                        `${sutContractName} ` +
+                        `${(0, ansicolor_1.underline)(r.selectedTestFunction.name)} ` +
+                        printedTestFunctionArgs);
+                    if (r.canMineBlocks) {
+                        simnet.mineEmptyBurnBlocks(r.burnBlocks);
+                    }
+                }
+                else {
+                    throw new Error(`Test failed for ${sutContractName} contract: "${r.selectedTestFunction.name}" returned ${testFunctionCallResultJson.value.value}`);
+                }
+            }
+            catch (error) {
+                // Capture the error and log the test failure.
+                radio.emit("logMessage", (0, ansicolor_1.red)(`₿ ${simnet.burnBlockHeight.toString().padStart(8)} ` +
+                    `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
+                    `${testCallerWallet} ` +
+                    `[FAIL] ` +
+                    `${sutContractName} ` +
+                    `${(0, ansicolor_1.underline)(r.selectedTestFunction.name)} ` +
+                    printedTestFunctionArgs));
+                // Re-throw the error for fast-check to catch and process.
+                throw error;
+            }
+        }
+    }), {
+        verbose: true,
+        reporter: radioReporter,
+        seed: seed,
+        path: path,
+        numRuns: runs,
+    });
+};
+exports.checkProperties = checkProperties;
+const filterTestFunctions = (allFunctionsMap) => new Map(Array.from(allFunctionsMap, ([contractId, functions]) => [
+    contractId,
+    functions.filter((f) => f.access === "public" && f.name.startsWith("test-")),
+]));
+const isTestDiscardedInPlace = (testFunctionCallResultJson) => testFunctionCallResultJson.success === true &&
+    testFunctionCallResultJson.value.value === false;
+exports.isTestDiscardedInPlace = isTestDiscardedInPlace;
+/**
+ * Check if the test function has to be discarded.
+ * @param discardFunctionName The discard function name.
+ * @param selectedTestFunctionArgs The generated test function arguments.
+ * @param contractId The contract identifier.
+ * @param simnet The simnet instance.
+ * @param selectedCaller The selected caller.
+ * @returns A boolean indicating if the test function has to be discarded.
+ */
+const isTestDiscarded = (discardFunctionName, selectedTestFunctionArgs, contractId, simnet, selectedCaller) => {
+    if (!discardFunctionName)
+        return false;
+    const { result: discardFunctionCallResult } = simnet.callReadOnlyFn(contractId, discardFunctionName, selectedTestFunctionArgs, selectedCaller);
+    const jsonDiscardFunctionCallResult = (0, transactions_1.cvToJSON)(discardFunctionCallResult);
+    return jsonDiscardFunctionCallResult.value === false;
+};
+/**
+ * Validate the discard function, ensuring that its parameters match the test
+ * function's parameters and that its return type is boolean.
+ * @param contractId The contract identifier.
+ * @param discardFunctionName The discard function name.
+ * @param testFunctionName The test function name.
+ * @param testContractsDiscardFunctions The discard functions map.
+ * @param testContractsTestFunctions The test functions map.
+ * @param radio The radio event emitter.
+ * @returns A boolean indicating if the discard function passes the checks.
+ */
+const validateDiscardFunction = (contractId, discardFunctionName, testFunctionName, testContractsDiscardFunctions, testContractsTestFunctions, radio) => {
+    var _a, _b;
+    const testFunction = (_a = testContractsTestFunctions
+        .get(contractId)) === null || _a === void 0 ? void 0 : _a.find((f) => f.name === testFunctionName);
+    const discardFunction = (_b = testContractsDiscardFunctions
+        .get(contractId)) === null || _b === void 0 ? void 0 : _b.find((f) => f.name === discardFunctionName);
+    if (!testFunction || !discardFunction)
+        return false;
+    if (!(0, exports.isParamsMatch)(testFunction, discardFunction)) {
+        radio.emit("logMessage", (0, ansicolor_1.red)(`\nError: Parameter mismatch for discard function "${discardFunctionName}" in contract "${(0, shared_1.getContractNameFromContractId)(contractId)}".\n`));
+        return false;
+    }
+    if (!(0, exports.isReturnTypeBoolean)(discardFunction)) {
+        radio.emit("logMessage", (0, ansicolor_1.red)(`\nError: Return type must be boolean for discard function "${discardFunctionName}" in contract "${(0, shared_1.getContractNameFromContractId)(contractId)}".\n`));
+        return false;
+    }
+    return true;
+};
+/**
+ * Verify if the test function parameters match the discard function
+ * parameters.
+ * @param testFunction The test function's interface.
+ * @param discardFunction The discard function's interface.
+ * @returns A boolean indicating if the parameters match.
+ */
+const isParamsMatch = (testFunction, discardFunction) => {
+    const sortedTestFunctionArgs = [...testFunction.args].sort((a, b) => a.name.localeCompare(b.name));
+    const sortedDiscardFunctionArgs = [...discardFunction.args].sort((a, b) => a.name.localeCompare(b.name));
+    return (JSON.stringify(sortedTestFunctionArgs) ===
+        JSON.stringify(sortedDiscardFunctionArgs));
+};
+exports.isParamsMatch = isParamsMatch;
+/**
+ * Verify if the discard function's return type is boolean.
+ * @param discardFunction The discard function's interface.
+ * @returns A boolean indicating if the return type is boolean.
+ */
+const isReturnTypeBoolean = (discardFunction) => discardFunction.outputs.type === "bool";
+exports.isReturnTypeBoolean = isReturnTypeBoolean;

package/dist/property.types.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file is a placeholder for the property-based testing routine-related
+// types.