@secondlayer/cli 1.1.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, {
@@ -30,28 +15,70 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/utils/format.ts
 var exports_format = {};
 __export(exports_format, {
-  formatCode: () => formatCode,
-  PRETTIER_OPTIONS: () => PRETTIER_OPTIONS
+  formatCode: () => formatCode
 });
-import { format } from "prettier";
+import { Biome, Distribution } from "@biomejs/js-api";
+async function getBiome() {
+  if (!biome) {
+    biome = await Biome.create({
+      distribution: Distribution.NODE
+    });
+    biome.applyConfiguration({
+      formatter: {
+        enabled: true,
+        indentStyle: "tab",
+        lineWidth: 80
+      },
+      javascript: {
+        formatter: {
+          semicolons: "always",
+          quoteStyle: "single"
+        }
+      },
+      organizeImports: {
+        enabled: true
+      },
+      linter: {
+        enabled: true
+      },
+      assists: {
+        enabled: true
+      }
+    });
+    biome.registerProjectFolder();
+  }
+  return biome;
+}
 async function formatCode(code) {
-  return format(code, PRETTIER_OPTIONS);
-}
-var PRETTIER_OPTIONS;
-var init_format = __esm(() => {
-  PRETTIER_OPTIONS = {
-    parser: "typescript",
-    singleQuote: true,
-    semi: true,
-    printWidth: 100,
-    trailingComma: "es5"
-  };
-});
+  const b = await getBiome();
+  const linted = b.lintContent(code, {
+    filePath: "generated.ts",
+    fixFileMode: "SafeFixes"
+  });
+  const formatted = b.formatContent(linted.content, {
+    filePath: "generated.ts"
+  });
+  return formatted.content;
+}
+var biome = null;
+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) {
@@ -62,6 +89,8 @@ function isDirectFileContract(c) {
 }
 
 // src/core/plugin-manager.ts
+var validateStacksAddress = _validateStacksAddress;
+
 class PluginManager {
   plugins = [];
   logger;
@@ -123,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" }
@@ -137,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" }
@@ -169,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
@@ -314,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));
@@ -349,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) {
@@ -397,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} }`;
@@ -432,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 `/**
@@ -472,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();
@@ -523,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 {
@@ -536,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}]) {
@@ -552,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(", ");
@@ -579,211 +746,78 @@ 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");
+function generateMapsObject(maps, address, contractName) {
+  if (!maps || maps.length === 0) {
+    return "";
+  }
+  const mapMethods = maps.map((map) => {
+    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('@secondlayer/stacks/clarity');
+          const baseUrl = getApiUrl('${address}', options?.network);
+          const mapKey = ${keyConversion};
+          const keyHex = serializeCV(mapKey).toString('hex');
+
+          const response = await fetch(
+            \`\${baseUrl}/v2/map_entry/${address}/${contractName}/${map.name}\`,
+            {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify(keyHex)
             }
-            return Cl.contractPrincipal(address, contractName);
+          );
+
+          if (!response.ok) {
+            throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
           }
-          return Cl.standardPrincipal(${argName});
-        })()`;
-      default:
-        return `${argName}`;
-    }
-  }
-  if (type["string-ascii"]) {
-    return `Cl.stringAscii(${argName})`;
+
+          const result = await response.json();
+          if (!result.data || result.data === '0x09') {
+            return null; // none value
+          }
+
+          const { deserializeCV } = await import('@secondlayer/stacks/clarity');
+          const cv = deserializeCV(result.data);
+          const parsed = cvToJSON(cv);
+          // Unwrap the (some ...) wrapper
+          return parsed.value?.value ?? parsed.value ?? null;
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new Error(\`Map access failed for '${map.name}': \${error.message}\`);
+          }
+          throw error;
+        }
+      },
+      keyType: ${JSON.stringify(map.key)} as const,
+      valueType: ${JSON.stringify(map.value)} as const
+    }`;
+  });
+  return `maps: {
+    ${mapMethods.join(`,
+
+    `)}
+  }`;
+}
+function generateVarsObject(variables, address, contractName) {
+  if (!variables || variables.length === 0) {
+    return "";
   }
-  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 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 baseUrl = getApiUrl('${address}', options?.network);
-          const mapKey = ${keyConversion};
-          const keyHex = serializeCV(mapKey).toString('hex');
-
-          const response = await fetch(
-            \`\${baseUrl}/v2/map_entry/${address}/${contractName}/${map.name}\`,
-            {
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json' },
-              body: JSON.stringify(keyHex)
-            }
-          );
-
-          if (!response.ok) {
-            throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
-          }
-
-          const result = await response.json();
-          if (!result.data || result.data === '0x09') {
-            return null; // none value
-          }
-
-          const { deserializeCV } = await import('@stacks/transactions');
-          const cv = deserializeCV(result.data);
-          const parsed = cvToJSON(cv);
-          // Unwrap the (some ...) wrapper
-          return parsed.value?.value ?? parsed.value ?? null;
-        } catch (error) {
-          if (error instanceof Error) {
-            throw new Error(\`Map access failed for '${map.name}': \${error.message}\`);
-          }
-          throw error;
-        }
-      },
-      keyType: ${JSON.stringify(map.key)} as const,
-      valueType: ${JSON.stringify(map.value)} as const
-    }`;
-  });
-  return `maps: {
-    ${mapMethods.join(`,
-
-    `)}
-  }`;
-}
-function generateVarsObject(variables, address, contractName) {
-  if (!variables || variables.length === 0) {
-    return "";
-  }
-  const dataVars = variables.filter((v) => v.access === "variable");
-  if (dataVars.length === 0) {
-    return "";
+  const dataVars = variables.filter((v) => v.access === "variable");
+  if (dataVars.length === 0) {
+    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(
@@ -823,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(
@@ -862,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(", ");
@@ -871,12 +905,165 @@ function generateMapKeyConversion(keyType) {
   return generateClarityConversion("key", { type: keyType });
 }
 
+// src/utils/abi-compat.ts
+function normalizeAccess(access) {
+  if (access === "read_only")
+    return "read-only";
+  return access;
+}
+function normalizeType(type) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+      case "bool":
+      case "principal":
+      case "trait_reference":
+        return type;
+      default:
+        return type;
+    }
+  }
+  if (typeof type !== "object" || type === null) {
+    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 toCamelCase3(name);
+  return toCamelCase4(name);
 }
 async function isUserDefinedContract(contractId, manifestPath) {
-  const [address, contractName] = contractId.split(".");
+  const { address, contractName } = parseContractId(contractId);
   try {
     const { promises: fs2 } = await import("fs");
     const tomlContent = await fs2.readFile(manifestPath, "utf-8");
@@ -920,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}`);
@@ -937,7 +1124,7 @@ var clarinet = (options = {}) => {
           contracts.push({
             name: sanitizedName,
             address: contractId,
-            abi,
+            abi: normalizeAbi(abi),
             _clarinetSource: true
           });
         }
@@ -983,174 +1170,52 @@ 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})`;
+
+// src/plugins/actions/generators.ts
+function generateReadHelpers(contract, options) {
+  const { abi } = contract;
+  const functions = abi.functions || [];
+  const readOnlyFunctions = functions.filter((f) => f.access === "read-only");
+  if (readOnlyFunctions.length === 0) {
+    return "";
   }
-  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}`;
-}
-function generateReadHelpers(contract, options) {
-  const { abi, name } = contract;
-  const functions = abi.functions || [];
-  const readOnlyFunctions = functions.filter((f) => f.access === "read_only" || f.access === "read-only");
-  if (readOnlyFunctions.length === 0) {
-    return "";
-  }
-  const filteredFunctions = readOnlyFunctions.filter((func) => {
-    if (options.includeFunctions && !options.includeFunctions.includes(func.name)) {
-      return false;
-    }
-    if (options.excludeFunctions && options.excludeFunctions.includes(func.name)) {
-      return false;
-    }
-    return true;
-  });
-  if (filteredFunctions.length === 0) {
-    return "";
+  const filteredFunctions = readOnlyFunctions.filter((func) => {
+    if (options.includeFunctions && !options.includeFunctions.includes(func.name)) {
+      return false;
+    }
+    if (options.excludeFunctions && options.excludeFunctions.includes(func.name)) {
+      return false;
+    }
+    return true;
+  });
+  if (filteredFunctions.length === 0) {
+    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;
@@ -1172,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");
@@ -1192,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;
@@ -1288,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;
 }
@@ -1425,329 +1481,93 @@ 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}
+    // 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}\`)
+      }
+    }
 
-${header}
+    // 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)
+      }
 
-${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
-          }
-        }
+      // 2. Check for non-ASCII characters (UTF-8)
+      if (!/^[\\x00-\\x7F]*$/.test(value)) {
+        return Cl.bufferFromUtf8(value)
+      }
 
-        // 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
+      // 3. Default to ASCII for simple ASCII strings
+      return Cl.bufferFromAscii(value)
+    }
+
+    throw new Error(\`Invalid buffer value: \${value}\`)
+  }
+
+  // Helper function to convert a single JS value to ClarityValue
+  const convertJSValueToClarityValue = (value: any, type: any): any => {
+    if (typeof type === 'string') {
+      switch (type) {
+        case 'uint128':
+          return Cl.uint(value)
+        case 'int128':
+          return Cl.int(value)
+        case 'bool':
+          return Cl.bool(value)
+        case 'principal':
+          if (!validateStacksAddress(value.split('.')[0])) {
+            throw new Error('Invalid Stacks address format')
           }
-        }
+          if (value.includes('.')) {
+            const [address, contractName] = value.split('.')
+            return Cl.contractPrincipal(address, contractName)
+          } else {
+            return Cl.standardPrincipal(value)
+          }
+        default:
+          return value
+      }
+    }
 
-        // 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) {
-        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') {
-      // 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}\`)
-  }
-
-  // Helper function to convert a single JS value to ClarityValue
-  const convertJSValueToClarityValue = (value: any, type: any): any => {
-    if (typeof type === 'string') {
-      switch (type) {
-        case 'uint128':
-          return Cl.uint(value)
-        case 'int128':
-          return Cl.int(value)
-        case 'bool':
-          return Cl.bool(value)
-        case 'principal':
-          if (!validateStacksAddress(value.split('.')[0])) {
-            throw new Error('Invalid Stacks address format')
-          }
-          if (value.includes('.')) {
-            const [address, contractName] = value.split('.')
-            return Cl.contractPrincipal(address, contractName)
-          } else {
-            return Cl.standardPrincipal(value)
-          }
-        default:
-          return value
-      }
-    }
-
-    if (type['string-ascii']) {
-      return Cl.stringAscii(value)
-    }
+    if (type['string-ascii']) {
+      return Cl.stringAscii(value)
+    }
 
     if (type['string-utf8']) {
       return Cl.stringUtf8(value)
@@ -1774,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))
     }
@@ -1787,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;
@@ -1801,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')
@@ -1862,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;
@@ -1877,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;
@@ -1964,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
@@ -2065,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) => {
@@ -2110,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,
@@ -2130,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) => {
@@ -2165,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,
@@ -2186,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) => {
@@ -2229,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,
@@ -2256,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}`;
@@ -2296,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
@@ -2304,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
@@ -2326,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;
     }
@@ -2351,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;
     }
@@ -2359,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;
     }
@@ -2374,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);
@@ -2382,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'
     }),
@@ -2393,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()
@@ -2410,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
@@ -2460,7 +2370,7 @@ function generateWriteHook(func, contractName) {
     }
   })
 
-  const ${toCamelCase5(func.name)} = useCallback(async (
+  const ${toCamelCase7(func.name)} = useCallback(async (
     args: ${argsType},
     options?: {
       postConditions?: PostCondition[];
@@ -2473,7 +2383,7 @@ function generateWriteHook(func, contractName) {
   }, [mutation])
 
   return {
-    ${toCamelCase5(func.name)},
+    ${toCamelCase7(func.name)},
     // Expose mutation state
     isPending: mutation.isPending,
     isError: mutation.isError,
@@ -2485,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 }) {
@@ -2494,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()
@@ -2509,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()
@@ -2524,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
@@ -2572,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(
@@ -2732,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}) => {
@@ -2747,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(
@@ -2761,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}) => {
@@ -2826,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));
@@ -2855,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(`,
@@ -2983,5 +2755,5 @@ export {
   PluginManager
 };
 
-//# debugId=DBBDDA8E89A55EA464756E2164756E21
+//# debugId=217DF2A543BBE57564756E2164756E21
 //# sourceMappingURL=index.js.map