@secondlayer/cli 1.2.0 → 1.2.1

package/dist/index.js

@@ -1,20 +1,5 @@
 import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -81,7 +66,19 @@ var init_format = () => {};
 // src/core/plugin-manager.ts
 import { promises as fs } from "fs";
 import path from "path";
-import { validateStacksAddress } from "@stacks/transactions";
+import { isValidAddress as _validateStacksAddress } from "@secondlayer/stacks";
+
+// src/utils/contract-id.ts
+function parseContractId(contractId) {
+  const dotIndex = contractId.indexOf(".");
+  if (dotIndex === -1) {
+    throw new Error(`Invalid contract ID: "${contractId}" (expected "address.contractName")`);
+  }
+  return {
+    address: contractId.slice(0, dotIndex),
+    contractName: contractId.slice(dotIndex + 1)
+  };
+}
 
 // src/types/plugin.ts
 function isClarinetContract(c) {
@@ -92,6 +89,8 @@ function isDirectFileContract(c) {
 }
 
 // src/core/plugin-manager.ts
+var validateStacksAddress = _validateStacksAddress;
+
 class PluginManager {
   plugins = [];
   logger;
@@ -153,11 +152,11 @@ class PluginManager {
     for (let contract of contracts) {
       if (isClarinetContract(contract) && contract.abi) {
         const address = typeof contract.address === "string" ? contract.address : "";
-        const [contractAddress, contractName] = address.split(".");
+        const parsed = parseContractId(address);
         const processed = {
-          name: contract.name || contractName,
-          address: contractAddress,
-          contractName,
+          name: contract.name || parsed.contractName,
+          address: parsed.address,
+          contractName: parsed.contractName,
           abi: contract.abi,
           source: "local",
           metadata: { source: "clarinet" }
@@ -167,11 +166,11 @@ class PluginManager {
       }
       if (isDirectFileContract(contract) && contract.abi) {
         const address = typeof contract.address === "string" ? contract.address : "";
-        const [contractAddress, contractName] = address.split(".");
+        const parsed = parseContractId(address);
         const processed = {
-          name: contract.name || contractName,
-          address: contractAddress,
-          contractName,
+          name: contract.name || parsed.contractName,
+          address: parsed.address,
+          contractName: parsed.contractName,
           abi: contract.abi,
           source: "local",
           metadata: { source: "direct" }
@@ -199,11 +198,11 @@ class PluginManager {
       }
       if (contract.abi) {
         const addressStr = typeof contract.address === "string" ? contract.address : "";
-        const [contractAddress, originalContractName] = addressStr.split(".");
+        const parsed = parseContractId(addressStr);
         const processed = {
-          name: contract.name || originalContractName || "unknown",
-          address: contractAddress || "unknown",
-          contractName: originalContractName || contract.name || "unknown",
+          name: contract.name || parsed.contractName || "unknown",
+          address: parsed.address || "unknown",
+          contractName: parsed.contractName || contract.name || "unknown",
           abi: contract.abi,
           source: "api",
           metadata: contract.metadata
@@ -344,11 +343,10 @@ ${JSON.stringify(content, null, 2)}`;
         return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
       },
       validateAddress: (address) => {
-        return validateStacksAddress(address.split(".")[0]);
+        return validateStacksAddress(parseContractId(address).address);
       },
       parseContractId: (contractId) => {
-        const [address, contractName] = contractId.split(".");
-        return { address, contractName };
+        return parseContractId(contractId);
       },
       formatCode: async (code) => {
         const { formatCode: formatCode2 } = await Promise.resolve().then(() => (init_format(), exports_format));
@@ -379,25 +377,25 @@ ${JSON.stringify(content, null, 2)}`;
 }
 // src/plugins/clarinet/index.ts
 import { initSimnet } from "@hirosystems/clarinet-sdk";
-import { toCamelCase as toCamelCase3 } from "@secondlayer/clarity-types";
+import { toCamelCase as toCamelCase4 } from "@secondlayer/stacks/clarity";
 
 // src/generators/contract.ts
 init_format();
 import {
-  toCamelCase as toCamelCase2
-} from "@secondlayer/clarity-types";
+  toCamelCase as toCamelCase3
+} from "@secondlayer/stacks/clarity";
 
 // src/utils/type-mapping.ts
 import {
   toCamelCase,
-  isClarityList,
-  isClarityTuple,
-  isClarityOptional,
-  isClarityResponse,
-  isClarityBuffer,
-  isClarityStringAscii,
-  isClarityStringUtf8
-} from "@secondlayer/clarity-types";
+  isAbiList,
+  isAbiTuple,
+  isAbiOptional,
+  isAbiResponse,
+  isAbiBuffer,
+  isAbiStringAscii,
+  isAbiStringUtf8
+} from "@secondlayer/stacks/clarity";
 function clarityTypeToTS(type) {
   if (typeof type === "string") {
     switch (type) {
@@ -427,31 +425,31 @@ function clarityTypeToTS(type) {
       }
     }
   }
-  if (isClarityBuffer(type)) {
+  if (isAbiBuffer(type)) {
     return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
   }
-  if (isClarityStringAscii(type) || isClarityStringUtf8(type)) {
+  if (isAbiStringAscii(type) || isAbiStringUtf8(type)) {
     return "string";
   }
-  if (isClarityOptional(type)) {
+  if (isAbiOptional(type)) {
     const innerType = clarityTypeToTS(type.optional);
     if (innerType.includes(" | ") && !innerType.startsWith("(")) {
       return `(${innerType}) | null`;
     }
     return `${innerType} | null`;
   }
-  if (isClarityList(type)) {
+  if (isAbiList(type)) {
     const innerType = clarityTypeToTS(type.list.type);
     if (innerType.includes(" | ") && !innerType.startsWith("(")) {
       return `(${innerType})[]`;
     }
     return `${innerType}[]`;
   }
-  if (isClarityTuple(type)) {
+  if (isAbiTuple(type)) {
     const fields = type.tuple.map((field) => `${toCamelCase(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
     return `{ ${fields} }`;
   }
-  if (isClarityResponse(type)) {
+  if (isAbiResponse(type)) {
     const okType = clarityTypeToTS(type.response.ok);
     const errType = clarityTypeToTS(type.response.error);
     return `{ ok: ${okType} } | { err: ${errType} }`;
@@ -462,6 +460,145 @@ function getTypeForArg(arg) {
   return clarityTypeToTS(arg.type);
 }
 
+// src/utils/clarity-conversion.ts
+import {
+  toCamelCase as toCamelCase2,
+  isAbiStringAscii as isAbiStringAscii2,
+  isAbiStringUtf8 as isAbiStringUtf82,
+  isAbiBuffer as isAbiBuffer2,
+  isAbiOptional as isAbiOptional2,
+  isAbiList as isAbiList2,
+  isAbiTuple as isAbiTuple2,
+  isAbiResponse as isAbiResponse2
+} 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 (isAbiStringAscii2(type)) {
+    return `Cl.stringAscii(${argName})`;
+  }
+  if (isAbiStringUtf82(type)) {
+    return `Cl.stringUtf8(${argName})`;
+  }
+  if (isAbiBuffer2(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 (isAbiOptional2(type)) {
+    const innerConversion = generateClarityConversion(argName, {
+      type: type.optional
+    });
+    return `${argName} !== null ? Cl.some(${innerConversion.replace(argName, `${argName}`)}) : Cl.none()`;
+  }
+  if (isAbiList2(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 (isAbiTuple2(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 (isAbiResponse2(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}`;
+}
+
 // src/generators/contract.ts
 function generateNetworkUtils() {
   return `/**
@@ -502,12 +639,12 @@ function generateValidationUtils() {
 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 imports = `import { Cl, validateStacksAddress } from '@secondlayer/stacks'`;
   const header = `/**
  * Generated by @secondlayer/cli
  * DO NOT EDIT MANUALLY
  *
- * @requires @stacks/transactions - Install with: npm install @stacks/transactions
+ * @requires @secondlayer/stacks - Install with: npm install @secondlayer/stacks
  */`;
   const validationUtils = generateValidationUtils();
   const networkUtils = generateNetworkUtils();
@@ -553,7 +690,7 @@ function generateAbiConstant(name, abi) {
   return `export const ${name}Abi = ${abiJson} as const`;
 }
 function generateMethod(func, address, contractName) {
-  const methodName = toCamelCase2(func.name);
+  const methodName = toCamelCase3(func.name);
   if (func.args.length === 0) {
     return `${methodName}() {
     return {
@@ -566,7 +703,7 @@ function generateMethod(func, address, contractName) {
   }
   if (func.args.length === 1) {
     const originalArgName = func.args[0].name;
-    const argName = toCamelCase2(originalArgName);
+    const argName = toCamelCase3(originalArgName);
     const argType = getTypeForArg(func.args[0]);
     const clarityConversion = generateClarityConversion(argName, func.args[0]);
     return `${methodName}(...args: [{ ${argName}: ${argType} }] | [${argType}]) {
@@ -582,17 +719,17 @@ function generateMethod(func, address, contractName) {
     }
   }`;
   }
-  const argsList = func.args.map((arg) => toCamelCase2(arg.name)).join(", ");
+  const argsList = func.args.map((arg) => toCamelCase3(arg.name)).join(", ");
   const argsTypes = func.args.map((arg) => {
-    const camelName = toCamelCase2(arg.name);
+    const camelName = toCamelCase3(arg.name);
     return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   const argsArray = func.args.map((arg) => {
-    const argName = toCamelCase2(arg.name);
+    const argName = toCamelCase3(arg.name);
     return generateClarityConversion(argName, arg);
   }).join(", ");
   const objectAccess = func.args.map((arg) => {
-    const camelName = toCamelCase2(arg.name);
+    const camelName = toCamelCase3(arg.name);
     return `args[0].${camelName}`;
   }).join(", ");
   const positionTypes = func.args.map((arg) => getTypeForArg(arg)).join(", ");
@@ -609,152 +746,19 @@ function generateMethod(func, address, contractName) {
     }
   }`;
 }
-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 (type["string-ascii"]) {
-    return `Cl.stringAscii(${argName})`;
-  }
-  if (type["string-utf8"]) {
-    return `Cl.stringUtf8(${argName})`;
-  }
-  if (type.buff) {
-    return `(() => {
-      const value = ${argName};
-      // Direct Uint8Array
-      if (value instanceof Uint8Array) {
-        return Cl.buffer(value);
-      }
-      // Object notation with explicit type
-      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}\`);
-        }
-      }
-      // Auto-detect string type
-      if (typeof value === 'string') {
-        // Check for hex (0x prefix or pure hex pattern)
-        if (value.startsWith('0x') || /^[0-9a-fA-F]+$/.test(value)) {
-          return Cl.bufferFromHex(value);
-        }
-        // Check for non-ASCII characters (UTF-8) using char code comparison
-        const hasNonAscii = value.split('').some(char => char.charCodeAt(0) > 127);
-        if (hasNonAscii) {
-          return Cl.bufferFromUtf8(value);
-        }
-        // Default to ASCII for simple ASCII strings
-        return Cl.bufferFromAscii(value);
-      }
-      throw new Error(\`Invalid buffer value: \${value}\`);
-    })()`;
-  }
-  if (type.optional) {
-    const innerConversion = generateClarityConversion(argName, {
-      type: type.optional
-    });
-    return `${argName} !== null ? Cl.some(${innerConversion.replace(argName, `${argName}`)}) : Cl.none()`;
-  }
-  if (type.list) {
-    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 (type.tuple) {
-    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 (type.response) {
-    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}`;
-}
 function generateMapsObject(maps, address, contractName) {
   if (!maps || maps.length === 0) {
     return "";
   }
   const mapMethods = maps.map((map) => {
-    const methodName = toCamelCase2(map.name);
+    const methodName = toCamelCase3(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('@stacks/transactions');
+          const { cvToJSON, serializeCV } = await import('@secondlayer/stacks/clarity');
           const baseUrl = getApiUrl('${address}', options?.network);
           const mapKey = ${keyConversion};
           const keyHex = serializeCV(mapKey).toString('hex');
@@ -777,7 +781,7 @@ function generateMapsObject(maps, address, contractName) {
             return null; // none value
           }
 
-          const { deserializeCV } = await import('@stacks/transactions');
+          const { deserializeCV } = await import('@secondlayer/stacks/clarity');
           const cv = deserializeCV(result.data);
           const parsed = cvToJSON(cv);
           // Unwrap the (some ...) wrapper
@@ -808,12 +812,12 @@ function generateVarsObject(variables, address, contractName) {
     return "";
   }
   const varMethods = dataVars.map((variable) => {
-    const methodName = toCamelCase2(variable.name);
+    const methodName = toCamelCase3(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('@stacks/transactions');
+          const { cvToJSON, deserializeCV } = await import('@secondlayer/stacks/clarity');
           const baseUrl = getApiUrl('${address}', options?.network);
 
           const response = await fetch(
@@ -853,12 +857,12 @@ function generateConstantsObject(variables, address, contractName) {
     return "";
   }
   const constMethods = constants.map((constant) => {
-    const methodName = toCamelCase2(constant.name);
+    const methodName = toCamelCase3(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('@stacks/transactions');
+          const { cvToJSON, deserializeCV } = await import('@secondlayer/stacks/clarity');
           const baseUrl = getApiUrl('${address}', options?.network);
 
           const response = await fetch(
@@ -892,7 +896,7 @@ function generateConstantsObject(variables, address, contractName) {
 function generateMapKeyConversion(keyType) {
   if (keyType.tuple) {
     const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase2(field.name);
+      const camelFieldName = toCamelCase3(field.name);
       const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -901,14 +905,167 @@ function generateMapKeyConversion(keyType) {
   return generateClarityConversion("key", { type: keyType });
 }
 
-// src/plugins/clarinet/index.ts
-function sanitizeContractName(name) {
-  return toCamelCase3(name);
+// src/utils/abi-compat.ts
+function normalizeAccess(access) {
+  if (access === "read_only")
+    return "read-only";
+  return access;
 }
-async function isUserDefinedContract(contractId, manifestPath) {
-  const [address, contractName] = contractId.split(".");
-  try {
-    const { promises: fs2 } = await import("fs");
+function normalizeType(type) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+      case "bool":
+      case "principal":
+      case "trait_reference":
+        return type;
+      default:
+        return type;
+    }
+  }
+  if (typeof type !== "object" || type === null) {
+    throw new Error(`Invalid ABI type: expected object, got ${typeof type}`);
+  }
+  const typeObj = type;
+  if ("buffer" in typeObj) {
+    const buffer = typeObj.buffer;
+    return {
+      buff: {
+        length: buffer?.length ?? 32
+      }
+    };
+  }
+  if ("buff" in typeObj) {
+    const buff = typeObj.buff;
+    return {
+      buff: {
+        length: buff?.length ?? 32
+      }
+    };
+  }
+  if ("string-ascii" in typeObj) {
+    const strAscii = typeObj["string-ascii"];
+    return {
+      "string-ascii": {
+        length: strAscii?.length ?? 256
+      }
+    };
+  }
+  if ("string-utf8" in typeObj) {
+    const strUtf8 = typeObj["string-utf8"];
+    return {
+      "string-utf8": {
+        length: strUtf8?.length ?? 256
+      }
+    };
+  }
+  if ("response" in typeObj) {
+    const response = typeObj.response;
+    return {
+      response: {
+        ok: normalizeType(response?.ok ?? "bool"),
+        error: normalizeType(response?.error ?? "uint128")
+      }
+    };
+  }
+  if ("optional" in typeObj) {
+    return {
+      optional: normalizeType(typeObj.optional)
+    };
+  }
+  if ("list" in typeObj) {
+    const list = typeObj.list;
+    return {
+      list: {
+        type: normalizeType(list?.type ?? "uint128"),
+        length: list?.length ?? 100
+      }
+    };
+  }
+  if ("tuple" in typeObj) {
+    const tuple = typeObj.tuple;
+    return {
+      tuple: tuple.map((field) => ({
+        name: field.name,
+        type: normalizeType(field.type)
+      }))
+    };
+  }
+  throw new Error(`Unknown ABI type structure: ${JSON.stringify(type)}`);
+}
+function normalizeFunction(func) {
+  const access = normalizeAccess(func.access);
+  const args = func.args ?? [];
+  const outputs = func.outputs;
+  return {
+    name: func.name,
+    access,
+    args: args.map((arg) => ({
+      name: arg.name,
+      type: normalizeType(arg.type)
+    })),
+    outputs: normalizeType(typeof outputs === "object" && outputs !== null && "type" in outputs ? outputs.type : outputs)
+  };
+}
+function normalizeMap(map) {
+  return {
+    name: map.name,
+    key: normalizeType(map.key),
+    value: normalizeType(map.value)
+  };
+}
+function normalizeVariable(variable) {
+  return {
+    name: variable.name,
+    type: normalizeType(variable.type),
+    access: variable.access
+  };
+}
+function normalizeAbi(abi) {
+  if (typeof abi !== "object" || abi === null) {
+    return { functions: [] };
+  }
+  const abiObj = abi;
+  const functions = [];
+  const maps = [];
+  const variables = [];
+  if (Array.isArray(abiObj.functions)) {
+    for (const func of abiObj.functions) {
+      if (typeof func === "object" && func !== null) {
+        functions.push(normalizeFunction(func));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.maps)) {
+    for (const map of abiObj.maps) {
+      if (typeof map === "object" && map !== null) {
+        maps.push(normalizeMap(map));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.variables)) {
+    for (const variable of abiObj.variables) {
+      if (typeof variable === "object" && variable !== null) {
+        variables.push(normalizeVariable(variable));
+      }
+    }
+  }
+  return {
+    functions,
+    maps: maps.length > 0 ? maps : undefined,
+    variables: variables.length > 0 ? variables : undefined
+  };
+}
+
+// src/plugins/clarinet/index.ts
+function sanitizeContractName(name) {
+  return toCamelCase4(name);
+}
+async function isUserDefinedContract(contractId, manifestPath) {
+  const { address, contractName } = parseContractId(contractId);
+  try {
+    const { promises: fs2 } = await import("fs");
     const tomlContent = await fs2.readFile(manifestPath, "utf-8");
     const contractSectionRegex = /^\[contracts\.([^\]]+)\]/gm;
     const userContracts = new Set;
@@ -950,7 +1107,7 @@ var clarinet = (options = {}) => {
         const contractInterfaces = simnet.getContractsInterfaces();
         const contracts = [];
         for (const [contractId, abi] of contractInterfaces) {
-          const [_, contractName] = contractId.split(".");
+          const { contractName } = parseContractId(contractId);
           if (!await isUserDefinedContract(contractId, manifestPath)) {
             if (options.debug) {
               console.log(`\uD83D\uDEAB Skipping system contract: ${contractId}`);
@@ -967,7 +1124,7 @@ var clarinet = (options = {}) => {
           contracts.push({
             name: sanitizedName,
             address: contractId,
-            abi,
+            abi: normalizeAbi(abi),
             _clarinetSource: true
           });
         }
@@ -1013,155 +1170,33 @@ async function hasClarinetProject(path2 = "./Clarinet.toml") {
   }
 }
 // src/plugins/actions/generators.ts
-import { toCamelCase as toCamelCase4 } from "@secondlayer/clarity-types";
+import { toCamelCase as toCamelCase6 } from "@secondlayer/stacks/clarity";
+
+// src/utils/generator-helpers.ts
+import { toCamelCase as toCamelCase5 } from "@secondlayer/stacks/clarity";
 function generateArgsSignature(args) {
   if (args.length === 0)
     return "";
   const argsTypes = args.map((arg) => {
-    const camelName = toCamelCase4(arg.name);
+    const camelName = toCamelCase5(arg.name);
     return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   return `args: { ${argsTypes} }, `;
 }
-function generateClarityArgs(args, _contractName) {
+function generateClarityArgs(args) {
   if (args.length === 0)
     return "";
   return args.map((arg) => {
-    const argName = `args.${toCamelCase4(arg.name)}`;
-    return generateClarityConversion2(argName, arg);
+    const argName = `args.${toCamelCase5(arg.name)}`;
+    return generateClarityConversion(argName, arg);
   }).join(", ");
 }
-function generateClarityConversion2(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 (type["string-ascii"]) {
-    return `Cl.stringAscii(${argName})`;
-  }
-  if (type["string-utf8"]) {
-    return `Cl.stringUtf8(${argName})`;
-  }
-  if (type.buff) {
-    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 (type.optional) {
-    const innerConversion = generateClarityConversion2(argName, {
-      type: type.optional
-    });
-    return `${argName} !== null ? Cl.some(${innerConversion.replace(argName, `${argName}`)}) : Cl.none()`;
-  }
-  if (type.list) {
-    const innerConversion = generateClarityConversion2("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 (type.tuple) {
-    const requiredFields = type.tuple.map((f) => f.name);
-    const fieldNames = JSON.stringify(requiredFields);
-    const fields = type.tuple.map((field) => {
-      const camelFieldName = toCamelCase4(field.name);
-      const fieldConversion = generateClarityConversion2(`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 (type.response) {
-    const okConversion = generateClarityConversion2(`responseValue.ok`, {
-      type: type.response.ok
-    });
-    const errConversion = generateClarityConversion2(`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}`;
-}
+
+// src/plugins/actions/generators.ts
 function generateReadHelpers(contract, options) {
-  const { abi, name } = contract;
+  const { abi } = contract;
   const functions = abi.functions || [];
-  const readOnlyFunctions = functions.filter((f) => f.access === "read_only" || f.access === "read-only");
+  const readOnlyFunctions = functions.filter((f) => f.access === "read-only");
   if (readOnlyFunctions.length === 0) {
     return "";
   }
@@ -1178,9 +1213,9 @@ function generateReadHelpers(contract, options) {
     return "";
   }
   const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase4(func.name);
+    const methodName = toCamelCase6(func.name);
     const argsSignature = generateArgsSignature(func.args);
-    const clarityArgs = generateClarityArgs(func.args, name);
+    const clarityArgs = generateClarityArgs(func.args);
     return `async ${methodName}(${argsSignature}options?: {
       network?: 'mainnet' | 'testnet' | 'devnet';
       senderAddress?: string;
@@ -1202,7 +1237,7 @@ function generateReadHelpers(contract, options) {
   }`;
 }
 function generateWriteHelpers(contract, options) {
-  const { abi, name } = contract;
+  const { abi } = contract;
   const functions = abi.functions || [];
   const envVarName = options.senderKeyEnv ?? "STX_SENDER_KEY";
   const publicFunctions = functions.filter((f) => f.access === "public");
@@ -1222,9 +1257,9 @@ function generateWriteHelpers(contract, options) {
     return "";
   }
   const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase4(func.name);
+    const methodName = toCamelCase6(func.name);
     const argsSignature = generateArgsSignature(func.args);
-    const clarityArgs = generateClarityArgs(func.args, name);
+    const clarityArgs = generateClarityArgs(func.args);
     return `async ${methodName}(${argsSignature}senderKey?: string, options?: {
       network?: 'mainnet' | 'testnet' | 'devnet';
       fee?: string | number | undefined;
@@ -1318,28 +1353,19 @@ var actions = (options = {}) => {
   };
 };
 function addRequiredImports(content) {
-  const transactionsImportRegex = /import\s+\{([^}]+)\}\s+from\s+['"]@stacks\/transactions['"];/;
-  const match = content.match(transactionsImportRegex);
+  const stacksImportRegex = /import\s+\{([^}]+)\}\s+from\s+['"]@secondlayer\/stacks['"];/;
+  const match = content.match(stacksImportRegex);
   if (match) {
-    const existingImports = match[1].trim();
-    const requiredImports = [
-      "fetchCallReadOnlyFunction",
-      "makeContractCall"
-    ];
-    const newImports = requiredImports.filter((imp) => !existingImports.includes(imp)).join(", ");
-    if (newImports) {
-      const updatedImport = `import { ${existingImports}, ${newImports} } from '@stacks/transactions';`;
-      let updatedContent = content.replace(transactionsImportRegex, updatedImport);
-      if (!updatedContent.includes("type PostCondition")) {
-        updatedContent = updatedContent.replace(updatedImport, `${updatedImport}
-import type { PostCondition } from '@stacks/transactions';`);
-      }
-      return updatedContent;
+    let updatedContent = content;
+    if (!updatedContent.includes("fetchCallReadOnlyFunction")) {
+      updatedContent = updatedContent.replace(stacksImportRegex, `${match[0]}
+import { fetchCallReadOnlyFunction, makeContractCall } from '@secondlayer/stacks/clarity';`);
     }
-    if (!content.includes("type PostCondition")) {
-      return content.replace(transactionsImportRegex, `${match[0]}
-import type { PostCondition } from '@stacks/transactions';`);
+    if (!updatedContent.includes("type PostCondition")) {
+      updatedContent = updatedContent.replace(stacksImportRegex, `${match[0]}
+import type { PostCondition } from '@secondlayer/stacks';`);
     }
+    return updatedContent;
   }
   return content;
 }
@@ -1455,268 +1481,32 @@ export function useSecondLayerConfig(): SecondLayerReactConfig {
 
 // src/plugins/react/generators/generic.ts
 init_format();
-var GENERIC_HOOKS = [
-  "useAccount",
-  "useConnect",
-  "useDisconnect",
-  "useNetwork",
-  "useContract",
-  "useOpenSTXTransfer",
-  "useSignMessage",
-  "useDeployContract",
-  "useReadContract",
-  "useTransaction",
-  "useBlock",
-  "useAccountTransactions",
-  "useWaitForTransaction"
-];
-async function generateGenericHooks(excludeList = []) {
-  const hooksToGenerate = GENERIC_HOOKS.filter((hookName) => !excludeList.includes(hookName));
-  const imports = `import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { useState, useCallback } from 'react'
-import { useSecondLayerConfig } from './provider'
-import { connect, disconnect, isConnected, request, openContractCall as stacksOpenContractCall, openSTXTransfer, openSignatureRequestPopup, openContractDeploy } from '@stacks/connect'
-import { Cl, validateStacksAddress } from '@stacks/transactions'
-import type { PostCondition } from '@stacks/transactions'
-import type { ExtractFunctionArgs, ExtractFunctionNames, ClarityContract } from '@secondlayer/clarity-types'
 
-const API_URLS: Record<string, string> = {
-  mainnet: 'https://api.hiro.so',
-  testnet: 'https://api.testnet.hiro.so',
-  devnet: 'http://localhost:3999'
-}
+// src/generators/templates/use-contract.ts
+var USE_CONTRACT_TEMPLATE = `export function useContract() {
+  const config = useSecondLayerConfig()
+  const queryClient = useQueryClient()
+  const [isRequestPending, setIsRequestPending] = useState(false)
 
-async function fetchTransaction({ txId, network, apiUrl }: { txId: string; network?: string; apiUrl?: string }): Promise<any> {
-  const baseUrl = apiUrl || API_URLS[network || 'mainnet']
-  const response = await fetch(\`\${baseUrl}/extended/v1/tx/\${txId}\`)
-  if (!response.ok) throw new Error(\`Failed to fetch transaction: \${response.statusText}\`)
-  return response.json()
-}
+  // Helper function to convert JS values to Clarity values based on ABI
+  const convertArgsWithAbi = (args: any, abiArgs: any[]): any[] => {
+    if (!abiArgs || abiArgs.length === 0) return []
 
-async function fetchBlock({ height, network, apiUrl }: { height: number; network?: string; apiUrl?: string }): Promise<any> {
-  const baseUrl = apiUrl || API_URLS[network || 'mainnet']
-  const response = await fetch(\`\${baseUrl}/extended/v1/block/by_height/\${height}\`)
-  if (!response.ok) throw new Error(\`Failed to fetch block: \${response.statusText}\`)
-  return response.json()
-}
+    return abiArgs.map((abiArg, index) => {
+      const argValue = Array.isArray(args)
+        ? args[index]
+        : args[abiArg.name] || args[abiArg.name.replace(/-/g, '').replace(/_/g, '')]
+      return convertJSValueToClarityValue(argValue, abiArg.type)
+    })
+  }
 
-async function fetchAccountTransactions({ address, network, apiUrl }: { address: string; network?: string; apiUrl?: string }): Promise<any> {
-  const baseUrl = apiUrl || API_URLS[network || 'mainnet']
-  const response = await fetch(\`\${baseUrl}/extended/v1/address/\${address}/transactions\`)
-  if (!response.ok) throw new Error(\`Failed to fetch transactions: \${response.statusText}\`)
-  return response.json()
-}`;
-  const header = `/**
- * Generated generic Stacks React hooks
- * DO NOT EDIT MANUALLY
- */`;
-  const hooksCode = hooksToGenerate.map((hookName) => generateGenericHook(hookName)).filter(Boolean).join(`
+  // Helper function to convert buffer values with auto-detection
+  const convertBufferValue = (value: any): any => {
+    // Direct Uint8Array
+    if (value instanceof Uint8Array) {
+      return Cl.buffer(value)
+    }
 
-`);
-  const code = `${imports}
-
-${header}
-
-${hooksCode}`;
-  return formatCode(code);
-}
-function generateGenericHook(hookName) {
-  switch (hookName) {
-    case "useAccount":
-      return `export function useAccount() {
-  const config = useSecondLayerConfig()
-  
-  return useQuery({
-    queryKey: ['stacks-account', config.network],
-    queryFn: async () => {
-      try {
-        // Check if already connected using @stacks/connect v8
-        const connected = isConnected()
-        
-        if (!connected) {
-          return {
-            address: undefined,
-            addresses: undefined,
-            isConnected: false,
-            isConnecting: false,
-            isDisconnected: true,
-            status: 'disconnected' as const
-          }
-        }
-
-        // Get addresses using @stacks/connect v8 request method (SIP-030)
-        const result = await request('stx_getAddresses')
-        
-        if (!result || !result.addresses || result.addresses.length === 0) {
-          return {
-            address: undefined,
-            addresses: undefined,
-            isConnected: false,
-            isConnecting: false,
-            isDisconnected: true,
-            status: 'disconnected' as const
-          }
-        }
-
-        // Extract STX addresses from the response
-        const stxAddresses = result.addresses
-          .filter((addr: any) => addr.address.startsWith('SP') || addr.address.startsWith('ST'))
-          .map((addr: any) => addr.address)
-
-        return {
-          address: stxAddresses[0] || undefined,
-          addresses: stxAddresses,
-          isConnected: true,
-          isConnecting: false,
-          isDisconnected: false,
-          status: 'connected' as const
-        }
-      } catch (error) {
-        // Handle case where wallet is not available or user rejected
-        return {
-          address: undefined,
-          addresses: undefined,
-          isConnected: false,
-          isConnecting: false,
-          isDisconnected: true,
-          status: 'disconnected' as const
-        }
-      }
-    },
-    refetchOnWindowFocus: false,
-    retry: false,
-    staleTime: 1000 * 60 * 5, // 5 minutes
-    refetchInterval: 1000 * 30, // Refetch every 30 seconds to detect wallet changes
-  })
-}`;
-    case "useConnect":
-      return `export function useConnect() {
-  const queryClient = useQueryClient()
-  
-  const mutation = useMutation({
-    mutationFn: async (options: { forceWalletSelect?: boolean } = {}) => {
-      // Use @stacks/connect v8 connect method
-      return await connect(options)
-    },
-    onSuccess: () => {
-      // Invalidate account queries to refetch connection state
-      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
-    },
-    onError: (error) => {
-      console.error('Connection failed:', error)
-    }
-  })
-
-  return {
-    // Custom connect function that works without arguments
-    connect: (options?: { forceWalletSelect?: boolean }) => {
-      return mutation.mutate(options || {})
-    },
-    connectAsync: async (options?: { forceWalletSelect?: boolean }) => {
-      return mutation.mutateAsync(options || {})
-    },
-    // Expose all the mutation state
-    isPending: mutation.isPending,
-    isError: mutation.isError,
-    isSuccess: mutation.isSuccess,
-    error: mutation.error,
-    data: mutation.data,
-    reset: mutation.reset,
-    // Keep the original mutate/mutateAsync for advanced users
-    mutate: mutation.mutate,
-    mutateAsync: mutation.mutateAsync
-  }
-}`;
-    case "useDisconnect":
-      return `export function useDisconnect() {
-  const queryClient = useQueryClient()
-  
-  const mutation = useMutation({
-    mutationFn: async () => {
-      // Use @stacks/connect v8 disconnect method
-      return await disconnect()
-    },
-    onSuccess: () => {
-      // Clear all cached data on disconnect
-      queryClient.clear()
-    },
-    onError: (error) => {
-      console.error('Disconnect failed:', error)
-    }
-  })
-
-  return {
-    // Custom disconnect function
-    disconnect: () => {
-      return mutation.mutate()
-    },
-    disconnectAsync: async () => {
-      return mutation.mutateAsync()
-    },
-    // Expose all the mutation state
-    isPending: mutation.isPending,
-    isError: mutation.isError,
-    isSuccess: mutation.isSuccess,
-    error: mutation.error,
-    data: mutation.data,
-    reset: mutation.reset,
-    // Keep the original mutate/mutateAsync for advanced users
-    mutate: mutation.mutate,
-    mutateAsync: mutation.mutateAsync
-  }
-}`;
-    case "useNetwork":
-      return `export function useNetwork() {
-  const config = useSecondLayerConfig()
-  
-  return useQuery({
-    queryKey: ['stacks-network', config.network],
-    queryFn: async () => {
-      // Currently read-only from config
-      // Future: Use request('stx_getNetworks') when wallet support improves
-      const network = config.network
-      
-      return {
-        network,
-        isMainnet: network === 'mainnet',
-        isTestnet: network === 'testnet', 
-        isDevnet: network === 'devnet',
-        // Future: Add switchNetwork when wallets support stx_networkChange
-        // switchNetwork: async (newNetwork: string) => {
-        //   return await request('wallet_changeNetwork', { network: newNetwork })
-        // }
-      }
-    },
-    staleTime: Infinity, // Network config rarely changes
-    refetchOnWindowFocus: false,
-    retry: false
-  })
-}`;
-    case "useContract":
-      return `export function useContract() {
-  const config = useSecondLayerConfig()
-  const queryClient = useQueryClient()
-  const [isRequestPending, setIsRequestPending] = useState(false)
-  
-  // Helper function to convert JS values to Clarity values based on ABI
-  const convertArgsWithAbi = (args: any, abiArgs: any[]): any[] => {
-    if (!abiArgs || abiArgs.length === 0) return []
-    
-    return abiArgs.map((abiArg, index) => {
-      const argValue = Array.isArray(args) 
-        ? args[index] 
-        : args[abiArg.name] || args[abiArg.name.replace(/-/g, '').replace(/_/g, '')]
-      return convertJSValueToClarityValue(argValue, abiArg.type)
-    })
-  }
-
-  // Helper function to convert buffer values with auto-detection
-  const convertBufferValue = (value: any): any => {
-    // Direct Uint8Array
-    if (value instanceof Uint8Array) {
-      return Cl.buffer(value)
-    }
-    
     // Object notation with explicit type
     if (typeof value === 'object' && value !== null && value.type && value.value) {
       switch (value.type) {
@@ -1730,23 +1520,23 @@ function generateGenericHook(hookName) {
           throw new Error(\`Unsupported buffer type: \${value.type}\`)
       }
     }
-    
+
     // Auto-detect string type
     if (typeof value === 'string') {
       // 1. Check for hex (0x prefix or pure hex pattern)
       if (value.startsWith('0x') || /^[0-9a-fA-F]+$/.test(value)) {
         return Cl.bufferFromHex(value)
       }
-      
+
       // 2. Check for non-ASCII characters (UTF-8)
       if (!/^[\\x00-\\x7F]*$/.test(value)) {
         return Cl.bufferFromUtf8(value)
       }
-      
+
       // 3. Default to ASCII for simple ASCII strings
       return Cl.bufferFromAscii(value)
     }
-    
+
     throw new Error(\`Invalid buffer value: \${value}\`)
   }
 
@@ -1804,7 +1594,7 @@ function generateGenericHook(hookName) {
     }
 
     if (type.response) {
-      return 'ok' in value 
+      return 'ok' in value
         ? Cl.ok(convertJSValueToClarityValue(value.ok, type.response.ok))
         : Cl.error(convertJSValueToClarityValue(value.err, type.response.error))
     }
@@ -1817,13 +1607,13 @@ function generateGenericHook(hookName) {
     if (!abi || !abi.functions) return null
     return abi.functions.find((func: any) => func.name === functionName)
   }
-  
-  // Legacy function - unchanged, backward compatible
+
+  // Legacy function - pre-converted Clarity values
   const legacyOpenContractCall = useCallback(async (params: {
     contractAddress: string;
     contractName: string;
     functionName: string;
-    functionArgs: any[]; // Pre-converted Clarity values
+    functionArgs: any[];
     network?: string;
     postConditions?: PostCondition[];
     attachment?: string;
@@ -1831,57 +1621,23 @@ function generateGenericHook(hookName) {
     onCancel?: () => void;
   }) => {
     setIsRequestPending(true)
-    
+
     try {
       const { contractAddress, contractName, functionName, functionArgs, onFinish, onCancel, ...options } = params
       const network = params.network || config.network || 'mainnet'
       const contract = \`\${contractAddress}.\${contractName}\`
-      
-      // Try @stacks/connect v8 stx_callContract first (SIP-030)
-      try {
-        const result = await request('stx_callContract', {
-          contract,
-          functionName,
-          functionArgs,
-          network,
-          ...options
-        })
-        
-        // Invalidate relevant queries on success
-        queryClient.invalidateQueries({ 
-          queryKey: ['stacks-account'] 
-        })
-        
-        onFinish?.(result)
-        return result
-      } catch (connectError) {
-        // Fallback to openContractCall for broader wallet compatibility
-        console.warn('stx_callContract not supported, falling back to openContractCall:', connectError)
-        
-        return new Promise((resolve, reject) => {
-          stacksOpenContractCall({
-            contractAddress,
-            contractName,
-            functionName,
-            functionArgs,
-            network,
-            ...options,
-            onFinish: (data: any) => {
-              // Invalidate relevant queries on success
-              queryClient.invalidateQueries({ 
-                queryKey: ['stacks-account'] 
-              })
-              
-              onFinish?.(data)
-              resolve(data)
-            },
-            onCancel: () => {
-              onCancel?.()
-              reject(new Error('User cancelled transaction'))
-            }
-          })
-        })
-      }
+
+      const result = await request('stx_callContract', {
+        contract,
+        functionName,
+        functionArgs,
+        network,
+        ...options
+      })
+
+      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
+      onFinish?.(result)
+      return result
     } catch (error) {
       console.error('Contract call failed:', error)
       throw error instanceof Error ? error : new Error('Contract call failed')
@@ -1892,7 +1648,7 @@ function generateGenericHook(hookName) {
 
   // Enhanced function - requires ABI, auto-converts JS values
   const openContractCall = useCallback(async <
-    T extends ClarityContract,
+    T extends AbiContract,
     FN extends ExtractFunctionNames<T>
   >(params: {
     contractAddress: string;
@@ -1907,79 +1663,285 @@ function generateGenericHook(hookName) {
     onCancel?: () => void;
   }) => {
     setIsRequestPending(true)
-    
+
     try {
       const { contractAddress, contractName, functionName, functionArgs, abi, onFinish, onCancel, ...options } = params
       const network = params.network || config.network || 'mainnet'
       const contract = \`\${contractAddress}.\${contractName}\`
-      
-      // Find the function in the ABI and convert args
+
       const abiFunction = findFunctionInAbi(abi, functionName)
       if (!abiFunction) {
         throw new Error(\`Function '\${functionName}' not found in ABI\`)
       }
-      
+
       const processedArgs = convertArgsWithAbi(functionArgs, abiFunction.args || [])
-      
-      // Try @stacks/connect v8 stx_callContract first (SIP-030)
-      try {
-        const result = await request('stx_callContract', {
-          contract,
-          functionName,
-          functionArgs: processedArgs,
-          network,
-          ...options
-        })
-        
-        // Invalidate relevant queries on success
-        queryClient.invalidateQueries({ 
-          queryKey: ['stacks-account'] 
-        })
-        
-        onFinish?.(result)
-        return result
-      } catch (connectError) {
-        // Fallback to openContractCall for broader wallet compatibility
-        console.warn('stx_callContract not supported, falling back to openContractCall:', connectError)
-        
-        return new Promise((resolve, reject) => {
-          stacksOpenContractCall({
-            contractAddress,
-            contractName,
-            functionName,
-            functionArgs: processedArgs,
-            network,
-            ...options,
-            onFinish: (data: any) => {
-              // Invalidate relevant queries on success
-              queryClient.invalidateQueries({ 
-                queryKey: ['stacks-account'] 
-              })
-              
-              onFinish?.(data)
-              resolve(data)
-            },
-            onCancel: () => {
-              onCancel?.()
-              reject(new Error('User cancelled transaction'))
-            }
-          })
-        })
-      }
+
+      const result = await request('stx_callContract', {
+        contract,
+        functionName,
+        functionArgs: processedArgs,
+        network,
+        ...options
+      })
+
+      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
+      onFinish?.(result)
+      return result
     } catch (error) {
       console.error('Contract call failed:', error)
       throw error instanceof Error ? error : new Error('Contract call failed')
     } finally {
       setIsRequestPending(false)
     }
-  }, [config.network, queryClient])
+  }, [config.network, queryClient])
+
+  return {
+    legacyOpenContractCall,
+    openContractCall,
+    isRequestPending
+  }
+}`;
+
+// src/plugins/react/generators/generic.ts
+var GENERIC_HOOKS = [
+  "useAccount",
+  "useConnect",
+  "useDisconnect",
+  "useNetwork",
+  "useContract",
+  "useOpenSTXTransfer",
+  "useSignMessage",
+  "useDeployContract",
+  "useReadContract",
+  "useTransaction",
+  "useBlock",
+  "useAccountTransactions",
+  "useWaitForTransaction"
+];
+async function generateGenericHooks(excludeList = []) {
+  const hooksToGenerate = GENERIC_HOOKS.filter((hookName) => !excludeList.includes(hookName));
+  const imports = `import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
+import { useState, useCallback } from 'react'
+import { useSecondLayerConfig } from './provider'
+import { connect, disconnect, isConnected, request } from '@secondlayer/stacks/connect'
+import { Cl, validateStacksAddress } from '@secondlayer/stacks'
+import type { PostCondition } from '@secondlayer/stacks'
+import type { ExtractFunctionArgs, ExtractFunctionNames, AbiContract } from '@secondlayer/stacks/clarity'
+
+const API_URLS: Record<string, string> = {
+  mainnet: 'https://api.hiro.so',
+  testnet: 'https://api.testnet.hiro.so',
+  devnet: 'http://localhost:3999'
+}
+
+async function fetchTransaction({ txId, network, apiUrl }: { txId: string; network?: string; apiUrl?: string }): Promise<any> {
+  const baseUrl = apiUrl || API_URLS[network || 'mainnet']
+  const response = await fetch(\`\${baseUrl}/extended/v1/tx/\${txId}\`)
+  if (!response.ok) throw new Error(\`Failed to fetch transaction: \${response.statusText}\`)
+  return response.json()
+}
+
+async function fetchBlock({ height, network, apiUrl }: { height: number; network?: string; apiUrl?: string }): Promise<any> {
+  const baseUrl = apiUrl || API_URLS[network || 'mainnet']
+  const response = await fetch(\`\${baseUrl}/extended/v1/block/by_height/\${height}\`)
+  if (!response.ok) throw new Error(\`Failed to fetch block: \${response.statusText}\`)
+  return response.json()
+}
+
+async function fetchAccountTransactions({ address, network, apiUrl }: { address: string; network?: string; apiUrl?: string }): Promise<any> {
+  const baseUrl = apiUrl || API_URLS[network || 'mainnet']
+  const response = await fetch(\`\${baseUrl}/extended/v1/address/\${address}/transactions\`)
+  if (!response.ok) throw new Error(\`Failed to fetch transactions: \${response.statusText}\`)
+  return response.json()
+}`;
+  const header = `/**
+ * Generated generic Stacks React hooks
+ * DO NOT EDIT MANUALLY
+ */`;
+  const hooksCode = hooksToGenerate.map((hookName) => generateGenericHook(hookName)).filter(Boolean).join(`
+
+`);
+  const code = `${imports}
+
+${header}
+
+${hooksCode}`;
+  return formatCode(code);
+}
+function generateGenericHook(hookName) {
+  switch (hookName) {
+    case "useAccount":
+      return `export function useAccount() {
+  const config = useSecondLayerConfig()
+  
+  return useQuery({
+    queryKey: ['stacks-account', config.network],
+    queryFn: async () => {
+      try {
+        // Check if already connected
+        const connected = isConnected()
+        
+        if (!connected) {
+          return {
+            address: undefined,
+            addresses: undefined,
+            isConnected: false,
+            isConnecting: false,
+            isDisconnected: true,
+            status: 'disconnected' as const
+          }
+        }
+
+        // Get addresses via SIP-030
+        const result = await request('stx_getAddresses')
+        
+        if (!result || !result.addresses || result.addresses.length === 0) {
+          return {
+            address: undefined,
+            addresses: undefined,
+            isConnected: false,
+            isConnecting: false,
+            isDisconnected: true,
+            status: 'disconnected' as const
+          }
+        }
+
+        // Extract STX addresses from the response
+        const stxAddresses = result.addresses
+          .filter((addr: any) => addr.address.startsWith('SP') || addr.address.startsWith('ST'))
+          .map((addr: any) => addr.address)
+
+        return {
+          address: stxAddresses[0] || undefined,
+          addresses: stxAddresses,
+          isConnected: true,
+          isConnecting: false,
+          isDisconnected: false,
+          status: 'connected' as const
+        }
+      } catch (error) {
+        // Handle case where wallet is not available or user rejected
+        return {
+          address: undefined,
+          addresses: undefined,
+          isConnected: false,
+          isConnecting: false,
+          isDisconnected: true,
+          status: 'disconnected' as const
+        }
+      }
+    },
+    refetchOnWindowFocus: false,
+    retry: false,
+    staleTime: 1000 * 60 * 5, // 5 minutes
+    refetchInterval: 1000 * 30, // Refetch every 30 seconds to detect wallet changes
+  })
+}`;
+    case "useConnect":
+      return `export function useConnect() {
+  const queryClient = useQueryClient()
+  
+  const mutation = useMutation({
+    mutationFn: async (options: { forceWalletSelect?: boolean } = {}) => {
+      // SIP-030 connect
+      return await connect(options)
+    },
+    onSuccess: () => {
+      // Invalidate account queries to refetch connection state
+      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
+    },
+    onError: (error) => {
+      console.error('Connection failed:', error)
+    }
+  })
 
   return {
-    legacyOpenContractCall,
-    openContractCall,
-    isRequestPending
+    // Custom connect function that works without arguments
+    connect: (options?: { forceWalletSelect?: boolean }) => {
+      return mutation.mutate(options || {})
+    },
+    connectAsync: async (options?: { forceWalletSelect?: boolean }) => {
+      return mutation.mutateAsync(options || {})
+    },
+    // Expose all the mutation state
+    isPending: mutation.isPending,
+    isError: mutation.isError,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    data: mutation.data,
+    reset: mutation.reset,
+    // Keep the original mutate/mutateAsync for advanced users
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync
+  }
+}`;
+    case "useDisconnect":
+      return `export function useDisconnect() {
+  const queryClient = useQueryClient()
+  
+  const mutation = useMutation({
+    mutationFn: async () => {
+      // SIP-030 disconnect
+      return await disconnect()
+    },
+    onSuccess: () => {
+      // Clear all cached data on disconnect
+      queryClient.clear()
+    },
+    onError: (error) => {
+      console.error('Disconnect failed:', error)
+    }
+  })
+
+  return {
+    // Custom disconnect function
+    disconnect: () => {
+      return mutation.mutate()
+    },
+    disconnectAsync: async () => {
+      return mutation.mutateAsync()
+    },
+    // Expose all the mutation state
+    isPending: mutation.isPending,
+    isError: mutation.isError,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    data: mutation.data,
+    reset: mutation.reset,
+    // Keep the original mutate/mutateAsync for advanced users
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync
   }
 }`;
+    case "useNetwork":
+      return `export function useNetwork() {
+  const config = useSecondLayerConfig()
+  
+  return useQuery({
+    queryKey: ['stacks-network', config.network],
+    queryFn: async () => {
+      // Currently read-only from config
+      // Future: Use request('stx_getNetworks') when wallet support improves
+      const network = config.network
+      
+      return {
+        network,
+        isMainnet: network === 'mainnet',
+        isTestnet: network === 'testnet', 
+        isDevnet: network === 'devnet',
+        // Future: Add switchNetwork when wallets support stx_networkChange
+        // switchNetwork: async (newNetwork: string) => {
+        //   return await request('wallet_changeNetwork', { network: newNetwork })
+        // }
+      }
+    },
+    staleTime: Infinity, // Network config rarely changes
+    refetchOnWindowFocus: false,
+    retry: false
+  })
+}`;
+    case "useContract":
+      return USE_CONTRACT_TEMPLATE;
     case "useReadContract":
       return `export function useReadContract<TArgs = any, TResult = any>(params: {
   contractAddress: string;
@@ -1994,7 +1956,7 @@ function generateGenericHook(hookName) {
   return useQuery<TResult>({
     queryKey: ['read-contract', params.contractAddress, params.contractName, params.functionName, params.args, params.network || config.network],
     queryFn: async () => {
-      const { fetchCallReadOnlyFunction } = await import('@stacks/transactions')
+      const { fetchCallReadOnlyFunction } = await import('@secondlayer/stacks/clarity')
       
       // For now, we'll need to handle the args conversion here
       // In the future, we could integrate with the contract interface for automatic conversion
@@ -2095,39 +2057,25 @@ function generateGenericHook(hookName) {
       return `export function useOpenSTXTransfer() {
   const config = useSecondLayerConfig()
   const queryClient = useQueryClient()
-  
+
   const mutation = useMutation({
     mutationFn: async (params: {
       recipient: string;
       amount: string | number;
       memo?: string;
       network?: string;
-      onFinish?: (data: any) => void;
-      onCancel?: () => void;
     }) => {
-      const { recipient, amount, memo, onFinish, onCancel, ...options } = params
+      const { recipient, amount, memo } = params
       const network = params.network || config.network || 'mainnet'
-      
-      return new Promise((resolve, reject) => {
-        openSTXTransfer({
-          recipient,
-          amount: amount.toString(),
-          memo,
-          network,
-          ...options,
-          onFinish: (data: any) => {
-            onFinish?.(data)
-            resolve(data)
-          },
-          onCancel: () => {
-            onCancel?.()
-            reject(new Error('User cancelled transaction'))
-          }
-        })
+
+      return await request('stx_transferStx', {
+        recipient,
+        amount: amount.toString(),
+        memo,
+        network,
       })
     },
     onSuccess: () => {
-      // Invalidate relevant queries on success
       queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
     },
     onError: (error) => {
@@ -2140,15 +2088,12 @@ function generateGenericHook(hookName) {
     amount: string | number;
     memo?: string;
     network?: string;
-    onFinish?: (data: any) => void;
-    onCancel?: () => void;
   }) => {
     return mutation.mutateAsync(params)
   }, [mutation])
 
   return {
     openSTXTransfer,
-    // Expose mutation state
     isPending: mutation.isPending,
     isError: mutation.isError,
     isSuccess: mutation.isSuccess,
@@ -2160,31 +2105,18 @@ function generateGenericHook(hookName) {
     case "useSignMessage":
       return `export function useSignMessage() {
   const config = useSecondLayerConfig()
-  
+
   const mutation = useMutation({
     mutationFn: async (params: {
       message: string;
       network?: string;
-      onFinish?: (data: any) => void;
-      onCancel?: () => void;
     }) => {
-      const { message, onFinish, onCancel, ...options } = params
+      const { message } = params
       const network = params.network || config.network || 'mainnet'
-      
-      return new Promise((resolve, reject) => {
-        openSignatureRequestPopup({
-          message,
-          network,
-          ...options,
-          onFinish: (data: any) => {
-            onFinish?.(data)
-            resolve(data)
-          },
-          onCancel: () => {
-            onCancel?.()
-            reject(new Error('User cancelled message signing'))
-          }
-        })
+
+      return await request('stx_signMessage', {
+        message,
+        network,
       })
     },
     onError: (error) => {
@@ -2195,15 +2127,12 @@ function generateGenericHook(hookName) {
   const signMessage = useCallback(async (params: {
     message: string;
     network?: string;
-    onFinish?: (data: any) => void;
-    onCancel?: () => void;
   }) => {
     return mutation.mutateAsync(params)
   }, [mutation])
 
   return {
     signMessage,
-    // Expose mutation state
     isPending: mutation.isPending,
     isError: mutation.isError,
     isSuccess: mutation.isSuccess,
@@ -2216,38 +2145,23 @@ function generateGenericHook(hookName) {
       return `export function useDeployContract() {
   const config = useSecondLayerConfig()
   const queryClient = useQueryClient()
-  
+
   const mutation = useMutation({
     mutationFn: async (params: {
       contractName: string;
       codeBody: string;
       network?: string;
-      postConditions?: PostCondition[];
-      onFinish?: (data: any) => void;
-      onCancel?: () => void;
     }) => {
-      const { contractName, codeBody, onFinish, onCancel, ...options } = params
+      const { contractName, codeBody } = params
       const network = params.network || config.network || 'mainnet'
-      
-      return new Promise((resolve, reject) => {
-        openContractDeploy({
-          contractName,
-          codeBody,
-          network,
-          ...options,
-          onFinish: (data: any) => {
-            onFinish?.(data)
-            resolve(data)
-          },
-          onCancel: () => {
-            onCancel?.()
-            reject(new Error('User cancelled contract deployment'))
-          }
-        })
+
+      return await request('stx_deployContract', {
+        name: contractName,
+        clarityCode: codeBody,
+        network,
       })
     },
     onSuccess: () => {
-      // Invalidate relevant queries on success
       queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
     },
     onError: (error) => {
@@ -2259,16 +2173,12 @@ function generateGenericHook(hookName) {
     contractName: string;
     codeBody: string;
     network?: string;
-    postConditions?: PostCondition[];
-    onFinish?: (data: any) => void;
-    onCancel?: () => void;
   }) => {
     return mutation.mutateAsync(params)
   }, [mutation])
 
   return {
     deployContract,
-    // Expose mutation state
     isPending: mutation.isPending,
     isError: mutation.isError,
     isSuccess: mutation.isSuccess,
@@ -2286,35 +2196,30 @@ function generateGenericHook(hookName) {
 init_format();
 
 // src/plugins/react/generators/utils.ts
-import { toCamelCase as toCamelCase5 } from "@secondlayer/clarity-types";
+import { toCamelCase as toCamelCase7 } from "@secondlayer/stacks/clarity";
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function generateHookArgsSignature(args) {
   if (args.length === 0)
     return "";
-  const argsList = args.map((arg) => `${toCamelCase5(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
+  const argsList = args.map((arg) => `${toCamelCase7(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
   return `${argsList}`;
 }
 function generateArgsType(args) {
   if (args.length === 0)
     return "void";
-  const argsList = args.map((arg) => `${toCamelCase5(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
+  const argsList = args.map((arg) => `${toCamelCase7(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
   return `{ ${argsList} }`;
 }
-function generateQueryKeyArgs(args) {
+function generateArgNames(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => toCamelCase5(arg.name)).join(", ");
-}
-function generateFunctionCallArgs(args) {
-  if (args.length === 0)
-    return "";
-  return args.map((arg) => toCamelCase5(arg.name)).join(", ");
+  return args.map((arg) => toCamelCase7(arg.name)).join(", ");
 }
 function generateEnabledCondition(args) {
   return args.map((arg) => {
-    const camelName = toCamelCase5(arg.name);
+    const camelName = toCamelCase7(arg.name);
     const type = clarityTypeToTS(arg.type);
     if (type === "string")
       return `!!${camelName}`;
@@ -2326,7 +2231,7 @@ function generateEnabledCondition(args) {
 function generateObjectArgs(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => `${arg.name}: ${toCamelCase5(arg.name)}`).join(", ");
+  return args.map((arg) => `${arg.name}: ${toCamelCase7(arg.name)}`).join(", ");
 }
 
 // src/plugins/react/generators/contract.ts
@@ -2334,8 +2239,8 @@ async function generateContractHooks(contracts, excludeList = []) {
   const imports = `import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
 import { useCallback } from 'react'
 import { useSecondLayerConfig } from './provider'
-import { request, openContractCall as stacksOpenContractCall } from '@stacks/connect'
-import type { PostCondition } from '@stacks/transactions'
+import { request } from '@secondlayer/stacks/connect'
+import type { PostCondition } from '@secondlayer/stacks'
 import { ${contracts.map((c) => c.name).join(", ")} } from './contracts'`;
   const header = `/**
  * Generated contract-specific React hooks
@@ -2356,24 +2261,24 @@ function generateContractHookMethods(contract, excludeList) {
   const functions = abi.functions || [];
   const maps = abi.maps || [];
   const variables = abi.variables || [];
-  const readOnlyFunctions = functions.filter((f) => f.access === "read_only" || f.access === "read-only");
+  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(toCamelCase5(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase7(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(toCamelCase5(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase7(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(toCamelCase5(map.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase7(map.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -2381,7 +2286,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(toCamelCase5(variable.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase7(variable.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -2389,7 +2294,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(toCamelCase5(constant.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase7(constant.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -2404,7 +2309,7 @@ function generateContractHookMethods(contract, excludeList) {
 `);
 }
 function generateReadHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase5(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase7(func.name))}`;
   const argsSignature = generateHookArgsSignature(func.args);
   const enabledParam = func.args.length > 0 ? ", options?: { enabled?: boolean }" : "options?: { enabled?: boolean }";
   const returnType = clarityTypeToTS(func.outputs);
@@ -2412,8 +2317,8 @@ function generateReadHook(func, contractName) {
   const config = useSecondLayerConfig()
 
   return useQuery<${returnType}>({
-    queryKey: ['${func.name}', ${contractName}.address, ${generateQueryKeyArgs(func.args)}],
-    queryFn: () => ${contractName}.read.${toCamelCase5(func.name)}(${generateFunctionCallArgs(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
+    queryKey: ['${func.name}', ${contractName}.address, ${generateArgNames(func.args)}],
+    queryFn: () => ${contractName}.read.${toCamelCase7(func.name)}(${generateArgNames(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
       network: config.network,
       senderAddress: config.senderAddress || 'SP000000000000000000002Q6VF78'
     }),
@@ -2423,7 +2328,7 @@ function generateReadHook(func, contractName) {
 }`;
 }
 function generateWriteHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase5(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase7(func.name))}`;
   const argsType = generateArgsType(func.args);
   return `export function ${hookName}() {
   const config = useSecondLayerConfig()
@@ -2440,46 +2345,21 @@ function generateWriteHook(func, contractName) {
       };
     }) => {
       const { args, options = {} } = params
-      const contractCallData = ${contractName}.${toCamelCase5(func.name)}(args)
+      const contractCallData = ${contractName}.${toCamelCase7(func.name)}(args)
       const { contractAddress, contractName: name, functionName, functionArgs } = contractCallData
       const network = config.network || 'mainnet'
       const contract = \`\${contractAddress}.\${name}\`
-      
-      // Try @stacks/connect v8 stx_callContract first (SIP-030)
-      try {
-        const result = await request('stx_callContract', {
-          contract,
-          functionName,
-          functionArgs,
-          network,
-          ...options
-        })
-        
-        options.onFinish?.(result)
-        return result
-      } catch (connectError) {
-        // Fallback to openContractCall for broader wallet compatibility
-        console.warn('stx_callContract not supported, falling back to openContractCall:', connectError)
-        
-        return new Promise((resolve, reject) => {
-          stacksOpenContractCall({
-            contractAddress,
-            contractName: name,
-            functionName,
-            functionArgs,
-            network,
-            ...options,
-            onFinish: (data: any) => {
-              options.onFinish?.(data)
-              resolve(data)
-            },
-            onCancel: () => {
-              options.onCancel?.()
-              reject(new Error('User cancelled transaction'))
-            }
-          })
-        })
-      }
+
+      const result = await request('stx_callContract', {
+        contract,
+        functionName,
+        functionArgs,
+        network,
+        ...options
+      })
+
+      options.onFinish?.(result)
+      return result
     },
     onSuccess: () => {
       // Invalidate relevant queries on success
@@ -2490,7 +2370,7 @@ function generateWriteHook(func, contractName) {
     }
   })
 
-  const ${toCamelCase5(func.name)} = useCallback(async (
+  const ${toCamelCase7(func.name)} = useCallback(async (
     args: ${argsType},
     options?: {
       postConditions?: PostCondition[];
@@ -2503,7 +2383,7 @@ function generateWriteHook(func, contractName) {
   }, [mutation])
 
   return {
-    ${toCamelCase5(func.name)},
+    ${toCamelCase7(func.name)},
     // Expose mutation state
     isPending: mutation.isPending,
     isError: mutation.isError,
@@ -2515,7 +2395,7 @@ function generateWriteHook(func, contractName) {
 }`;
 }
 function generateMapHook(map, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase5(map.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase7(map.name))}`;
   const keyType = clarityTypeToTS(map.key);
   const valueType = clarityTypeToTS(map.value);
   return `export function ${hookName}(key: ${keyType}, options?: { enabled?: boolean }) {
@@ -2524,14 +2404,14 @@ function generateMapHook(map, contractVarName, _address, _contractName) {
   return useQuery<${valueType} | null>({
     queryKey: ['${contractVarName}', '${map.name}', 'map', key, config.network],
     queryFn: async () => {
-      return ${contractVarName}.maps.${toCamelCase5(map.name)}.get(key, { network: config.network })
+      return ${contractVarName}.maps.${toCamelCase7(map.name)}.get(key, { network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateVarHook(variable, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase5(variable.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase7(variable.name))}`;
   const valueType = clarityTypeToTS(variable.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useSecondLayerConfig()
@@ -2539,14 +2419,14 @@ function generateVarHook(variable, contractVarName, _address, _contractName) {
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${variable.name}', 'var', config.network],
     queryFn: async () => {
-      return ${contractVarName}.vars.${toCamelCase5(variable.name)}.get({ network: config.network })
+      return ${contractVarName}.vars.${toCamelCase7(variable.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateConstantHook(constant, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase5(constant.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase7(constant.name))}`;
   const valueType = clarityTypeToTS(constant.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useSecondLayerConfig()
@@ -2554,7 +2434,7 @@ function generateConstantHook(constant, contractVarName, _address, _contractName
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${constant.name}', 'constant', config.network],
     queryFn: async () => {
-      return ${contractVarName}.constants.${toCamelCase5(constant.name)}.get({ network: config.network })
+      return ${contractVarName}.constants.${toCamelCase7(constant.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true,
     staleTime: Infinity // Constants never change
@@ -2602,155 +2482,17 @@ var react = (options = {}) => {
 };
 // src/plugins/testing/generators.ts
 import {
-  toCamelCase as toCamelCase6
-} from "@secondlayer/clarity-types";
+  toCamelCase as toCamelCase8,
+  isAbiTuple as isAbiTuple3
+} from "@secondlayer/stacks/clarity";
 function toPascalCase(str) {
-  const camel = toCamelCase6(str);
+  const camel = toCamelCase8(str);
   return camel.charAt(0).toUpperCase() + camel.slice(1);
 }
-function generateArgsSignature2(args) {
-  if (args.length === 0)
-    return "";
-  const argsTypes = args.map((arg) => {
-    const camelName = toCamelCase6(arg.name);
-    return `${camelName}: ${getTypeForArg(arg)}`;
-  }).join("; ");
-  return `args: { ${argsTypes} }, `;
-}
-function generateClarityConversion3(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 principal = ${argName};
-          if (principal.includes(".")) {
-            const [address, contractName] = principal.split(".") as [string, string];
-            return Cl.contractPrincipal(address, contractName);
-          } else {
-            return Cl.standardPrincipal(principal);
-          }
-        })()`;
-      default:
-        return `${argName}`;
-    }
-  }
-  if (type["string-ascii"]) {
-    return `Cl.stringAscii(${argName})`;
-  }
-  if (type["string-utf8"]) {
-    return `Cl.stringUtf8(${argName})`;
-  }
-  if (type.buff) {
-    return `(() => {
-      const value = ${argName};
-      if (value instanceof Uint8Array) {
-        return Cl.buffer(value);
-      }
-      if (typeof value === 'object' && value !== null && 'type' in value && 'value' in 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);
-        }
-        if (!/^[\\x00-\\x7F]*$/.test(value)) {
-          return Cl.bufferFromUtf8(value);
-        }
-        return Cl.bufferFromAscii(value);
-      }
-      throw new Error(\`Invalid buffer value: \${value}\`);
-    })()`;
-  }
-  if (type.optional) {
-    const innerConversion = generateClarityConversion3("inner", {
-      type: type.optional
-    });
-    return `${argName} !== null ? Cl.some((() => { const inner = ${argName}; return ${innerConversion}; })()) : Cl.none()`;
-  }
-  if (type.list) {
-    const innerConversion = generateClarityConversion3("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 (type.tuple) {
-    const requiredFields = type.tuple.map((f) => f.name);
-    const fieldNames = JSON.stringify(requiredFields);
-    const fields = type.tuple.map((field) => {
-      const camelFieldName = toCamelCase6(field.name);
-      const fieldConversion = generateClarityConversion3(`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 (type.response) {
-    const okConversion = generateClarityConversion3(`responseValue.ok`, {
-      type: type.response.ok
-    });
-    const errConversion = generateClarityConversion3(`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}`;
-}
-function generateClarityArgs2(args) {
-  if (args.length === 0)
-    return "";
-  return args.map((arg) => {
-    const argName = `args.${toCamelCase6(arg.name)}`;
-    return generateClarityConversion3(argName, arg);
-  }).join(", ");
-}
 function generatePublicFunction(func, contractId) {
-  const methodName = toCamelCase6(func.name);
-  const argsSignature = generateArgsSignature2(func.args);
-  const clarityArgs = generateClarityArgs2(func.args);
+  const methodName = toCamelCase8(func.name);
+  const argsSignature = generateArgsSignature(func.args);
+  const clarityArgs = generateClarityArgs(func.args);
   return `${methodName}: (${argsSignature}caller: string) => {
       const callerAddr = accounts.get(caller) ?? caller;
       return simnet.callPublicFn(
@@ -2762,9 +2504,9 @@ function generatePublicFunction(func, contractId) {
     }`;
 }
 function generateReadOnlyFunction(func, contractId) {
-  const methodName = toCamelCase6(func.name);
-  const argsSignature = generateArgsSignature2(func.args);
-  const clarityArgs = generateClarityArgs2(func.args);
+  const methodName = toCamelCase8(func.name);
+  const argsSignature = generateArgsSignature(func.args);
+  const clarityArgs = generateClarityArgs(func.args);
   const hasArgs = func.args.length > 0;
   const argsParam = hasArgs ? argsSignature : "";
   return `${methodName}: (${argsParam}) => {
@@ -2777,9 +2519,9 @@ function generateReadOnlyFunction(func, contractId) {
     }`;
 }
 function generatePrivateFunction(func, contractId) {
-  const methodName = toCamelCase6(func.name);
-  const argsSignature = generateArgsSignature2(func.args);
-  const clarityArgs = generateClarityArgs2(func.args);
+  const methodName = toCamelCase8(func.name);
+  const argsSignature = generateArgsSignature(func.args);
+  const clarityArgs = generateClarityArgs(func.args);
   return `${methodName}: (${argsSignature}caller: string) => {
       const callerAddr = accounts.get(caller) ?? caller;
       return simnet.callPrivateFn(
@@ -2791,31 +2533,31 @@ function generatePrivateFunction(func, contractId) {
     }`;
 }
 function generateDataVarHelper(variable, contractId) {
-  const methodName = toCamelCase6(variable.name);
+  const methodName = toCamelCase8(variable.name);
   return `${methodName}: () => {
       return simnet.getDataVar('${contractId}', '${variable.name}');
     }`;
 }
 function getMapKeyType(keyType) {
-  if (keyType.tuple) {
-    const fields = keyType.tuple.map((field) => `${toCamelCase6(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
+  if (isAbiTuple3(keyType)) {
+    const fields = keyType.tuple.map((field) => `${toCamelCase8(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
     return `{ ${fields} }`;
   }
   return getTypeForArg({ type: keyType });
 }
 function generateMapKeyConversion2(keyType) {
-  if (keyType.tuple) {
+  if (isAbiTuple3(keyType)) {
     const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase6(field.name);
-      const fieldConversion = generateClarityConversion3(`key.${camelFieldName}`, { type: field.type });
+      const camelFieldName = toCamelCase8(field.name);
+      const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
     return `Cl.tuple({ ${fields} })`;
   }
-  return generateClarityConversion3("key", { type: keyType });
+  return generateClarityConversion("key", { type: keyType });
 }
 function generateMapEntryHelper(map, contractId) {
-  const methodName = toCamelCase6(map.name);
+  const methodName = toCamelCase8(map.name);
   const keyType = getMapKeyType(map.key);
   const keyConversion = generateMapKeyConversion2(map.key);
   return `${methodName}: (key: ${keyType}) => {
@@ -2856,7 +2598,7 @@ function generateContractHelper(contract, options) {
   const maps = abi.maps || [];
   const pascalName = toPascalCase(name);
   const publicFns = functions.filter((f) => f.access === "public");
-  const readOnlyFns = functions.filter((f) => f.access === "read_only" || f.access === "read-only");
+  const readOnlyFns = functions.filter((f) => f.access === "read-only");
   const privateFns = options.includePrivate ? functions.filter((f) => f.access === "private") : [];
   const publicHelpers = publicFns.map((f) => generatePublicFunction(f, address));
   const readOnlyHelpers = readOnlyFns.map((f) => generateReadOnlyFunction(f, address));
@@ -2885,7 +2627,7 @@ function generateContractHelper(contract, options) {
 }
 function generateGetContracts(contracts) {
   const contractEntries = contracts.map((contract) => {
-    const camelName = toCamelCase6(contract.name);
+    const camelName = toCamelCase8(contract.name);
     const pascalName = toPascalCase(contract.name);
     return `${camelName}: get${pascalName}(simnet)`;
   }).join(`,
@@ -3013,5 +2755,5 @@ export {
   PluginManager
 };
 
-//# debugId=161C0B3D172075E364756E2164756E21
+//# debugId=217DF2A543BBE57564756E2164756E21
 //# sourceMappingURL=index.js.map