@secondlayer/cli 8.6.1 → 8.6.3

package/dist/plugins/index.js

@@ -387,562 +387,15 @@ var init_plugin_manager = __esm(() => {
   validateStacksAddress = _validateStacksAddress;
 });
 
-// src/utils/clarity-conversion.ts
-import {
-  isAbiBuffer,
-  isAbiList,
-  isAbiOptional,
-  isAbiResponse,
-  isAbiStringAscii,
-  isAbiStringUtf8,
-  isAbiTuple,
-  toCamelCase as toCamelCase2
-} from "@secondlayer/stacks/clarity";
-function generateClarityConversion(argName, argType) {
-  const type = argType.type;
-  if (typeof type === "string") {
-    switch (type) {
-      case "uint128":
-        return `Cl.uint(${argName})`;
-      case "int128":
-        return `Cl.int(${argName})`;
-      case "bool":
-        return `Cl.bool(${argName})`;
-      case "principal":
-      case "trait_reference":
-        return `(() => {
-          const [address, contractName] = ${argName}.split(".") as [string, string | undefined];
-          if (!validateStacksAddress(address)) {
-            throw new Error("Invalid Stacks address format");
-          }
-          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});
-        })()`;
-      default:
-        return `${argName}`;
-    }
-  }
-  if (isAbiStringAscii(type)) {
-    return `Cl.stringAscii(${argName})`;
-  }
-  if (isAbiStringUtf8(type)) {
-    return `Cl.stringUtf8(${argName})`;
-  }
-  if (isAbiBuffer(type)) {
-    return `(() => {
-      const value = ${argName};
-      if (value instanceof Uint8Array) {
-        return Cl.buffer(value);
-      }
-      if (typeof value === 'object' && value !== null && value.type && value.value) {
-        switch (value.type) {
-          case 'ascii':
-            return Cl.bufferFromAscii(value.value);
-          case 'utf8':
-            return Cl.bufferFromUtf8(value.value);
-          case 'hex':
-            return Cl.bufferFromHex(value.value);
-          default:
-            throw new Error(\`Unsupported buffer type: \${value.type}\`);
-        }
-      }
-      if (typeof value === 'string') {
-        if (value.startsWith('0x') || /^[0-9a-fA-F]+$/.test(value)) {
-          return Cl.bufferFromHex(value);
-        }
-        const hasNonAscii = value.split('').some(char => char.charCodeAt(0) > 127);
-        if (hasNonAscii) {
-          return Cl.bufferFromUtf8(value);
-        }
-        return Cl.bufferFromAscii(value);
-      }
-      throw new Error(\`Invalid buffer value: \${value}\`);
-    })()`;
-  }
-  if (isAbiOptional(type)) {
-    const innerConversion = generateClarityConversion(argName, {
-      type: type.optional
-    });
-    return `${argName} !== null ? Cl.some(${innerConversion.replace(argName, `${argName}`)}) : Cl.none()`;
-  }
-  if (isAbiList(type)) {
-    const innerConversion = generateClarityConversion("item", {
-      type: type.list.type
-    });
-    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 (isAbiTuple(type)) {
-    const requiredFields = type.tuple.map((f) => f.name);
-    const fieldNames = JSON.stringify(requiredFields);
-    const fields = type.tuple.map((field) => {
-      const camelFieldName = toCamelCase2(field.name);
-      const fieldConversion = generateClarityConversion(`tupleValue.${camelFieldName}`, { type: field.type });
-      return `"${field.name}": ${fieldConversion}`;
-    }).join(", ");
-    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 (isAbiResponse(type)) {
-    const okConversion = generateClarityConversion("responseValue.ok", {
-      type: type.response.ok
-    });
-    const errConversion = generateClarityConversion("responseValue.err", {
-      type: type.response.error
-    });
-    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}`;
-}
-var init_clarity_conversion = () => {};
-
-// src/utils/type-mapping.ts
-import {
-  isAbiBuffer as isAbiBuffer2,
-  isAbiList as isAbiList2,
-  isAbiOptional as isAbiOptional2,
-  isAbiResponse as isAbiResponse2,
-  isAbiStringAscii as isAbiStringAscii2,
-  isAbiStringUtf8 as isAbiStringUtf82,
-  isAbiTuple as isAbiTuple2,
-  toCamelCase as toCamelCase3
-} from "@secondlayer/stacks/clarity";
-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 === "none") {
-          return "null";
-        }
-        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 (isAbiBuffer2(type)) {
-    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
-  }
-  if (isAbiStringAscii2(type) || isAbiStringUtf82(type)) {
-    return "string";
-  }
-  if (isAbiOptional2(type)) {
-    const innerType = clarityTypeToTS(type.optional);
-    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
-      return `(${innerType}) | null`;
-    }
-    return `${innerType} | null`;
-  }
-  if (isAbiList2(type)) {
-    const innerType = clarityTypeToTS(type.list.type);
-    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
-      return `(${innerType})[]`;
-    }
-    return `${innerType}[]`;
-  }
-  if (isAbiTuple2(type)) {
-    const fields = type.tuple.map((field) => `${toCamelCase3(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
-    return `{ ${fields} }`;
-  }
-  if (isAbiResponse2(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);
-}
-var init_type_mapping = () => {};
-
-// src/utils/generator-helpers.ts
-import {
-  isAbiTuple as isAbiTuple3,
-  toCamelCase as toCamelCase4
-} from "@secondlayer/stacks/clarity";
-function generateArgsSignature(args) {
-  if (args.length === 0)
-    return "";
-  const argsTypes = args.map((arg) => {
-    const camelName = toCamelCase4(arg.name);
-    return `${camelName}: ${getTypeForArg(arg)}`;
-  }).join("; ");
-  return `args: { ${argsTypes} }, `;
-}
-function generateClarityArgs(args) {
-  if (args.length === 0)
-    return "";
-  return args.map((arg) => {
-    const argName = `args.${toCamelCase4(arg.name)}`;
-    return generateClarityConversion(argName, arg);
-  }).join(", ");
-}
-function generateMapKeyConversion(keyType) {
-  if (isAbiTuple3(keyType)) {
-    const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase4(field.name);
-      const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
-      return `"${field.name}": ${fieldConversion}`;
-    }).join(", ");
-    return `Cl.tuple({ ${fields} })`;
-  }
-  return generateClarityConversion("key", { type: keyType });
-}
-var init_generator_helpers = __esm(() => {
-  init_clarity_conversion();
-  init_type_mapping();
-});
-
 // src/generators/contract.ts
 import {
-  toCamelCase as toCamelCase5
-} from "@secondlayer/stacks/clarity";
-function generateNetworkUtils() {
-  return `/**
- * API URLs for different networks
- */
-const API_URLS: Record<'mainnet' | 'testnet' | 'devnet', string> = {
-  mainnet: 'https://api.hiro.so',
-  testnet: 'https://api.testnet.hiro.so',
-  devnet: 'http://localhost:3999'
-};
-
-/**
- * Infer network from Stacks address prefix
- * SP/SM = mainnet, ST/SN = testnet
- */
-function inferNetworkFromAddress(address: string): 'mainnet' | 'testnet' | undefined {
-  if (address.startsWith('SP') || address.startsWith('SM')) return 'mainnet';
-  if (address.startsWith('ST') || address.startsWith('SN')) return 'testnet';
-  return undefined;
-}
-
-/**
- * Get API URL, inferring network from contract address if not specified
- */
-function getApiUrl(
-  contractAddress: string,
-  explicitNetwork?: 'mainnet' | 'testnet' | 'devnet'
-): string {
-  const network = explicitNetwork ?? inferNetworkFromAddress(contractAddress) ?? 'mainnet';
-  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}$/;`;
-}
+  generateContractInterface as buildContractInterface
+} from "@secondlayer/scaffold";
 async function generateContractInterface(contracts) {
-  const imports = `import { Cl, validateStacksAddress } from '@secondlayer/stacks'`;
-  const header = `/**
- * Generated by @secondlayer/cli
- * DO NOT EDIT MANUALLY
- *
- * @requires @secondlayer/stacks - Install with: npm install @secondlayer/stacks
- */`;
-  const validationUtils = generateValidationUtils();
-  const networkUtils = generateNetworkUtils();
-  const contractsCode = contracts.map((contract) => generateContract(contract)).join(`
-
-`);
-  const code = `${imports}
-
-${header}
-
-${validationUtils}
-
-${networkUtils}
-
-${contractsCode}`;
-  return formatCode(code);
-}
-function generateContract(contract) {
-  const { name, address, contractName, abi } = contract;
-  const abiCode = generateAbiConstant(name, abi);
-  const methods = abi.functions.filter((func) => func.access !== "private").map((func) => generateMethod(func, address, contractName)).join(`,
-
-  `);
-  const mapsObject = generateMapsObject(abi.maps || [], address, contractName);
-  const varsObject = generateVarsObject(abi.variables || [], address, contractName);
-  const constantsObject = generateConstantsObject(abi.variables || [], address, contractName);
-  const allMembers = [methods, mapsObject, varsObject, constantsObject].filter(Boolean);
-  const contractCode = `export const ${name} = {
-  address: '${address}',
-  contractAddress: '${address}',
-  contractName: '${contractName}',
-
-  ${allMembers.join(`,
-
-  `)}
-} as const`;
-  return `${abiCode}
-
-${contractCode}`;
-}
-function generateAbiConstant(name, abi) {
-  const abiJson = JSON.stringify(abi, null, 2).replace(/"([a-zA-Z_$][a-zA-Z0-9_$]*)":/g, "$1:").replace(/"/g, "'");
-  return `export const ${name}Abi = ${abiJson} as const`;
-}
-function generateMethod(func, address, contractName) {
-  const methodName = toCamelCase5(func.name);
-  if (func.args.length === 0) {
-    return `${methodName}() {
-    return {
-      contractAddress: '${address}',
-      contractName: '${contractName}',
-      functionName: '${func.name}',
-      functionArgs: []
-    }
-  }`;
-  }
-  if (func.args.length === 1) {
-    const originalArgName = func.args[0].name;
-    const argName = toCamelCase5(originalArgName);
-    const argType = getTypeForArg(func.args[0]);
-    const clarityConversion = generateClarityConversion(argName, func.args[0]);
-    return `${methodName}(...args: [{ ${argName}: ${argType} }] | [${argType}]) {
-    const ${argName} = args.length === 1 && typeof args[0] === 'object' && args[0] !== null && '${argName}' in args[0]
-      ? args[0].${argName}
-      : args[0] as ${argType}
-    
-    return {
-      contractAddress: '${address}',
-      contractName: '${contractName}',
-      functionName: '${func.name}',
-      functionArgs: [${clarityConversion}]
-    }
-  }`;
-  }
-  const argsList = func.args.map((arg) => toCamelCase5(arg.name)).join(", ");
-  const argsTypes = func.args.map((arg) => {
-    const camelName = toCamelCase5(arg.name);
-    return `${camelName}: ${getTypeForArg(arg)}`;
-  }).join("; ");
-  const argsArray = func.args.map((arg) => {
-    const argName = toCamelCase5(arg.name);
-    return generateClarityConversion(argName, arg);
-  }).join(", ");
-  const objectAccess = func.args.map((arg) => {
-    const camelName = toCamelCase5(arg.name);
-    return `args[0].${camelName}`;
-  }).join(", ");
-  const positionTypes = func.args.map((arg) => getTypeForArg(arg)).join(", ");
-  return `${methodName}(...args: [{ ${argsTypes} }] | [${positionTypes}]) {
-    const [${argsList}] = args.length === 1 && typeof args[0] === 'object' && args[0] !== null
-      ? [${objectAccess}]
-      : args as [${positionTypes}]
-    
-    return {
-      contractAddress: '${address}',
-      contractName: '${contractName}',
-      functionName: '${func.name}',
-      functionArgs: [${argsArray}]
-    }
-  }`;
-}
-function generateMapsObject(maps, address, contractName) {
-  if (!maps || maps.length === 0) {
-    return "";
-  }
-  const mapMethods = maps.map((map) => {
-    const methodName = toCamelCase5(map.name);
-    const keyType = getTypeForArg({ type: map.key });
-    const valueType = getTypeForArg({ type: map.value });
-    const keyConversion = generateMapKeyConversion(map.key);
-    return `${methodName}: {
-      async get(key: ${keyType}, options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType} | null> {
-        try {
-          const { cvToJSON, serializeCV } = await import('@secondlayer/stacks/clarity');
-          const baseUrl = getApiUrl('${address}', options?.network);
-          const mapKey = ${keyConversion};
-          const keyHex = serializeCV(mapKey).toString('hex');
-
-          const response = await fetch(
-            \`\${baseUrl}/v2/map_entry/${address}/${contractName}/${map.name}\`,
-            {
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json' },
-              body: JSON.stringify(keyHex)
-            }
-          );
-
-          if (!response.ok) {
-            throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
-          }
-
-          const result = await response.json();
-          if (!result.data || result.data === '0x09') {
-            return null; // none value
-          }
-
-          const { deserializeCV } = await import('@secondlayer/stacks/clarity');
-          const cv = deserializeCV(result.data);
-          const parsed = cvToJSON(cv);
-          // Unwrap the (some ...) wrapper
-          return parsed.value?.value ?? parsed.value ?? null;
-        } catch (error) {
-          if (error instanceof Error) {
-            throw new Error(\`Map access failed for '${map.name}': \${error.message}\`);
-          }
-          throw error;
-        }
-      },
-      keyType: ${JSON.stringify(map.key)} as const,
-      valueType: ${JSON.stringify(map.value)} as const
-    }`;
-  });
-  return `maps: {
-    ${mapMethods.join(`,
-
-    `)}
-  }`;
-}
-function generateVarsObject(variables, address, contractName) {
-  if (!variables || variables.length === 0) {
-    return "";
-  }
-  const dataVars = variables.filter((v) => v.access === "variable");
-  if (dataVars.length === 0) {
-    return "";
-  }
-  const varMethods = dataVars.map((variable) => {
-    const methodName = toCamelCase5(variable.name);
-    const valueType = getTypeForArg({ type: variable.type });
-    return `${methodName}: {
-      async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
-        try {
-          const { cvToJSON, deserializeCV } = await import('@secondlayer/stacks/clarity');
-          const baseUrl = getApiUrl('${address}', options?.network);
-
-          const response = await fetch(
-            \`\${baseUrl}/v2/data_var/${address}/${contractName}/${variable.name}?proof=0\`
-          );
-
-          if (!response.ok) {
-            throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
-          }
-
-          const result = await response.json();
-          const cv = deserializeCV(result.data);
-          const parsed = cvToJSON(cv);
-          return parsed.value ?? parsed;
-        } catch (error) {
-          if (error instanceof Error) {
-            throw new Error(\`Variable access failed for '${variable.name}': \${error.message}\`);
-          }
-          throw error;
-        }
-      },
-      type: ${JSON.stringify(variable.type)} as const
-    }`;
-  });
-  return `vars: {
-    ${varMethods.join(`,
-
-    `)}
-  }`;
-}
-function generateConstantsObject(variables, address, contractName) {
-  if (!variables || variables.length === 0) {
-    return "";
-  }
-  const constants = variables.filter((v) => v.access === "constant");
-  if (constants.length === 0) {
-    return "";
-  }
-  const constMethods = constants.map((constant) => {
-    const methodName = toCamelCase5(constant.name);
-    const valueType = getTypeForArg({ type: constant.type });
-    return `${methodName}: {
-      async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
-        try {
-          const { cvToJSON, deserializeCV } = await import('@secondlayer/stacks/clarity');
-          const baseUrl = getApiUrl('${address}', options?.network);
-
-          const response = await fetch(
-            \`\${baseUrl}/v2/constant_val/${address}/${contractName}/${constant.name}?proof=0\`
-          );
-
-          if (!response.ok) {
-            throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
-          }
-
-          const result = await response.json();
-          const cv = deserializeCV(result.data);
-          const parsed = cvToJSON(cv);
-          return parsed.value ?? parsed;
-        } catch (error) {
-          if (error instanceof Error) {
-            throw new Error(\`Constant access failed for '${constant.name}': \${error.message}\`);
-          }
-          throw error;
-        }
-      },
-      type: ${JSON.stringify(constant.type)} as const
-    }`;
-  });
-  return `constants: {
-    ${constMethods.join(`,
-
-    `)}
-  }`;
+  return formatCode(buildContractInterface(contracts));
 }
 var init_contract = __esm(() => {
-  init_clarity_conversion();
   init_format();
-  init_generator_helpers();
-  init_type_mapping();
 });
 
 // src/utils/abi-compat.ts
@@ -1104,9 +557,9 @@ init_plugin_manager();
 // src/plugins/clarinet/index.ts
 init_contract();
 import { initSimnet } from "@hirosystems/clarinet-sdk";
-import { toCamelCase as toCamelCase6 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase2 } from "@secondlayer/stacks/clarity";
 function sanitizeContractName(name) {
-  return toCamelCase6(name);
+  return toCamelCase2(name);
 }
 async function isUserDefinedContract(contractId, manifestPath) {
   const { address, contractName } = parseContractId(contractId);
@@ -1217,8 +670,16 @@ async function hasClarinetProject(path2 = "./Clarinet.toml") {
   }
 }
 // src/plugins/actions/generators.ts
-init_generator_helpers();
-import { toCamelCase as toCamelCase7 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
+
+// src/utils/generator-helpers.ts
+import {
+  generateArgsSignature,
+  generateClarityArgs,
+  generateMapKeyConversion
+} from "@secondlayer/scaffold";
+
+// src/plugins/actions/generators.ts
 function generateReadHelpers(contract, options) {
   const { abi } = contract;
   const functions = abi.functions || [];
@@ -1239,7 +700,7 @@ function generateReadHelpers(contract, options) {
     return "";
   }
   const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase7(func.name);
+    const methodName = toCamelCase3(func.name);
     const argsSignature = generateArgsSignature(func.args);
     const clarityArgs = generateClarityArgs(func.args);
     return `async ${methodName}(${argsSignature}options?: {
@@ -1283,7 +744,7 @@ function generateWriteHelpers(contract, options) {
     return "";
   }
   const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase7(func.name);
+    const methodName = toCamelCase3(func.name);
     const argsSignature = generateArgsSignature(func.args);
     const clarityArgs = generateClarityArgs(func.args);
     return `async ${methodName}(${argsSignature}senderKey?: string, options?: {
@@ -1417,36 +878,42 @@ ${indentedHelpersCode}
 init_format();
 
 // src/utils/case-conversion.ts
-import { toCamelCase as toCamelCase8 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase4 } from "@secondlayer/stacks/clarity";
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function toPascalCase(str) {
-  return capitalize(toCamelCase8(str));
+  return capitalize(toCamelCase4(str));
 }
 
+// src/utils/type-mapping.ts
+import {
+  clarityTypeToTS,
+  generateArgsTypeSignature,
+  getTypeForArg
+} from "@secondlayer/scaffold";
+
 // src/plugins/react/generators/utils.ts
-init_type_mapping();
 function generateHookArgsSignature(args) {
   if (args.length === 0)
     return "";
-  const argsList = args.map((arg) => `${toCamelCase8(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
+  const argsList = args.map((arg) => `${toCamelCase4(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
   return `${argsList}`;
 }
 function generateArgsType(args) {
   if (args.length === 0)
     return "void";
-  const argsList = args.map((arg) => `${toCamelCase8(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
+  const argsList = args.map((arg) => `${toCamelCase4(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
   return `{ ${argsList} }`;
 }
 function generateArgNames(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => toCamelCase8(arg.name)).join(", ");
+  return args.map((arg) => toCamelCase4(arg.name)).join(", ");
 }
 function generateEnabledCondition(args) {
   return args.map((arg) => {
-    const camelName = toCamelCase8(arg.name);
+    const camelName = toCamelCase4(arg.name);
     const type = clarityTypeToTS(arg.type);
     if (type === "string")
       return `!!${camelName}`;
@@ -1458,7 +925,7 @@ function generateEnabledCondition(args) {
 function generateObjectArgs(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => `${arg.name}: ${toCamelCase8(arg.name)}`).join(", ");
+  return args.map((arg) => `${arg.name}: ${toCamelCase4(arg.name)}`).join(", ");
 }
 
 // src/plugins/react/generators/contract.ts
@@ -1491,21 +958,21 @@ function generateContractHookMethods(contract, excludeList) {
   const readOnlyFunctions = functions.filter((f) => f.access === "read-only");
   const publicFunctions = functions.filter((f) => f.access === "public");
   const readHooks = readOnlyFunctions.map((func) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase8(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(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(toCamelCase8(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(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(toCamelCase8(map.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(map.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -1513,7 +980,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(toCamelCase8(variable.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(variable.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -1521,7 +988,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(toCamelCase8(constant.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(constant.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -1542,7 +1009,7 @@ function generateContractHookMethods(contract, excludeList) {
 `);
 }
 function generateReadHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase8(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase4(func.name))}`;
   const argsSignature = generateHookArgsSignature(func.args);
   const enabledParam = func.args.length > 0 ? ", options?: { enabled?: boolean }" : "options?: { enabled?: boolean }";
   const returnType = clarityTypeToTS(func.outputs);
@@ -1551,7 +1018,7 @@ function generateReadHook(func, contractName) {
 
   return useQuery<${returnType}>({
     queryKey: ['${func.name}', ${contractName}.address, ${generateArgNames(func.args)}],
-    queryFn: () => ${contractName}.read.${toCamelCase8(func.name)}(${generateArgNames(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
+    queryFn: () => ${contractName}.read.${toCamelCase4(func.name)}(${generateArgNames(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
       network: config.network,
       senderAddress: config.senderAddress || 'SP000000000000000000002Q6VF78'
     }),
@@ -1561,7 +1028,7 @@ function generateReadHook(func, contractName) {
 }`;
 }
 function generateWriteHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase8(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase4(func.name))}`;
   const argsType = generateArgsType(func.args);
   return `export function ${hookName}() {
   const config = useSecondLayerConfig()
@@ -1578,7 +1045,7 @@ function generateWriteHook(func, contractName) {
       };
     }) => {
       const { args, options = {} } = params
-      const contractCallData = ${contractName}.${toCamelCase8(func.name)}(args)
+      const contractCallData = ${contractName}.${toCamelCase4(func.name)}(args)
       const { contractAddress, contractName: name, functionName, functionArgs } = contractCallData
       const network = config.network || 'mainnet'
       const contract = \`\${contractAddress}.\${name}\`
@@ -1603,7 +1070,7 @@ function generateWriteHook(func, contractName) {
     }
   })
 
-  const ${toCamelCase8(func.name)} = useCallback(async (
+  const ${toCamelCase4(func.name)} = useCallback(async (
     args: ${argsType},
     options?: {
       postConditions?: PostCondition[];
@@ -1616,7 +1083,7 @@ function generateWriteHook(func, contractName) {
   }, [mutation])
 
   return {
-    ${toCamelCase8(func.name)},
+    ${toCamelCase4(func.name)},
     // Expose mutation state
     isPending: mutation.isPending,
     isError: mutation.isError,
@@ -1628,7 +1095,7 @@ function generateWriteHook(func, contractName) {
 }`;
 }
 function generateMapHook(map, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase8(map.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(map.name))}`;
   const keyType = clarityTypeToTS(map.key);
   const valueType = clarityTypeToTS(map.value);
   return `export function ${hookName}(key: ${keyType}, options?: { enabled?: boolean }) {
@@ -1637,14 +1104,14 @@ function generateMapHook(map, contractVarName, _address, _contractName) {
   return useQuery<${valueType} | null>({
     queryKey: ['${contractVarName}', '${map.name}', 'map', key, config.network],
     queryFn: async () => {
-      return ${contractVarName}.maps.${toCamelCase8(map.name)}.get(key, { network: config.network })
+      return ${contractVarName}.maps.${toCamelCase4(map.name)}.get(key, { network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateVarHook(variable, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase8(variable.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(variable.name))}`;
   const valueType = clarityTypeToTS(variable.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useSecondLayerConfig()
@@ -1652,14 +1119,14 @@ function generateVarHook(variable, contractVarName, _address, _contractName) {
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${variable.name}', 'var', config.network],
     queryFn: async () => {
-      return ${contractVarName}.vars.${toCamelCase8(variable.name)}.get({ network: config.network })
+      return ${contractVarName}.vars.${toCamelCase4(variable.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateConstantHook(constant, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase8(constant.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(constant.name))}`;
   const valueType = clarityTypeToTS(constant.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useSecondLayerConfig()
@@ -1667,7 +1134,7 @@ function generateConstantHook(constant, contractVarName, _address, _contractName
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${constant.name}', 'constant', config.network],
     queryFn: async () => {
-      return ${contractVarName}.constants.${toCamelCase8(constant.name)}.get({ network: config.network })
+      return ${contractVarName}.constants.${toCamelCase4(constant.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true,
     staleTime: Infinity // Constants never change
@@ -2518,12 +1985,10 @@ var react = (options = {}) => {
 };
 // src/plugins/testing/generators.ts
 import {
-  isAbiTuple as isAbiTuple4
+  isAbiTuple
 } from "@secondlayer/stacks/clarity";
-init_generator_helpers();
-init_type_mapping();
 function generatePublicFunction(func, contractId) {
-  const methodName = toCamelCase8(func.name);
+  const methodName = toCamelCase4(func.name);
   const argsSignature = generateArgsSignature(func.args);
   const clarityArgs = generateClarityArgs(func.args);
   return `${methodName}: (${argsSignature}caller: string) => {
@@ -2537,7 +2002,7 @@ function generatePublicFunction(func, contractId) {
     }`;
 }
 function generateReadOnlyFunction(func, contractId) {
-  const methodName = toCamelCase8(func.name);
+  const methodName = toCamelCase4(func.name);
   const argsSignature = generateArgsSignature(func.args);
   const clarityArgs = generateClarityArgs(func.args);
   const hasArgs = func.args.length > 0;
@@ -2552,7 +2017,7 @@ function generateReadOnlyFunction(func, contractId) {
     }`;
 }
 function generatePrivateFunction(func, contractId) {
-  const methodName = toCamelCase8(func.name);
+  const methodName = toCamelCase4(func.name);
   const argsSignature = generateArgsSignature(func.args);
   const clarityArgs = generateClarityArgs(func.args);
   return `${methodName}: (${argsSignature}caller: string) => {
@@ -2566,20 +2031,20 @@ function generatePrivateFunction(func, contractId) {
     }`;
 }
 function generateDataVarHelper(variable, contractId) {
-  const methodName = toCamelCase8(variable.name);
+  const methodName = toCamelCase4(variable.name);
   return `${methodName}: () => {
       return simnet.getDataVar('${contractId}', '${variable.name}');
     }`;
 }
 function getMapKeyType(keyType) {
-  if (isAbiTuple4(keyType)) {
-    const fields = keyType.tuple.map((field) => `${toCamelCase8(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
+  if (isAbiTuple(keyType)) {
+    const fields = keyType.tuple.map((field) => `${toCamelCase4(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
     return `{ ${fields} }`;
   }
   return getTypeForArg({ type: keyType });
 }
 function generateMapEntryHelper(map, contractId) {
-  const methodName = toCamelCase8(map.name);
+  const methodName = toCamelCase4(map.name);
   const keyType = getMapKeyType(map.key);
   const keyConversion = generateMapKeyConversion(map.key);
   return `${methodName}: (key: ${keyType}) => {
@@ -2590,7 +2055,7 @@ function generateMapEntryHelper(map, contractId) {
       );
     }`;
 }
-function generateVarsObject2(variables, contractId) {
+function generateVarsObject(variables, contractId) {
   const dataVars = variables.filter((v) => v.access === "variable");
   if (dataVars.length === 0) {
     return "";
@@ -2602,7 +2067,7 @@ function generateVarsObject2(variables, contractId) {
       `)}
     }`;
 }
-function generateMapsObject2(maps, contractId) {
+function generateMapsObject(maps, contractId) {
   if (maps.length === 0) {
     return "";
   }
@@ -2625,8 +2090,8 @@ function generateContractHelper(contract, options) {
   const publicHelpers = publicFns.map((f) => generatePublicFunction(f, address));
   const readOnlyHelpers = readOnlyFns.map((f) => generateReadOnlyFunction(f, address));
   const privateHelpers = privateFns.map((f) => generatePrivateFunction(f, address));
-  const varsObject = generateVarsObject2(variables, address);
-  const mapsObject = generateMapsObject2(maps, address);
+  const varsObject = generateVarsObject(variables, address);
+  const mapsObject = generateMapsObject(maps, address);
   const allHelpers = [...publicHelpers, ...readOnlyHelpers, ...privateHelpers];
   if (varsObject) {
     allHelpers.push(varsObject);
@@ -2649,7 +2114,7 @@ function generateContractHelper(contract, options) {
 }
 function generateGetContracts(contracts) {
   const contractEntries = contracts.map((contract) => {
-    const camelName = toCamelCase8(contract.name);
+    const camelName = toCamelCase4(contract.name);
     const pascalName = toPascalCase(contract.name);
     return `${camelName}: get${pascalName}(simnet)`;
   }).join(`,
@@ -2777,5 +2242,5 @@ export {
   PluginManager
 };
 
-//# debugId=E3DECC5373F2A20964756E2164756E21
+//# debugId=29216900E6AC4AF864756E2164756E21
 //# sourceMappingURL=index.js.map