@secondlayer/cli 1.4.1 → 1.5.1

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { AbiContract as AbiContract2 } from "@secondlayer/stacks/clarity";
 import { AbiContract } from "@secondlayer/stacks/clarity";
 /** Supported Stacks network identifiers for contract resolution. */
 type NetworkName = "mainnet" | "testnet" | "devnet";
@@ -96,7 +97,7 @@ interface ContractConfig {
 	name?: string;
 	address?: string | Partial<Record<NetworkName, string>>;
 	source?: string;
-	abi?: any;
+	abi?: AbiContract2;
 	metadata?: Record<string, any>;
 }
 /**
@@ -259,6 +260,10 @@ declare class PluginManager {
 	*/
 	getExecutionResults(): Map<string, HookResult[]>;
 	/**
+	* Convert a contract config with an ABI into a ProcessedContract
+	*/
+	private contractToProcessed;
+	/**
 	* Augment existing output with additional content
 	*/
 	private augmentOutput;

package/dist/index.js

@@ -82,6 +82,8 @@ var init_format = () => {};
 import { promises as fs } from "fs";
 import path from "path";
 import { isValidAddress as _validateStacksAddress } from "@secondlayer/stacks";
+import { getErrorMessage } from "@secondlayer/shared";
+import { toCamelCase } from "@secondlayer/stacks/clarity";
 
 // src/utils/contract-id.ts
 function parseContractId(contractId) {
@@ -147,12 +149,11 @@ class PluginManager {
             success: true
           });
         } catch (error) {
-          const err = error;
           this.recordHookResult(plugin.name, "transformConfig", {
             success: false,
-            error: err
+            error: error instanceof Error ? error : new Error(getErrorMessage(error))
           });
-          throw new Error(`Plugin "${plugin.name}" failed during config transformation: ${err.message}`);
+          throw new Error(`Plugin "${plugin.name}" failed during config transformation: ${getErrorMessage(error)}`);
         }
       }
     }
@@ -166,31 +167,11 @@ class PluginManager {
     const processedContracts = [];
     for (let contract of contracts) {
       if (isClarinetContract(contract) && contract.abi) {
-        const address = typeof contract.address === "string" ? contract.address : "";
-        const parsed = parseContractId(address);
-        const processed = {
-          name: contract.name || parsed.contractName,
-          address: parsed.address,
-          contractName: parsed.contractName,
-          abi: contract.abi,
-          source: "local",
-          metadata: { source: "clarinet" }
-        };
-        processedContracts.push(processed);
+        processedContracts.push(this.contractToProcessed(contract, "clarinet"));
         continue;
       }
       if (isDirectFileContract(contract) && contract.abi) {
-        const address = typeof contract.address === "string" ? contract.address : "";
-        const parsed = parseContractId(address);
-        const processed = {
-          name: contract.name || parsed.contractName,
-          address: parsed.address,
-          contractName: parsed.contractName,
-          abi: contract.abi,
-          source: "local",
-          metadata: { source: "direct" }
-        };
-        processedContracts.push(processed);
+        processedContracts.push(this.contractToProcessed(contract, "direct"));
         continue;
       }
       for (const plugin of this.plugins) {
@@ -202,27 +183,16 @@ class PluginManager {
               success: true
             });
           } catch (error) {
-            const err = error;
             this.recordHookResult(plugin.name, "transformContract", {
               success: false,
-              error: err
+              error: error instanceof Error ? error : new Error(getErrorMessage(error))
             });
-            this.logger.warn(`Plugin "${plugin.name}" failed to transform contract: ${err.message}`);
+            this.logger.warn(`Plugin "${plugin.name}" failed to transform contract: ${getErrorMessage(error)}`);
           }
         }
       }
       if (contract.abi) {
-        const addressStr = typeof contract.address === "string" ? contract.address : "";
-        const parsed = parseContractId(addressStr);
-        const processed = {
-          name: contract.name || parsed.contractName || "unknown",
-          address: parsed.address || "unknown",
-          contractName: parsed.contractName || contract.name || "unknown",
-          abi: contract.abi,
-          source: "api",
-          metadata: contract.metadata
-        };
-        processedContracts.push(processed);
+        processedContracts.push(this.contractToProcessed(contract, "api"));
       }
     }
     return processedContracts;
