@stacks/rendezvous 0.1.3 → 0.3.0

package/dist/property.js

@@ -9,12 +9,42 @@ 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) => {
+const traits_1 = require("./traits");
+/**
+ * Runs property-based tests on the target contract and logs the progress.
+ * Reports the test results through a custom reporter.
+ * @param simnet The simnet instance.
+ * @param targetContractName The name of the target contract.
+ * @param rendezvousList The list of contract IDs for each target contract.
+ * @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 radio The custom logging event emitter.
+ * @returns void
+ */
+const checkProperties = (simnet, targetContractName, rendezvousList, rendezvousAllFunctions, seed, path, runs, radio) => {
+    const testContractId = rendezvousList[0];
     // 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`);
+    const traitReferenceFunctions = testContractsTestFunctions
+        .get(testContractId)
+        .filter((fn) => (0, traits_1.isTraitReferenceFunction)(fn));
+    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;
+    }
+    const enrichedTestFunctionsInterfaces = traitReferenceFunctions.length > 0
+        ? (0, traits_1.enrichInterfaceWithTraitData)(simnet.getContractAST(targetContractName), (0, traits_1.buildTraitReferenceMap)(testContractsTestFunctions.get(testContractId)), testContractsTestFunctions.get(testContractId), testContractId)
+        : testContractsTestFunctions;
+    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
     // functions.
@@ -43,15 +73,9 @@ const checkProperties = (simnet, sutContractName, rendezvousList, rendezvousAllF
     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);
+    const testFunctions = (0, shared_1.getFunctionsListForContract)(enrichedTestFunctionsInterfaces, 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`));
+        radio.emit("logMessage", (0, ansicolor_1.red)(`No test functions found for the "${targetContractName}" contract.\n`));
         return;
     }
     const radioReporter = (runDetails) => {
@@ -65,12 +89,12 @@ const checkProperties = (simnet, sutContractName, rendezvousList, rendezvousAllF
     })
         .chain((r) => fast_check_1.default
         .record({
-        selectedTestFunction: fast_check_1.default.constantFrom(...eligibleTestFunctions),
+        selectedTestFunction: fast_check_1.default.constantFrom(...testFunctions),
     })
         .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)),
+        functionArgs: fast_check_1.default.tuple(...(0, shared_1.functionToArbitrary)(r.selectedTestFunction, simnetAddresses, projectTraitImplementations)),
     })
         .map((args) => (Object.assign(Object.assign({}, r), args))))
         .chain((r) => fast_check_1.default
@@ -89,8 +113,8 @@ const checkProperties = (simnet, sutContractName, rendezvousList, rendezvousAllF
             : 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
+        const selectedTestFunctionArgs = (0, shared_1.argsToCV)(r.selectedTestFunction, r.functionArgs);
+        const printedTestFunctionArgs = r.functionArgs
             .map((arg) => {
             try {
                 return typeof arg === "object"
@@ -112,7 +136,7 @@ const checkProperties = (simnet, sutContractName, rendezvousList, rendezvousAllF
                 `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
                 `${(0, ansicolor_1.dim)(testCallerWallet)} ` +
                 `${(0, ansicolor_1.yellow)("[WARN]")} ` +
-                `${sutContractName} ` +
+                `${targetContractName} ` +
                 `${(0, ansicolor_1.underline)(r.selectedTestFunction.name)} ` +
                 (0, ansicolor_1.dim)(printedTestFunctionArgs));
         }
@@ -128,7 +152,7 @@ const checkProperties = (simnet, sutContractName, rendezvousList, rendezvousAllF
                         `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
                         `${(0, ansicolor_1.dim)(testCallerWallet)} ` +
                         `${(0, ansicolor_1.yellow)("[WARN]")} ` +
-                        `${sutContractName} ` +
+                        `${targetContractName} ` +
                         `${(0, ansicolor_1.underline)(r.selectedTestFunction.name)} ` +
                         (0, ansicolor_1.dim)(printedTestFunctionArgs));
                 }
@@ -139,7 +163,7 @@ const checkProperties = (simnet, sutContractName, rendezvousList, rendezvousAllF
                         `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
                         `${(0, ansicolor_1.dim)(testCallerWallet)} ` +
                         `${(0, ansicolor_1.green)("[PASS]")} ` +
-                        `${sutContractName} ` +
+                        `${targetContractName} ` +
                         `${(0, ansicolor_1.underline)(r.selectedTestFunction.name)} ` +
                         printedTestFunctionArgs);
                     if (r.canMineBlocks) {
@@ -147,7 +171,7 @@ const checkProperties = (simnet, sutContractName, rendezvousList, rendezvousAllF
                     }
                 }
                 else {
-                    throw new Error(`Test failed for ${sutContractName} contract: "${r.selectedTestFunction.name}" returned ${testFunctionCallResultJson.value.value}`);
+                    throw new Error(`Test failed for ${targetContractName} contract: "${r.selectedTestFunction.name}" returned ${testFunctionCallResultJson.value.value}`);
                 }
             }
             catch (error) {
@@ -156,7 +180,7 @@ const checkProperties = (simnet, sutContractName, rendezvousList, rendezvousAllF
                     `Ӿ ${simnet.blockHeight.toString().padStart(8)}   ` +
                     `${testCallerWallet} ` +
                     `[FAIL] ` +
-                    `${sutContractName} ` +
+                    `${targetContractName} ` +
                     `${(0, ansicolor_1.underline)(r.selectedTestFunction.name)} ` +
                     printedTestFunctionArgs));
                 // Re-throw the error for fast-check to catch and process.
