@secondlayer/cli 0.3.5 → 0.3.7

package/dist/index.js

@@ -318,6 +318,83 @@ import { initSimnet } from "@hirosystems/clarinet-sdk";
 
 // src/generators/contract.ts
 import { format } from "prettier";
+import {
+  toCamelCase as toCamelCase2
+} from "@secondlayer/clarity-types";
+
+// 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 (isClarityBuffer(type)) {
+    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
+  }
+  if (isClarityStringAscii(type) || isClarityStringUtf8(type)) {
+    return "string";
+  }
+  if (isClarityOptional(type)) {
+    const innerType = clarityTypeToTS(type.optional);
+    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
+      return `(${innerType}) | null`;
+    }
+    return `${innerType} | null`;
+  }
+  if (isClarityList(type)) {
+    const innerType = clarityTypeToTS(type.list.type);
+    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
+      return `(${innerType})[]`;
+    }
+    return `${innerType}[]`;
+  }
+  if (isClarityTuple(type)) {
+    const fields = type.tuple.map((field) => `${toCamelCase(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
+    return `{ ${fields} }`;
+  }
+  if (isClarityResponse(type)) {
+    const okType = clarityTypeToTS(type.response.ok);
+    const errType = clarityTypeToTS(type.response.error);
+    return `{ ok: ${okType} } | { err: ${errType} }`;
+  }
+  return "any";
+}
+function getTypeForArg(arg) {
+  return clarityTypeToTS(arg.type);
+}
+
+// src/generators/contract.ts
 function generateNetworkUtils() {
   return `/**
  * API URLs for different networks
@@ -349,6 +426,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 = `/**
@@ -357,6 +441,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(`
 
@@ -365,6 +450,8 @@ async function generateContractInterface(contracts) {
 
 ${header}
 
+${validationUtils}
+
 ${networkUtils}
 
 ${contractsCode}`;
@@ -405,7 +492,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 {
@@ -418,7 +505,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}]) {
@@ -434,17 +521,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(", ");
@@ -461,50 +548,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") {
@@ -518,11 +561,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});
@@ -584,24 +630,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}`;
 }
@@ -610,7 +686,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);
@@ -664,7 +740,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}> {
@@ -702,7 +778,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}> {
@@ -734,7 +810,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(", ");
@@ -744,11 +820,11 @@ function generateMapKeyConversion(keyType) {
 }
 
 // src/plugins/clarinet/index.ts
-function toCamelCase2(str) {
+function toCamelCase3(str) {
   return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
 }
 function sanitizeContractName(name) {
-  return toCamelCase2(name);
+  return toCamelCase3(name);
 }
 async function isUserDefinedContract(contractId, manifestPath) {
   const [address, contractName] = contractId.split(".");
@@ -858,56 +934,13 @@ async function hasClarinetProject(path2 = "./Clarinet.toml") {
   }
 }
 // src/plugins/actions/generators.ts
-function toCamelCase3(str) {
-  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
-}
-function getTypeForArg2(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 = getTypeForArg2({ type: type.optional });
-    return `${innerType} | null`;
-  }
-  if (type.list) {
-    const innerType = getTypeForArg2({ type: type.list.type });
-    return `${innerType}[]`;
-  }
-  if (type.tuple) {
-    const fields = type.tuple.map((field) => `${toCamelCase3(field.name)}: ${getTypeForArg2({ type: field.type })}`).join("; ");
-    return `{ ${fields} }`;
-  }
-  if (type.response) {
-    const okType = getTypeForArg2({ type: type.response.ok });
-    const errType = getTypeForArg2({ type: type.response.error });
-    return `{ ok: ${okType} } | { err: ${errType} }`;
-  }
-  return "any";
-}
+import { toCamelCase as toCamelCase4 } from "@secondlayer/clarity-types";
 function generateArgsSignature(args) {
   if (args.length === 0)
     return "";
   const argsTypes = args.map((arg) => {
-    const camelName = toCamelCase3(arg.name);
-    return `${camelName}: ${getTypeForArg2(arg)}`;
+    const camelName = toCamelCase4(arg.name);
+    return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   return `args: { ${argsTypes} }, `;
 }
@@ -915,7 +948,7 @@ function generateClarityArgs(args, _contractName) {
   if (args.length === 0)
     return "";
   return args.map((arg) => {
-    const argName = `args.${toCamelCase3(arg.name)}`;
+    const argName = `args.${toCamelCase4(arg.name)}`;
     return generateClarityConversion2(argName, arg);
   }).join(", ");
 }
@@ -932,11 +965,14 @@ function generateClarityConversion2(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});
@@ -992,24 +1028,54 @@ function generateClarityConversion2(argName, argType) {
     const innerConversion = generateClarityConversion2("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 = toCamelCase3(field.name);
-      const fieldConversion = generateClarityConversion2(`${argName}.${camelFieldName}`, { type: field.type });
+      const camelFieldName = toCamelCase4(field.name);
+      const fieldConversion = generateClarityConversion2(`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 = generateClarityConversion2(`${argName}.ok`, {
+    const okConversion = generateClarityConversion2(`responseValue.ok`, {
       type: type.response.ok
     });
-    const errConversion = generateClarityConversion2(`${argName}.err`, {
+    const errConversion = generateClarityConversion2(`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}`;
 }
@@ -1033,7 +1099,7 @@ function generateReadHelpers(contract, options) {
     return "";
   }
   const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase3(func.name);
+    const methodName = toCamelCase4(func.name);
     const argsSignature = generateArgsSignature(func.args);
     const clarityArgs = generateClarityArgs(func.args, name);
     return `async ${methodName}(${argsSignature}options?: {
@@ -1076,7 +1142,7 @@ function generateWriteHelpers(contract, options) {
     return "";
   }
   const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase3(func.name);
+    const methodName = toCamelCase4(func.name);
     const argsSignature = generateArgsSignature(func.args);
     const clarityArgs = generateClarityArgs(func.args, name);
     return `async ${methodName}(${argsSignature}options: {
@@ -2124,38 +2190,36 @@ function generateGenericHook(hookName) {
 import { format as format4 } from "prettier";
 
 // src/plugins/react/generators/utils.ts
-function toCamelCase4(str) {
-  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-}
+import { toCamelCase as toCamelCase5 } from "@secondlayer/clarity-types";
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function generateHookArgsSignature(args) {
   if (args.length === 0)
     return "";
-  const argsList = args.map((arg) => `${toCamelCase4(arg.name)}: ${mapClarityTypeToTS(arg.type)}`).join(", ");
+  const argsList = args.map((arg) => `${toCamelCase5(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
   return `${argsList}`;
 }
 function generateArgsType(args) {
   if (args.length === 0)
     return "void";
-  const argsList = args.map((arg) => `${toCamelCase4(arg.name)}: ${mapClarityTypeToTS(arg.type)}`).join("; ");
+  const argsList = args.map((arg) => `${toCamelCase5(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
   return `{ ${argsList} }`;
 }
 function generateQueryKeyArgs(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => toCamelCase4(arg.name)).join(", ");
+  return args.map((arg) => toCamelCase5(arg.name)).join(", ");
 }
 function generateFunctionCallArgs(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => toCamelCase4(arg.name)).join(", ");
+  return args.map((arg) => toCamelCase5(arg.name)).join(", ");
 }
 function generateEnabledCondition(args) {
   return args.map((arg) => {
-    const camelName = toCamelCase4(arg.name);
-    const type = mapClarityTypeToTS(arg.type);
+    const camelName = toCamelCase5(arg.name);
+    const type = clarityTypeToTS(arg.type);
     if (type === "string")
       return `!!${camelName}`;
     if (type === "bigint")
@@ -2163,62 +2227,10 @@ function generateEnabledCondition(args) {
     return `${camelName} !== undefined`;
   }).join(" && ");
 }
-function mapClarityTypeToTS(clarityType) {
-  if (typeof clarityType !== "string") {
-    if (clarityType?.uint || clarityType?.int)
-      return "bigint";
-    if (clarityType?.principal)
-      return "string";
-    if (clarityType?.bool)
-      return "boolean";
-    if (clarityType?.string || clarityType?.ascii)
-      return "string";
-    if (clarityType?.["string-ascii"] || clarityType?.["string-utf8"])
-      return "string";
-    if (clarityType?.buff)
-      return "Uint8Array";
-    if (clarityType?.optional) {
-      const innerType = mapClarityTypeToTS(clarityType.optional);
-      return `${innerType} | null`;
-    }
-    if (clarityType?.response) {
-      const okType = mapClarityTypeToTS(clarityType.response.ok);
-      const errType = mapClarityTypeToTS(clarityType.response.error);
-      return `{ ok: ${okType} } | { err: ${errType} }`;
-    }
-    if (clarityType?.tuple) {
-      const fields = clarityType.tuple.map((field) => `${toCamelCase4(field.name)}: ${mapClarityTypeToTS(field.type)}`).join("; ");
-      return `{ ${fields} }`;
-    }
-    if (clarityType?.list) {
-      const innerType = mapClarityTypeToTS(clarityType.list.type);
-      if (innerType.includes(" | ")) {
-        return `(${innerType})[]`;
-      }
-      return `${innerType}[]`;
-    }
-    return "any";
-  }
-  if (clarityType.includes("uint") || clarityType.includes("int"))
-    return "bigint";
-  if (clarityType.includes("principal"))
-    return "string";
-  if (clarityType.includes("bool"))
-    return "boolean";
-  if (clarityType.includes("string") || clarityType.includes("ascii"))
-    return "string";
-  if (clarityType.includes("buff"))
-    return "Uint8Array";
-  if (clarityType.includes("optional")) {
-    const innerType = clarityType.replace(/optional\s*/, "").trim();
-    return `${mapClarityTypeToTS(innerType)} | null`;
-  }
-  return "any";
-}
 function generateObjectArgs(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => `${arg.name}: ${toCamelCase4(arg.name)}`).join(", ");
