@secondlayer/cli 8.14.3 → 9.0.1

package/dist/plugins/index.js

@@ -576,22 +576,38 @@ function matchesContractFilters(name, options) {
 function sanitizeContractName(name) {
   return toCamelCase2(name);
 }
-async function isUserDefinedContract(contractId, manifestPath) {
-  const { address, contractName } = parseContractId(contractId);
+async function readManifestInfo(manifestPath) {
   try {
     const { promises: fs2 } = await import("node:fs");
     const tomlContent = await fs2.readFile(manifestPath, "utf-8");
+    const projectContracts = new Set;
     const contractSectionRegex = /^\[contracts\.([^\]]+)\]/gm;
-    const userContracts = new Set;
     let match = contractSectionRegex.exec(tomlContent);
     while (match !== null) {
-      userContracts.add(match[1]);
+      projectContracts.add(match[1]);
       match = contractSectionRegex.exec(tomlContent);
     }
-    if (userContracts.has(contractName)) {
-      return true;
+    const requirementIds = new Set;
+    const requirementRegex = /contract_id\s*=\s*["']([^"']+)["']/g;
+    match = requirementRegex.exec(tomlContent);
+    while (match !== null) {
+      requirementIds.add(match[1]);
+      match = requirementRegex.exec(tomlContent);
     }
-  } catch {}
+    return { projectContracts, requirementIds };
+  } catch {
+    return null;
+  }
+}
+function classifyContract(contractId, manifest) {
+  const { address, contractName } = parseContractId(contractId);
+  if (manifest) {
+    if (manifest.projectContracts.has(contractName))
+      return "project";
+    if (manifest.requirementIds.has(contractId))
+      return "requirement";
+    return "system";
+  }
   const systemContractPatterns = [
     /^pox-\d+$/,
     /^bns$/,
@@ -599,16 +615,16 @@ async function isUserDefinedContract(contractId, manifestPath) {
     /^lockup$/
   ];
   if (systemContractPatterns.some((pattern) => pattern.test(contractName))) {
-    return false;
+    return "system";
   }
   const systemAddresses = [
     DEFAULT_SENDER_ADDRESS,
     "ST000000000000000000002AMW42H"
   ];
   if (systemAddresses.includes(address)) {
-    return false;
+    return "system";
   }
-  return true;
+  return "project";
 }
 var clarinet = (options = {}) => {
   const manifestPath = options.path || "./Clarinet.toml";
@@ -621,11 +637,14 @@ var clarinet = (options = {}) => {
         simnet = await initSimnet(manifestPath);
         const contractInterfaces = simnet.getContractsInterfaces();
         const contracts = [];
+        const manifest = await readManifestInfo(manifestPath);
+        const includeRequirements = options.includeRequirements ?? true;
         for (const [contractId, abi] of contractInterfaces) {
           const { contractName } = parseContractId(contractId);
-          if (!await isUserDefinedContract(contractId, manifestPath)) {
+          const kind = classifyContract(contractId, manifest);
+          if (kind === "system" || kind === "requirement" && !includeRequirements) {
             if (options.debug) {
-              console.log(`\uD83D\uDEAB Skipping system contract: ${contractId}`);
+              console.log(`\uD83D\uDEAB Skipping ${kind} contract: ${contractId}`);
             }
             continue;
           }
@@ -683,208 +702,16 @@ async function hasClarinetProject(path2 = "./Clarinet.toml") {
     return false;
   }
 }
-// src/plugins/actions/generators.ts
-import { toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
-
-// src/utils/generator-helpers.ts
-import {
-  generateArgsSignature,
-  generateClarityArgs,
-  generateMapKeyConversion
-} from "@secondlayer/scaffold";
-
-// src/plugins/actions/generators.ts
-function applyFunctionFilters(functions, options) {
-  return functions.filter((func) => {
-    if (options.includeFunctions && !options.includeFunctions.includes(func.name)) {
-      return false;
-    }
-    if (options.excludeFunctions?.includes(func.name)) {
-      return false;
-    }
-    return true;
-  });
-}
-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 "";
-  }
-  const filteredFunctions = applyFunctionFilters(readOnlyFunctions, options);
-  if (filteredFunctions.length === 0) {
-    return "";
-  }
-  const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase3(func.name);
-    const argsSignature = generateArgsSignature(func.args);
-    const clarityArgs = generateClarityArgs(func.args);
-    return `async ${methodName}(${argsSignature}options?: {
-      network?: 'mainnet' | 'testnet' | 'devnet';
-      senderAddress?: string;
-    }) {
-      return await fetchCallReadOnlyFunction({
-        contractAddress: '${contract.address}',
-        contractName: '${contract.contractName}',
-        functionName: '${func.name}',
-        functionArgs: [${clarityArgs}],
-        network: options?.network ?? inferNetworkFromAddress('${contract.address}') ?? 'mainnet',
-        senderAddress: options?.senderAddress || '${DEFAULT_SENDER_ADDRESS}'
-      });
-    }`;
-  });
-  return `read: {
-    ${helpers.join(`,
-
-    `)}
-  }`;
-}
-function generateWriteHelpers(contract, options) {
-  const { abi } = contract;
-  const functions = abi.functions || [];
-  const envVarName = options.senderKeyEnv ?? "STX_SENDER_KEY";
-  const publicFunctions = functions.filter((f) => f.access === "public");
-  if (publicFunctions.length === 0) {
-    return "";
-  }
-  const filteredFunctions = applyFunctionFilters(publicFunctions, options);
-  if (filteredFunctions.length === 0) {
-    return "";
-  }
-  const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase3(func.name);
-    const argsSignature = generateArgsSignature(func.args);
-    const clarityArgs = generateClarityArgs(func.args);
-    return `async ${methodName}(${argsSignature}senderKey?: string, options?: {
-      network?: 'mainnet' | 'testnet' | 'devnet';
-      fee?: string | number | undefined;
-      nonce?: bigint;
-      anchorMode?: 1 | 2 | 3; // AnchorMode: OnChainOnly = 1, OffChainOnly = 2, Any = 3
-      postConditions?: PostCondition[];
-      validateWithAbi?: boolean;
-    }) {
-      const resolvedSenderKey = senderKey ?? process.env.${envVarName};
-      if (!resolvedSenderKey) {
-        throw new Error('senderKey required: pass as argument or set ${envVarName} env var');
-      }
-      const { network = 'mainnet', ...txOptions } = options ?? {};
-
-      return await makeContractCall({
-        contractAddress: '${contract.address}',
-        contractName: '${contract.contractName}',
-        functionName: '${func.name}',
-        functionArgs: [${clarityArgs}],
-        senderKey: resolvedSenderKey,
-        network,
-        validateWithAbi: true,
-        ...txOptions
-      });
-    }`;
-  });
-  return `write: {
-    ${helpers.join(`,
-
-    `)}
-  }`;
-}
-async function generateActionHelpers(contract, options) {
-  const readHelpers = generateReadHelpers(contract, options);
-  const writeHelpers = generateWriteHelpers(contract, options);
-  if (!readHelpers && !writeHelpers) {
-    return "";
-  }
-  const helpers = [readHelpers, writeHelpers].filter(Boolean);
-  return helpers.join(`,
-
-`);
-}
-
-// src/plugins/actions/index.ts
-var actions = (options = {}) => {
-  return {
-    name: "@secondlayer/cli/plugin-actions",
-    version: "1.0.0",
-    async generate(context) {
-      const { contracts } = context;
-      const filteredContracts = contracts.filter((contract) => matchesContractFilters(contract.name, options));
-      if (filteredContracts.length === 0) {
-        if (options.debug) {
-          context.logger.debug("Actions plugin: No contracts to process");
-        }
-        return;
-      }
-      if (options.debug) {
-        context.logger.debug(`Actions plugin: Generating read/write helpers for ${filteredContracts.length} contracts`);
-      }
-      const contractHelpers = new Map;
-      for (const contract of filteredContracts) {
-        const actionsCode = await generateActionHelpers(contract, options);
-        if (actionsCode) {
-          contractHelpers.set(contract.name, actionsCode);
-        }
-      }
-      if (contractHelpers.size > 0) {
-        const existingOutput = context.outputs.get("contracts");
-        if (existingOutput) {
-          let modifiedContent = addRequiredImports(existingOutput.content);
-          for (const [contractName, helpersCode] of contractHelpers) {
-            modifiedContent = injectHelpersIntoContract(modifiedContent, contractName, helpersCode);
-          }
-          context.outputs.set("contracts", {
-            ...existingOutput,
-            content: modifiedContent
-          });
-        }
-      }
-    }
-  };
-};
-function addRequiredImports(content) {
-  const stacksImportRegex = /import\s+\{([^}]+)\}\s+from\s+['"]@secondlayer\/stacks['"];/;
-  const match = content.match(stacksImportRegex);
-  if (match) {
-    let updatedContent = content;
-    if (!updatedContent.includes("fetchCallReadOnlyFunction")) {
-      updatedContent = updatedContent.replace(stacksImportRegex, `${match[0]}
-import { fetchCallReadOnlyFunction, makeContractCall } from '@secondlayer/stacks/clarity';`);
-    }
-    if (!updatedContent.includes("type PostCondition")) {
-      updatedContent = updatedContent.replace(stacksImportRegex, `${match[0]}
-import type { PostCondition } from '@secondlayer/stacks';`);
-    }
-    return updatedContent;
-  }
-  return content;
-}
-function injectHelpersIntoContract(content, contractName, helpersCode) {
-  const contractPattern = new RegExp(`(export const ${contractName} = \\{[\\s\\S]*?)\\n\\} as const;`, "g");
-  return content.replace(contractPattern, (_, contractBody) => {
-    const cleanBody = contractBody.replace(/,\s*$/, "");
-    const indentedHelpersCode = helpersCode.split(`
-`).map((line) => {
-      if (line.match(/^[a-zA-Z_$][a-zA-Z0-9_$]*\s*:/)) {
-        return `  ${line}`;
-      }
-      return line;
-    }).join(`
-`);
-    return `${cleanBody},
-
-${indentedHelpersCode}
-} as const;`;
-  });
-}
 // src/plugins/react/generators/contract.ts
 init_format();
 
 // src/utils/case-conversion.ts
