@secondlayer/cli 0.1.1 → 0.2.1

package/dist/index.js

@@ -1,47 +1,56 @@
-// src/utils/config.ts
-import { transformSync } from "esbuild";
+// @bun
+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 __require = import.meta.require;
 
 // src/core/plugin-manager.ts
 import { format } from "prettier";
 import { promises as fs } from "fs";
 import path from "path";
 import { validateStacksAddress } from "@stacks/transactions";
-var PluginManager = class {
+
+class PluginManager {
+  plugins = [];
+  logger;
+  utils;
+  executionContext;
   constructor() {
-    this.plugins = [];
     this.logger = this.createLogger();
     this.utils = this.createUtils();
     this.executionContext = {
       phase: "config",
       startTime: Date.now(),
-      results: /* @__PURE__ */ new Map()
+      results: new Map
     };
   }
-  /**
-   * Register a plugin
-   */
   register(plugin) {
     if (!plugin.name || !plugin.version) {
       throw new Error("Plugin must have a name and version");
     }
     const existing = this.plugins.find((p) => p.name === plugin.name);
     if (existing) {
-      throw new Error(
-        `Plugin "${plugin.name}" is already registered (version ${existing.version})`
-      );
+      throw new Error(`Plugin "${plugin.name}" is already registered (version ${existing.version})`);
     }
     this.plugins.push(plugin);
     this.logger.debug(`Registered plugin: ${plugin.name}@${plugin.version}`);
   }
-  /**
-   * Get all registered plugins
-   */
   getPlugins() {
     return [...this.plugins];
   }
-  /**
-   * Transform user config through all plugins
-   */
   async transformConfig(config) {
     this.executionContext.phase = "config";
     let transformedConfig = { ...config };
@@ -60,9 +69,7 @@ var PluginManager = class {
             success: false,
             error: err
           });
-          throw new Error(
-            `Plugin "${plugin.name}" failed during config transformation: ${err.message}`
-          );
+          throw new Error(`Plugin "${plugin.name}" failed during config transformation: ${err.message}`);
         }
       }
     }
@@ -72,9 +79,6 @@ var PluginManager = class {
     };
     return resolvedConfig;
   }
-  /**
-   * Transform contracts through all plugins
-   */
   async transformContracts(contracts, _config) {
     const processedContracts = [];
     for (let contract of contracts) {
@@ -92,6 +96,20 @@ var PluginManager = class {
         processedContracts.push(processed);
         continue;
       }
+      if (contract._directFile && contract.abi) {
+        const address = typeof contract.address === "string" ? contract.address : "";
+        const [contractAddress, contractName] = address.split(".");
+        const processed = {
+          name: contract.name || contractName,
+          address: contractAddress,
+          contractName,
+          abi: contract.abi,
+          source: "local",
+          metadata: { source: "direct" }
+        };
+        processedContracts.push(processed);
+        continue;
+      }
       for (const plugin of this.plugins) {
         if (plugin.transformContract) {
           this.executionContext.currentPlugin = plugin;
@@ -106,9 +124,7 @@ var PluginManager = class {
               success: false,
               error: err
             });
-            this.logger.warn(
-              `Plugin "${plugin.name}" failed to transform contract: ${err.message}`
-            );
+            this.logger.warn(`Plugin "${plugin.name}" failed to transform contract: ${err.message}`);
           }
         }
       }
@@ -119,7 +135,6 @@ var PluginManager = class {
           contractName: contract.name || "unknown",
           abi: contract.abi,
           source: "api",
-          // Use "api" as default for plugin-processed contracts
           metadata: contract.metadata
         };
         processedContracts.push(processed);
@@ -127,9 +142,6 @@ var PluginManager = class {
     }
     return processedContracts;
   }
-  /**
-   * Execute lifecycle hooks
-   */
   async executeHook(hookName, context) {
     for (const plugin of this.plugins) {
       const hook = plugin[hookName];
@@ -146,19 +158,14 @@ var PluginManager = class {
             success: false,
             error: err
           });
-          this.logger.error(
-            `Plugin "${plugin.name}" failed during ${hookName}: ${err.message}`
-          );
+          this.logger.error(`Plugin "${plugin.name}" failed during ${hookName}: ${err.message}`);
         }
       }
     }
   }