@@ -238,12 +208,11 @@ class PluginManager {
             success: true
           });
         } catch (error) {
-          const err = error;
           this.recordHookResult(plugin.name, hookName, {
             success: false,
-            error: err
+            error: error instanceof Error ? error : new Error(getErrorMessage(error))
           });
-          this.logger.error(`Plugin "${plugin.name}" failed during ${hookName}: ${err.message}`);
+          this.logger.error(`Plugin "${plugin.name}" failed during ${hookName}: ${getErrorMessage(error)}`);
         }
       }
     }
@@ -283,12 +252,11 @@ class PluginManager {
               success: true
             });
           } catch (error) {
-            const err = error;
             this.recordHookResult(plugin.name, "transformOutput", {
               success: false,
-              error: err
+              error: error instanceof Error ? error : new Error(getErrorMessage(error))
             });
-            this.logger.warn(`Plugin "${plugin.name}" failed to transform output: ${err.message}`);
+            this.logger.warn(`Plugin "${plugin.name}" failed to transform output: ${getErrorMessage(error)}`);
           }
         }
       }
@@ -306,15 +274,26 @@ class PluginManager {
         await this.utils.ensureDir(path.dirname(resolvedPath));
         await this.utils.writeFile(resolvedPath, output.content);
       } catch (error) {
-        const err = error;
-        this.logger.error(`Failed to write ${output.path}: ${err.message}`);
-        throw err;
+        this.logger.error(`Failed to write ${output.path}: ${getErrorMessage(error)}`);
+        throw error;
       }
     }
   }
   getExecutionResults() {
     return new Map(this.executionContext.results);
   }