@@ -180,12 +204,12 @@ const isTestDiscardedInPlace = (testFunctionCallResultJson) => testFunctionCallR
     testFunctionCallResultJson.value.value === false;
 exports.isTestDiscardedInPlace = isTestDiscardedInPlace;
 /**
- * Check if the test function has to be discarded.
+ * Checks 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.
+ * @param selectedCaller The selected caller address.
  * @returns A boolean indicating if the test function has to be discarded.
  */
 const isTestDiscarded = (discardFunctionName, selectedTestFunctionArgs, contractId, simnet, selectedCaller) => {
@@ -196,7 +220,7 @@ const isTestDiscarded = (discardFunctionName, selectedTestFunctionArgs, contract
     return jsonDiscardFunctionCallResult.value === false;
 };
 /**
- * Validate the discard function, ensuring that its parameters match the test
+ * Validates a 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.
@@ -225,23 +249,23 @@ const validateDiscardFunction = (contractId, discardFunctionName, testFunctionNa
     return true;
 };
 /**
- * Verify if the test function parameters match the discard function
+ * Checks if the test function parameters match the discard function
  * parameters.
- * @param testFunction The test function's interface.
- * @param discardFunction The discard function's interface.
+ * @param testFunctionInterface The test function's interface.
+ * @param discardFunctionInterface 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));
+const isParamsMatch = (testFunctionInterface, discardFunctionInterface) => {
+    const sortedTestFunctionArgs = [...testFunctionInterface.args].sort((a, b) => a.name.localeCompare(b.name));
+    const sortedDiscardFunctionArgs = [...discardFunctionInterface.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.
+ * Checks if the discard function's return type is boolean.
+ * @param discardFunctionInterface The discard function's interface.
  * @returns A boolean indicating if the return type is boolean.
  */
-const isReturnTypeBoolean = (discardFunction) => discardFunction.outputs.type === "bool";
+const isReturnTypeBoolean = (discardFunctionInterface) => discardFunctionInterface.outputs.type === "bool";
 exports.isReturnTypeBoolean = isReturnTypeBoolean;

package/dist/shared.js

@@ -3,42 +3,50 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContractNameFromContractId = exports.isTraitReferenceFunction = exports.argsToCV = exports.hexaString = exports.functionToArbitrary = exports.getFunctionsListForContract = exports.getFunctionsFromContractInterfaces = exports.getSimnetDeployerContractsInterfaces = void 0;
+exports.getContractNameFromContractId = exports.argsToCV = exports.hexaString = exports.functionToArbitrary = exports.getFunctionsListForContract = exports.getFunctionsFromContractInterfaces = exports.getSimnetDeployerContractsInterfaces = void 0;
 const fast_check_1 = __importDefault(require("fast-check"));
 const transactions_1 = require("@stacks/transactions");
+const traits_1 = require("./traits");
 /**
- * Get the interfaces of contracts deployed by the specified deployer from the
- * simnet.
+ * Retrieves the contract interfaces of the contracts deployed by a specific
+ * deployer from the simnet instance.
  * @param simnet The simnet instance.
- * @param deployer The deployer address.
- * @returns The contracts interfaces.
+ * @returns The contract IDs mapped to their interfaces.
  */
 const getSimnetDeployerContractsInterfaces = (simnet) => new Map(Array.from(simnet.getContractsInterfaces()).filter(([key]) => key.split(".")[0] === simnet.deployer));
 exports.getSimnetDeployerContractsInterfaces = getSimnetDeployerContractsInterfaces;
 /**
- * Get the functions from the smart contract interfaces.
- * @param contractsInterfaces The smart contract interfaces map.
- * @returns A map containing the contracts functions.
+ * Retrieves the function interfaces from the contract interfaces. Filters out
+ * other contract interface data such as data maps, variables, and constants.
+ * @param contractInterfaces The smart contract interfaces map.
+ * @returns The contract IDs mapped to their function interfaces.
  */
-const getFunctionsFromContractInterfaces = (contractsInterfaces) => new Map(Array.from(contractsInterfaces, ([contractId, contractInterface]) => [
+const getFunctionsFromContractInterfaces = (contractInterfaces) => new Map(Array.from(contractInterfaces, ([contractId, contractInterface]) => [
     contractId,
     contractInterface.functions,
 ]));
 exports.getFunctionsFromContractInterfaces = getFunctionsFromContractInterfaces;
 const getFunctionsListForContract = (functionsMap, contractId) => functionsMap.get(contractId) || [];
 exports.getFunctionsListForContract = getFunctionsListForContract;
-/** For a given function, dynamically generate fast-check arbitraries.
- * @param fn The function interface.
+/** Dynamically generates fast-check arbitraries for a given function
+ * interface.
+ * @param functionInterface The "enriched" function interface.
+ * @param addresses The array of addresses to use for principal types.
+ * @param projectTraitImplementations The contract IDs mapped to the traits
+ * they implement.
  * @returns Array of fast-check arbitraries.
  */
-const functionToArbitrary = (fn, addresses) => fn.args.map((arg) => parameterTypeToArbitrary(arg.type, addresses));
+const functionToArbitrary = (functionInterface, addresses, projectTraitImplementations) => functionInterface.args.map((arg) => parameterTypeToArbitrary(arg.type, addresses, projectTraitImplementations));
 exports.functionToArbitrary = functionToArbitrary;
 /**
- * For a given type, generate a fast-check arbitrary.
- * @param type The parameter type.
+ * Generates a fast-check arbitrary for a given parameter type.
+ * @param type The "enriched" parameter type.
+ * @param addresses The array of addresses to use for principal types.
+ * @param projectTraitImplementations The contract IDs mapped to the traits
+ * they implement.
  * @returns Fast-check arbitrary.
  */
-const parameterTypeToArbitrary = (type, addresses) => {
+const parameterTypeToArbitrary = (type, addresses, projectTraitImplementations) => {
     if (typeof type === "string") {
         // The type is a base type.
         if (type === "principal") {
@@ -46,9 +54,6 @@ const parameterTypeToArbitrary = (type, addresses) => {
                 throw new Error("No addresses could be retrieved from the simnet instance!");
             return baseTypesToArbitrary.principal(addresses);
         }
-        else if (type === "trait_reference") {
-            throw new Error("Unsupported parameter type: trait_reference");
-        }
         else
             return baseTypesToArbitrary[type];
     }
@@ -64,16 +69,19 @@ const parameterTypeToArbitrary = (type, addresses) => {
             return complexTypesToArbitrary["string-utf8"](type["string-utf8"].length);
         }
         else if ("list" in type) {
-            return complexTypesToArbitrary["list"](type.list.type, type.list.length, addresses);
+            return complexTypesToArbitrary["list"](type.list.type, type.list.length, addresses, projectTraitImplementations);
         }
         else if ("tuple" in type) {
-            return complexTypesToArbitrary["tuple"](type.tuple, addresses);
+            return complexTypesToArbitrary["tuple"](type.tuple, addresses, projectTraitImplementations);
         }
         else if ("optional" in type) {
-            return complexTypesToArbitrary["optional"](type.optional, addresses);
+            return complexTypesToArbitrary["optional"](type.optional, addresses, projectTraitImplementations);
         }
         else if ("response" in type) {
-            return complexTypesToArbitrary.response(type.response.ok, type.response.error, addresses);
+            return complexTypesToArbitrary.response(type.response.ok, type.response.error, addresses, projectTraitImplementations);
+        }
+        else if ("trait_reference" in type) {
+            return complexTypesToArbitrary.trait_reference(type.trait_reference, projectTraitImplementations);
         }
         else {
             throw new Error(`Unsupported complex type: ${JSON.stringify(type)}`);
@@ -88,28 +96,7 @@ const baseTypesToArbitrary = {
     uint128: fast_check_1.default.nat(),
     bool: fast_check_1.default.boolean(),
     principal: (addresses) => fast_check_1.default.constantFrom(...addresses),
-    trait_reference: undefined,
 };
-/**
- * Custom hexadecimal string generator. The `hexaString` generator from
- * fast-check has been deprecated. This generator is implemented to precisely
- * match the behavior of the deprecated generator.
- *
- * @param constraints Fast-check string constraints.
- * @returns Fast-check arbitrary for hexadecimal strings.
- *
- * Reference for the proposed replacement of the deprecated `hexaString`
- * generator:
- * https://github.com/dubzzz/fast-check/commit/3f4f1203a8863c07d22b45591bf0de1fac02b948
- */
-const hexaString = (constraints = {}) => {
-    const hexa = () => {
-        const hexCharSet = "0123456789abcdef";
-        return fast_check_1.default.integer({ min: 0, max: 15 }).map((n) => hexCharSet[n]);
-    };
-    return fast_check_1.default.string(Object.assign(Object.assign({}, constraints), { unit: hexa() }));
-};
-exports.hexaString = hexaString;
 /**
  * Complex types to fast-check arbitraries mapping.
  */
@@ -125,51 +112,76 @@ const complexTypesToArbitrary = {
         maxLength: length,
     }),
     "string-utf8": (length) => fast_check_1.default.string({ maxLength: length }),
-    list: (type, length, addresses) => fast_check_1.default.array(parameterTypeToArbitrary(type, addresses), { maxLength: length }),
-    tuple: (items, addresses) => {
+    list: (type, length, addresses, projectTraitImplementations) => fast_check_1.default.array(parameterTypeToArbitrary(type, addresses, projectTraitImplementations), {
+        maxLength: length,
+    }),
+    tuple: (items, addresses, projectTraitImplementations) => {
         const tupleArbitraries = {};
         items.forEach((item) => {
-            tupleArbitraries[item.name] = parameterTypeToArbitrary(item.type, addresses);
+            tupleArbitraries[item.name] = parameterTypeToArbitrary(item.type, addresses, projectTraitImplementations);
         });
         return fast_check_1.default.record(tupleArbitraries);
     },
-    optional: (type, addresses) => fast_check_1.default.option(parameterTypeToArbitrary(type, addresses)),
-    response: (okType, errType, addresses) => fast_check_1.default.oneof(fast_check_1.default.record({
+    optional: (type, addresses, projectTraitImplementations) => fast_check_1.default.option(parameterTypeToArbitrary(type, addresses, projectTraitImplementations)),
+    response: (okType, errType, addresses, projectTraitImplementations) => fast_check_1.default.oneof(fast_check_1.default.record({
         status: fast_check_1.default.constant("ok"),
-        value: parameterTypeToArbitrary(okType, addresses),
+        value: parameterTypeToArbitrary(okType, addresses, projectTraitImplementations),
     }), fast_check_1.default.record({
         status: fast_check_1.default.constant("error"),
-        value: parameterTypeToArbitrary(errType, addresses),
+        value: parameterTypeToArbitrary(errType, addresses, projectTraitImplementations),
     })),
+    trait_reference: (traitData, projectTraitImplementations) => {
+        return fast_check_1.default.constantFrom(...(0, traits_1.getContractIdsImplementingTrait)(traitData, projectTraitImplementations));
+    },
 };
+/**
+ * Custom hexadecimal string generator. The `hexaString` generator from
+ * fast-check has been deprecated. This generator is implemented to match the
+ * behavior of the deprecated generator.
+ *
+ * @param constraints Fast-check string constraints.
+ * @returns Fast-check arbitrary for hexadecimal strings.
+ *
+ * Reference for the proposed replacement of the deprecated `hexaString`
+ * generator:
+ * https://github.com/dubzzz/fast-check/commit/3f4f1203a8863c07d22b45591bf0de1fac02b948
+ */
+const hexaString = (constraints = {}) => {
+    const hexa = () => {
+        const hexCharSet = "0123456789abcdef";
+        return fast_check_1.default.integer({ min: 0, max: 15 }).map((n) => hexCharSet[n]);
+    };
+    return fast_check_1.default.string(Object.assign(Object.assign({}, constraints), { unit: hexa() }));
+};
+exports.hexaString = hexaString;
 /** The character set used for generating ASCII strings.*/
 const charSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
 /**
- * Convert function arguments to Clarity values.
- * @param fn The function interface.
- * @param args Array of arguments.
+ * Converts JavaScript generated function arguments to Clarity values.
+ * @param functionInterface The function interface.
+ * @param generatedArguments Array of generated arguments.
  * @returns Array of Clarity values.
  */
-const argsToCV = (fn, args) => fn.args.map((arg, i) => argToCV(args[i], arg.type));
+const argsToCV = (functionInterface, generatedArguments) => functionInterface.args.map((arg, i) => argToCV(generatedArguments[i], arg.type));
 exports.argsToCV = argsToCV;
 /**
- * Convert a function argument to a Clarity value.
- * @param arg Generated argument.
+ * Converts a JavaScript generated function argument to a Clarity value.
+ * @param generatedArgument Generated argument.
  * @param type Argument type (base or complex).
  * @returns Clarity value.
  */
-const argToCV = (arg, type) => {
+const argToCV = (generatedArgument, type) => {
     if (isBaseType(type)) {
         // Base type.
         switch (type) {
             case "int128":
-                return baseTypesToCV.int128(arg);
+                return baseTypesToCV.int128(generatedArgument);
             case "uint128":
-                return baseTypesToCV.uint128(arg);
+                return baseTypesToCV.uint128(generatedArgument);
             case "bool":
-                return baseTypesToCV.bool(arg);
+                return baseTypesToCV.bool(generatedArgument);
             case "principal":
-                return baseTypesToCV.principal(arg);
+                return baseTypesToCV.principal(generatedArgument);
             default:
                 throw new Error(`Unsupported base parameter type: ${type}`);
         }
@@ -177,34 +189,39 @@ const argToCV = (arg, type) => {
     else {
         // Complex type.
         if ("buffer" in type) {
-            return complexTypesToCV.buffer(arg);
+            return complexTypesToCV.buffer(generatedArgument);
         }
         else if ("string-ascii" in type) {
-            return complexTypesToCV["string-ascii"](arg);
+            return complexTypesToCV["string-ascii"](generatedArgument);
         }
         else if ("string-utf8" in type) {
-            return complexTypesToCV["string-utf8"](arg);
+            return complexTypesToCV["string-utf8"](generatedArgument);
         }
         else if ("list" in type) {
-            const listItems = arg.map((item) => argToCV(item, type.list.type));
+            const listItems = generatedArgument.map((item) => argToCV(item, type.list.type));
             return complexTypesToCV.list(listItems);
         }
         else if ("tuple" in type) {
             const tupleData = {};
             type.tuple.forEach((field) => {
-                tupleData[field.name] = argToCV(arg[field.name], field.type);
+                tupleData[field.name] = argToCV(generatedArgument[field.name], field.type);
             });
             return complexTypesToCV.tuple(tupleData);
         }
         else if ("optional" in type) {
-            return (0, transactions_1.optionalCVOf)(arg ? argToCV(arg, type.optional) : undefined);
+            return (0, transactions_1.optionalCVOf)(generatedArgument
+                ? argToCV(generatedArgument, type.optional)
+                : undefined);
         }
         else if ("response" in type) {
-            const status = arg.status;
+            const status = generatedArgument.status;
             const branchType = type.response[status];
-            const responseValue = argToCV(arg.value, branchType);
+            const responseValue = argToCV(generatedArgument.value, branchType);
             return complexTypesToCV.response(status, responseValue);
         }
+        else if ("trait_reference" in type) {
+            return complexTypesToCV.trait_reference(generatedArgument);
+        }
         else {
             throw new Error(`Unsupported complex parameter type: ${JSON.stringify(type)}`);
         }
@@ -241,45 +258,10 @@ const complexTypesToCV = {
         else
             throw new Error(`Unsupported response status: ${status}`);
     },
+    trait_reference: (traitImplementation) => (0, transactions_1.principalCV)(traitImplementation),
 };
 const isBaseType = (type) => {
     return ["int128", "uint128", "bool", "principal"].includes(type);
 };
-/**
- * Checks if any parameter of the function contains a `trait_reference` type.
- * @param fn The function interface.
- * @returns Boolean - true if the function contains a trait reference, false
- * otherwise.
- */
-const isTraitReferenceFunction = (fn) => {
-    const hasTraitReference = (type) => {
-        if (typeof type === "string") {
-            // The type is a base type.
-            return type === "trait_reference";
-        }
-        else {
-            // The type is a complex type.
-            if ("buffer" in type)
-                return false;
-            if ("string-ascii" in type)
-                return false;
-            if ("string-utf8" in type)
-                return false;
-            if ("list" in type)
-                return hasTraitReference(type.list.type);
-            if ("tuple" in type)
-                return type.tuple.some((item) => hasTraitReference(item.type));
-            if ("optional" in type)
-                return hasTraitReference(type.optional);
-            if ("response" in type)
-                return (hasTraitReference(type.response.ok) ||
-                    hasTraitReference(type.response.error));
-            // Default to false for unexpected types.
-            return false;
-        }
-    };
-    return fn.args.some((arg) => hasTraitReference(arg.type));
-};
-exports.isTraitReferenceFunction = isTraitReferenceFunction;
 const getContractNameFromContractId = (contractId) => contractId.split(".")[1];
 exports.getContractNameFromContractId = getContractNameFromContractId;