-  /**
-   * Execute generation phase with full context
-   */
   async executeGeneration(contracts, config) {
     this.executionContext.phase = "generate";
-    const outputs = /* @__PURE__ */ new Map();
+    const outputs = new Map;
     const context = {
       config,
       logger: this.logger,
@@ -177,22 +184,16 @@ var PluginManager = class {
     await this.executeHook("afterGenerate", context);
     return outputs;
   }
-  /**
-   * Transform outputs through plugins
-   */
   async transformOutputs(outputs) {
     this.executionContext.phase = "output";
-    const transformedOutputs = /* @__PURE__ */ new Map();
+    const transformedOutputs = new Map;
     for (const [key, output] of outputs) {
       let transformedContent = output.content;
       for (const plugin of this.plugins) {
         if (plugin.transformOutput) {
           this.executionContext.currentPlugin = plugin;
           try {
-            transformedContent = await plugin.transformOutput(
-              transformedContent,
-              output.type || "other"
-            );
+            transformedContent = await plugin.transformOutput(transformedContent, output.type || "other");
             this.recordHookResult(plugin.name, "transformOutput", {
               success: true
             });
@@ -202,9 +203,7 @@ var PluginManager = class {
               success: false,
               error: err
             });
-            this.logger.warn(
-              `Plugin "${plugin.name}" failed to transform output: ${err.message}`
-            );
+            this.logger.warn(`Plugin "${plugin.name}" failed to transform output: ${err.message}`);
           }
         }
       }
@@ -215,9 +214,6 @@ var PluginManager = class {
     }
     return transformedOutputs;
   }
-  /**
-   * Write outputs to disk
-   */
   async writeOutputs(outputs) {
     for (const [, output] of outputs) {
       try {
@@ -231,15 +227,9 @@ var PluginManager = class {
       }
     }
   }
-  /**
-   * Get execution results for debugging
-   */
   getExecutionResults() {
     return new Map(this.executionContext.results);
   }
-  /**
-   * Augment existing output with additional content
-   */
   augmentOutput(outputs, outputKey, contractName, content) {
     const existing = outputs.get(outputKey);
     if (!existing) {
@@ -255,18 +245,12 @@ ${JSON.stringify(content, null, 2)}`;
       content: augmentedContent
     });
   }
-  /**
-   * Record hook execution result
-   */
   recordHookResult(pluginName, hookName, result) {
     const key = `${pluginName}:${hookName}`;
     const existing = this.executionContext.results.get(key) || [];
     existing.push({ ...result, plugin: pluginName });
     this.executionContext.results.set(key, existing);
   }
-  /**
-   * Create logger instance
-   */
   createLogger() {
     return {
       info: (message) => console.log(`\u2139\uFE0F  ${message}`),
@@ -274,15 +258,12 @@ ${JSON.stringify(content, null, 2)}`;
       error: (message) => console.error(`\u274C ${message}`),
       debug: (message) => {
         if (process.env.DEBUG) {
-          console.log(`\u{1F41B} ${message}`);
+          console.log(`\uD83D\uDC1B ${message}`);
         }
       },
       success: (message) => console.log(`\u2705 ${message}`)
     };
   }
-  /**
-   * Create utils instance
-   */
   createUtils() {
     return {
       toCamelCase: (str) => {
@@ -329,14 +310,2346 @@ ${JSON.stringify(content, null, 2)}`;
       }
     };
   }
+}
+// src/plugins/clarinet/index.ts
+import { initSimnet } from "@hirosystems/clarinet-sdk";
+
+// src/generators/contract.ts
+import { format as format2 } from "prettier";
+async function generateContractInterface(contracts) {
+  const imports = `import { Cl, validateStacksAddress } from '@stacks/transactions'`;
+  const header = `/**
+ * Generated by @secondlayer/cli
+ * DO NOT EDIT MANUALLY
+ */`;
+  const contractsCode = contracts.map((contract) => generateContract(contract)).join(`
+
+`);
+  const code = `${imports}
+
+${header}
+
+${contractsCode}`;
+  const formatted = await format2(code, {
+    parser: "typescript",
+    singleQuote: true,
+    semi: true,
+    printWidth: 100,
+    trailingComma: "es5"
+  });
+  return formatted;
+}
+function generateContract(contract) {
+  const { name, address, contractName, abi } = contract;
+  const abiCode = generateAbiConstant(name, abi);
+  const methods = abi.functions.filter((func) => func.access !== "private").map((func) => generateMethod(func, address, contractName)).join(`,
+
+  `);
+  const contractCode = `export const ${name} = {
+  address: '${address}',
+  contractAddress: '${address}',
+  contractName: '${contractName}',
+  
+  ${methods}
+} as const`;
+  return `${abiCode}
+
+${contractCode}`;
+}
+function generateAbiConstant(name, abi) {
+  const abiJson = JSON.stringify(abi, null, 2).replace(/"([a-zA-Z_$][a-zA-Z0-9_$]*)":/g, "$1:").replace(/"/g, "'");
+  return `export const ${name}Abi = ${abiJson} as const`;
+}
+function generateMethod(func, address, contractName) {
+  const methodName = toCamelCase(func.name);
+  if (func.args.length === 0) {
+    return `${methodName}() {
+    return {
+      contractAddress: '${address}',
+      contractName: '${contractName}',
+      functionName: '${func.name}',
+      functionArgs: []
+    }
+  }`;
+  }
+  if (func.args.length === 1) {
+    const originalArgName = func.args[0].name;
+    const argName = toCamelCase(originalArgName);
+    const argType = getTypeForArg(func.args[0]);
+    const clarityConversion = generateClarityConversion(argName, func.args[0]);
+    return `${methodName}(...args: [{ ${argName}: ${argType} }] | [${argType}]) {
+    const ${argName} = args.length === 1 && typeof args[0] === 'object' && args[0] !== null && '${argName}' in args[0]
+      ? args[0].${argName}
+      : args[0] as ${argType}
+    
+    return {
+      contractAddress: '${address}',
+      contractName: '${contractName}',
+      functionName: '${func.name}',
+      functionArgs: [${clarityConversion}]
+    }
+  }`;
+  }
+  const argsList = func.args.map((arg) => toCamelCase(arg.name)).join(", ");
+  const argsTypes = func.args.map((arg) => {
+    const camelName = toCamelCase(arg.name);
+    return `${camelName}: ${getTypeForArg(arg)}`;
+  }).join("; ");
+  const argsArray = func.args.map((arg) => {
+    const argName = toCamelCase(arg.name);
+    return generateClarityConversion(argName, arg);
+  }).join(", ");
+  const objectAccess = func.args.map((arg) => {
+    const camelName = toCamelCase(arg.name);
+    return `args[0].${camelName}`;
+  }).join(", ");
+  const positionTypes = func.args.map((arg) => getTypeForArg(arg)).join(", ");
+  return `${methodName}(...args: [{ ${argsTypes} }] | [${positionTypes}]) {
+    const [${argsList}] = args.length === 1 && typeof args[0] === 'object' && args[0] !== null
+      ? [${objectAccess}]
+      : args as [${positionTypes}]
+    
+    return {
+      contractAddress: '${address}',
+      contractName: '${contractName}',
+      functionName: '${func.name}',
+      functionArgs: [${argsArray}]
+    }
+  }`;
+}
+function getTypeForArg(arg) {
+  const type = arg.type;
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+        return "bigint";
+      case "bool":
+        return "boolean";
+      case "principal":
+      case "trait_reference":
+        return "string";
+      default:
+        return "any";
+    }
+  }
+  if (type["string-ascii"] || type["string-utf8"]) {
+    return "string";
+  }
+  if (type.buff) {
+    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
+  }
+  if (type.optional) {
+    const innerType = getTypeForArg({ type: type.optional });
+    return `${innerType} | null`;
+  }
+  if (type.list) {
+    const innerType = getTypeForArg({ type: type.list.type });
+    return `${innerType}[]`;
+  }
+  if (type.tuple) {
+    const fields = type.tuple.map((field) => `${toCamelCase(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
+    return `{ ${fields} }`;
+  }
+  if (type.response) {
+    const okType = getTypeForArg({ type: type.response.ok });
+    const errType = getTypeForArg({ type: type.response.error });
+    return `{ ok: ${okType} } | { err: ${errType} }`;
+  }
+  return "any";
+}
+function toCamelCase(str) {
+  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "");
+}
+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];
+          if (!validateStacksAddress(address)) {
+            throw new Error("Invalid Stacks address format");
+          }
+          if (${argName}.includes(".")) {
+            return Cl.contractPrincipal(address, contractName);
+          } else {
+            return Cl.standardPrincipal(${argName});
+          }
+        })()`;
+      default:
+        return `${argName}`;
+    }
+  }
+  if (type["string-ascii"]) {
+    return `Cl.stringAscii(${argName})`;
+  }
+  if (type["string-utf8"]) {
+    return `Cl.stringUtf8(${argName})`;
+  }
+  if (type.buff) {
+    return `(() => {
+      const value = ${argName};
+      // Direct Uint8Array
+      if (value instanceof Uint8Array) {
+        return Cl.buffer(value);
+      }
+      // Object notation with explicit type
+      if (typeof value === 'object' && value !== null && value.type && value.value) {
+        switch (value.type) {
+          case 'ascii':
+            return Cl.bufferFromAscii(value.value);
+          case 'utf8':
+            return Cl.bufferFromUtf8(value.value);
+          case 'hex':
+            return Cl.bufferFromHex(value.value);
+          default:
+            throw new Error(\`Unsupported buffer type: \${value.type}\`);
+        }
+      }
+      // Auto-detect string type
+      if (typeof value === 'string') {
+        // Check for hex (0x prefix or pure hex pattern)
+        if (value.startsWith('0x') || /^[0-9a-fA-F]+$/.test(value)) {
+          return Cl.bufferFromHex(value);
+        }
+        // Check for non-ASCII characters (UTF-8)
+        if (!/^[\\x00-\\x7F]*$/.test(value)) {
+          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
+    });
+    return `Cl.list(${argName}.map(item => ${innerConversion}))`;
+  }
+  if (type.tuple) {
+    const fields = type.tuple.map((field) => {
+      const camelFieldName = toCamelCase(field.name);
+      const fieldConversion = generateClarityConversion(`${argName}.${camelFieldName}`, { type: field.type });
+      return `"${field.name}": ${fieldConversion}`;
+    }).join(", ");
+    return `Cl.tuple({ ${fields} })`;
+  }
+  if (type.response) {
+    const okConversion = generateClarityConversion(`${argName}.ok`, {
+      type: type.response.ok
+    });
+    const errConversion = generateClarityConversion(`${argName}.err`, {
+      type: type.response.error
+    });
+    return `'ok' in ${argName} ? Cl.ok(${okConversion.replace(`${argName}.ok`, `${argName}.ok`)}) : Cl.error(${errConversion.replace(`${argName}.err`, `${argName}.err`)})`;
+  }
+  return `${argName}`;
+}
+
+// src/plugins/clarinet/index.ts
+function toCamelCase2(str) {
+  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
+}
+function sanitizeContractName(name) {
+  return toCamelCase2(name);
+}
+async function isUserDefinedContract(contractId, manifestPath) {
+  const [address, contractName] = contractId.split(".");
+  try {
+    const { promises: fs2 } = await import("fs");
+    const tomlContent = await fs2.readFile(manifestPath, "utf-8");
+    const contractSectionRegex = /^\[contracts\.([^\]]+)\]/gm;
+    const userContracts = new Set;
+    let match;
+    while ((match = contractSectionRegex.exec(tomlContent)) !== null) {
+      userContracts.add(match[1]);
+    }
+    if (userContracts.has(contractName)) {
+      return true;
+    }
+  } catch (error) {}
+  const systemContractPatterns = [
+    /^pox-\d+$/,
+    /^bns$/,
+    /^costs-\d+$/,
+    /^lockup$/
+  ];
+  if (systemContractPatterns.some((pattern) => pattern.test(contractName))) {
+    return false;
+  }
+  const systemAddresses = [
+    "SP000000000000000000002Q6VF78",
+    "ST000000000000000000002AMW42H"
+  ];
+  if (systemAddresses.includes(address)) {
+    return false;
+  }
+  return true;
+}
+var clarinet = (options = {}) => {
+  const manifestPath = options.path || "./Clarinet.toml";
+  let simnet;
+  return {
+    name: "@secondlayer/cli/plugin-clarinet",
+    version: "1.0.0",
+    async transformConfig(config) {
+      try {
+        simnet = await initSimnet(manifestPath);
+        const contractInterfaces = simnet.getContractsInterfaces();
+        const contracts = [];
+        for (const [contractId, abi] of contractInterfaces) {
+          const [_, contractName] = contractId.split(".");
+          if (!await isUserDefinedContract(contractId, manifestPath)) {
+            if (options.debug) {
+              console.log(`\uD83D\uDEAB Skipping system contract: ${contractId}`);
+            }
+            continue;
+          }
+          if (options.include && !options.include.includes(contractName)) {
+            continue;
+          }
+          if (options.exclude && options.exclude.includes(contractName)) {
+            continue;
+          }
+          const sanitizedName = sanitizeContractName(contractName);
+          contracts.push({
+            name: sanitizedName,
+            address: contractId,
+            abi,
+            _clarinetSource: true
+          });
+        }
+        if (options.debug) {
+          console.log(`\uD83D\uDD0D Clarinet plugin found ${contracts.length} user-defined contracts`);
+        }
+        return {
+          ...config,
+          contracts: [...config.contracts || [], ...contracts]
+        };
+      } catch (error) {
+        const err = error;
+        if (options.debug) {
+          console.warn(`\u26A0\uFE0F  Clarinet plugin failed to load contracts: ${err.message}`);
+        }
+        return config;
+      }
+    },
+    async generate(context) {
+      const clarinetContracts = context.contracts.filter((contract) => contract.metadata?.source === "clarinet");
+      if (clarinetContracts.length === 0) {
+        return;
+      }
+      if (options.debug) {
+        context.logger.debug(`Generating interfaces for ${clarinetContracts.length} Clarinet contracts`);
+      }
+      const contractsCode = await generateContractInterface(clarinetContracts);
+      context.addOutput("contracts", {
+        path: context.config.out,
+        content: contractsCode,
+        type: "contracts"
+      });
+    }
+  };
+};
+async function hasClarinetProject(path2 = "./Clarinet.toml") {
+  try {
+    const { promises: fs2 } = await import("fs");
+    await fs2.access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+// src/plugins/actions/generators.ts
+function toCamelCase3(str) {
+  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
+}
+function getTypeForArg2(arg) {
+  const type = arg.type;
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+        return "bigint";
+      case "bool":
+        return "boolean";
+      case "principal":
+      case "trait_reference":
+        return "string";
+      default:
+        return "any";
+    }
+  }
+  if (type["string-ascii"] || type["string-utf8"]) {
+    return "string";
+  }
+  if (type.buff) {
+    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
+  }
+  if (type.optional) {
+    const innerType = getTypeForArg2({ type: type.optional });
+    return `${innerType} | null`;
+  }
+  if (type.list) {
+    const innerType = getTypeForArg2({ type: type.list.type });
+    return `${innerType}[]`;
+  }
+  if (type.tuple) {
+    const fields = type.tuple.map((field) => `${toCamelCase3(field.name)}: ${getTypeForArg2({ type: field.type })}`).join("; ");
+    return `{ ${fields} }`;
+  }
+  if (type.response) {
+    const okType = getTypeForArg2({ type: type.response.ok });
+    const errType = getTypeForArg2({ type: type.response.error });
+    return `{ ok: ${okType} } | { err: ${errType} }`;
+  }
+  return "any";
+}
+function generateArgsSignature(args) {
+  if (args.length === 0)
+    return "";
+  const argsTypes = args.map((arg) => {
+    const camelName = toCamelCase3(arg.name);
+    return `${camelName}: ${getTypeForArg2(arg)}`;
+  }).join("; ");
+  return `args: { ${argsTypes} }, `;
+}
+function generateClarityArgs(args, _contractName) {
+  if (args.length === 0)
+    return "";
+  return args.map((arg) => {
+    const argName = `args.${toCamelCase3(arg.name)}`;
+    return generateClarityConversion2(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];
+          if (!validateStacksAddress(address)) {
+            throw new Error("Invalid Stacks address format");
+          }
+          if (${argName}.includes(".")) {
+            return Cl.contractPrincipal(address, contractName);
+          } else {
+            return Cl.standardPrincipal(${argName});
+          }
+        })()`;
+      default:
+        return `${argName}`;
+    }
+  }
+  if (type["string-ascii"]) {
+    return `Cl.stringAscii(${argName})`;
+  }
+  if (type["string-utf8"]) {
+    return `Cl.stringUtf8(${argName})`;
+  }
+  if (type.buff) {
+    return `(() => {
+      const value = ${argName};
+      if (value instanceof Uint8Array) {
+        return Cl.buffer(value);
+      }
+      if (typeof value === 'object' && value !== null && value.type && value.value) {
+        switch (value.type) {
+          case 'ascii':
+            return Cl.bufferFromAscii(value.value);
+          case 'utf8':
+            return Cl.bufferFromUtf8(value.value);
+          case 'hex':
+            return Cl.bufferFromHex(value.value);
+          default:
+            throw new Error(\`Unsupported buffer type: \${value.type}\`);
+        }
+      }
+      if (typeof value === 'string') {
+        if (value.startsWith('0x') || /^[0-9a-fA-F]+$/.test(value)) {
+          return Cl.bufferFromHex(value);
+        }
+        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 = 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
+    });
+    return `Cl.list(${argName}.map(item => ${innerConversion}))`;
+  }
+  if (type.tuple) {
+    const fields = type.tuple.map((field) => {
+      const camelFieldName = toCamelCase3(field.name);
+      const fieldConversion = generateClarityConversion2(`${argName}.${camelFieldName}`, { type: field.type });
+      return `"${field.name}": ${fieldConversion}`;
+    }).join(", ");
+    return `Cl.tuple({ ${fields} })`;
+  }
+  if (type.response) {
+    const okConversion = generateClarityConversion2(`${argName}.ok`, {
+      type: type.response.ok
+    });
+    const errConversion = generateClarityConversion2(`${argName}.err`, {
+      type: type.response.error
+    });
+    return `'ok' in ${argName} ? Cl.ok(${okConversion.replace(`${argName}.ok`, `${argName}.ok`)}) : Cl.error(${errConversion.replace(`${argName}.err`, `${argName}.err`)})`;
+  }
+  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 helpers = filteredFunctions.map((func) => {
+    const methodName = toCamelCase3(func.name);
+    const argsSignature = generateArgsSignature(func.args);
+    const clarityArgs = generateClarityArgs(func.args, name);
+    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 || 'mainnet',
+        senderAddress: options?.senderAddress || 'SP000000000000000000002Q6VF78'
+      });
+    }`;
+  });
+  return `read: {
+    ${helpers.join(`,
+
+    `)}
+  }`;
+}
+function generateWriteHelpers(contract, options) {
+  const { abi, name } = contract;
+  const functions = abi.functions || [];
+  const publicFunctions = functions.filter((f) => f.access === "public");
+  if (publicFunctions.length === 0) {
+    return "";
+  }
+  const filteredFunctions = publicFunctions.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 = toCamelCase3(func.name);
+    const argsSignature = generateArgsSignature(func.args);
+    const clarityArgs = generateClarityArgs(func.args, name);
+    return `async ${methodName}(${argsSignature}options: {
+      senderKey: string;
+      network?: 'mainnet' | 'testnet' | 'devnet';
+      fee?: string | number | undefined;
+      nonce?: bigint;
+      anchorMode?: 1 | 2 | 3; // AnchorMode: OnChainOnly = 1, OffChainOnly = 2, Any = 3
+      postConditions?: any[]; // TODO: Add proper PostCondition types
+      validateWithAbi?: boolean;
+    }) {
+      const { senderKey, network = 'mainnet', ...txOptions } = options;
+      
+      return await makeContractCall({
+        contractAddress: '${contract.address}',
+        contractName: '${contract.contractName}',
+        functionName: '${func.name}',
+        functionArgs: [${clarityArgs}],
+        senderKey,
+        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) => {
+        if (options.include && !options.include.includes(contract.name)) {
+          return false;
+        }
+        if (options.exclude && options.exclude.includes(contract.name)) {
+          return false;
+        }
+        return true;
+      });
+      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) {
+  if (content.includes("fetchCallReadOnlyFunction") && content.includes("makeContractCall")) {
+    return content;
+  }
+  const transactionsImportRegex = /import\s+\{([^}]+)\}\s+from\s+['"]@stacks\/transactions['"];/;
+  const match = content.match(transactionsImportRegex);
+  if (match) {
+    const existingImports = match[1].trim();
+    const newImports = ["fetchCallReadOnlyFunction", "makeContractCall"].filter((imp) => !existingImports.includes(imp)).join(", ");
+    if (newImports) {
+      const updatedImport = `import { ${existingImports}, ${newImports} } from '@stacks/transactions';`;
+      return content.replace(transactionsImportRegex, updatedImport);
+    }
+  }
+  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},
 
-// src/utils/config.ts
-function defineConfig(configOrDefiner) {
-  return configOrDefiner;
+${indentedHelpersCode}
+} as const;`;
+  });
+}
+// src/plugins/react/provider/index.ts
+import { format as format3 } from "prettier";
+async function generateProvider() {
+  const code = `/**
+ * Generated Stacks React Provider
+ * DO NOT EDIT MANUALLY
+ */
+
+import React, { createContext, useContext } from 'react'
+
+/**
+ * Stacks configuration interface
+ */
+export interface StacksReactConfig {
+  /**
+   * Network to use for API calls
+   */
+  network: 'mainnet' | 'testnet' | 'devnet'
+
+  /**
+   * API key for Stacks API (optional)
+   */
+  apiKey?: string
+
+  /**
+   * Base URL for Stacks API (optional override)
+   */
+  apiUrl?: string
+
+  /**
+   * Default sender address for read-only calls
+   */
+  senderAddress?: string
+}
+
+/**
+ * Provider component props
+ */
+export interface StacksProviderProps {
+  children: React.ReactNode
+  config: StacksReactConfig
+}
+
+/**
+ * React context for Stacks configuration
+ */
+const StacksContext = createContext<StacksReactConfig | undefined>(undefined)
+StacksContext.displayName = 'StacksContext'
+
+/**
+ * Create a Stacks React configuration with defaults
+ */
+export function createStacksConfig(config: StacksReactConfig): StacksReactConfig {
+  return {
+    network: config.network,
+    apiKey: config.apiKey,
+    apiUrl: config.apiUrl,
+    senderAddress: config.senderAddress || 'SP000000000000000000002Q6VF78'
+  }
+}
+
+/**
+ * Provider component that makes Stacks configuration available to hooks
+ */
+export function StacksProvider({ children, config }: StacksProviderProps) {
+  const resolvedConfig = createStacksConfig(config)
+
+  return (
+    <StacksContext.Provider value={resolvedConfig}>
+      {children}
+    </StacksContext.Provider>
+  )
+}
+
+/**
+ * Hook to access the Stacks configuration
+ */
+export function useStacksConfig(): StacksReactConfig {
+  const context = useContext(StacksContext)
+  
+  if (context === undefined) {
+    throw new Error(
+      'useStacksConfig must be used within a StacksProvider. ' +
+      'Make sure to wrap your app with <StacksProvider config={{...}}>'
+    )
+  }
+  
+  return context
+}`;
+  const formatted = await format3(code, {
+    parser: "typescript",
+    singleQuote: true,
+    semi: false,
+    printWidth: 100,
+    trailingComma: "es5"
+  });
+  return formatted;
+}
+
+// src/plugins/react/generators/generic.ts
+import { format as format4 } from "prettier";
+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 { useStacksConfig } from './provider'
+import { connect, disconnect, isConnected, request, openContractCall as stacksOpenContractCall } from '@stacks/connect'
+import { Cl, validateStacksAddress } from '@stacks/transactions'
+import type { ExtractFunctionArgs, ExtractFunctionNames, ClarityContract } from '@secondlayer/clarity-types'`;
+  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}`;
+  const formatted = await format4(code, {
+    parser: "typescript",
+    singleQuote: true,
+    semi: false,
+    printWidth: 100,
+    trailingComma: "es5"
+  });
+  return formatted;
+}
+function generateGenericHook(hookName) {
+  switch (hookName) {
+    case "useAccount":
+      return `export function useAccount() {
+  const config = useStacksConfig()
+  
+  return useQuery({
+    queryKey: ['stacks-account', config.network],
+    queryFn: async () => {
+      try {
+        // Check if already connected using @stacks/connect v8
+        const connected = isConnected()
+        
+        if (!connected) {
+          return {
+            address: undefined,
+            addresses: undefined,
+            isConnected: false,
+            isConnecting: false,
+            isDisconnected: true,
+            status: 'disconnected' as const
+          }
+        }
+
+        // Get addresses using @stacks/connect v8 request method (SIP-030)
+        const result = await request('stx_getAddresses')
+        
+        if (!result || !result.addresses || result.addresses.length === 0) {
+          return {
+            address: undefined,
+            addresses: undefined,
+            isConnected: false,
+            isConnecting: false,
+            isDisconnected: true,
+            status: 'disconnected' as const
+          }
+        }
+
+        // Extract STX addresses from the response
+        const stxAddresses = result.addresses
+          .filter((addr: any) => addr.address.startsWith('SP') || addr.address.startsWith('ST'))
+          .map((addr: any) => addr.address)
+
+        return {
+          address: stxAddresses[0] || undefined,
+          addresses: stxAddresses,
+          isConnected: true,
+          isConnecting: false,
+          isDisconnected: false,
+          status: 'connected' as const
+        }
+      } catch (error) {
+        // Handle case where wallet is not available or user rejected
+        return {
+          address: undefined,
+          addresses: undefined,
+          isConnected: false,
+          isConnecting: false,
+          isDisconnected: true,
+          status: 'disconnected' as const
+        }
+      }
+    },
+    refetchOnWindowFocus: false,
+    retry: false,
+    staleTime: 1000 * 60 * 5, // 5 minutes
+    refetchInterval: 1000 * 30, // Refetch every 30 seconds to detect wallet changes
+  })
+}`;
+    case "useConnect":
+      return `export function useConnect() {
+  const queryClient = useQueryClient()
+  
+  const mutation = useMutation({
+    mutationFn: async (options: { forceWalletSelect?: boolean } = {}) => {
+      // Use @stacks/connect v8 connect method
+      return await connect(options)
+    },
+    onSuccess: () => {
+      // Invalidate account queries to refetch connection state
+      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
+    },
+    onError: (error) => {
+      console.error('Connection failed:', error)
+    }
+  })
+
+  return {
+    // Custom connect function that works without arguments
+    connect: (options?: { forceWalletSelect?: boolean }) => {
+      return mutation.mutate(options || {})
+    },
+    connectAsync: async (options?: { forceWalletSelect?: boolean }) => {
+      return mutation.mutateAsync(options || {})
+    },
+    // Expose all the mutation state
+    isPending: mutation.isPending,
+    isError: mutation.isError,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    data: mutation.data,
+    reset: mutation.reset,
+    // Keep the original mutate/mutateAsync for advanced users
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync
+  }
+}`;
+    case "useDisconnect":
+      return `export function useDisconnect() {
+  const queryClient = useQueryClient()
+  
+  const mutation = useMutation({
+    mutationFn: async () => {
+      // Use @stacks/connect v8 disconnect method
+      return await disconnect()
+    },
+    onSuccess: () => {
+      // Clear all cached data on disconnect
+      queryClient.clear()
+    },
+    onError: (error) => {
+      console.error('Disconnect failed:', error)
+    }
+  })
+
+  return {
+    // Custom disconnect function
+    disconnect: () => {
+      return mutation.mutate()
+    },
+    disconnectAsync: async () => {
+      return mutation.mutateAsync()
+    },
+    // Expose all the mutation state
+    isPending: mutation.isPending,
+    isError: mutation.isError,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    data: mutation.data,
+    reset: mutation.reset,
+    // Keep the original mutate/mutateAsync for advanced users
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync
+  }
+}`;
+    case "useNetwork":
+      return `export function useNetwork() {
+  const config = useStacksConfig()
+  
+  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 = useStacksConfig()
+  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-utf8']) {
+      return Cl.stringUtf8(value)
+    }
+
+    if (type.buff) {
+      return convertBufferValue(value)
+    }
+
+    if (type.optional) {
+      return value !== null ? Cl.some(convertJSValueToClarityValue(value, type.optional)) : Cl.none()
+    }
+
+    if (type.list) {
+      return Cl.list(value.map((item: any) => convertJSValueToClarityValue(item, type.list.type)))
+    }
+
+    if (type.tuple) {
+      const tupleData = type.tuple.reduce((acc: any, field: any) => {
+        acc[field.name] = convertJSValueToClarityValue(value[field.name], field.type)
+        return acc
+      }, {})
+      return Cl.tuple(tupleData)
+    }
+
+    if (type.response) {
+      return 'ok' in value 
+        ? Cl.ok(convertJSValueToClarityValue(value.ok, type.response.ok))
+        : Cl.error(convertJSValueToClarityValue(value.err, type.response.error))
+    }
+
+    return value
+  }
+
+  // Helper function to find a function in an ABI by name
+  const findFunctionInAbi = (abi: any, functionName: string): any => {
+    if (!abi || !abi.functions) return null
+    return abi.functions.find((func: any) => func.name === functionName)
+  }
+  
+  // Legacy function - unchanged, backward compatible
+  const legacyOpenContractCall = useCallback(async (params: {
+    contractAddress: string;
+    contractName: string;
+    functionName: string;
+    functionArgs: any[]; // Pre-converted Clarity values
+    network?: string;
+    postConditions?: any[];
+    attachment?: string;
+    onFinish?: (data: any) => void;
+    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'))
+            }
+          })
+        })
+      }
+    } catch (error) {
+      console.error('Contract call failed:', error)
+      throw error instanceof Error ? error : new Error('Contract call failed')
+    } finally {
+      setIsRequestPending(false)
+    }
+  }, [config.network, queryClient])
+
+  // Enhanced function - requires ABI, auto-converts JS values
+  const openContractCall = useCallback(async <
+    T extends ClarityContract,
+    FN extends ExtractFunctionNames<T>
+  >(params: {
+    contractAddress: string;
+    contractName: string;
+    functionName: FN;
+    abi: T;
+    functionArgs: ExtractFunctionArgs<T, FN>;
+    network?: string;
+    postConditions?: any[];
+    attachment?: string;
+    onFinish?: (data: any) => void;
+    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'))
+            }
+          })
+        })
+      }
+    } catch (error) {
+      console.error('Contract call failed:', error)
+      throw error instanceof Error ? error : new Error('Contract call failed')
+    } finally {
+      setIsRequestPending(false)
+    }
+  }, [config.network, queryClient])
+
+  return {
+    legacyOpenContractCall,
+    openContractCall,
+    isRequestPending
+  }
+}`;
+    case "useReadContract":
+      return `export function useReadContract<TArgs = any, TResult = any>(params: {
+  contractAddress: string;
+  contractName: string;
+  functionName: string;
+  args?: TArgs;
+  network?: 'mainnet' | 'testnet' | 'devnet';
+  enabled?: boolean;
+}) {
+  const config = useStacksConfig()
+  
+  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')
+      
+      // For now, we'll need to handle the args conversion here
+      // In the future, we could integrate with the contract interface for automatic conversion
+      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({
+        contractAddress: params.contractAddress,
+        contractName: params.contractName,
+        functionName: params.functionName,
+        functionArgs,
+        network: params.network || config.network || 'mainnet',
+        senderAddress: config.senderAddress || 'SP000000000000000000002Q6VF78'
+      }) as TResult
+    },
+    enabled: params.enabled ?? true
+  })
+}`;
+    case "useTransaction":
+      return `export function useTransaction(txId?: string) {
+  const config = useStacksConfig()
+  
+  return useQuery({
+    queryKey: ['transaction', txId, config.network],
+    queryFn: () => fetchTransaction({
+      txId: txId!,
+      network: config.network,
+      apiUrl: config.apiUrl
+    }),
+    enabled: !!txId
+  })
+}`;
+    case "useBlock":
+      return `export function useBlock(height?: number) {
+  const config = useStacksConfig()
+  
+  return useQuery({
+    queryKey: ['block', height, config.network],
+    queryFn: () => fetchBlock({
+      height: height!,
+      network: config.network,
+      apiUrl: config.apiUrl
+    }),
+    enabled: typeof height === 'number'
+  })
+}`;
+    case "useAccountTransactions":
+      return `export function useAccountTransactions(address?: string) {
+  const config = useStacksConfig()
+  
+  return useQuery({
+    queryKey: ['account-transactions', address, config.network],
+    queryFn: () => fetchAccountTransactions({
+      address: address!,
+      network: config.network,
+      apiUrl: config.apiUrl
+    }),
+    enabled: !!address
+  })
+}`;
+    case "useWaitForTransaction":
+      return `export function useWaitForTransaction(txId?: string) {
+  const config = useStacksConfig()
+  
+  return useQuery({
+    queryKey: ['wait-for-transaction', txId, config.network],
+    queryFn: () => fetchTransaction({
+      txId: txId!,
+      network: config.network,
+      apiUrl: config.apiUrl
+    }),
+    enabled: !!txId,
+    refetchInterval: (data) => {
+      // Stop polling when transaction is complete
+      if (data?.tx_status === 'success' || 
+          data?.tx_status === 'abort_by_response' || 
+          data?.tx_status === 'abort_by_post_condition') {
+        return false
+      }
+      return 2000 // Poll every 2 seconds
+    },
+    staleTime: 0 // Always refetch
+  })
+}`;
+    case "useOpenSTXTransfer":
+      return `export function useOpenSTXTransfer() {
+  const config = useStacksConfig()
+  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 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'))
+          }
+        })
+      })
+    },
+    onSuccess: () => {
+      // Invalidate relevant queries on success
+      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
+    },
+    onError: (error) => {
+      console.error('STX transfer failed:', error)
+    }
+  })
+
+  const openSTXTransfer = useCallback(async (params: {
+    recipient: string;
+    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,
+    error: mutation.error,
+    data: mutation.data,
+    reset: mutation.reset
+  }
+}`;
+    case "useSignMessage":
+      return `export function useSignMessage() {
+  const config = useStacksConfig()
+  
+  const mutation = useMutation({
+    mutationFn: async (params: {
+      message: string;
+      network?: string;
+      onFinish?: (data: any) => void;
+      onCancel?: () => void;
+    }) => {
+      const { message, onFinish, onCancel, ...options } = 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'))
+          }
+        })
+      })
+    },
+    onError: (error) => {
+      console.error('Message signing failed:', error)
+    }
+  })
+
+  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,
+    error: mutation.error,
+    data: mutation.data,
+    reset: mutation.reset
+  }
+}`;
+    case "useDeployContract":
+      return `export function useDeployContract() {
+  const config = useStacksConfig()
+  const queryClient = useQueryClient()
+  
+  const mutation = useMutation({
+    mutationFn: async (params: {
+      contractName: string;
+      codeBody: string;
+      network?: string;
+      postConditions?: any[];
+      onFinish?: (data: any) => void;
+      onCancel?: () => void;
+    }) => {
+      const { contractName, codeBody, onFinish, onCancel, ...options } = 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'))
+          }
+        })
+      })
+    },
+    onSuccess: () => {
+      // Invalidate relevant queries on success
+      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
+    },
+    onError: (error) => {
+      console.error('Contract deployment failed:', error)
+    }
+  })
+
+  const deployContract = useCallback(async (params: {
+    contractName: string;
+    codeBody: string;
+    network?: string;
+    postConditions?: any[];
+    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,
+    error: mutation.error,
+    data: mutation.data,
+    reset: mutation.reset
+  }
+}`;
+    default:
+      return "";
+  }
+}
+
+// src/plugins/react/generators/contract.ts
+import { format as format5 } from "prettier";
+
+// src/plugins/react/generators/utils.ts
+function toCamelCase4(str) {
+  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function generateHookArgsSignature(args) {
+  if (args.length === 0)
+    return "";
+  const argsList = args.map((arg) => `${toCamelCase4(arg.name)}: ${mapClarityTypeToTS(arg.type)}`).join(", ");
+  return `${argsList}`;
+}
+function generateArgsType(args) {
+  if (args.length === 0)
+    return "void";
+  const argsList = args.map((arg) => `${toCamelCase4(arg.name)}: ${mapClarityTypeToTS(arg.type)}`).join("; ");
+  return `{ ${argsList} }`;
+}
+function generateQueryKeyArgs(args) {
+  if (args.length === 0)
+    return "";
+  return args.map((arg) => toCamelCase4(arg.name)).join(", ");
+}
+function generateFunctionCallArgs(args) {
+  if (args.length === 0)
+    return "";
+  return args.map((arg) => toCamelCase4(arg.name)).join(", ");
+}
+function generateEnabledCondition(args) {
+  return args.map((arg) => {
+    const camelName = toCamelCase4(arg.name);
+    const type = mapClarityTypeToTS(arg.type);
+    if (type === "string")
+      return `!!${camelName}`;
+    if (type === "bigint")
+      return `${camelName} !== undefined`;
+    return `${camelName} !== undefined`;
+  }).join(" && ");
+}
+function mapClarityTypeToTS(clarityType) {
+  if (typeof clarityType !== "string") {
+    if (clarityType?.uint || clarityType?.int)
+      return "bigint";
+    if (clarityType?.principal)
+      return "string";
+    if (clarityType?.bool)
+      return "boolean";
+    if (clarityType?.string || clarityType?.ascii)
+      return "string";
+    if (clarityType?.buff)
+      return "Uint8Array";
+    if (clarityType?.optional) {
+      const innerType = mapClarityTypeToTS(clarityType.optional);
+      return `${innerType} | null`;
+    }
+    if (clarityType?.response)
+      return "any";
+    if (clarityType?.tuple)
+      return "any";
+    if (clarityType?.list)
+      return "any[]";
+    return "any";
+  }
+  if (clarityType.includes("uint") || clarityType.includes("int"))
+    return "bigint";
+  if (clarityType.includes("principal"))
+    return "string";
+  if (clarityType.includes("bool"))
+    return "boolean";
+  if (clarityType.includes("string") || clarityType.includes("ascii"))
+    return "string";
+  if (clarityType.includes("buff"))
+    return "Uint8Array";
+  if (clarityType.includes("optional")) {
+    const innerType = clarityType.replace(/optional\s*/, "").trim();
+    return `${mapClarityTypeToTS(innerType)} | null`;
+  }
+  if (clarityType.includes("response"))
+    return "any";
+  if (clarityType.includes("tuple"))
+    return "any";
+  if (clarityType.includes("list"))
+    return "any[]";
+  return "any";
+}
+function generateObjectArgs(args) {
+  if (args.length === 0)
+    return "";
+  return args.map((arg) => `${arg.name}: ${toCamelCase4(arg.name)}`).join(", ");
+}
+
+// src/plugins/react/generators/contract.ts
+async function generateContractHooks(contracts, excludeList = []) {
+  const imports = `import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
+import { useCallback } from 'react'
+import { useStacksConfig } from './provider'
+import { request, openContractCall as stacksOpenContractCall } from '@stacks/connect'
+import { ${contracts.map((c) => c.name).join(", ")} } from './contracts'`;
+  const header = `/**
+ * Generated contract-specific React hooks
+ * DO NOT EDIT MANUALLY
+ */`;
+  const hooksCode = contracts.map((contract) => generateContractHookMethods(contract, excludeList)).filter(Boolean).join(`
+
+`);
+  const code = `${imports}
+
+${header}
+
+${hooksCode}`;
+  const formatted = await format5(code, {
+    parser: "typescript",
+    singleQuote: true,
+    semi: false,
+    printWidth: 100,
+    trailingComma: "es5"
+  });
+  return formatted;
+}
+function generateContractHookMethods(contract, excludeList) {
+  const { abi, name } = contract;
+  const functions = abi.functions || [];
+  const readOnlyFunctions = functions.filter((f) => f.access === "read_only" || 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))}`;
+    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))}`;
+    if (excludeList.includes(hookName)) {
+      return null;
+    }
+    return generateWriteHook(func, name);
+  }).filter(Boolean);
+  const allHooks = [...readHooks, ...writeHooks];
+  if (allHooks.length === 0) {
+    return "";
+  }
+  return allHooks.join(`
+
+`);
+}
+function generateReadHook(func, contractName) {
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase4(func.name))}`;
+  const argsSignature = generateHookArgsSignature(func.args);
+  const enabledParam = func.args.length > 0 ? ", options?: { enabled?: boolean }" : "options?: { enabled?: boolean }";
+  return `export function ${hookName}(${argsSignature}${enabledParam}) {
+  const config = useStacksConfig()
+  
+  return useQuery({
+    queryKey: ['${func.name}', ${contractName}.address, ${generateQueryKeyArgs(func.args)}],
+    queryFn: () => ${contractName}.read.${toCamelCase4(func.name)}(${generateFunctionCallArgs(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{ 
+      network: config.network,
+      senderAddress: config.senderAddress || 'SP000000000000000000002Q6VF78'
+    }),
+    ${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 argsType = generateArgsType(func.args);
+  return `export function ${hookName}() {
+  const config = useStacksConfig()
+  const queryClient = useQueryClient()
+  
+  const mutation = useMutation({
+    mutationFn: async (params: {
+      args: ${argsType};
+      options?: {
+        postConditions?: any[];
+        attachment?: string;
+        onFinish?: (data: any) => void;
+        onCancel?: () => void;
+      };
+    }) => {
+      const { args, options = {} } = params
+      const contractCallData = ${contractName}.${toCamelCase4(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'))
+            }
+          })
+        })
+      }
+    },
+    onSuccess: () => {
+      // Invalidate relevant queries on success
+      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
+    },
+    onError: (error) => {
+      console.error('Contract call failed:', error)
+    }
+  })
+
+  const ${toCamelCase4(func.name)} = useCallback(async (
+    args: ${argsType}, 
+    options?: {
+      postConditions?: any[];
+      attachment?: string;
+      onFinish?: (data: any) => void;
+      onCancel?: () => void;
+    }
+  ) => {
+    return mutation.mutateAsync({ args, options })
+  }, [mutation])
+
+  return {
+    ${toCamelCase4(func.name)},
+    // Expose mutation state
+    isPending: mutation.isPending,
+    isError: mutation.isError,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    data: mutation.data,
+    reset: mutation.reset
+  }
+}`;
+}
+
+// src/plugins/react/index.ts
+var react = (options = {}) => {
+  const excludeList = options.exclude || [];
+  return {
+    name: "@secondlayer/cli/plugin-react",
+    version: "1.0.0",
+    async generate(context) {
+      if (options.debug) {
+        context.logger.debug(`React plugin generating hooks (excluding: ${excludeList.join(", ") || "none"})`);
+      }
+      const provider = await generateProvider();
+      context.addOutput("provider", {
+        path: "./src/generated/provider.tsx",
+        content: provider,
+        type: "config"
+      });
+      const genericHooks = await generateGenericHooks(excludeList);
+      context.addOutput("generic-hooks", {
+        path: "./src/generated/hooks.ts",
+        content: genericHooks,
+        type: "hooks"
+      });
+      if (context.contracts.length > 0) {
+        const contractHooks = await generateContractHooks(context.contracts, excludeList);
+        if (contractHooks.trim()) {
+          context.addOutput("contract-hooks", {
+            path: "./src/generated/contract-hooks.ts",
+            content: contractHooks,
+            type: "hooks"
+          });
+        }
+      }
+      if (options.debug) {
+        context.logger.success(`React plugin generated ${context.contracts.length} contract hook sets`);
+      }
+    }
+  };
+};
+// src/plugins/testing/generators.ts
+function toCamelCase5(str) {
+  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
+}
+function toPascalCase(str) {
+  const camel = toCamelCase5(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function getTypeForArg3(arg) {
+  const type = arg.type;
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+        return "bigint";
+      case "bool":
+        return "boolean";
+      case "principal":
+      case "trait_reference":
+        return "string";
+      default:
+        return "any";
+    }
+  }
+  if (type["string-ascii"] || type["string-utf8"]) {
+    return "string";
+  }
+  if (type.buff) {
+    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
+  }
+  if (type.optional) {
+    const innerType = getTypeForArg3({ type: type.optional });
+    return `${innerType} | null`;
+  }
+  if (type.list) {
+    const innerType = getTypeForArg3({ type: type.list.type });
+    return `${innerType}[]`;
+  }
+  if (type.tuple) {
+    const fields = type.tuple.map((field) => `${toCamelCase5(field.name)}: ${getTypeForArg3({ type: field.type })}`).join("; ");
+    return `{ ${fields} }`;
+  }
+  if (type.response) {
+    const okType = getTypeForArg3({ type: type.response.ok });
+    const errType = getTypeForArg3({ type: type.response.error });
+    return `{ ok: ${okType} } | { err: ${errType} }`;
+  }
+  return "any";
+}
+function generateArgsSignature2(args) {
+  if (args.length === 0)
+    return "";
+  const argsTypes = args.map((arg) => {
+    const camelName = toCamelCase5(arg.name);
+    return `${camelName}: ${getTypeForArg3(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
+    });
+    return `Cl.list(${argName}.map(item => ${innerConversion}))`;
+  }
+  if (type.tuple) {
+    const fields = type.tuple.map((field) => {
+      const camelFieldName = toCamelCase5(field.name);
+      const fieldConversion = generateClarityConversion3(`${argName}.${camelFieldName}`, { type: field.type });
+      return `"${field.name}": ${fieldConversion}`;
+    }).join(", ");
+    return `Cl.tuple({ ${fields} })`;
+  }
+  if (type.response) {
+    const okConversion = generateClarityConversion3(`${argName}.ok`, {
+      type: type.response.ok
+    });
+    const errConversion = generateClarityConversion3(`${argName}.err`, {
+      type: type.response.error
+    });
+    return `'ok' in ${argName} ? Cl.ok(${okConversion}) : Cl.error(${errConversion})`;
+  }
+  return `${argName}`;
+}
+function generateClarityArgs2(args) {
+  if (args.length === 0)
+    return "";
+  return args.map((arg) => {
+    const argName = `args.${toCamelCase5(arg.name)}`;
+    return generateClarityConversion3(argName, arg);
+  }).join(", ");
+}
+function generatePublicFunction(func, contractId) {
+  const methodName = toCamelCase5(func.name);
+  const argsSignature = generateArgsSignature2(func.args);
+  const clarityArgs = generateClarityArgs2(func.args);
+  return `${methodName}: (${argsSignature}caller: string) => {
+      const callerAddr = accounts.get(caller) ?? caller;
+      return simnet.callPublicFn(
+        '${contractId}',
+        '${func.name}',
+        [${clarityArgs}],
+        callerAddr
+      );
+    }`;
+}
+function generateReadOnlyFunction(func, contractId) {
+  const methodName = toCamelCase5(func.name);
+  const argsSignature = generateArgsSignature2(func.args);
+  const clarityArgs = generateClarityArgs2(func.args);
+  const hasArgs = func.args.length > 0;
+  const argsParam = hasArgs ? argsSignature : "";
+  return `${methodName}: (${argsParam}) => {
+      return simnet.callReadOnlyFn(
+        '${contractId}',
+        '${func.name}',
+        [${clarityArgs}],
+        accounts.get('deployer')!
+      );
+    }`;
+}
+function generatePrivateFunction(func, contractId) {
+  const methodName = toCamelCase5(func.name);
+  const argsSignature = generateArgsSignature2(func.args);
+  const clarityArgs = generateClarityArgs2(func.args);
+  return `${methodName}: (${argsSignature}caller: string) => {
+      const callerAddr = accounts.get(caller) ?? caller;
+      return simnet.callPrivateFn(
+        '${contractId}',
+        '${func.name}',
+        [${clarityArgs}],
+        callerAddr
+      );
+    }`;
+}
+function generateDataVarHelper(variable, contractId) {
+  const methodName = toCamelCase5(variable.name);
+  return `${methodName}: () => {
+      return simnet.getDataVar('${contractId}', '${variable.name}');
+    }`;
+}
+function getMapKeyType(keyType) {
+  if (keyType.tuple) {
+    const fields = keyType.tuple.map((field) => `${toCamelCase5(field.name)}: ${getTypeForArg3({ type: field.type })}`).join("; ");
+    return `{ ${fields} }`;
+  }
+  return getTypeForArg3({ type: keyType });
+}
+function generateMapKeyConversion(keyType) {
+  if (keyType.tuple) {
+    const fields = keyType.tuple.map((field) => {
+      const camelFieldName = toCamelCase5(field.name);
+      const fieldConversion = generateClarityConversion3(`key.${camelFieldName}`, { type: field.type });
+      return `"${field.name}": ${fieldConversion}`;
+    }).join(", ");
+    return `Cl.tuple({ ${fields} })`;
+  }
+  return generateClarityConversion3("key", { type: keyType });
+}
+function generateMapEntryHelper(map, contractId) {
+  const methodName = toCamelCase5(map.name);
+  const keyType = getMapKeyType(map.key);
+  const keyConversion = generateMapKeyConversion(map.key);
+  return `${methodName}: (key: ${keyType}) => {
+      return simnet.getMapEntry(
+        '${contractId}',
+        '${map.name}',
+        ${keyConversion}
+      );
+    }`;
+}
+function generateVarsObject(variables, contractId) {
+  const dataVars = variables.filter((v) => v.access === "variable");
+  if (dataVars.length === 0) {
+    return "";
+  }
+  const varHelpers = dataVars.map((v) => generateDataVarHelper(v, contractId));
+  return `vars: {
+      ${varHelpers.join(`,
+
+      `)}
+    }`;
+}
+function generateMapsObject(maps, contractId) {
+  if (maps.length === 0) {
+    return "";
+  }
+  const mapHelpers = maps.map((m) => generateMapEntryHelper(m, contractId));
+  return `maps: {
+      ${mapHelpers.join(`,
+
+      `)}
+    }`;
+}
+function generateContractHelper(contract, options) {
+  const { abi, name, address } = contract;
+  const functions = abi.functions || [];
+  const variables = abi.variables || [];
+  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 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));
+  const privateHelpers = privateFns.map((f) => generatePrivateFunction(f, address));
+  const varsObject = generateVarsObject(variables, address);
+  const mapsObject = generateMapsObject(maps, address);
+  const allHelpers = [...publicHelpers, ...readOnlyHelpers, ...privateHelpers];
+  if (varsObject) {
+    allHelpers.push(varsObject);
+  }
+  if (mapsObject) {
+    allHelpers.push(mapsObject);
+  }
+  if (allHelpers.length === 0) {
+    return "";
+  }
+  return `export function get${pascalName}(simnet: Simnet) {
+  const accounts = simnet.getAccounts();
+
+  return {
+    ${allHelpers.join(`,
+
+    `)}
+  };
+}`;
+}
+function generateGetContracts(contracts) {
+  const contractEntries = contracts.map((contract) => {
+    const camelName = toCamelCase5(contract.name);
+    const pascalName = toPascalCase(contract.name);
+    return `${camelName}: get${pascalName}(simnet)`;
+  }).join(`,
+    `);
+  return `export function getContracts(simnet: Simnet) {
+  const accounts = simnet.getAccounts();
+
+  return {
+    accounts,
+    ${contractEntries}
+  };
+}`;
+}
+function generateTypeExports(contracts) {
+  const typeExports = contracts.map((contract) => {
+    const pascalName = toPascalCase(contract.name);
+    return `export type ${pascalName}Helpers = ReturnType<typeof get${pascalName}>;`;
+  }).join(`
+`);
+  return `${typeExports}
+export type Contracts = ReturnType<typeof getContracts>;`;
+}
+async function generateTestingHelpers(contracts, options) {
+  const contractHelpers = contracts.map((contract) => generateContractHelper(contract, options)).filter(Boolean);
+  if (contractHelpers.length === 0) {
+    return `// No contracts with functions to generate helpers for
+export {};`;
+  }
+  const getContractsCode = generateGetContracts(contracts);
+  const typeExports = generateTypeExports(contracts);
+  return `/**
+ * Generated by @secondlayer/cli testing plugin
+ * Type-safe helpers for Clarinet SDK unit tests
+ */
+
+import { type Simnet, Cl } from '@hirosystems/clarinet-sdk';
+
+// ============================================
+// Per-contract factory functions
+// ============================================
+
+${contractHelpers.join(`
+
+`)}
+
+// ============================================
+// Convenience: all contracts at once
+// ============================================
+
+${getContractsCode}
+
+// ============================================
+// Type exports
+// ============================================
+
+${typeExports}
+`;
+}
+
+// src/plugins/testing/index.ts
+var testing = (options = {}) => {
+  return {
+    name: "@secondlayer/cli/plugin-testing",
+    version: "1.0.0",
+    async generate(context) {
+      const { contracts } = context;
+      const filteredContracts = contracts.filter((contract) => {
+        if (options.include && !options.include.includes(contract.name)) {
+          return false;
+        }
+        if (options.exclude && options.exclude.includes(contract.name)) {
+          return false;
+        }
+        return true;
+      });
+      if (filteredContracts.length === 0) {
+        if (options.debug) {
+          context.logger.debug("Testing plugin: No contracts to process");
+        }
+        return;
+      }
+      if (options.debug) {
+        context.logger.debug(`Testing plugin: Generating helpers for ${filteredContracts.length} contracts`);
+      }
+      const testingCode = await generateTestingHelpers(filteredContracts, options);
+      const outputPath = options.out || "./src/generated/testing.ts";
+      context.addOutput("testing", {
+        path: outputPath,
+        content: testingCode,
+        type: "utils"
+      });
+      if (options.debug) {
+        context.logger.debug(`Testing plugin: Generated helpers for ${filteredContracts.length} contracts`);
+      }
+    }
+  };
+};
+
+// src/plugins/index.ts
+function filterByOptions(items, options = {}) {
+  let filtered = items;
+  if (options.include && options.include.length > 0) {
+    filtered = filtered.filter((item) => options.include.some((pattern) => item.name.includes(pattern) || item.name.match(new RegExp(pattern))));
+  }
+  if (options.exclude && options.exclude.length > 0) {
+    filtered = filtered.filter((item) => !options.exclude.some((pattern) => item.name.includes(pattern) || item.name.match(new RegExp(pattern))));
+  }
+  return filtered;
+}
+function createPlugin(name, version, implementation) {
+  return {
+    name,
+    version,
+    ...implementation
+  };
 }
 export {
-  PluginManager,
-  defineConfig
+  testing,
+  react,
+  hasClarinetProject,
+  filterByOptions,
+  createPlugin,
+  clarinet,
+  actions,
+  PluginManager
 };
-//# sourceMappingURL=index.js.map
+
+//# debugId=944FF0A218B7401F64756E2164756E21
+//# sourceMappingURL=index.js.map