+  contractToProcessed(contract, source) {
+    const address = typeof contract.address === "string" ? contract.address : "";
+    const parsed = parseContractId(address);
+    return {
+      name: contract.name || parsed.contractName || "unknown",
+      address: parsed.address || "unknown",
+      contractName: parsed.contractName || contract.name || "unknown",
+      abi: contract.abi,
+      source: source === "api" ? "api" : "local",
+      metadata: contract.metadata ?? { source }
+    };
+  }
   augmentOutput(outputs, outputKey, contractName, content) {
     const existing = outputs.get(outputKey);
     if (!existing) {
@@ -351,9 +330,7 @@ ${JSON.stringify(content, null, 2)}`;
   }
   createUtils() {
     return {
-      toCamelCase: (str) => {
-        return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-      },
+      toCamelCase,
       toKebabCase: (str) => {
         return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
       },
@@ -392,17 +369,17 @@ ${JSON.stringify(content, null, 2)}`;
 }
 // src/plugins/clarinet/index.ts
 import { initSimnet } from "@hirosystems/clarinet-sdk";
-import { toCamelCase as toCamelCase5 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase6 } from "@secondlayer/stacks/clarity";
 
 // src/generators/contract.ts
 init_format();
 import {
-  toCamelCase as toCamelCase4
+  toCamelCase as toCamelCase5
 } from "@secondlayer/stacks/clarity";
 
 // src/utils/type-mapping.ts
 import {
-  toCamelCase,
+  toCamelCase as toCamelCase2,
   isAbiList,
   isAbiTuple,
   isAbiOptional,
@@ -461,7 +438,7 @@ function clarityTypeToTS(type) {
     return `${innerType}[]`;
   }
   if (isAbiTuple(type)) {
-    const fields = type.tuple.map((field) => `${toCamelCase(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
+    const fields = type.tuple.map((field) => `${toCamelCase2(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
     return `{ ${fields} }`;
   }
   if (isAbiResponse(type)) {
@@ -477,7 +454,7 @@ function getTypeForArg(arg) {
 
 // src/utils/clarity-conversion.ts
 import {
-  toCamelCase as toCamelCase2,
+  toCamelCase as toCamelCase3,
   isAbiStringAscii as isAbiStringAscii2,
   isAbiStringUtf8 as isAbiStringUtf82,
   isAbiBuffer as isAbiBuffer2,
@@ -575,7 +552,7 @@ function generateClarityConversion(argName, argType) {
     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 camelFieldName = toCamelCase3(field.name);
       const fieldConversion = generateClarityConversion(`tupleValue.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -615,12 +592,12 @@ function generateClarityConversion(argName, argType) {
 }
 
 // src/utils/generator-helpers.ts
-import { toCamelCase as toCamelCase3, isAbiTuple as isAbiTuple3 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase4, isAbiTuple as isAbiTuple3 } from "@secondlayer/stacks/clarity";
 function generateArgsSignature(args) {
   if (args.length === 0)
     return "";
   const argsTypes = args.map((arg) => {
-    const camelName = toCamelCase3(arg.name);
+    const camelName = toCamelCase4(arg.name);
     return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   return `args: { ${argsTypes} }, `;
@@ -629,14 +606,14 @@ function generateClarityArgs(args) {
   if (args.length === 0)
     return "";
   return args.map((arg) => {
-    const argName = `args.${toCamelCase3(arg.name)}`;
+    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 = toCamelCase3(field.name);
+      const camelFieldName = toCamelCase4(field.name);
       const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -736,7 +713,7 @@ function generateAbiConstant(name, abi) {
   return `export const ${name}Abi = ${abiJson} as const`;
 }
 function generateMethod(func, address, contractName) {
-  const methodName = toCamelCase4(func.name);
+  const methodName = toCamelCase5(func.name);
   if (func.args.length === 0) {
     return `${methodName}() {
     return {
@@ -749,7 +726,7 @@ function generateMethod(func, address, contractName) {
   }
   if (func.args.length === 1) {
     const originalArgName = func.args[0].name;
-    const argName = toCamelCase4(originalArgName);
+    const argName = toCamelCase5(originalArgName);
     const argType = getTypeForArg(func.args[0]);
     const clarityConversion = generateClarityConversion(argName, func.args[0]);
     return `${methodName}(...args: [{ ${argName}: ${argType} }] | [${argType}]) {
@@ -765,17 +742,17 @@ function generateMethod(func, address, contractName) {
     }
   }`;
   }
-  const argsList = func.args.map((arg) => toCamelCase4(arg.name)).join(", ");
+  const argsList = func.args.map((arg) => toCamelCase5(arg.name)).join(", ");
   const argsTypes = func.args.map((arg) => {
-    const camelName = toCamelCase4(arg.name);
+    const camelName = toCamelCase5(arg.name);
     return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   const argsArray = func.args.map((arg) => {
-    const argName = toCamelCase4(arg.name);
+    const argName = toCamelCase5(arg.name);
     return generateClarityConversion(argName, arg);
   }).join(", ");
   const objectAccess = func.args.map((arg) => {
-    const camelName = toCamelCase4(arg.name);
+    const camelName = toCamelCase5(arg.name);
     return `args[0].${camelName}`;
   }).join(", ");
   const positionTypes = func.args.map((arg) => getTypeForArg(arg)).join(", ");
@@ -797,7 +774,7 @@ function generateMapsObject(maps, address, contractName) {
     return "";
   }
   const mapMethods = maps.map((map) => {
-    const methodName = toCamelCase4(map.name);
+    const methodName = toCamelCase5(map.name);
     const keyType = getTypeForArg({ type: map.key });
     const valueType = getTypeForArg({ type: map.value });
     const keyConversion = generateMapKeyConversion(map.key);
@@ -858,7 +835,7 @@ function generateVarsObject(variables, address, contractName) {
     return "";
   }
   const varMethods = dataVars.map((variable) => {
-    const methodName = toCamelCase4(variable.name);
+    const methodName = toCamelCase5(variable.name);
     const valueType = getTypeForArg({ type: variable.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -903,7 +880,7 @@ function generateConstantsObject(variables, address, contractName) {
     return "";
   }
   const constMethods = constants.map((constant) => {
-    const methodName = toCamelCase4(constant.name);
+    const methodName = toCamelCase5(constant.name);
     const valueType = getTypeForArg({ type: constant.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -1095,7 +1072,7 @@ function normalizeAbi(abi) {
 
 // src/plugins/clarinet/index.ts
 function sanitizeContractName(name) {
-  return toCamelCase5(name);
+  return toCamelCase6(name);
 }
 async function isUserDefinedContract(contractId, manifestPath) {
   const { address, contractName } = parseContractId(contractId);
@@ -1205,7 +1182,7 @@ async function hasClarinetProject(path2 = "./Clarinet.toml") {
   }
 }
 // src/plugins/actions/generators.ts
-import { toCamelCase as toCamelCase6 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase7 } from "@secondlayer/stacks/clarity";
 function generateReadHelpers(contract, options) {
   const { abi } = contract;
   const functions = abi.functions || [];
@@ -1226,7 +1203,7 @@ function generateReadHelpers(contract, options) {
     return "";
   }
   const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase6(func.name);
+    const methodName = toCamelCase7(func.name);
     const argsSignature = generateArgsSignature(func.args);
     const clarityArgs = generateClarityArgs(func.args);
     return `async ${methodName}(${argsSignature}options?: {
@@ -1270,7 +1247,7 @@ function generateWriteHelpers(contract, options) {
     return "";
   }
   const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase6(func.name);
+    const methodName = toCamelCase7(func.name);
     const argsSignature = generateArgsSignature(func.args);
     const clarityArgs = generateClarityArgs(func.args);
     return `async ${methodName}(${argsSignature}senderKey?: string, options?: {
@@ -2208,31 +2185,36 @@ function generateGenericHook(hookName) {
 // src/plugins/react/generators/contract.ts
 init_format();
 
-// src/plugins/react/generators/utils.ts
-import { toCamelCase as toCamelCase7 } from "@secondlayer/stacks/clarity";
+// src/utils/case-conversion.ts
+import { toCamelCase as toCamelCase8 } from "@secondlayer/stacks/clarity";
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
+function toPascalCase(str) {
+  return capitalize(toCamelCase8(str));
+}
+
+// src/plugins/react/generators/utils.ts
 function generateHookArgsSignature(args) {
   if (args.length === 0)
     return "";
-  const argsList = args.map((arg) => `${toCamelCase7(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
+  const argsList = args.map((arg) => `${toCamelCase8(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
   return `${argsList}`;
 }
 function generateArgsType(args) {
   if (args.length === 0)
     return "void";
-  const argsList = args.map((arg) => `${toCamelCase7(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
+  const argsList = args.map((arg) => `${toCamelCase8(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
   return `{ ${argsList} }`;
 }
 function generateArgNames(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => toCamelCase7(arg.name)).join(", ");
+  return args.map((arg) => toCamelCase8(arg.name)).join(", ");
 }
 function generateEnabledCondition(args) {
   return args.map((arg) => {
-    const camelName = toCamelCase7(arg.name);
+    const camelName = toCamelCase8(arg.name);
     const type = clarityTypeToTS(arg.type);
     if (type === "string")
       return `!!${camelName}`;
@@ -2244,7 +2226,7 @@ function generateEnabledCondition(args) {
 function generateObjectArgs(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => `${arg.name}: ${toCamelCase7(arg.name)}`).join(", ");
+  return args.map((arg) => `${arg.name}: ${toCamelCase8(arg.name)}`).join(", ");
 }
 
 // src/plugins/react/generators/contract.ts
@@ -2277,21 +2259,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(toCamelCase7(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase8(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(toCamelCase7(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase8(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(toCamelCase7(map.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase8(map.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -2299,7 +2281,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(toCamelCase7(variable.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase8(variable.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -2307,7 +2289,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(toCamelCase7(constant.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase8(constant.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -2322,7 +2304,7 @@ function generateContractHookMethods(contract, excludeList) {
 `);
 }
 function generateReadHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase7(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase8(func.name))}`;
   const argsSignature = generateHookArgsSignature(func.args);
   const enabledParam = func.args.length > 0 ? ", options?: { enabled?: boolean }" : "options?: { enabled?: boolean }";
   const returnType = clarityTypeToTS(func.outputs);
@@ -2331,7 +2313,7 @@ function generateReadHook(func, contractName) {
 
   return useQuery<${returnType}>({
     queryKey: ['${func.name}', ${contractName}.address, ${generateArgNames(func.args)}],
-    queryFn: () => ${contractName}.read.${toCamelCase7(func.name)}(${generateArgNames(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
+    queryFn: () => ${contractName}.read.${toCamelCase8(func.name)}(${generateArgNames(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
       network: config.network,
       senderAddress: config.senderAddress || 'SP000000000000000000002Q6VF78'
     }),
@@ -2341,7 +2323,7 @@ function generateReadHook(func, contractName) {
 }`;
 }
 function generateWriteHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase7(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase8(func.name))}`;
   const argsType = generateArgsType(func.args);
   return `export function ${hookName}() {
   const config = useSecondLayerConfig()
@@ -2358,7 +2340,7 @@ function generateWriteHook(func, contractName) {
       };
     }) => {
       const { args, options = {} } = params
-      const contractCallData = ${contractName}.${toCamelCase7(func.name)}(args)
+      const contractCallData = ${contractName}.${toCamelCase8(func.name)}(args)
       const { contractAddress, contractName: name, functionName, functionArgs } = contractCallData
       const network = config.network || 'mainnet'
       const contract = \`\${contractAddress}.\${name}\`
@@ -2383,7 +2365,7 @@ function generateWriteHook(func, contractName) {
     }
   })
 
-  const ${toCamelCase7(func.name)} = useCallback(async (
+  const ${toCamelCase8(func.name)} = useCallback(async (
     args: ${argsType},
     options?: {
       postConditions?: PostCondition[];
@@ -2396,7 +2378,7 @@ function generateWriteHook(func, contractName) {
   }, [mutation])
 
   return {
-    ${toCamelCase7(func.name)},
+    ${toCamelCase8(func.name)},
     // Expose mutation state
     isPending: mutation.isPending,
     isError: mutation.isError,
@@ -2408,7 +2390,7 @@ function generateWriteHook(func, contractName) {
 }`;
 }
 function generateMapHook(map, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase7(map.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase8(map.name))}`;
   const keyType = clarityTypeToTS(map.key);
   const valueType = clarityTypeToTS(map.value);
   return `export function ${hookName}(key: ${keyType}, options?: { enabled?: boolean }) {
@@ -2417,14 +2399,14 @@ function generateMapHook(map, contractVarName, _address, _contractName) {
   return useQuery<${valueType} | null>({
     queryKey: ['${contractVarName}', '${map.name}', 'map', key, config.network],
     queryFn: async () => {
-      return ${contractVarName}.maps.${toCamelCase7(map.name)}.get(key, { network: config.network })
+      return ${contractVarName}.maps.${toCamelCase8(map.name)}.get(key, { network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateVarHook(variable, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase7(variable.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase8(variable.name))}`;
   const valueType = clarityTypeToTS(variable.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useSecondLayerConfig()
@@ -2432,14 +2414,14 @@ function generateVarHook(variable, contractVarName, _address, _contractName) {
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${variable.name}', 'var', config.network],
     queryFn: async () => {
-      return ${contractVarName}.vars.${toCamelCase7(variable.name)}.get({ network: config.network })
+      return ${contractVarName}.vars.${toCamelCase8(variable.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateConstantHook(constant, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase7(constant.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase8(constant.name))}`;
   const valueType = clarityTypeToTS(constant.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useSecondLayerConfig()
@@ -2447,7 +2429,7 @@ function generateConstantHook(constant, contractVarName, _address, _contractName
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${constant.name}', 'constant', config.network],
     queryFn: async () => {
-      return ${contractVarName}.constants.${toCamelCase7(constant.name)}.get({ network: config.network })
+      return ${contractVarName}.constants.${toCamelCase8(constant.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true,
     staleTime: Infinity // Constants never change
@@ -2495,13 +2477,8 @@ var react = (options = {}) => {
 };
 // src/plugins/testing/generators.ts
 import {
-  toCamelCase as toCamelCase8,
   isAbiTuple as isAbiTuple4
 } from "@secondlayer/stacks/clarity";
-function toPascalCase(str) {
-  const camel = toCamelCase8(str);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
 function generatePublicFunction(func, contractId) {
   const methodName = toCamelCase8(func.name);
   const argsSignature = generateArgsSignature(func.args);
@@ -2757,5 +2734,5 @@ export {
   PluginManager
 };
 
-//# debugId=A0CB31E87C48058164756E2164756E21
+//# debugId=76F0203451B4697D64756E2164756E21
 //# sourceMappingURL=index.js.map