@stacks/rendezvous 0.10.0 → 0.11.0

package/README.md

@@ -8,7 +8,7 @@ Rendezvous `rv` is a Clarity fuzzer designed to cut through your smart contract'
 
 ### Prerequisites
 
-- **Node.js**: Supported versions include 18, 20, and 22. Other versions may work, but they are untested.
+- **Node.js**: Supported versions include 20, 22, and 23. Other versions may work, but they are untested.
 
 ### Inspiration
 
@@ -53,7 +53,6 @@ npx rv <path-to-clarinet-project> <contract-name> <type>
 **Options:**
 
 - `--seed` – The seed to use for the replay functionality.
-- `--path` – The path to use for the replay functionality.
 - `--runs` – The number of test iterations to use for exercising the contracts.
   (default: `100`)
 - `--bail` – Stop after the first failure.

package/dist/app.js

@@ -25,6 +25,7 @@ const citizen_1 = require("./citizen");
 const package_json_1 = require("./package.json");
 const ansicolor_1 = require("ansicolor");
 const fs_1 = require("fs");
+const util_1 = require("util");
 const dialer_1 = require("./dialer");
 const logger = (log, logLevel = "log") => {
     console[logLevel](log);
@@ -71,7 +72,7 @@ exports.tryParseRemoteDataSettings = tryParseRemoteDataSettings;
 const helpMessage = `
   rv v${package_json_1.version}
   
-  Usage: rv <path-to-clarinet-project> <contract-name> <type> [--seed=<seed>] [--path=<path>] [--runs=<runs>] [--dial=<path-to-dialers-file>] [--help]
+  Usage: rv <path-to-clarinet-project> <contract-name> <type> [--seed=<seed>] [--runs=<runs>] [--dial=<path-to-dialers-file>] [--help]
 
   Positional arguments:
     path-to-clarinet-project - The path to the Clarinet project.
@@ -80,45 +81,61 @@ const helpMessage = `
 
   Options:
     --seed - The seed to use for the replay functionality.
-    --path - The path to use for the replay functionality.
     --runs - The runs to use for iterating over the tests. Default: 100.
     --bail - Stop after the first failure.
     --dial – The path to a JavaScript file containing custom pre- and post-execution functions (dialers).
     --help - Show the help message.
   `;
-const parseBooleanOption = (argName) => process.argv.slice(4).includes(`--${argName}`);
-const parseOption = (argName) => {
-    var _a;
-    return (_a = process.argv
-        .find((arg, idx) => idx >= 4 && arg.toLowerCase().startsWith(`--${argName}`))) === null || _a === void 0 ? void 0 : _a.split("=")[1];
-};
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
         const radio = new events_1.EventEmitter();
         radio.on("logMessage", (log) => logger(log));
         radio.on("logFailure", (log) => logger((0, ansicolor_1.red)(log), "error"));
-        const args = process.argv;
-        if (args.includes("--help")) {
+        const { positionals: positionalArgs, values: options } = (0, util_1.parseArgs)({
+            allowPositionals: true,
+            args: process.argv.slice(2),
+            options: {
+                seed: { type: "string" },
+                runs: { type: "string" },
+                dial: { type: "string" },
+                bail: { type: "boolean" },
+                help: { type: "boolean", short: "h" },
+            },
+        });
+        const [manifestDir, sutContractName, type] = positionalArgs;
+        const runConfig = {
+            /** The relative path to the Clarinet project. */
+            manifestDir: manifestDir,
+            /** The target contract name. */
+            sutContractName: sutContractName,
+            /** The type of testing to be executed. Valid values: test, invariant. */
+            type: type === null || type === void 0 ? void 0 : type.toLowerCase(),
+            /** The seed to use for the replay functionality. */
+            seed: options.seed ? parseInt(options.seed, 10) : undefined,
+            /** The number of runs to use. */
+            runs: options.runs ? parseInt(options.runs, 10) : undefined,
+            /** Whether to bail on the first failure. */
+            bail: options.bail || false,
+            /** The path to the dialer file. */
+            dial: options.dial || undefined,
+            /** Whether to show the help message. */
+            help: options.help || false,
+        };
+        if (runConfig.help) {
             radio.emit("logMessage", helpMessage);
             return;
         }
-        /** The relative path to the Clarinet project. */
-        const manifestDir = args[2];
-        if (!manifestDir || manifestDir.startsWith("--")) {
+        if (!runConfig.manifestDir) {
             radio.emit("logMessage", (0, ansicolor_1.red)("\nNo path to Clarinet project provided. Supply it immediately or face the relentless scrutiny of your contract's vulnerabilities."));
             radio.emit("logMessage", helpMessage);
             return;
         }
-        /** The target contract name. */
-        const sutContractName = args[3];
-        if (!sutContractName || sutContractName.startsWith("--")) {
+        if (!runConfig.sutContractName) {
             radio.emit("logMessage", (0, ansicolor_1.red)("\nNo target contract name provided. Please provide the contract name to be fuzzed."));
             radio.emit("logMessage", helpMessage);
             return;
         }
-        const type = (_a = args[4]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-        if (!type || type.startsWith("--") || !["test", "invariant"].includes(type)) {
+        if (!runConfig.type || !["test", "invariant"].includes(runConfig.type)) {
             radio.emit("logMessage", (0, ansicolor_1.red)("\nInvalid type provided. Please provide the type of test to be executed. Possible values: test, invariant."));
             radio.emit("logMessage", helpMessage);
             return;
@@ -127,59 +144,49 @@ function main() {
          * The relative path to the manifest file, either `Clarinet.toml` or
          * `Clarinet-<contract-name>.toml`. If the latter exists, it is used.
          */
-        const manifestPath = (0, path_1.join)(manifestDir, (0, exports.getManifestFileName)(manifestDir, sutContractName));
+        const manifestPath = (0, path_1.join)(runConfig.manifestDir, (0, exports.getManifestFileName)(runConfig.manifestDir, runConfig.sutContractName));
         radio.emit("logMessage", `Using manifest path: ${manifestPath}`);
-        radio.emit("logMessage", `Target contract: ${sutContractName}`);
-        const seed = parseInt(parseOption("seed"), 10) || undefined;
-        if (seed !== undefined) {
-            radio.emit("logMessage", `Using seed: ${seed}`);
-        }
-        const path = parseOption("path") || undefined;
-        if (path !== undefined) {
-            radio.emit("logMessage", `Using path: ${path}`);
+        radio.emit("logMessage", `Target contract: ${runConfig.sutContractName}`);
+        if (runConfig.seed !== undefined) {
+            radio.emit("logMessage", `Using seed: ${runConfig.seed}`);
         }
-        const runs = parseInt(parseOption("runs"), 10) || undefined;
-        if (runs !== undefined) {
-            radio.emit("logMessage", `Using runs: ${runs}`);
+        if (runConfig.runs !== undefined) {
+            radio.emit("logMessage", `Using runs: ${runConfig.runs}`);
         }
-        const bail = parseBooleanOption("bail");
-        if (bail) {
+        if (runConfig.bail) {
             radio.emit("logMessage", `Bailing on first failure.`);
         }
-        /**
-         * The path to the dialer file. The dialer file allows the user to register
-         * custom pre and post-execution JavaScript functions to be executed before
-         * and after the public function calls during invariant testing.
-         */
-        const dialPath = parseOption("dial") || undefined;
-        if (dialPath !== undefined) {
-            radio.emit("logMessage", `Using dial path: ${dialPath}`);
+        if (runConfig.dial !== undefined) {
+            radio.emit("logMessage", `Using dial path: ${runConfig.dial}`);
         }
         /**
          * The dialer registry, which is used to keep track of all the custom dialers
          * registered by the user using the `--dial` flag.
          */
-        const dialerRegistry = dialPath !== undefined ? new dialer_1.DialerRegistry(dialPath) : undefined;
+        const dialerRegistry = runConfig.dial !== undefined
+            ? new dialer_1.DialerRegistry(runConfig.dial)
+            : undefined;
         if (dialerRegistry !== undefined) {
             dialerRegistry.registerDialers();
         }
         const remoteDataSettings = (0, exports.tryParseRemoteDataSettings)(manifestPath, radio);
-        const simnet = yield (0, citizen_1.issueFirstClassCitizenship)(manifestDir, manifestPath, remoteDataSettings, sutContractName);
+        const simnet = yield (0, citizen_1.issueFirstClassCitizenship)(runConfig.manifestDir, manifestPath, remoteDataSettings, runConfig.sutContractName);
         /**
          * The list of contract IDs for the SUT contract names, as per the simnet.
          */
-        const rendezvousList = Array.from((0, shared_1.getSimnetDeployerContractsInterfaces)(simnet).keys()).filter((deployedContract) => (0, shared_1.getContractNameFromContractId)(deployedContract) === sutContractName);
+        const rendezvousList = Array.from((0, shared_1.getSimnetDeployerContractsInterfaces)(simnet).keys()).filter((deployedContract) => (0, shared_1.getContractNameFromContractId)(deployedContract) ===
+            runConfig.sutContractName);
         const rendezvousAllFunctions = (0, shared_1.getFunctionsFromContractInterfaces)(new Map(Array.from((0, shared_1.getSimnetDeployerContractsInterfaces)(simnet)).filter(([contractId]) => rendezvousList.includes(contractId))));
         // Select the testing routine based on `type`.
         // If "invariant", call `checkInvariants` to verify contract invariants.
         // If "test", call `checkProperties` for property-based testing.
-        switch (type) {
+        switch (runConfig.type) {
             case "invariant": {
-                yield (0, invariant_1.checkInvariants)(simnet, sutContractName, rendezvousList, rendezvousAllFunctions, seed, path, runs, bail, dialerRegistry, radio);
+                yield (0, invariant_1.checkInvariants)(simnet, runConfig.sutContractName, rendezvousList, rendezvousAllFunctions, runConfig.seed, runConfig.runs, runConfig.bail, dialerRegistry, radio);
                 break;
             }
             case "test": {
-                (0, property_1.checkProperties)(simnet, sutContractName, rendezvousList, rendezvousAllFunctions, seed, path, runs, bail, radio);
+                (0, property_1.checkProperties)(simnet, runConfig.sutContractName, rendezvousList, rendezvousAllFunctions, runConfig.seed, runConfig.runs, runConfig.bail, radio);
                 break;
             }
         }

package/dist/invariant.js

@@ -29,7 +29,6 @@ const dialer_1 = require("./dialer");
  * @param rendezvousAllFunctions The map of all function interfaces for each
  * target contract.
  * @param seed The seed for reproducible invariant testing.
- * @param path The path for reproducible invariant testing.
  * @param runs The number of test runs.
  * @param bail Stop execution after the first failure and prevent further
  * shrinking.
@@ -37,7 +36,7 @@ const dialer_1 = require("./dialer");
  * @param radio The custom logging event emitter.
  * @returns void
  */
-const checkInvariants = (simnet, targetContractName, rendezvousList, rendezvousAllFunctions, seed, path, runs, bail, dialerRegistry, radio) => __awaiter(void 0, void 0, void 0, function* () {
+const checkInvariants = (simnet, targetContractName, rendezvousList, rendezvousAllFunctions, seed, runs, bail, dialerRegistry, radio) => __awaiter(void 0, void 0, void 0, function* () {
     const statistics = {
         sut: {
             successful: new Map(),
@@ -48,13 +47,14 @@ const checkInvariants = (simnet, targetContractName, rendezvousList, rendezvousA
             failed: new Map(),
         },
     };
+    // The Rendezvous identifier is the first one in the list. Only one contract
+    // can be fuzzed at a time.
+    const rendezvousContractId = rendezvousList[0];
     // 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);
-    // The Rendezvous identifier is the first one in the list. Only one contract
-    // can be fuzzed at a time.
-    const rendezvousContractId = rendezvousList[0];
+    // Initialize the statistics for the SUT functions.
     for (const functionInterface of rendezvousSutFunctions.get(rendezvousContractId)) {
         statistics.sut.successful.set(functionInterface.name, 0);
         statistics.sut.failed.set(functionInterface.name, 0);
@@ -63,47 +63,79 @@ const checkInvariants = (simnet, targetContractName, rendezvousList, rendezvousA
     // arrays of their invariant functions. This map will be used to access the
     // invariant functions for each Rendezvous contract afterwards.
     const rendezvousInvariantFunctions = filterInvariantFunctions(rendezvousAllFunctions);
+    // Initialize the statistics for the invariant functions.
     for (const functionInterface of rendezvousInvariantFunctions.get(rendezvousContractId)) {
         statistics.invariant.successful.set(functionInterface.name, 0);
         statistics.invariant.failed.set(functionInterface.name, 0);
     }
-    const traitReferenceSutFunctions = rendezvousSutFunctions
-        .get(rendezvousContractId)
-        .filter((fn) => (0, traits_1.isTraitReferenceFunction)(fn));
-    const traitReferenceInvariantFunctions = rendezvousInvariantFunctions
-        .get(rendezvousContractId)
-        .filter((fn) => (0, traits_1.isTraitReferenceFunction)(fn));
-    const projectTraitImplementations = (0, traits_1.extractProjectTraitImplementations)(simnet);
-    if (Object.entries(projectTraitImplementations).length === 0 &&
-        (traitReferenceSutFunctions.length > 0 ||
-            traitReferenceInvariantFunctions.length > 0)) {
-        const foundTraitReferenceMessage = traitReferenceSutFunctions.length > 0 &&
-            traitReferenceInvariantFunctions.length > 0
-            ? "public functions and invariants"
-            : traitReferenceSutFunctions.length > 0
-                ? "public functions"
-                : "invariants";
-        radio.emit("logMessage", (0, ansicolor_1.red)(`\nFound ${foundTraitReferenceMessage} referencing traits, but no trait implementations were found in the project.
-\nNote: You can add contracts implementing traits either as project contracts or as Clarinet requirements. For more details, visit: https://www.hiro.so/clarinet/.
-\n`));
-        return;
-    }
+    const sutFunctions = rendezvousSutFunctions.get(rendezvousContractId);
+    const traitReferenceSutFunctions = sutFunctions.filter(traits_1.isTraitReferenceFunction);
+    const invariantFunctions = rendezvousInvariantFunctions.get(rendezvousContractId);
+    const traitReferenceInvariantFunctions = invariantFunctions.filter(traits_1.isTraitReferenceFunction);
+    const sutTraitReferenceMap = (0, traits_1.buildTraitReferenceMap)(sutFunctions);
+    const invariantTraitReferenceMap = (0, traits_1.buildTraitReferenceMap)(invariantFunctions);
     const enrichedSutFunctionsInterfaces = traitReferenceSutFunctions.length > 0
-        ? (0, traits_1.enrichInterfaceWithTraitData)(simnet.getContractAST(targetContractName), (0, traits_1.buildTraitReferenceMap)(rendezvousSutFunctions.get(rendezvousContractId)), rendezvousSutFunctions.get(rendezvousContractId), rendezvousContractId)
+        ? (0, traits_1.enrichInterfaceWithTraitData)(simnet.getContractAST(targetContractName), sutTraitReferenceMap, sutFunctions, rendezvousContractId)
         : rendezvousSutFunctions;
     const enrichedInvariantFunctionsInterfaces = traitReferenceInvariantFunctions.length > 0
-        ? (0, traits_1.enrichInterfaceWithTraitData)(simnet.getContractAST(targetContractName), (0, traits_1.buildTraitReferenceMap)(rendezvousInvariantFunctions.get(rendezvousContractId)), rendezvousInvariantFunctions.get(rendezvousContractId), rendezvousContractId)
+        ? (0, traits_1.enrichInterfaceWithTraitData)(simnet.getContractAST(targetContractName), invariantTraitReferenceMap, invariantFunctions, rendezvousContractId)
         : rendezvousInvariantFunctions;
+    // Map all the project/requirement contracts to the traits they implement.
+    const projectTraitImplementations = (0, traits_1.extractProjectTraitImplementations)(simnet);
+    // Extract SUT functions with missing trait implementations. These functions
+    // will be skipped during invariant testing. Otherwise, the invariant testing
+    // routine can fail during argument generation.
+    const sutFunctionsWithMissingTraits = (0, traits_1.getNonTestableTraitFunctions)(enrichedSutFunctionsInterfaces, sutTraitReferenceMap, projectTraitImplementations, rendezvousContractId);
+    // Extract invariant functions with missing trait implementations. These
+    // functions will be skipped during invariant testing. Otherwise, the
+    // invariant testing routine can fail during argument generation.
+    const invariantFunctionsWithMissingTraits = (0, traits_1.getNonTestableTraitFunctions)(enrichedInvariantFunctionsInterfaces, invariantTraitReferenceMap, projectTraitImplementations, rendezvousContractId);
+    if (sutFunctionsWithMissingTraits.length > 0 ||
+        invariantFunctionsWithMissingTraits.length > 0) {
+        if (sutFunctionsWithMissingTraits.length > 0) {
+            const functionList = sutFunctionsWithMissingTraits
+                .map((fn) => `  - ${fn}`)
+                .join("\n");
+            radio.emit("logMessage", (0, ansicolor_1.yellow)(`\nWarning: The following SUT functions reference traits without eligible implementations and will be skipped:\n\n${functionList}\n`));
+        }
+        if (invariantFunctionsWithMissingTraits.length > 0) {
+            const functionList = invariantFunctionsWithMissingTraits
+                .map((fn) => `  - ${fn}`)
+                .join("\n");
+            radio.emit("logMessage", (0, ansicolor_1.yellow)(`\nWarning: The following invariant functions reference traits without eligible implementations and will be skipped:\n\n${functionList}\n`));
+        }
+        radio.emit("logMessage", (0, ansicolor_1.yellow)(`Note: You can add contracts implementing traits either as project contracts or as Clarinet requirements.\n`));
+    }
+    // Filter out functions with missing trait implementations from the enriched
+    // map.
+    const executableSutFunctions = new Map([
+        [
+            rendezvousContractId,
+            enrichedSutFunctionsInterfaces
+                .get(rendezvousContractId)
+                .filter((f) => !sutFunctionsWithMissingTraits.includes(f.name)),
+        ],
+    ]);
+    // Filter out functions with missing trait implementations from the enriched
+    // map.
+    const executableInvariantFunctions = new Map([
+        [
+            rendezvousContractId,
+            enrichedInvariantFunctionsInterfaces
+                .get(rendezvousContractId)
+                .filter((f) => !invariantFunctionsWithMissingTraits.includes(f.name)),
+        ],
+    ]);
     // Set up local context to track SUT function call counts.
-    const localContext = (0, exports.initializeLocalContext)(enrichedSutFunctionsInterfaces);
+    const localContext = (0, exports.initializeLocalContext)(executableSutFunctions);
     // Set up context in simnet by initializing state for SUT.
-    (0, exports.initializeClarityContext)(simnet, enrichedSutFunctionsInterfaces);
+    (0, exports.initializeClarityContext)(simnet, executableSutFunctions);
     radio.emit("logMessage", `\nStarting invariant testing type for the ${targetContractName} contract...\n`);
     const simnetAccounts = simnet.getAccounts();
     const eligibleAccounts = new Map([...simnetAccounts].filter(([key]) => key !== "faucet"));
     const simnetAddresses = Array.from(simnetAccounts.values());
-    const functions = (0, shared_1.getFunctionsListForContract)(enrichedSutFunctionsInterfaces, rendezvousContractId);
-    const invariants = (0, shared_1.getFunctionsListForContract)(enrichedInvariantFunctionsInterfaces, rendezvousContractId);
+    const functions = (0, shared_1.getFunctionsListForContract)(executableSutFunctions, rendezvousContractId);
+    const invariants = (0, shared_1.getFunctionsListForContract)(executableInvariantFunctions, 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 "${targetContractName}" contract. Without public functions, no state transitions can happen inside the contract, and the invariant test is not meaningful.\n`));
         return;
