@stacks/rendezvous 0.1.3 → 0.3.0

package/dist/traits.js

@@ -0,0 +1,389 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+ * function constructs a copy of the contract interface with trait reference
+ * data for parameters that are trait references.
+ * @param ast The contract AST.
+ * @param traitReferenceMap The function names mapped to their trait reference
+ * parameter paths.
+ * @param functionInterfaceList The list of function interfaces for a contract.
+ * @param targetContractId The contract ID to enrich with trait reference data.
+ * @returns The contract IDs mapped to a list of enriched function interfaces.
+ */
+const enrichInterfaceWithTraitData = (ast, traitReferenceMap, functionInterfaceList, targetContractId) => {
+    const enriched = new Map();
+    const enrichArgs = (args, functionName, traitReferenceMap, path = []) => {
+        return args.map((arg) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const listNested = !arg.name;
+            const currentPath = listNested ? path : [...path, arg.name];
+            if (arg.type && arg.type.tuple) {
+                return Object.assign(Object.assign({}, arg), { type: {
+                        tuple: enrichArgs(arg.type.tuple, functionName, listNested
+                            ? traitReferenceMap.tuple
+                            : (_a = traitReferenceMap[arg.name]) === null || _a === void 0 ? void 0 : _a.tuple, currentPath),
+                    } });
+            }
+            else if (arg.type && arg.type.list) {
+                return Object.assign(Object.assign({}, arg), { type: {
+                        list: enrichArgs([arg.type.list], functionName, listNested
+                            ? traitReferenceMap.list
+                            : (_b = traitReferenceMap[arg.name]) === null || _b === void 0 ? void 0 : _b.list, arg.type.list.type.tuple
+                            ? [...currentPath, "tuple"]
+                            : arg.type.list.type.response
+                                ? [...currentPath, "response"]
+                                : arg.type.list.type.optional
+                                    ? [...currentPath, "optional"]
+                                    : [...currentPath, "list"])[0],
+                    } });
+            }
+            else if (arg.type && arg.type.response) {
+                const okPath = listNested ? currentPath : [...currentPath, "ok"];
+                const errorPath = listNested ? currentPath : [...currentPath, "error"];
+                const okTraitReference = enrichArgs([{ name: "ok", type: arg.type.response.ok }], functionName, {
+                    ok: listNested
+                        ? (_c = traitReferenceMap.response) === null || _c === void 0 ? void 0 : _c.ok
+                        : (_e = (_d = traitReferenceMap[arg.name]) === null || _d === void 0 ? void 0 : _d.response) === null || _e === void 0 ? void 0 : _e.ok,
+                }, okPath)[0];
+                const errorTraitReference = enrichArgs([{ name: "error", type: arg.type.response.error }], functionName, {
+                    error: listNested
+                        ? (_f = traitReferenceMap.response) === null || _f === void 0 ? void 0 : _f.error
+                        : (_h = (_g = traitReferenceMap[arg.name]) === null || _g === void 0 ? void 0 : _g.response) === null || _h === void 0 ? void 0 : _h.error,
+                }, errorPath)[0];
+                return Object.assign(Object.assign({}, arg), { type: {
+                        response: {
+                            ok: okTraitReference.type,
+                            error: errorTraitReference.type,
+                        },
+                    } });
+            }
+            else if (arg.type && arg.type.optional) {
+                const optionalPath = [...currentPath, "optional"];
+                const optionalTraitReference = enrichArgs([{ name: "optional", type: arg.type.optional }], functionName, {
+                    optional: listNested
+                        ? traitReferenceMap.optional
+                        : (_j = traitReferenceMap[arg.name]) === null || _j === void 0 ? void 0 : _j.optional,
+                }, optionalPath)[0];
+                return Object.assign(Object.assign({}, arg), { type: {
+                        optional: optionalTraitReference.type,
+                    } });
+            }
+            else if (traitReferenceMap && traitReferenceMap[arg.name]) {
+                const [traitReferenceName, traitReferenceImport] = (0, exports.getTraitReferenceData)(ast, functionName, currentPath.filter((x) => x !== undefined));
+                if (traitReferenceName && traitReferenceImport) {
+                    return Object.assign(Object.assign({}, arg), { type: {
+                            trait_reference: {
+                                name: traitReferenceName,
+                                import: traitReferenceImport,
+                            },
+                        } });
+                }
+            }
+            else if (traitReferenceMap === "trait_reference") {
+                const [traitReferenceName, traitReferenceImport] = (0, exports.getTraitReferenceData)(ast, functionName, path);
+                if (traitReferenceName && traitReferenceImport) {
+                    return Object.assign(Object.assign({}, arg), { type: {
+                            trait_reference: {
+                                name: traitReferenceName,
+                                import: traitReferenceImport,
+                            },
+                        } });
+                }
+            }
+            return arg;
+        });
+    };
+    const enrichedFunctions = functionInterfaceList.map((f) => {
+        return Object.assign(Object.assign({}, f), { args: enrichArgs(f.args, f.name, traitReferenceMap.get(f.name)) });
+    });
+    enriched.set(targetContractId, enrichedFunctions);
+    return enriched;
+};
+exports.enrichInterfaceWithTraitData = enrichInterfaceWithTraitData;
+/**
+ * Searches for a trait reference in the contract AST, given the function name
+ * and the nesting path of the trait reference.
+ * @param ast The contract AST.
+ * @param functionName The name of the function to search for trait references
+ * import data.
+ * @param parameterPath The path to search for the trait reference. The path is
+ * an array of strings that represent the nested location of the trait
+ * reference in the contract AST.
+ * @returns A tuple containing the `trait reference name` and the `imported
+ * trait data` if the trait reference is found. Otherwise, returns a tuple of
+ * `undefined` values.
+ */
+const getTraitReferenceData = (ast, functionName, parameterPath) => {
+    /**
+     * Recursively searches for a trait reference import details in the contract
+     * parameter nodes, part of the contract AST.
+     * @param functionParameterNodes The list of function parameter nodes from
+     * the AST. This is the list of nodes following the function name node.
+     * @param path The path to search for the trait reference. The path is an
+     * array of strings that represent the nested location of the trait reference
+     * in the function parameter nodes.
+     * @returns A tuple containing the `trait reference name` and the `imported
+     * trait data` if the trait reference is found. Otherwise, returns a tuple of
+     * `undefined` values.
+     */
+    const findTraitReference = (functionParameterNodes, path) => {
+        for (const parameterNode of functionParameterNodes) {
+            // Check if the current parameter node is a trait reference in the first
+            // level of the function parameter nodes.
+            if (parameterNode.expr &&
+                parameterNode.expr.TraitReference) {
+                const [name, importData] = parameterNode.expr
+                    .TraitReference;
+                return [name, importData];
+            }
+            if (!parameterNode.expr || !parameterNode.expr.List) {
+                continue;
+            }
+            // The parameter name node is the first node in the parameter node list.
+            const parameterNameNode = parameterNode.expr.List[0];
+            if (!parameterNameNode || !parameterNameNode.expr.Atom) {
+                continue;
+            }
+            const currentParameterName = parameterNameNode.expr.Atom.toString();
+            // Check the first item in the path list to see if it matches the current
+            // parameter name. If it does, we are on the right track.
+            if (currentParameterName === path[0]) {
+                // If the path only has one item left, the trait reference should be
+                // right under our noses, in the next node.
+                if (path.length === 1) {
+                    const traitReferenceNode = parameterNode.expr.List[1];
+                    if (traitReferenceNode &&
+                        traitReferenceNode.expr.TraitReference) {
+                        const [name, importData] = traitReferenceNode.expr.TraitReference;
+                        return [name, importData];
+                    }
+                }
+                else {
+                    // If the path has more than one item left, we need to traverse down
+                    // the expression list to find the nested trait reference.
+                    if (parameterNode.expr.List[1] &&
+                        parameterNode.expr.List[1].expr) {
+                        const nestedParameterList = parameterNode.expr.List[1]
+                            .expr;
+                        if (nestedParameterList.TraitReference) {
+                            const [name, importData] = nestedParameterList
+                                .TraitReference;
+                            return [name, importData];
+                        }
+                        else {
+                            // Recursively search for the trait reference in the nested
+                            // parameter list.
+                            const result = findTraitReference(nestedParameterList.List, path.slice(1));
+                            if (result[0] !== undefined)
+                                return result;
+                        }
+                    }
+                }
+            }
+        }
+        return [undefined, undefined];
+    };
+    for (const node of ast.expressions) {
+        if (!node.expr || !node.expr.List) {
+            continue;
+        }
+        // Traverse down the expression.
+        const expressionList = node.expr.List;
+        // Extract the first atom in the expression list to determine if it is a
+        // function definition.
+        const potentialFunctionDefinitionAtom = expressionList[0];
+        // Check if the potential function definition atom is an actual function
+        // definition.
+        if (!potentialFunctionDefinitionAtom ||
+            !["define-public", "define-read-only"].includes(potentialFunctionDefinitionAtom.expr.Atom.toString())) {
+            continue;
+        }
+        // The current expression is a function definition. Extract the function
+        // name node, which is the second node in the expression list.
+        const functionNameNode = expressionList[1];
+        // Check if the function name node exists and if it is a list.
+        if (!functionNameNode || !functionNameNode.expr.List) {
+            continue;
+        }
+        // Extract the function definition list.
+        const functionDefinitionList = functionNameNode.expr.List;
+        const functionNameAtom = functionDefinitionList[0];
+        // Check if the function name atom exists.
+        if (!functionNameAtom || !functionNameAtom.expr.Atom) {
+            continue;
+        }
+        const currentFunctionName = functionNameAtom.expr.Atom.toString();
+        // Check if the current function name matches the function name we are
+        // looking for.
+        if (currentFunctionName !== functionName) {
+            continue;
+        }
+        // Bingo! Found the function definition. The function parameters are the
+        // nodes following the function name node.
+        const functionParameterNodes = functionDefinitionList.slice(1);
+        const traitReferenceImportData = findTraitReference(functionParameterNodes, parameterPath);
+        if (traitReferenceImportData[0] !== undefined)
+            return traitReferenceImportData;
+    }
+    return [undefined, undefined];
+};
+exports.getTraitReferenceData = getTraitReferenceData;
+/**
+ * Builds a map of function names to trait reference paths. The trait reference
+ * path is the nesting path of the trait reference in the function parameter
+ * list.
+ * @param functionInterfaces The list of function interfaces for a contract.
+ * @returns The function names mapped to their trait reference parameter paths.
+ */
+const buildTraitReferenceMap = (functionInterfaces) => {
+    const traitReferenceMap = new Map();
+    const findTraitReferences = (args) => {
+        const traitReferences = {};
+        args.forEach((arg) => {
+            if (arg.type && arg.type.tuple) {
+                const nestedTraitReferences = findTraitReferences(arg.type.tuple);
+                if (Object.keys(nestedTraitReferences).length > 0) {
+                    traitReferences[arg.name] = { tuple: nestedTraitReferences };
+                }
+            }
+            else if (arg.type && arg.type.list) {
+                const nestedTraitReferences = findTraitReferences([arg.type.list]);
+                if (Object.keys(nestedTraitReferences).length > 0) {
+                    traitReferences[arg.name] = {
+                        list: nestedTraitReferences["undefined"],
+                    };
+                }
+            }
+            else if (arg.type && arg.type.response) {
+                const okTraitReferences = findTraitReferences([arg.type.response.ok]);
+                const errorTraitReferences = findTraitReferences([
+                    arg.type.response.error,
+                ]);
+                const responseTraitReferences = {};
+                if (Object.keys(okTraitReferences).length > 0) {
+                    responseTraitReferences.ok =
+                        okTraitReferences[arg.name] || "trait_reference";
+                }
+                if (Object.keys(errorTraitReferences).length > 0) {
+                    responseTraitReferences.error =
+                        errorTraitReferences[arg.name] || "trait_reference";
+                }
+                if (Object.keys(responseTraitReferences).length > 0) {
+                    traitReferences[arg.name] = { response: responseTraitReferences };
+                }
+            }
+            else if (arg.type && arg.type.optional) {
+                const nestedTraitReferences = findTraitReferences([arg.type.optional]);
+                if (Object.keys(nestedTraitReferences).length > 0) {
+                    traitReferences[arg.name] = {
+                        optional: nestedTraitReferences[arg.name] || "trait_reference",
+                    };
+                }
+            }
+            else if (arg.type === "trait_reference") {
+                traitReferences[arg.name] = "trait_reference";
+            }
+            else if (arg === "trait_reference") {
+                traitReferences[arg.name] = "trait_reference";
+            }
+        });
+        return traitReferences;
+    };
+    functionInterfaces.forEach((fn) => {
+        const traitReferences = findTraitReferences(fn.args);
+        if (Object.keys(traitReferences).length > 0) {
+            traitReferenceMap.set(fn.name, traitReferences);
+        }
+    });
+    return traitReferenceMap;
+};
+exports.buildTraitReferenceMap = buildTraitReferenceMap;
+/**
+ * Retrieves the contract IDs that implement a given trait.
+ * @param trait The trait to search for.
+ * @param projectTraitImplementations The record of the project contract IDs to
+ * their implemented traits.
+ * @returns An array of contract IDs that implement the trait.
+ */
+const getContractIdsImplementingTrait = (trait, projectTraitImplementations) => {
+    const contracts = Object.keys(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);
+            const isTraitIssuersMatch = JSON.stringify(implementedTrait.contract_identifier.issuer) ===
+                JSON.stringify((_b = trait.import.Imported) === null || _b === void 0 ? void 0 : _b.contract_identifier.issuer);
+            return isTraitNamesMatch && isTraitIssuersMatch;
+        });
+        return traitImplemented;
+    });
+    return filteredContracts;
+};
+exports.getContractIdsImplementingTrait = getContractIdsImplementingTrait;
+/**
+ * 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;
+/**
+ * Iterates over all project contracts's ASTs excluding the boot ones and
+ * extracts a record of contract IDs to their implemented traits.
+ * @param simnet The Simnet instance.
+ * @returns The contract IDs mapped to their implemented traits.
+ */
+const extractProjectTraitImplementations = (simnet) => {
+    const allProjectContracts = [
+        ...simnet.getContractsInterfaces().keys(),
+    ].filter((contractId) => {
+        const contractDeployer = contractId.split(".")[0];
+        return ![
+            "SP000000000000000000002Q6VF78",
+            "ST000000000000000000002AMW42H",
+        ].includes(contractDeployer);
+    });
+    const projectTraitImplementations = allProjectContracts.reduce((acc, contractId) => {
+        const ast = simnet.getContractAST(contractId);
+        const implementedTraits = ast.implemented_traits;
+        if (implementedTraits.length > 0) {
+            acc[contractId] = implementedTraits;
+        }
+        return acc;
+    }, {});
+    return projectTraitImplementations;
+};
+exports.extractProjectTraitImplementations = extractProjectTraitImplementations;

package/dist/traits.types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stacks/rendezvous",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Meet your contract's vulnerabilities head-on.",
   "main": "app.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "build": "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": "npx jest",
     "test:coverage": "npx tsc --project tsconfig.json && npx jest --coverage"
   },
   "keywords": [
@@ -25,6 +25,10 @@
     "README.md",
     "LICENSE"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stacks-network/rendezvous.git"
+  },
   "dependencies": {
     "@hirosystems/clarinet-sdk": "2.12.0",
     "@stacks/transactions": "^6.16.1",
@@ -36,7 +40,7 @@
     "@hirosystems/clarinet-sdk-wasm": "2.12.0",
     "@types/jest": "^29.5.12",
     "jest": "^29.7.0",
-    "ts-jest": "^29.2.3",
+    "ts-jest": "^29.2.5",
     "typescript": "^5.5.4"
   }
 }