@secondlayer/cli 0.3.5 → 0.3.7

package/dist/cli.js

@@ -15617,6 +15617,159 @@ var init_api = __esm(() => {
   };
 });
 
+// src/utils/abi-compat.ts
+function normalizeAccess(access) {
+  if (access === "read_only")
+    return "read-only";
+  return access;
+}
+function normalizeType(type) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+      case "bool":
+      case "principal":
+      case "trait_reference":
+        return type;
+      default:
+        return type;
+    }
+  }
+  if (typeof type !== "object" || type === null) {
+    return "uint128";
+  }
+  const typeObj = type;
+  if ("buffer" in typeObj) {
+    const buffer = typeObj.buffer;
+    return {
+      buff: {
+        length: buffer?.length ?? 32
+      }
+    };
+  }
+  if ("buff" in typeObj) {
+    const buff = typeObj.buff;
+    return {
+      buff: {
+        length: buff?.length ?? 32
+      }
+    };
+  }
+  if ("string-ascii" in typeObj) {
+    const strAscii = typeObj["string-ascii"];
+    return {
+      "string-ascii": {
+        length: strAscii?.length ?? 256
+      }
+    };
+  }
+  if ("string-utf8" in typeObj) {
+    const strUtf8 = typeObj["string-utf8"];
+    return {
+      "string-utf8": {
+        length: strUtf8?.length ?? 256
+      }
+    };
+  }
+  if ("response" in typeObj) {
+    const response2 = typeObj.response;
+    return {
+      response: {
+        ok: normalizeType(response2?.ok ?? "bool"),
+        error: normalizeType(response2?.error ?? "uint128")
+      }
+    };
+  }
+  if ("optional" in typeObj) {
+    return {
+      optional: normalizeType(typeObj.optional)
+    };
+  }
+  if ("list" in typeObj) {
+    const list = typeObj.list;
+    return {
+      list: {
+        type: normalizeType(list?.type ?? "uint128"),
+        length: list?.length ?? 100
+      }
+    };
+  }
+  if ("tuple" in typeObj) {
+    const tuple = typeObj.tuple;
+    return {
+      tuple: tuple.map((field) => ({
+        name: field.name,
+        type: normalizeType(field.type)
+      }))
+    };
+  }
+  return "uint128";
+}
+function normalizeFunction(func) {
+  const access = normalizeAccess(func.access);
+  const args = func.args ?? [];
+  const outputs = func.outputs;
+  return {
+    name: func.name,
+    access,
+    args: args.map((arg) => ({
+      name: arg.name,
+      type: normalizeType(arg.type)
+    })),
+    outputs: normalizeType(typeof outputs === "object" && outputs !== null && "type" in outputs ? outputs.type : outputs)
+  };
+}
+function normalizeMap(map) {
+  return {
+    name: map.name,
+    key: normalizeType(map.key),
+    value: normalizeType(map.value)
+  };
+}
+function normalizeVariable(variable) {
+  return {
+    name: variable.name,
+    type: normalizeType(variable.type),
+    access: variable.access
+  };
+}
+function normalizeAbi(abi) {
+  if (typeof abi !== "object" || abi === null) {
+    return { functions: [] };
+  }
+  const abiObj = abi;
+  const functions = [];
+  const maps = [];
+  const variables = [];
+  if (Array.isArray(abiObj.functions)) {
+    for (const func of abiObj.functions) {
+      if (typeof func === "object" && func !== null) {
+        functions.push(normalizeFunction(func));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.maps)) {
+    for (const map of abiObj.maps) {
+      if (typeof map === "object" && map !== null) {
+        maps.push(normalizeMap(map));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.variables)) {
+    for (const variable of abiObj.variables) {
+      if (typeof variable === "object" && variable !== null) {
+        variables.push(normalizeVariable(variable));
+      }
+    }
+  }
+  return {
+    functions,
+    maps: maps.length > 0 ? maps : undefined,
+    variables: variables.length > 0 ? variables : undefined
+  };
+}
+
 // src/parsers/clarity.ts
 import { promises as fs3 } from "fs";
 async function parseClarityFile(filePath) {
@@ -15703,116 +15856,91 @@ function inferReturnType(body) {
 }
 function parseApiResponse(apiResponse) {
   try {
-    const functions = [];
-    const maps = [];
-    const variables = [];
-    if (apiResponse.functions) {
-      for (const func of apiResponse.functions) {
-        const access = func.access === "read_only" ? "read-only" : func.access;
-        functions.push({
-          name: func.name,
-          access,
-          args: func.args.map((arg) => ({
-            name: arg.name,
-            type: convertApiType(arg.type)
-          })),
-          outputs: convertApiType(func.outputs.type)
-        });
-      }
-    }
-    if (apiResponse.maps) {
-      for (const map of apiResponse.maps) {
-        maps.push({
-          name: map.name,
-          key: convertApiType(map.key),
-          value: convertApiType(map.value)
-        });
-      }
-    }
-    if (apiResponse.variables) {
-      for (const variable of apiResponse.variables) {
-        variables.push({
-          name: variable.name,
-          type: convertApiType(variable.type),
-          access: variable.access
-        });
-      }
-    }
-    return {
-      functions,
-      maps: maps.length > 0 ? maps : undefined,
-      variables: variables.length > 0 ? variables : undefined
-    };
+    return normalizeAbi(apiResponse);
   } catch (error) {
     throw new Error(`Failed to parse API response: ${error}`);
   }
 }
-function convertApiType(apiType) {
-  if (typeof apiType === "string") {
-    if (apiType === "trait_reference") {
-      return "trait_reference";
-    }
-    return parseType(apiType) || "uint128";
-  }
-  if (apiType.response) {
-    return {
-      response: {
-        ok: convertApiType(apiType.response.ok),
-        error: convertApiType(apiType.response.error)
+var init_clarity = () => {};
+
+// src/utils/type-mapping.ts
+import {
+  toCamelCase,
+  isClarityList,
+  isClarityTuple,
+  isClarityOptional,
+  isClarityResponse,
+  isClarityBuffer,
+  isClarityStringAscii,
+  isClarityStringUtf8
+} from "@secondlayer/clarity-types";
+function clarityTypeToTS(type) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+        return "bigint";
+      case "bool":
+        return "boolean";
+      case "principal":
+      case "trait_reference":
+        return "string";
+      default: {
+        const typeStr = type;
+        if (typeStr.includes("string") || typeStr.includes("ascii") || typeStr.includes("utf8")) {
+          return "string";
+        }
+        if (typeStr.includes("buff")) {
+          return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
+        }
+        if (typeStr.includes("uint") || typeStr.includes("int")) {
+          return "bigint";
+        }
+        return "any";
       }
-    };
-  }
-  if (apiType.optional) {
-    return {
-      optional: convertApiType(apiType.optional)
-    };
+    }
   }
-  if (apiType.list) {
-    return {
-      list: {
-        type: convertApiType(apiType.list.type),
-        length: apiType.list.length || 100
-      }
-    };
+  if (isClarityBuffer(type)) {
+    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
   }
-  if (apiType.tuple) {
-    return {
-      tuple: apiType.tuple.map((field) => ({
-        name: field.name,
-        type: convertApiType(field.type)
-      }))
-    };
+  if (isClarityStringAscii(type) || isClarityStringUtf8(type)) {
+    return "string";
   }
-  if (apiType.buffer) {
-    return {
-      buff: {
-        length: apiType.buffer.length || 32
-      }
-    };
+  if (isClarityOptional(type)) {
+    const innerType = clarityTypeToTS(type.optional);
+    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
+      return `(${innerType}) | null`;
+    }
+    return `${innerType} | null`;
   }
-  if (apiType["string-ascii"]) {
-    return {
-      "string-ascii": {
-        length: apiType["string-ascii"].length || 256
-      }
-    };
+  if (isClarityList(type)) {
+    const innerType = clarityTypeToTS(type.list.type);
+    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
+      return `(${innerType})[]`;
+    }
+    return `${innerType}[]`;
   }
-  if (apiType["string-utf8"]) {
-    return {
-      "string-utf8": {
-        length: apiType["string-utf8"].length || 256
-      }
-    };
+  if (isClarityTuple(type)) {
+    const fields = type.tuple.map((field) => `${toCamelCase(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
+    return `{ ${fields} }`;
   }
-  if (apiType === "none") {
-    return "uint128";
+  if (isClarityResponse(type)) {
+    const okType = clarityTypeToTS(type.response.ok);
+    const errType = clarityTypeToTS(type.response.error);
+    return `{ ok: ${okType} } | { err: ${errType} }`;
   }
-  return "uint128";
+  return "any";
 }
-var init_clarity = () => {};
+function getTypeForArg(arg) {
+  return clarityTypeToTS(arg.type);
+}
+var init_type_mapping = () => {};
 
 // src/generators/contract.ts
 import { format } from "prettier";
+import {
+  toCamelCase as toCamelCase2
+} from "@secondlayer/clarity-types";
 function generateNetworkUtils() {
   return `/**
  * API URLs for different networks
@@ -15844,6 +15972,13 @@ function getApiUrl(
   return API_URLS[network];
 }`;
 }
+function generateValidationUtils() {
+  return `/**
+ * Contract name validation regex
+ * Must start with letter, contain only letters, numbers, and hyphens, max 128 chars
+ */
+const CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9\\-]{0,127}$/;`;
+}
 async function generateContractInterface(contracts) {
   const imports = `import { Cl, validateStacksAddress } from '@stacks/transactions'`;
   const header = `/**
@@ -15852,6 +15987,7 @@ async function generateContractInterface(contracts) {
  *
  * @requires @stacks/transactions - Install with: npm install @stacks/transactions
  */`;
+  const validationUtils = generateValidationUtils();
   const networkUtils = generateNetworkUtils();
   const contractsCode = contracts.map((contract) => generateContract(contract)).join(`
 
@@ -15860,6 +15996,8 @@ async function generateContractInterface(contracts) {
 
 ${header}
 
+${validationUtils}
+
 ${networkUtils}
 
 ${contractsCode}`;
@@ -15900,7 +16038,7 @@ function generateAbiConstant(name, abi) {
   return `export const ${name}Abi = ${abiJson} as const`;
 }
 function generateMethod(func, address, contractName) {
-  const methodName = toCamelCase(func.name);
+  const methodName = toCamelCase2(func.name);
   if (func.args.length === 0) {
     return `${methodName}() {
     return {
@@ -15913,7 +16051,7 @@ function generateMethod(func, address, contractName) {
   }
   if (func.args.length === 1) {
     const originalArgName = func.args[0].name;
-    const argName = toCamelCase(originalArgName);
+    const argName = toCamelCase2(originalArgName);
     const argType = getTypeForArg(func.args[0]);
     const clarityConversion = generateClarityConversion(argName, func.args[0]);
     return `${methodName}(...args: [{ ${argName}: ${argType} }] | [${argType}]) {
@@ -15929,17 +16067,17 @@ function generateMethod(func, address, contractName) {
     }
   }`;
   }
-  const argsList = func.args.map((arg) => toCamelCase(arg.name)).join(", ");
+  const argsList = func.args.map((arg) => toCamelCase2(arg.name)).join(", ");
   const argsTypes = func.args.map((arg) => {
-    const camelName = toCamelCase(arg.name);
+    const camelName = toCamelCase2(arg.name);
     return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   const argsArray = func.args.map((arg) => {
-    const argName = toCamelCase(arg.name);
+    const argName = toCamelCase2(arg.name);
     return generateClarityConversion(argName, arg);
   }).join(", ");
   const objectAccess = func.args.map((arg) => {
-    const camelName = toCamelCase(arg.name);
+    const camelName = toCamelCase2(arg.name);
     return `args[0].${camelName}`;
   }).join(", ");
   const positionTypes = func.args.map((arg) => getTypeForArg(arg)).join(", ");
@@ -15956,50 +16094,6 @@ function generateMethod(func, address, contractName) {
     }
   }`;
 }
-function getTypeForArg(arg) {
-  const type = arg.type;
-  if (typeof type === "string") {
-    switch (type) {
-      case "uint128":
-      case "int128":
-        return "bigint";
-      case "bool":
-        return "boolean";
-      case "principal":
-      case "trait_reference":
-        return "string";
-      default:
-        return "any";
-    }
-  }
-  if (type["string-ascii"] || type["string-utf8"]) {
-    return "string";
-  }
-  if (type.buff) {
-    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
-  }
-  if (type.optional) {
-    const innerType = getTypeForArg({ type: type.optional });
-    return `${innerType} | null`;
-  }
-  if (type.list) {
-    const innerType = getTypeForArg({ type: type.list.type });
-    return `${innerType}[]`;
-  }
-  if (type.tuple) {
-    const fields = type.tuple.map((field) => `${toCamelCase(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
-    return `{ ${fields} }`;
-  }
-  if (type.response) {
-    const okType = getTypeForArg({ type: type.response.ok });
-    const errType = getTypeForArg({ type: type.response.error });
-    return `{ ok: ${okType} } | { err: ${errType} }`;
-  }
-  return "any";
-}
-function toCamelCase(str) {
-  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "");
-}
 function generateClarityConversion(argName, argType) {
   const type = argType.type;
   if (typeof type === "string") {
@@ -16013,11 +16107,14 @@ function generateClarityConversion(argName, argType) {
       case "principal":
       case "trait_reference":
         return `(() => {
-          const [address, contractName] = ${argName}.split(".") as [string, string];
+          const [address, contractName] = ${argName}.split(".") as [string, string | undefined];
           if (!validateStacksAddress(address)) {
             throw new Error("Invalid Stacks address format");
           }
-          if (${argName}.includes(".")) {
+          if (contractName !== undefined) {
+            if (!CONTRACT_NAME_REGEX.test(contractName)) {
+              throw new Error("Invalid contract name format: must start with letter and contain only letters, numbers, and hyphens");
+            }
             return Cl.contractPrincipal(address, contractName);
           }
           return Cl.standardPrincipal(${argName});
@@ -16079,24 +16176,54 @@ function generateClarityConversion(argName, argType) {
     const innerConversion = generateClarityConversion("item", {
       type: type.list.type
     });
-    return `Cl.list(${argName}.map(item => ${innerConversion}))`;
+    const maxLength = type.list.length || 100;
+    return `(() => {
+      const listValue = ${argName};
+      if (listValue.length > ${maxLength}) {
+        throw new Error(\`List length \${listValue.length} exceeds max ${maxLength}\`);
+      }
+      return Cl.list(listValue.map(item => ${innerConversion}));
+    })()`;
   }
   if (type.tuple) {
+    const requiredFields = type.tuple.map((f) => f.name);
+    const fieldNames = JSON.stringify(requiredFields);
     const fields = type.tuple.map((field) => {
-      const camelFieldName = toCamelCase(field.name);
-      const fieldConversion = generateClarityConversion(`${argName}.${camelFieldName}`, { type: field.type });
+      const camelFieldName = toCamelCase2(field.name);
+      const fieldConversion = generateClarityConversion(`tupleValue.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
-    return `Cl.tuple({ ${fields} })`;
+    return `(() => {
+      const tupleValue = ${argName};
+      const requiredFields = ${fieldNames};
+      for (const fieldName of requiredFields) {
+        const camelName = fieldName.replace(/-([a-z])/g, (_: string, l: string) => l.toUpperCase());
+        if (!(fieldName in tupleValue) && !(camelName in tupleValue)) {
+          throw new Error(\`Missing tuple field: \${fieldName}\`);
+        }
+      }
+      return Cl.tuple({ ${fields} });
+    })()`;
   }
   if (type.response) {
-    const okConversion = generateClarityConversion(`${argName}.ok`, {
+    const okConversion = generateClarityConversion(`responseValue.ok`, {
       type: type.response.ok
     });
-    const errConversion = generateClarityConversion(`${argName}.err`, {
+    const errConversion = generateClarityConversion(`responseValue.err`, {
       type: type.response.error
     });
-    return `'ok' in ${argName} ? Cl.ok(${okConversion.replace(`${argName}.ok`, `${argName}.ok`)}) : Cl.error(${errConversion.replace(`${argName}.err`, `${argName}.err`)})`;
+    return `(() => {
+      const responseValue = ${argName};
+      const hasOk = 'ok' in responseValue;
+      const hasErr = 'err' in responseValue;
+      if (hasOk && !hasErr) {
+        return Cl.ok(${okConversion});
+      }
+      if (hasErr && !hasOk) {
+        return Cl.error(${errConversion});
+      }
+      throw new Error("Response must have exactly 'ok' or 'err' property");
+    })()`;
   }
   return `${argName}`;
 }
@@ -16105,7 +16232,7 @@ function generateMapsObject(maps, address, contractName) {
     return "";
   }
   const mapMethods = maps.map((map) => {
-    const methodName = toCamelCase(map.name);
+    const methodName = toCamelCase2(map.name);
     const keyType = getTypeForArg({ type: map.key });
     const valueType = getTypeForArg({ type: map.value });
     const keyConversion = generateMapKeyConversion(map.key);
@@ -16159,7 +16286,7 @@ function generateVarsObject(variables, address, contractName) {
     return "";
   }
   const varMethods = dataVars.map((variable) => {
-    const methodName = toCamelCase(variable.name);
+    const methodName = toCamelCase2(variable.name);
     const valueType = getTypeForArg({ type: variable.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -16197,7 +16324,7 @@ function generateConstantsObject(variables, address, contractName) {
     return "";
   }
   const constMethods = constants.map((constant) => {
-    const methodName = toCamelCase(constant.name);
+    const methodName = toCamelCase2(constant.name);
     const valueType = getTypeForArg({ type: constant.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -16229,7 +16356,7 @@ function generateConstantsObject(variables, address, contractName) {
 function generateMapKeyConversion(keyType) {
   if (keyType.tuple) {
     const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase(field.name);
+      const camelFieldName = toCamelCase2(field.name);
       const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -16237,7 +16364,9 @@ function generateMapKeyConversion(keyType) {
   }
   return generateClarityConversion("key", { type: keyType });
 }
-var init_contract = () => {};
+var init_contract = __esm(() => {
+  init_type_mapping();
+});
 
 // ../../node_modules/ansis/index.cjs
 var require_ansis = __commonJS((exports, module) => {
@@ -27838,7 +27967,7 @@ function deriveContractName(filePath) {
   const basename = path11.basename(filePath, ".clar");
   return basename.replace(/[-_](.)/g, (_2, char) => char.toUpperCase()).replace(/^(.)/, (_2, char) => char.toLowerCase()).replace(/^\d/, "_$&");
 }
-function toCamelCase2(str) {
+function toCamelCase3(str) {
   return str.replace(/[-_](.)/g, (_2, char) => char.toUpperCase()).replace(/^(.)/, (_2, char) => char.toLowerCase()).replace(/^\d/, "_$&");
 }
 async function buildConfigFromInputs(parsedInputs, outPath, apiKey) {
@@ -27860,7 +27989,7 @@ async function buildConfigFromInputs(parsedInputs, outPath, apiKey) {
       const apiClient = new StacksApiClient(network, apiKey);
       const contractInfo = await apiClient.getContractInfo(contractId);
       const abi = parseApiResponse(contractInfo);
-      const name = toCamelCase2(contractName);
+      const name = toCamelCase3(contractName);
       contracts.push({
         name,
         address: contractId,
@@ -28105,7 +28234,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "0.3.5",
+  version: "0.3.7",
   description: "CLI for generating type-safe contract interfaces for the Stacks blockchain",
   type: "module",
   bin: {
@@ -28144,7 +28273,7 @@ var package_default = {
   author: "",
   license: "MIT",
   dependencies: {
-    "@secondlayer/clarity-types": "^0.4.0",
+    "@secondlayer/clarity-types": "^0.4.1",
     "@stacks/transactions": "7.0.6",
     esbuild: "^0.19.0",
     prettier: "^3.1.0"
@@ -28181,5 +28310,5 @@ program.command("init").description("Initialize a new stacks.config.ts file").ac
 });
 program.parse();
 
-//# debugId=3733E41892E3FCC464756E2164756E21
+//# debugId=58D4865FBB414E7B64756E2164756E21
 //# sourceMappingURL=cli.js.map