@@ -325,7 +357,6 @@ const checkInvariants = (simnet, targetContractName, rendezvousList, rendezvousA
     })), {
         endOnFailure: bail,
         numRuns: runs,
-        path: path,
         reporter: radioReporter,
         seed: seed,
         verbose: true,

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stacks/rendezvous",
-    "version": "0.10.0",
+    "version": "0.11.0",
     "description": "Meet your contract's vulnerabilities head-on.",
     "main": "app.js",
     "bin": {
@@ -8,8 +8,8 @@
     },
     "scripts": {
         "build": "npx -p typescript tsc --project tsconfig.json && node -e \"if (process.platform !== 'win32') require('fs').chmodSync('./dist/app.js', 0o755);\"",
-        "test": "npx jest --testTimeout=15000",
-        "test:coverage": "npx tsc --project tsconfig.json && npx jest --coverage"
+        "test": "npx jest",
+        "test:coverage": "npx jest --coverage"
     },
     "keywords": [
         "stacks",

package/dist/property.js

@@ -19,14 +19,13 @@ const traits_1 = require("./traits");
  * @param rendezvousAllFunctions A map of all target contract IDs to their
  * function interfaces.
  * @param seed The seed for reproducible property-based tests.
- * @param path The path for reproducible property-based tests.
  * @param runs The number of test runs.
  * @param bail Stop execution after the first failure and prevent further
  * shrinking.
  * @param radio The custom logging event emitter.
  * @returns void
  */
-const checkProperties = (simnet, targetContractName, rendezvousList, rendezvousAllFunctions, seed, path, runs, bail, radio) => {
+const checkProperties = (simnet, targetContractName, rendezvousList, rendezvousAllFunctions, seed, runs, bail, radio) => {
     const statistics = {
         test: {
             successful: new Map(),
@@ -44,20 +43,39 @@ const checkProperties = (simnet, targetContractName, rendezvousList, rendezvousA
         statistics.test.discarded.set(functionInterface.name, 0);
         statistics.test.failed.set(functionInterface.name, 0);
     }
-    const traitReferenceFunctions = testContractsTestFunctions
-        .get(testContractId)
-        .filter((fn) => (0, traits_1.isTraitReferenceFunction)(fn));
+    const allTestFunctions = testContractsTestFunctions.get(testContractId);
+    const traitReferenceFunctionsCount = allTestFunctions.filter(traits_1.isTraitReferenceFunction).length;
+    const traitReferenceMap = (0, traits_1.buildTraitReferenceMap)(allTestFunctions);
+    const enrichedTestFunctionsInterfaces = traitReferenceFunctionsCount > 0
+        ? (0, traits_1.enrichInterfaceWithTraitData)(simnet.getContractAST(targetContractName), traitReferenceMap, allTestFunctions, testContractId)
+        : testContractsTestFunctions;
     const projectTraitImplementations = (0, traits_1.extractProjectTraitImplementations)(simnet);
-    if (Object.entries(projectTraitImplementations).length === 0 &&
-        traitReferenceFunctions.length > 0) {
-        radio.emit("logMessage", (0, ansicolor_1.red)(`\nFound test functions referencing traits, but no trait implementations were found in the project.
-\nNote: You can add contracts implementing traits either as project contracts or as Clarinet requirements. For more details, visit: https://www.hiro.so/clarinet/.
-\n`));
-        return;
+    // If the tests contain trait reference functions, extract the functions with
+    // missing trait implementations. These functions need to be skipped during
+    // property-based testing. Otherwise, the property-based testing routine will
+    // eventually fail during argument generation.
+    const functionsMissingTraitImplementations = traitReferenceFunctionsCount > 0
+        ? (0, traits_1.getNonTestableTraitFunctions)(enrichedTestFunctionsInterfaces, traitReferenceMap, projectTraitImplementations, testContractId)
+        : [];
+    // If the tests contain trait reference functions without eligible trait
+    // implementations, log a warning and filter out the functions.
+    if (functionsMissingTraitImplementations.length > 0) {
+        const functionList = functionsMissingTraitImplementations
+            .map((fn) => `  - ${fn}`)
+            .join("\n");
+        radio.emit("logMessage", (0, ansicolor_1.yellow)(`\nWarning: The following test functions reference traits without eligible implementations and will be skipped:\n\n${functionList}\n`));
+        radio.emit("logMessage", (0, ansicolor_1.yellow)(`Note: You can add contracts implementing traits either as project contracts or as requirements.\n`));
     }
-    const enrichedTestFunctionsInterfaces = traitReferenceFunctions.length > 0
-        ? (0, traits_1.enrichInterfaceWithTraitData)(simnet.getContractAST(targetContractName), (0, traits_1.buildTraitReferenceMap)(testContractsTestFunctions.get(testContractId)), testContractsTestFunctions.get(testContractId), testContractId)
-        : testContractsTestFunctions;
+    // Filter out test functions with missing trait implementations from the
+    // enriched map.
+    const executableTestContractsTestFunctions = new Map([
+        [
+            testContractId,
+            enrichedTestFunctionsInterfaces
+                .get(testContractId)
+                .filter((functionInterface) => !functionsMissingTraitImplementations.includes(functionInterface.name)),
+        ],
+    ]);
     radio.emit("logMessage", `\nStarting property testing type for the ${targetContractName} contract...\n`);
     // Search for discard functions, for each test function. This map will
     // be used to pair the test functions with their corresponding discard
@@ -69,7 +87,7 @@ const checkProperties = (simnet, targetContractName, rendezvousList, rendezvousA
     // 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]) => [
+    const testContractsPairedFunctions = new Map(Array.from(executableTestContractsTestFunctions, ([contractId, functions]) => [
         contractId,
         new Map(functions.map((f) => {
             var _a;
@@ -87,7 +105,7 @@ const checkProperties = (simnet, targetContractName, rendezvousList, rendezvousA
     const simnetAccounts = simnet.getAccounts();
     const eligibleAccounts = new Map([...simnetAccounts].filter(([key]) => key !== "faucet"));
     const simnetAddresses = Array.from(simnetAccounts.values());
-    const testFunctions = (0, shared_1.getFunctionsListForContract)(enrichedTestFunctionsInterfaces, testContractId);
+    const testFunctions = (0, shared_1.getFunctionsListForContract)(executableTestContractsTestFunctions, 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 "${targetContractName}" contract.\n`));
         return;
@@ -223,7 +241,6 @@ const checkProperties = (simnet, targetContractName, rendezvousList, rendezvousA
     }), {
         endOnFailure: bail,
         numRuns: runs,
-        path: path,
         reporter: radioReporter,
         seed: seed,
         verbose: true,

package/dist/test.utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIsolatedTestEnvironment = createIsolatedTestEnvironment;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const os_1 = require("os");
+/**
+ * Creates an isolated test environment by copying the Clarinet project to a
+ * unique temporary directory. This prevents race conditions when multiple
+ * tests try to initialize simnet concurrently.
+ *
+ * @param manifestDir - The absolute path to the manifest directory.
+ * @param testPrefix - Prefix for the temporary directory name.
+ * @returns The path to the temporary directory containing the isolated project
+ * copy.
+ */
+function createIsolatedTestEnvironment(manifestDir, testPrefix) {
+    const tempDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), testPrefix));
+    (0, fs_1.cpSync)(manifestDir, tempDir, { recursive: true });
+    return tempDir;
+}

package/dist/traits.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractProjectTraitImplementations = exports.isTraitReferenceFunction = exports.getContractIdsImplementingTrait = exports.buildTraitReferenceMap = exports.getTraitReferenceData = exports.enrichInterfaceWithTraitData = void 0;
+exports.getNonTestableTraitFunctions = exports.extractProjectTraitImplementations = exports.isTraitReferenceFunction = exports.getContractIdsImplementingTrait = exports.buildTraitReferenceMap = exports.getTraitReferenceData = exports.enrichInterfaceWithTraitData = void 0;
 /**
  * Enriches a contract interface with trait reference data. Before enrichment,
  * the contract interface lacks trait reference data for parameters. This
@@ -329,10 +329,15 @@ const getContractIdsImplementingTrait = (trait, projectTraitImplementations) =>
     const filteredContracts = contracts.filter((contractId) => {
         var _a;
         const traitImplemented = (_a = projectTraitImplementations[contractId]) === null || _a === void 0 ? void 0 : _a.some((implementedTrait) => {
-            var _a, _b;
-            const isTraitNamesMatch = implementedTrait.name === ((_a = trait.import.Imported) === null || _a === void 0 ? void 0 : _a.name);
+            var _a, _b, _c, _d;
+            const isTraitNamesMatch = implementedTrait.name ===
+                ((_a = trait.import.Imported) === null || _a === void 0 ? void 0 : _a.name) ||
+                implementedTrait.name ===
+                    ((_b = trait.import.Defined) === null || _b === void 0 ? void 0 : _b.name);
             const isTraitIssuersMatch = JSON.stringify(implementedTrait.contract_identifier.issuer) ===
-                JSON.stringify((_b = trait.import.Imported) === null || _b === void 0 ? void 0 : _b.contract_identifier.issuer);
+                JSON.stringify((_c = trait.import.Imported) === null || _c === void 0 ? void 0 : _c.contract_identifier.issuer) ||
+                JSON.stringify(implementedTrait.contract_identifier.issuer) ===
+                    JSON.stringify((_d = trait.import.Defined) === null || _d === void 0 ? void 0 : _d.contract_identifier.issuer);
             return isTraitNamesMatch && isTraitIssuersMatch;
         });
         return traitImplemented;
@@ -403,3 +408,45 @@ const extractProjectTraitImplementations = (simnet) => {
     return projectTraitImplementations;
 };
 exports.extractProjectTraitImplementations = extractProjectTraitImplementations;
+/**
+ * Filters functions that reference traits without eligible implementations in
+ * the project. Recursively checks nested parameters for trait reference types.
+ * @param enrichedFunctionsInterfaces The map of contract IDs to enriched
+ * function interfaces with trait reference data.
+ * @param traitReferenceMap The map of function names to their trait reference
+ * parameter data.
+ * @param projectTraitImplementations The record of contract IDs to their
+ * implemented traits.
+ * @param contractId The contract ID to filter functions for.
+ * @returns An array of function names with trait references without eligible
+ * trait implementations.
+ */
+const getNonTestableTraitFunctions = (enrichedFunctionsInterfaces, traitReferenceMap, projectTraitImplementations, contractId) => {
+    const hasTraitReferenceWithoutImplementation = (type) => {
+        if (!type)
+            return false;
+        if (typeof type === "object" && "trait_reference" in type) {
+            const contractIdsImplementingTrait = (0, exports.getContractIdsImplementingTrait)(type.trait_reference, projectTraitImplementations);
+            return contractIdsImplementingTrait.length === 0;
+        }
+        if (typeof type === "object") {
+            return (("list" in type &&
+                hasTraitReferenceWithoutImplementation(type.list.type)) ||
+                ("tuple" in type &&
+                    type.tuple.some((item) => hasTraitReferenceWithoutImplementation(item.type))) ||
+                ("optional" in type &&
+                    hasTraitReferenceWithoutImplementation(type.optional)) ||
+                ("response" in type &&
+                    (hasTraitReferenceWithoutImplementation(type.response.ok) ||
+                        hasTraitReferenceWithoutImplementation(type.response.error))));
+        }
+        return false;
+    };
+    return Array.from(traitReferenceMap.keys()).filter((functionName) => {
+        var _a, _b;
+        const enrichedFunctionInterface = (_a = enrichedFunctionsInterfaces
+            .get(contractId)) === null || _a === void 0 ? void 0 : _a.find((f) => f.name === functionName);
+        return ((_b = enrichedFunctionInterface === null || enrichedFunctionInterface === void 0 ? void 0 : enrichedFunctionInterface.args.some((param) => hasTraitReferenceWithoutImplementation(param.type))) !== null && _b !== void 0 ? _b : false);
+    });
+};
+exports.getNonTestableTraitFunctions = getNonTestableTraitFunctions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stacks/rendezvous",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Meet your contract's vulnerabilities head-on.",
   "main": "app.js",
   "bin": {
@@ -8,8 +8,8 @@
   },
   "scripts": {
     "build": "npx -p typescript tsc --project tsconfig.json && node -e \"if (process.platform !== 'win32') require('fs').chmodSync('./dist/app.js', 0o755);\"",
-    "test": "npx jest --testTimeout=15000",
-    "test:coverage": "npx tsc --project tsconfig.json && npx jest --coverage"
+    "test": "npx jest",
+    "test:coverage": "npx jest --coverage"
   },
   "keywords": [
     "stacks",