+  return args.map((arg) => `${arg.name}: ${toCamelCase5(arg.name)}`).join(", ");
 }
 
 // src/plugins/react/generators/contract.ts
@@ -2258,21 +2270,21 @@ function generateContractHookMethods(contract, excludeList) {
   const readOnlyFunctions = functions.filter((f) => f.access === "read_only" || f.access === "read-only");
   const publicFunctions = functions.filter((f) => f.access === "public");
   const readHooks = readOnlyFunctions.map((func) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase5(func.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
     return generateReadHook(func, name);
   }).filter(Boolean);
   const writeHooks = publicFunctions.map((func) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase5(func.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
     return generateWriteHook(func, name);
   }).filter(Boolean);
   const mapHooks = maps.map((map) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(map.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase5(map.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -2280,7 +2292,7 @@ function generateContractHookMethods(contract, excludeList) {
   }).filter(Boolean);
   const dataVars = variables.filter((v) => v.access === "variable");
   const varHooks = dataVars.map((variable) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(variable.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase5(variable.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -2288,7 +2300,7 @@ function generateContractHookMethods(contract, excludeList) {
   }).filter(Boolean);
   const constants = variables.filter((v) => v.access === "constant");
   const constantHooks = constants.map((constant) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(constant.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase5(constant.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -2303,16 +2315,16 @@ function generateContractHookMethods(contract, excludeList) {
 `);
 }
 function generateReadHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase4(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase5(func.name))}`;
   const argsSignature = generateHookArgsSignature(func.args);
   const enabledParam = func.args.length > 0 ? ", options?: { enabled?: boolean }" : "options?: { enabled?: boolean }";
-  const returnType = mapClarityTypeToTS(func.outputs);
+  const returnType = clarityTypeToTS(func.outputs);
   return `export function ${hookName}(${argsSignature}${enabledParam}) {
   const config = useStacksConfig()
 
   return useQuery<${returnType}>({
     queryKey: ['${func.name}', ${contractName}.address, ${generateQueryKeyArgs(func.args)}],
-    queryFn: () => ${contractName}.read.${toCamelCase4(func.name)}(${generateFunctionCallArgs(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
+    queryFn: () => ${contractName}.read.${toCamelCase5(func.name)}(${generateFunctionCallArgs(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
       network: config.network,
       senderAddress: config.senderAddress || 'SP000000000000000000002Q6VF78'
     }),
@@ -2322,7 +2334,7 @@ function generateReadHook(func, contractName) {
 }`;
 }
 function generateWriteHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase4(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase5(func.name))}`;
   const argsType = generateArgsType(func.args);
   return `export function ${hookName}() {
   const config = useStacksConfig()
@@ -2339,7 +2351,7 @@ function generateWriteHook(func, contractName) {
       };
     }) => {
       const { args, options = {} } = params
-      const contractCallData = ${contractName}.${toCamelCase4(func.name)}(args)
+      const contractCallData = ${contractName}.${toCamelCase5(func.name)}(args)
       const { contractAddress, contractName: name, functionName, functionArgs } = contractCallData
       const network = config.network || 'mainnet'
       const contract = \`\${contractAddress}.\${name}\`
@@ -2389,7 +2401,7 @@ function generateWriteHook(func, contractName) {
     }
   })
 
-  const ${toCamelCase4(func.name)} = useCallback(async (
+  const ${toCamelCase5(func.name)} = useCallback(async (
     args: ${argsType},
     options?: {
       postConditions?: PostCondition[];
@@ -2402,7 +2414,7 @@ function generateWriteHook(func, contractName) {
   }, [mutation])
 
   return {
-    ${toCamelCase4(func.name)},
+    ${toCamelCase5(func.name)},
     // Expose mutation state
     isPending: mutation.isPending,
     isError: mutation.isError,
@@ -2414,46 +2426,46 @@ function generateWriteHook(func, contractName) {
 }`;
 }
 function generateMapHook(map, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(map.name))}`;
-  const keyType = mapClarityTypeToTS(map.key);
-  const valueType = mapClarityTypeToTS(map.value);
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase5(map.name))}`;
+  const keyType = clarityTypeToTS(map.key);
+  const valueType = clarityTypeToTS(map.value);
   return `export function ${hookName}(key: ${keyType}, options?: { enabled?: boolean }) {
   const config = useStacksConfig()
 
   return useQuery<${valueType} | null>({
     queryKey: ['${contractVarName}', '${map.name}', 'map', key, config.network],
     queryFn: async () => {
-      return ${contractVarName}.maps.${toCamelCase4(map.name)}.get(key, { network: config.network })
+      return ${contractVarName}.maps.${toCamelCase5(map.name)}.get(key, { network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateVarHook(variable, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(variable.name))}`;
-  const valueType = mapClarityTypeToTS(variable.type);
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase5(variable.name))}`;
+  const valueType = clarityTypeToTS(variable.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useStacksConfig()
 
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${variable.name}', 'var', config.network],
     queryFn: async () => {
-      return ${contractVarName}.vars.${toCamelCase4(variable.name)}.get({ network: config.network })
+      return ${contractVarName}.vars.${toCamelCase5(variable.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateConstantHook(constant, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(constant.name))}`;
-  const valueType = mapClarityTypeToTS(constant.type);
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase5(constant.name))}`;
+  const valueType = clarityTypeToTS(constant.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useStacksConfig()
 
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${constant.name}', 'constant', config.network],
     queryFn: async () => {
-      return ${contractVarName}.constants.${toCamelCase4(constant.name)}.get({ network: config.network })
+      return ${contractVarName}.constants.${toCamelCase5(constant.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true,
     staleTime: Infinity // Constants never change
@@ -2500,60 +2512,19 @@ var react = (options = {}) => {
   };
 };
 // src/plugins/testing/generators.ts
-function toCamelCase5(str) {
-  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
-}
+import {
+  toCamelCase as toCamelCase6
+} from "@secondlayer/clarity-types";
 function toPascalCase(str) {
-  const camel = toCamelCase5(str);
+  const camel = toCamelCase6(str);
   return camel.charAt(0).toUpperCase() + camel.slice(1);
 }
-function getTypeForArg3(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 = getTypeForArg3({ type: type.optional });
-    return `${innerType} | null`;
-  }
-  if (type.list) {
-    const innerType = getTypeForArg3({ type: type.list.type });
-    return `${innerType}[]`;
-  }
-  if (type.tuple) {
-    const fields = type.tuple.map((field) => `${toCamelCase5(field.name)}: ${getTypeForArg3({ type: field.type })}`).join("; ");
-    return `{ ${fields} }`;
-  }
-  if (type.response) {
-    const okType = getTypeForArg3({ type: type.response.ok });
-    const errType = getTypeForArg3({ type: type.response.error });
-    return `{ ok: ${okType} } | { err: ${errType} }`;
-  }
-  return "any";
-}
 function generateArgsSignature2(args) {
   if (args.length === 0)
     return "";
   const argsTypes = args.map((arg) => {
-    const camelName = toCamelCase5(arg.name);
-    return `${camelName}: ${getTypeForArg3(arg)}`;
+    const camelName = toCamelCase6(arg.name);
+    return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   return `args: { ${argsTypes} }, `;
 }
@@ -2628,24 +2599,54 @@ function generateClarityConversion3(argName, argType) {
     const innerConversion = generateClarityConversion3("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 = toCamelCase5(field.name);
-      const fieldConversion = generateClarityConversion3(`${argName}.${camelFieldName}`, { type: field.type });
+      const camelFieldName = toCamelCase6(field.name);
+      const fieldConversion = generateClarityConversion3(`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 = generateClarityConversion3(`${argName}.ok`, {
+    const okConversion = generateClarityConversion3(`responseValue.ok`, {
       type: type.response.ok
     });
-    const errConversion = generateClarityConversion3(`${argName}.err`, {
+    const errConversion = generateClarityConversion3(`responseValue.err`, {
       type: type.response.error
     });
-    return `'ok' in ${argName} ? Cl.ok(${okConversion}) : Cl.error(${errConversion})`;
+    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}`;
 }
@@ -2653,12 +2654,12 @@ function generateClarityArgs2(args) {
   if (args.length === 0)
     return "";
   return args.map((arg) => {
-    const argName = `args.${toCamelCase5(arg.name)}`;
+    const argName = `args.${toCamelCase6(arg.name)}`;
     return generateClarityConversion3(argName, arg);
   }).join(", ");
 }
 function generatePublicFunction(func, contractId) {
-  const methodName = toCamelCase5(func.name);
+  const methodName = toCamelCase6(func.name);
   const argsSignature = generateArgsSignature2(func.args);
   const clarityArgs = generateClarityArgs2(func.args);
   return `${methodName}: (${argsSignature}caller: string) => {
@@ -2672,7 +2673,7 @@ function generatePublicFunction(func, contractId) {
     }`;
 }
 function generateReadOnlyFunction(func, contractId) {
-  const methodName = toCamelCase5(func.name);
+  const methodName = toCamelCase6(func.name);
   const argsSignature = generateArgsSignature2(func.args);
   const clarityArgs = generateClarityArgs2(func.args);
   const hasArgs = func.args.length > 0;
@@ -2687,7 +2688,7 @@ function generateReadOnlyFunction(func, contractId) {
     }`;
 }
 function generatePrivateFunction(func, contractId) {
-  const methodName = toCamelCase5(func.name);
+  const methodName = toCamelCase6(func.name);
   const argsSignature = generateArgsSignature2(func.args);
   const clarityArgs = generateClarityArgs2(func.args);
   return `${methodName}: (${argsSignature}caller: string) => {
@@ -2701,22 +2702,22 @@ function generatePrivateFunction(func, contractId) {
     }`;
 }
 function generateDataVarHelper(variable, contractId) {
-  const methodName = toCamelCase5(variable.name);
+  const methodName = toCamelCase6(variable.name);
   return `${methodName}: () => {
       return simnet.getDataVar('${contractId}', '${variable.name}');
     }`;
 }
 function getMapKeyType(keyType) {
   if (keyType.tuple) {
-    const fields = keyType.tuple.map((field) => `${toCamelCase5(field.name)}: ${getTypeForArg3({ type: field.type })}`).join("; ");
+    const fields = keyType.tuple.map((field) => `${toCamelCase6(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
     return `{ ${fields} }`;
   }
-  return getTypeForArg3({ type: keyType });
+  return getTypeForArg({ type: keyType });
 }
 function generateMapKeyConversion2(keyType) {
   if (keyType.tuple) {
     const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase5(field.name);
+      const camelFieldName = toCamelCase6(field.name);
       const fieldConversion = generateClarityConversion3(`key.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -2725,7 +2726,7 @@ function generateMapKeyConversion2(keyType) {
   return generateClarityConversion3("key", { type: keyType });
 }
 function generateMapEntryHelper(map, contractId) {
-  const methodName = toCamelCase5(map.name);
+  const methodName = toCamelCase6(map.name);
   const keyType = getMapKeyType(map.key);
   const keyConversion = generateMapKeyConversion2(map.key);
   return `${methodName}: (key: ${keyType}) => {
@@ -2795,7 +2796,7 @@ function generateContractHelper(contract, options) {
 }
 function generateGetContracts(contracts) {
   const contractEntries = contracts.map((contract) => {
-    const camelName = toCamelCase5(contract.name);
+    const camelName = toCamelCase6(contract.name);
     const pascalName = toPascalCase(contract.name);
     return `${camelName}: get${pascalName}(simnet)`;
   }).join(`,
@@ -2923,5 +2924,5 @@ export {
   PluginManager
 };
 
-//# debugId=AA54807E287F170A64756E2164756E21
+//# debugId=7C8745101A6FCC2D64756E2164756E21
 //# sourceMappingURL=index.js.map