-import { toCamelCase as toCamelCase4 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function toPascalCase(str) {
-  return capitalize(toCamelCase4(str));
+  return capitalize(toCamelCase3(str));
 }
 
 // src/utils/type-mapping.ts
@@ -898,23 +725,23 @@ import {
 function generateHookArgsSignature(args) {
   if (args.length === 0)
     return "";
-  const argsList = args.map((arg) => `${toCamelCase4(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
+  const argsList = args.map((arg) => `${toCamelCase3(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
   return `${argsList}`;
 }
 function generateArgsType(args) {
   if (args.length === 0)
     return "void";
-  const argsList = args.map((arg) => `${toCamelCase4(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
+  const argsList = args.map((arg) => `${toCamelCase3(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
   return `{ ${argsList} }`;
 }
 function generateArgNames(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => toCamelCase4(arg.name)).join(", ");
+  return args.map((arg) => toCamelCase3(arg.name)).join(", ");
 }
 function generateEnabledCondition(args) {
   return args.map((arg) => {
-    const camelName = toCamelCase4(arg.name);
+    const camelName = toCamelCase3(arg.name);
     const type = clarityTypeToTS(arg.type);
     if (type === "string")
       return `!!${camelName}`;
@@ -926,7 +753,7 @@ function generateEnabledCondition(args) {
 function generateObjectArgs(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => `${arg.name}: ${toCamelCase4(arg.name)}`).join(", ");
+  return args.map((arg) => `${arg.name}: ${toCamelCase3(arg.name)}`).join(", ");
 }
 
 // src/plugins/react/generators/contract.ts
@@ -935,8 +762,47 @@ async function generateContractHooks(contracts, excludeList = []) {
 import { useCallback } from 'react'
 import { useSecondLayerConfig } from './provider'
 import { request } from '@secondlayer/stacks/connect'
-import type { PostCondition } from '@secondlayer/stacks'
-import { ${contracts.map((c) => c.name).join(", ")} } from './contracts'`;
+import type { PostCondition } from '@secondlayer/stacks/postconditions'
+import { ${contracts.map((c) => c.name).join(", ")} } from './contracts'
+
+const API_URLS: Record<string, string> = {
+  mainnet: 'https://api.hiro.so',
+  testnet: 'https://api.testnet.hiro.so',
+  devnet: 'http://localhost:3999'
+}
+
+async function readContractCall(params: {
+  contractAddress: string;
+  contractName: string;
+  functionName: string;
+  functionArgs: any[];
+  outputType: any;
+  senderAddress: string;
+  network?: string;
+  apiUrl?: string;
+}): Promise<any> {
+  const { serializeCV, deserializeCV, clarityValueToJS } = await import('@secondlayer/stacks/clarity')
+  // Untyped call: outputType is a runtime ABI value; relating the generic
+  // signature (even via a direct cast) explodes into deep instantiation on
+  // the AbiType union, so route the cast through unknown.
+  const toJS = clarityValueToJS as unknown as (type: any, cv: any) => any
+  const baseUrl = params.apiUrl || API_URLS[params.network || 'mainnet']
+  const response = await fetch(
+    \`\${baseUrl}/v2/contracts/call-read/\${params.contractAddress}/\${params.contractName}/\${params.functionName}\`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sender: params.senderAddress,
+        arguments: params.functionArgs.map((arg: any) => \`0x\${serializeCV(arg)}\`)
+      })
+    }
+  )
+  if (!response.ok) throw new Error(\`Read-only call failed: \${response.statusText}\`)
+  const data = await response.json()
+  if (!data.okay) throw new Error(data.cause ?? 'Read-only call failed')
+  return toJS(params.outputType, deserializeCV(data.result))
+}`;
   const header = `/**
  * Generated contract-specific React hooks
  * DO NOT EDIT MANUALLY
@@ -959,21 +825,21 @@ function generateContractHookMethods(contract, excludeList) {
   const readOnlyFunctions = functions.filter((f) => f.access === "read-only");
   const publicFunctions = functions.filter((f) => f.access === "public");
   const readHooks = readOnlyFunctions.map((func) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(func.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
     return generateReadHook(func, name);
   }).filter(Boolean);
   const writeHooks = publicFunctions.map((func) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(func.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
     return generateWriteHook(func, name);
   }).filter(Boolean);
   const mapHooks = maps.map((map) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(map.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(map.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -981,7 +847,7 @@ function generateContractHookMethods(contract, excludeList) {
   }).filter(Boolean);
   const dataVars = variables.filter((v) => v.access === "variable");
   const varHooks = dataVars.map((variable) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(variable.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(variable.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -989,7 +855,7 @@ function generateContractHookMethods(contract, excludeList) {
   }).filter(Boolean);
   const constants = variables.filter((v) => v.access === "constant");
   const constantHooks = constants.map((constant) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(constant.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(constant.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -1010,26 +876,33 @@ function generateContractHookMethods(contract, excludeList) {
 `);
 }
 function generateReadHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase4(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase3(func.name))}`;
   const argsSignature = generateHookArgsSignature(func.args);
   const enabledParam = func.args.length > 0 ? ", options?: { enabled?: boolean }" : "options?: { enabled?: boolean }";
   const returnType = clarityTypeToTS(func.outputs);
+  const callArgs = func.args.length > 0 ? `{ ${generateObjectArgs(func.args)} }` : "";
   return `export function ${hookName}(${argsSignature}${enabledParam}) {
   const config = useSecondLayerConfig()
 
   return useQuery<${returnType}>({
     queryKey: ['${func.name}', ${contractName}.address, ${generateArgNames(func.args)}],
-    queryFn: () => ${contractName}.read.${toCamelCase4(func.name)}(${generateArgNames(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
-      network: config.network,
-      senderAddress: config.senderAddress || '${DEFAULT_SENDER_ADDRESS}'
-    }),
+    queryFn: async () => {
+      const call = ${contractName}.${toCamelCase3(func.name)}(${callArgs})
+      return await readContractCall({
+        ...call,
+        outputType: ${JSON.stringify(func.outputs)},
+        network: config.network,
+        apiUrl: config.apiUrl,
+        senderAddress: config.senderAddress || '${DEFAULT_SENDER_ADDRESS}'
+      }) as ${returnType}
+    },
     ${func.args.length > 0 ? `enabled: ${generateEnabledCondition(func.args)} && (options?.enabled ?? true),` : ""}
     ...options
   })
 }`;
 }
 function generateWriteHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase4(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase3(func.name))}`;
   const argsType = generateArgsType(func.args);
   return `export function ${hookName}() {
   const config = useSecondLayerConfig()
@@ -1046,7 +919,7 @@ function generateWriteHook(func, contractName) {
       };
     }) => {
       const { args, options = {} } = params
-      const contractCallData = ${contractName}.${toCamelCase4(func.name)}(args)
+      const contractCallData = ${contractName}.${toCamelCase3(func.name)}(args)
       const { contractAddress, contractName: name, functionName, functionArgs } = contractCallData
       const network = config.network || 'mainnet'
       const contract = \`\${contractAddress}.\${name}\`
@@ -1071,7 +944,7 @@ function generateWriteHook(func, contractName) {
     }
   })
 
-  const ${toCamelCase4(func.name)} = useCallback(async (
+  const ${toCamelCase3(func.name)} = useCallback(async (
     args: ${argsType},
     options?: {
       postConditions?: PostCondition[];
@@ -1084,7 +957,7 @@ function generateWriteHook(func, contractName) {
   }, [mutation])
 
   return {
-    ${toCamelCase4(func.name)},
+    ${toCamelCase3(func.name)},
     // Expose mutation state
     isPending: mutation.isPending,
     isError: mutation.isError,
@@ -1096,7 +969,7 @@ function generateWriteHook(func, contractName) {
 }`;
 }
 function generateMapHook(map, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(map.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase3(map.name))}`;
   const keyType = clarityTypeToTS(map.key);
   const valueType = clarityTypeToTS(map.value);
   return `export function ${hookName}(key: ${keyType}, options?: { enabled?: boolean }) {
@@ -1105,14 +978,14 @@ function generateMapHook(map, contractVarName, _address, _contractName) {
   return useQuery<${valueType} | null>({
     queryKey: ['${contractVarName}', '${map.name}', 'map', key, config.network],
     queryFn: async () => {
-      return ${contractVarName}.maps.${toCamelCase4(map.name)}.get(key, { network: config.network })
+      return ${contractVarName}.maps.${toCamelCase3(map.name)}.get(key, { network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateVarHook(variable, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(variable.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase3(variable.name))}`;
   const valueType = clarityTypeToTS(variable.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useSecondLayerConfig()
@@ -1120,14 +993,14 @@ function generateVarHook(variable, contractVarName, _address, _contractName) {
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${variable.name}', 'var', config.network],
     queryFn: async () => {
-      return ${contractVarName}.vars.${toCamelCase4(variable.name)}.get({ network: config.network })
+      return ${contractVarName}.vars.${toCamelCase3(variable.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateConstantHook(constant, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(constant.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase3(constant.name))}`;
   const valueType = clarityTypeToTS(constant.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useSecondLayerConfig()
@@ -1135,7 +1008,7 @@ function generateConstantHook(constant, contractVarName, _address, _contractName
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${constant.name}', 'constant', config.network],
     queryFn: async () => {
-      return ${contractVarName}.constants.${toCamelCase4(constant.name)}.get({ network: config.network })
+      return ${contractVarName}.constants.${toCamelCase3(constant.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true,
     staleTime: Infinity // Constants never change
@@ -1386,9 +1259,10 @@ async function generateGenericHooks(excludeList = []) {
 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 { Cl } from '@secondlayer/stacks/clarity'
 import type { ExtractFunctionArgs, ExtractFunctionNames, AbiContract } from '@secondlayer/stacks/clarity'
+import type { PostCondition } from '@secondlayer/stacks/postconditions'
+import { validateStacksAddress } from '@secondlayer/stacks/utils'
 
 const API_URLS: Record<string, string> = {
   mainnet: 'https://api.hiro.so',
@@ -1396,6 +1270,34 @@ const API_URLS: Record<string, string> = {
   devnet: 'http://localhost:3999'
 }
 
+async function callReadOnly(params: {
+  contractAddress: string;
+  contractName: string;
+  functionName: string;
+  functionArgs: any[];
+  senderAddress: string;
+  network?: string;
+  apiUrl?: string;
+}): Promise<any> {
+  const { serializeCV, deserializeCV } = await import('@secondlayer/stacks/clarity')
+  const baseUrl = params.apiUrl || API_URLS[params.network || 'mainnet']
+  const response = await fetch(
+    \`\${baseUrl}/v2/contracts/call-read/\${params.contractAddress}/\${params.contractName}/\${params.functionName}\`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sender: params.senderAddress,
+        arguments: params.functionArgs.map((arg: any) => \`0x\${serializeCV(arg)}\`)
+      })
+    }
+  )
+  if (!response.ok) throw new Error(\`Read-only call failed: \${response.statusText}\`)
+  const data = await response.json()
+  if (!data.okay) throw new Error(data.cause ?? 'Read-only call failed')
+  return deserializeCV(data.result)
+}
+
 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}\`)
@@ -1504,9 +1406,9 @@ function generateGenericHook(hookName) {
   const queryClient = useQueryClient()
   
   const mutation = useMutation({
-    mutationFn: async (options: { forceWalletSelect?: boolean } = {}) => {
+    mutationFn: async () => {
       // SIP-030 connect
-      return await connect(options)
+      return await connect()
     },
     onSuccess: () => {
       // Invalidate account queries to refetch connection state
@@ -1519,11 +1421,11 @@ function generateGenericHook(hookName) {
 
   return {
     // Custom connect function that works without arguments
-    connect: (options?: { forceWalletSelect?: boolean }) => {
-      return mutation.mutate(options || {})
+    connect: () => {
+      return mutation.mutate(undefined)
     },
-    connectAsync: async (options?: { forceWalletSelect?: boolean }) => {
-      return mutation.mutateAsync(options || {})
+    connectAsync: async () => {
+      return mutation.mutateAsync(undefined)
     },
     // Expose all the mutation state
     isPending: mutation.isPending,
@@ -1618,31 +1520,27 @@ 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('@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
+      // Args must already be ClarityValues (build them with Cl.* or a generated
+      // contract method's descriptor). Positional array, ABI declaration order.
       let functionArgs: any[] = []
-      
+
       if (params.args) {
-        // This is a simplified conversion - in practice, we'd need the ABI to do proper conversion
-        // For now, we'll assume the args are already in the correct format or simple types
         if (Array.isArray(params.args)) {
           functionArgs = params.args
         } else if (typeof params.args === 'object') {
-          // Convert object args to array (this is a basic implementation)
           functionArgs = Object.values(params.args)
         } else {
           functionArgs = [params.args]
         }
       }
-      
-      return await fetchCallReadOnlyFunction({
+
+      return await callReadOnly({
         contractAddress: params.contractAddress,
         contractName: params.contractName,
         functionName: params.functionName,
         functionArgs,
         network: params.network || config.network || 'mainnet',
+        apiUrl: config.apiUrl,
         senderAddress: config.senderAddress || '${DEFAULT_SENDER_ADDRESS}'
       }) as TResult
     },
@@ -1703,11 +1601,13 @@ function generateGenericHook(hookName) {
       apiUrl: config.apiUrl
     }),
     enabled: !!txId,
-    refetchInterval: (data) => {
+    refetchInterval: (queryOrData: any) => {
+      // react-query v5 passes the query object, v4 passed the data — support both
+      const tx = queryOrData?.state?.data ?? queryOrData
       // Stop polling when transaction is complete
-      if (data?.tx_status === 'success' || 
-          data?.tx_status === 'abort_by_response' || 
-          data?.tx_status === 'abort_by_post_condition') {
+      if (tx?.tx_status === 'success' ||
+          tx?.tx_status === 'abort_by_response' ||
+          tx?.tx_status === 'abort_by_post_condition') {
         return false
       }
       return 2000 // Poll every 2 seconds
@@ -1988,8 +1888,17 @@ var react = (options = {}) => {
 import {
   isAbiTuple
 } from "@secondlayer/stacks/clarity";
+
+// src/utils/generator-helpers.ts
+import {
+  generateArgsSignature,
+  generateClarityArgs,
+  generateMapKeyConversion
+} from "@secondlayer/scaffold";
+
+// src/plugins/testing/generators.ts
 function generatePublicFunction(func, contractId) {
-  const methodName = toCamelCase4(func.name);
+  const methodName = toCamelCase3(func.name);
   const argsSignature = generateArgsSignature(func.args);
   const clarityArgs = generateClarityArgs(func.args);
   return `${methodName}: (${argsSignature}caller: string) => {
@@ -2003,7 +1912,7 @@ function generatePublicFunction(func, contractId) {
     }`;
 }
 function generateReadOnlyFunction(func, contractId) {
-  const methodName = toCamelCase4(func.name);
+  const methodName = toCamelCase3(func.name);
   const argsSignature = generateArgsSignature(func.args);
   const clarityArgs = generateClarityArgs(func.args);
   const hasArgs = func.args.length > 0;
@@ -2018,7 +1927,7 @@ function generateReadOnlyFunction(func, contractId) {
     }`;
 }
 function generatePrivateFunction(func, contractId) {
-  const methodName = toCamelCase4(func.name);
+  const methodName = toCamelCase3(func.name);
   const argsSignature = generateArgsSignature(func.args);
   const clarityArgs = generateClarityArgs(func.args);
   return `${methodName}: (${argsSignature}caller: string) => {
@@ -2032,20 +1941,20 @@ function generatePrivateFunction(func, contractId) {
     }`;
 }
 function generateDataVarHelper(variable, contractId) {
-  const methodName = toCamelCase4(variable.name);
+  const methodName = toCamelCase3(variable.name);
   return `${methodName}: () => {
       return simnet.getDataVar('${contractId}', '${variable.name}');
     }`;
 }
 function getMapKeyType(keyType) {
   if (isAbiTuple(keyType)) {
-    const fields = keyType.tuple.map((field) => `${toCamelCase4(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
+    const fields = keyType.tuple.map((field) => `${toCamelCase3(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
     return `{ ${fields} }`;
   }
   return getTypeForArg({ type: keyType });
 }
 function generateMapEntryHelper(map, contractId) {
-  const methodName = toCamelCase4(map.name);
+  const methodName = toCamelCase3(map.name);
   const keyType = getMapKeyType(map.key);
   const keyConversion = generateMapKeyConversion(map.key);
   return `${methodName}: (key: ${keyType}) => {
@@ -2115,7 +2024,7 @@ function generateContractHelper(contract, options) {
 }
 function generateGetContracts(contracts) {
   const contractEntries = contracts.map((contract) => {
-    const camelName = toCamelCase4(contract.name);
+    const camelName = toCamelCase3(contract.name);
     const pascalName = toPascalCase(contract.name);
     return `${camelName}: get${pascalName}(simnet)`;
   }).join(`,
@@ -2231,9 +2140,8 @@ export {
   filterByOptions,
   createPlugin,
   clarinet,
-  actions,
   PluginManager
 };
 
-//# debugId=B22EAFB44071D00264756E2164756E21
+//# debugId=15CE4A0BEE59E1A664756E2164756E21
 //# sourceMappingURL=index.js.map