@stacks/rendezvous 0.1.2

package/dist/shared.js

@@ -0,0 +1,285 @@
+"use strict";
+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;
+const fast_check_1 = __importDefault(require("fast-check"));
+const transactions_1 = require("@stacks/transactions");
+/**
+ * Get the interfaces of contracts deployed by the specified deployer from the
+ * simnet.
+ * @param simnet The simnet instance.
+ * @param deployer The deployer address.
+ * @returns The contracts 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.
+ */
+const getFunctionsFromContractInterfaces = (contractsInterfaces) => new Map(Array.from(contractsInterfaces, ([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.
+ * @returns Array of fast-check arbitraries.
+ */
+const functionToArbitrary = (fn, addresses) => fn.args.map((arg) => parameterTypeToArbitrary(arg.type, addresses));
+exports.functionToArbitrary = functionToArbitrary;
+/**
+ * For a given type, generate a fast-check arbitrary.
+ * @param type The parameter type.
+ * @returns Fast-check arbitrary.
+ */
+const parameterTypeToArbitrary = (type, addresses) => {
+    if (typeof type === "string") {
+        // The type is a base type.
+        if (type === "principal") {
+            if (addresses.length === 0)
+                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];
+    }
+    else {
+        // The type is a complex type.
+        if ("buffer" in type) {
+            return complexTypesToArbitrary["buffer"](type.buffer.length);
+        }
+        else if ("string-ascii" in type) {
+            return complexTypesToArbitrary["string-ascii"](type["string-ascii"].length);
+        }
+        else if ("string-utf8" in type) {
+            return complexTypesToArbitrary["string-utf8"](type["string-utf8"].length);
+        }
+        else if ("list" in type) {
+            return complexTypesToArbitrary["list"](type.list.type, type.list.length, addresses);
+        }
+        else if ("tuple" in type) {
+            return complexTypesToArbitrary["tuple"](type.tuple, addresses);
+        }
+        else if ("optional" in type) {
+            return complexTypesToArbitrary["optional"](type.optional, addresses);
+        }
+        else if ("response" in type) {
+            return complexTypesToArbitrary.response(type.response.ok, type.response.error, addresses);
+        }
+        else {
+            throw new Error(`Unsupported complex type: ${JSON.stringify(type)}`);
+        }
+    }
+};
+/**
+ * Base types to fast-check arbitraries mapping.
+ */
+const baseTypesToArbitrary = {
+    int128: fast_check_1.default.integer(),
+    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.
+ */
+const complexTypesToArbitrary = {
+    // For buffer types, the length must be doubled because they are represented
+    // in hex. The `argToCV` function expects this format for `buff` ClarityValue
+    // conversion. The UInt8Array will have half the length of the corresponding
+    // hex string. Stacks.js reference:
+    // https://github.com/hirosystems/stacks.js/blob/fd0bf26b5f29fc3c1bf79581d0ad9b89f0d7f15a/packages/common/src/utils.ts#L522
+    buffer: (length) => (0, exports.hexaString)({ maxLength: 2 * length }),
+    "string-ascii": (length) => fast_check_1.default.string({
+        unit: fast_check_1.default.constantFrom(...charSet),
+        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) => {
+        const tupleArbitraries = {};
+        items.forEach((item) => {
+            tupleArbitraries[item.name] = parameterTypeToArbitrary(item.type, addresses);
+        });
+        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({
+        status: fast_check_1.default.constant("ok"),
+        value: parameterTypeToArbitrary(okType, addresses),
+    }), fast_check_1.default.record({
+        status: fast_check_1.default.constant("error"),
+        value: parameterTypeToArbitrary(errType, addresses),
+    })),
+};
+/** 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.
+ * @returns Array of Clarity values.
+ */
+const argsToCV = (fn, args) => fn.args.map((arg, i) => argToCV(args[i], arg.type));
+exports.argsToCV = argsToCV;
+/**
+ * Convert a function argument to a Clarity value.
+ * @param arg Generated argument.
+ * @param type Argument type (base or complex).
+ * @returns Clarity value.
+ */
+const argToCV = (arg, type) => {
+    if (isBaseType(type)) {
+        // Base type.
+        switch (type) {
+            case "int128":
+                return baseTypesToCV.int128(arg);
+            case "uint128":
+                return baseTypesToCV.uint128(arg);
+            case "bool":
+                return baseTypesToCV.bool(arg);
+            case "principal":
+                return baseTypesToCV.principal(arg);
+            default:
+                throw new Error(`Unsupported base parameter type: ${type}`);
+        }
+    }
+    else {
+        // Complex type.
+        if ("buffer" in type) {
+            return complexTypesToCV.buffer(arg);
+        }
+        else if ("string-ascii" in type) {
+            return complexTypesToCV["string-ascii"](arg);
+        }
+        else if ("string-utf8" in type) {
+            return complexTypesToCV["string-utf8"](arg);
+        }
+        else if ("list" in type) {
+            const listItems = arg.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);
+            });
+            return complexTypesToCV.tuple(tupleData);
+        }
+        else if ("optional" in type) {
+            return (0, transactions_1.optionalCVOf)(arg ? argToCV(arg, type.optional) : undefined);
+        }
+        else if ("response" in type) {
+            const status = arg.status;
+            const branchType = type.response[status];
+            const responseValue = argToCV(arg.value, branchType);
+            return complexTypesToCV.response(status, responseValue);
+        }
+        else {
+            throw new Error(`Unsupported complex parameter type: ${JSON.stringify(type)}`);
+        }
+    }
+};
+/**
+ * Base types to Clarity values mapping.
+ */
+const baseTypesToCV = {
+    int128: (arg) => transactions_1.Cl.int(arg),
+    uint128: (arg) => transactions_1.Cl.uint(arg),
+    bool: (arg) => transactions_1.Cl.bool(arg),
+    principal: (arg) => transactions_1.Cl.principal(arg),
+};
+/**
+ * Complex types to Clarity values mapping.
+ */
+const complexTypesToCV = {
+    buffer: (arg) => transactions_1.Cl.bufferFromHex(arg),
+    "string-ascii": (arg) => transactions_1.Cl.stringAscii(arg),
+    "string-utf8": (arg) => transactions_1.Cl.stringUtf8(arg),
+    list: (items) => {
+        return transactions_1.Cl.list(items);
+    },
+    tuple: (tupleData) => {
+        return transactions_1.Cl.tuple(tupleData);
+    },
+    optional: (arg) => arg ? (0, transactions_1.optionalCVOf)(arg) : (0, transactions_1.optionalCVOf)(undefined),
+    response: (status, value) => {
+        if (status === "ok")
+            return (0, transactions_1.responseOkCV)(value);
+        else if (status === "error")
+            return (0, transactions_1.responseErrorCV)(value);
+        else
+            throw new Error(`Unsupported response status: ${status}`);
+    },
+};
+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;

package/dist/shared.types.js

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

package/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"
+  }
+}