@secondlayer/cli 0.1.0

package/dist/plugins/index.js

@@ -0,0 +1,2578 @@
+// 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 {
+  constructor() {
+    this.plugins = [];
+    this.logger = this.createLogger();
+    this.utils = this.createUtils();
+    this.executionContext = {
+      phase: "config",
+      startTime: Date.now(),
+      results: /* @__PURE__ */ 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})`
+      );
+    }
+    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 };
+    for (const plugin of this.plugins) {
+      if (plugin.transformConfig) {
+        this.executionContext.currentPlugin = plugin;
+        try {
+          const result = await plugin.transformConfig(transformedConfig);
+          transformedConfig = result;
+          this.recordHookResult(plugin.name, "transformConfig", {
+            success: true
+          });
+        } catch (error) {
+          const err = error;
+          this.recordHookResult(plugin.name, "transformConfig", {
+            success: false,
+            error: err
+          });
+          throw new Error(
+            `Plugin "${plugin.name}" failed during config transformation: ${err.message}`
+          );
+        }
+      }
+    }
+    const resolvedConfig = {
+      ...transformedConfig,
+      plugins: this.plugins
+    };
+    return resolvedConfig;
+  }
+  /**
+   * Transform contracts through all plugins
+   */
+  async transformContracts(contracts, _config) {
+    const processedContracts = [];
+    for (let contract of contracts) {
+      if (contract._clarinetSource && 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: "clarinet" }
+        };
+        processedContracts.push(processed);
+        continue;
+      }
+      for (const plugin of this.plugins) {
+        if (plugin.transformContract) {
+          this.executionContext.currentPlugin = plugin;
+          try {
+            contract = await plugin.transformContract(contract);
+            this.recordHookResult(plugin.name, "transformContract", {
+              success: true
+            });
+          } catch (error) {
+            const err = error;
+            this.recordHookResult(plugin.name, "transformContract", {
+              success: false,
+              error: err
+            });
+            this.logger.warn(
+              `Plugin "${plugin.name}" failed to transform contract: ${err.message}`
+            );
+          }
+        }
+      }
+      if (contract.abi) {
+        const processed = {
+          name: contract.name || "unknown",
+          address: typeof contract.address === "string" ? contract.address.split(".")[0] : "unknown",
+          contractName: contract.name || "unknown",
+          abi: contract.abi,
+          source: "api",
+          // Use "api" as default for plugin-processed contracts
+          metadata: contract.metadata
+        };
+        processedContracts.push(processed);
+      }
+    }
+    return processedContracts;
+  }
+  /**
+   * Execute lifecycle hooks
+   */
+  async executeHook(hookName, context) {
+    for (const plugin of this.plugins) {
+      const hook = plugin[hookName];
+      if (typeof hook === "function") {
+        this.executionContext.currentPlugin = plugin;
+        try {
+          await hook.call(plugin, context);
+          this.recordHookResult(plugin.name, hookName, {
+            success: true
+          });
+        } catch (error) {
+          const err = error;
+          this.recordHookResult(plugin.name, hookName, {
+            success: false,
+            error: err
+          });
+          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 context = {
+      config,
+      logger: this.logger,
+      utils: this.utils,
+      contracts,
+      outputs,
+      augment: (outputKey, contractName, content) => {
+        this.augmentOutput(outputs, outputKey, contractName, content);
+      },
+      addOutput: (key, output) => {
+        outputs.set(key, output);
+      }
+    };
+    await this.executeHook("beforeGenerate", context);
+    await this.executeHook("generate", context);
+    await this.executeHook("afterGenerate", context);
+    return outputs;
+  }
+  /**
+   * Transform outputs through plugins
+   */
+  async transformOutputs(outputs) {
+    this.executionContext.phase = "output";
+    const transformedOutputs = /* @__PURE__ */ 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"
+            );
+            this.recordHookResult(plugin.name, "transformOutput", {
+              success: true
+            });
+          } catch (error) {
+            const err = error;
+            this.recordHookResult(plugin.name, "transformOutput", {
+              success: false,
+              error: err
+            });
+            this.logger.warn(
+              `Plugin "${plugin.name}" failed to transform output: ${err.message}`
+            );
+          }
+        }
+      }
+      transformedOutputs.set(key, {
+        ...output,
+        content: transformedContent
+      });
+    }
+    return transformedOutputs;
+  }
+  /**
+   * Write outputs to disk
+   */
+  async writeOutputs(outputs) {
+    for (const [, output] of outputs) {
+      try {
+        const resolvedPath = path.resolve(process.cwd(), output.path);
+        await this.utils.ensureDir(path.dirname(resolvedPath));
+        await this.utils.writeFile(resolvedPath, output.content);
+      } catch (error) {
+        const err = error;
+        this.logger.error(`Failed to write ${output.path}: ${err.message}`);
+        throw err;
+      }
+    }
+  }
+  /**
+   * 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) {
+      this.logger.warn(`Cannot augment non-existent output: ${outputKey}`);
+      return;
+    }
+    const augmentedContent = `${existing.content}
+
+// Augmented by plugin for ${contractName}
+${JSON.stringify(content, null, 2)}`;
+    outputs.set(outputKey, {
+      ...existing,
+      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}`),
+      warn: (message) => console.warn(`\u26A0\uFE0F  ${message}`),
+      error: (message) => console.error(`\u274C ${message}`),
+      debug: (message) => {
+        if (process.env.DEBUG) {
+          console.log(`\u{1F41B} ${message}`);
+        }
+      },
+      success: (message) => console.log(`\u2705 ${message}`)
+    };
+  }
+  /**
+   * Create utils instance
+   */
+  createUtils() {
+    return {
+      toCamelCase: (str) => {
+        return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+      },
+      toKebabCase: (str) => {
+        return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+      },
+      validateAddress: (address) => {
+        return validateStacksAddress(address.split(".")[0]);
+      },
+      parseContractId: (contractId) => {
+        const [address, contractName] = contractId.split(".");
+        return { address, contractName };
+      },
+      formatCode: async (code) => {
+        return format(code, {
+          parser: "typescript",
+          singleQuote: true,
+          semi: true,
+          printWidth: 100,
+          trailingComma: "es5"
+        });
+      },
+      resolvePath: (relativePath) => {
+        return path.resolve(process.cwd(), relativePath);
+      },
+      fileExists: async (filePath) => {
+        try {
+          await fs.access(filePath);
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      readFile: async (filePath) => {
+        return fs.readFile(filePath, "utf-8");
+      },
+      writeFile: async (filePath, content) => {
+        await fs.writeFile(filePath, content, "utf-8");
+      },
+      ensureDir: async (dirPath) => {
+        await fs.mkdir(dirPath, { recursive: true });
+      }
+    };
+  }
+};
+
+// 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 @stacks/codegen
+ * DO NOT EDIT MANUALLY
+ */`;
+  const contractsCode = contracts.map((contract) => generateContract(contract)).join("\n\n");
+  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(",\n\n  ");
+  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 = /* @__PURE__ */ 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+$/,
+    // pox-2, pox-3, etc.
+    /^bns$/,
+    // Blockchain Name System
+    /^costs-\d+$/,
+    // costs-2, costs-3, etc.
+    /^lockup$/
+    // lockup contract
+  ];
+  if (systemContractPatterns.some((pattern) => pattern.test(contractName))) {
+    return false;
+  }
+  const systemAddresses = [
+    "SP000000000000000000002Q6VF78",
+    // Boot contracts address
+    "ST000000000000000000002AMW42H"
+    // Boot contracts address (testnet)
+  ];
+  if (systemAddresses.includes(address)) {
+    return false;
+  }
+  return true;
+}
+var clarinet = (options = {}) => {
+  const manifestPath = options.path || "./Clarinet.toml";
+  let simnet;
+  return {
+    name: "@stacks/codegen/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(`\u{1F6AB} 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,
+            // Remove source field - this was causing the path resolution issue
+            _clarinetSource: true
+            // Internal flag for our plugin
+          });
+        }
+        if (options.debug) {
+          console.log(
+            `\u{1F50D} 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(",\n\n    ")}
+  }`;
+}
+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(",\n\n    ")}
+  }`;
+}
+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(",\n\n");
+}
+
+// src/plugins/actions/index.ts
+var actions = (options = {}) => {
+  return {
+    name: "@stacks/codegen/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 = /* @__PURE__ */ 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("\n").map((line) => {
+      if (line.match(/^[a-zA-Z_$][a-zA-Z0-9_$]*\s*:/)) {
+        return `  ${line}`;
+      }
+      return line;
+    }).join("\n");
+    return `${cleanBody},
+
+${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("\n\n");
+  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("\n\n");
+  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("\n\n");
+}
+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: "@stacks/codegen/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/utils/api.ts
+import got from "got";
+var API_URLS = {
+  mainnet: "https://api.hiro.so",
+  testnet: "https://api.testnet.hiro.so",
+  devnet: "http://localhost:3999"
+};
+var StacksApiClient = class {
+  constructor(network = "mainnet", apiKey, apiUrl) {
+    this.baseUrl = apiUrl || API_URLS[network];
+    this.headers = apiKey ? { "x-api-key": apiKey } : {};
+  }
+  async getContractInfo(contractId) {
+    const [address, contractName] = contractId.split(".");
+    if (!address || !contractName) {
+      throw new Error(
+        `Invalid contract ID format: ${contractId}. Expected format: ADDRESS.CONTRACT_NAME`
+      );
+    }
+    const url = `${this.baseUrl}/v2/contracts/interface/${address}/${contractName}`;
+    try {
+      const response = await got(url, {
+        headers: this.headers,
+        responseType: "json"
+      });
+      return response.body;
+    } catch (error) {
+      if (error.response?.statusCode === 404) {
+        throw new Error(`Contract not found: ${contractId}`);
+      }
+      if (error.response?.statusCode === 429) {
+        throw new Error(
+          "Rate limited. Please provide an API key in your config."
+        );
+      }
+      throw new Error(`Failed to fetch contract: ${error.message}`);
+    }
+  }
+  async getContractSource(contractId) {
+    const [address, contractName] = contractId.split(".");
+    if (!address || !contractName) {
+      throw new Error(
+        `Invalid contract ID format: ${contractId}. Expected format: ADDRESS.CONTRACT_NAME`
+      );
+    }
+    const url = `${this.baseUrl}/v2/contracts/source/${address}/${contractName}`;
+    try {
+      const response = await got(url, {
+        headers: this.headers,
+        responseType: "json"
+      });
+      const data = response.body;
+      return data.source;
+    } catch (error) {
+      return "";
+    }
+  }
+};
+
+// src/parsers/clarity.ts
+function parseType(typeStr) {
+  typeStr = typeStr.replace(/[()]/g, "").trim();
+  switch (typeStr) {
+    case "uint":
+    case "uint128":
+      return "uint128";
+    case "int":
+    case "int128":
+      return "int128";
+    case "bool":
+      return "bool";
+    case "principal":
+      return "principal";
+    case "trait_reference":
+      return "principal";
+    default:
+      if (typeStr.startsWith("string-ascii")) {
+        return { "string-ascii": { length: 256 } };
+      }
+      if (typeStr.startsWith("string-utf8")) {
+        return { "string-utf8": { length: 256 } };
+      }
+      if (typeStr.startsWith("buff")) {
+        return { buff: { length: 32 } };
+      }
+      return "uint128";
+  }
+}
+function parseApiResponse(apiResponse) {
+  try {
+    const functions = [];
+    if (apiResponse.functions) {
+      for (const func of apiResponse.functions) {
+        const access = func.access === "read_only" ? "read-only" : func.access;
+        functions.push({
+          name: func.name,
+          access,
+          args: func.args.map((arg) => ({
+            name: arg.name,
+            type: convertApiType(arg.type)
+          })),
+          outputs: convertApiType(func.outputs.type)
+        });
+      }
+    }
+    return { functions };
+  } catch (error) {
+    throw new Error(`Failed to parse API response: ${error}`);
+  }
+}
+function convertApiType(apiType) {
+  if (typeof apiType === "string") {
+    if (apiType === "trait_reference") {
+      return "trait_reference";
+    }
+    return parseType(apiType) || "uint128";
+  }
+  if (apiType.response) {
+    return {
+      response: {
+        ok: convertApiType(apiType.response.ok),
+        error: convertApiType(apiType.response.error)
+      }
+    };
+  }
+  if (apiType.optional) {
+    return {
+      optional: convertApiType(apiType.optional)
+    };
+  }
+  if (apiType.list) {
+    return {
+      list: {
+        type: convertApiType(apiType.list.type),
+        length: apiType.list.length || 100
+      }
+    };
+  }
+  if (apiType.tuple) {
+    return {
+      tuple: apiType.tuple.map((field) => ({
+        name: field.name,
+        type: convertApiType(field.type)
+      }))
+    };
+  }
+  if (apiType.buffer) {
+    return {
+      buff: {
+        length: apiType.buffer.length || 32
+      }
+    };
+  }
+  if (apiType["string-ascii"]) {
+    return {
+      "string-ascii": {
+        length: apiType["string-ascii"].length || 256
+      }
+    };
+  }
+  if (apiType["string-utf8"]) {
+    return {
+      "string-utf8": {
+        length: apiType["string-utf8"].length || 256
+      }
+    };
+  }
+  if (apiType === "none") {
+    return "uint128";
+  }
+  return "uint128";
+}
+
+// src/plugins/hiro/index.ts
+var hiro = (options) => {
+  if (!options?.apiKey) {
+    throw new Error(
+      "Hiro plugin requires an API key. Get one for free at https://platform.hiro.so/"
+    );
+  }
+  if (!options.network) {
+    throw new Error("Hiro plugin requires a network ('mainnet' or 'testnet')");
+  }
+  if (!options.contracts || options.contracts.length === 0) {
+    throw new Error(
+      "Hiro plugin requires a contracts array with contract IDs to fetch"
+    );
+  }
+  return {
+    name: "@stacks/codegen/plugin-hiro",
+    version: "1.0.0",
+    async transformConfig(config) {
+      if (options.debug) {
+        console.log(
+          `\u{1F504} Hiro plugin: Fetching ABIs for ${options.contracts.length} contracts from ${options.network}`
+        );
+      }
+      const apiClient = new StacksApiClient(options.network, options.apiKey);
+      const fetchedContracts = [];
+      for (const contractId of options.contracts) {
+        const result = await fetchContractABI(
+          contractId,
+          apiClient,
+          options.debug
+        );
+        if (result.success && result.abi) {
+          const [address, contractName] = contractId.split(".");
+          const name = contractName ? contractName.replace(/-/g, "_").replace(/^\d/, "_$&") : address.replace(/^SP|^ST/, "").toLowerCase();
+          fetchedContracts.push({
+            name,
+            address: contractId,
+            abi: result.abi,
+            metadata: {
+              source: "hiro-api",
+              network: options.network,
+              fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+          if (options.debug) {
+            console.log(
+              `\u2705 Hiro plugin: Successfully fetched ABI for ${contractId}`
+            );
+          }
+        } else {
+          if (options.debug) {
+            console.warn(
+              `\u26A0\uFE0F  Hiro plugin: Failed to fetch ${contractId}: ${result.error}`
+            );
+          }
+        }
+      }
+      if (options.debug) {
+        console.log(
+          `\u{1F50D} Hiro plugin: Successfully fetched ${fetchedContracts.length}/${options.contracts.length} contracts`
+        );
+      }
+      return {
+        ...config,
+        contracts: [...config.contracts || [], ...fetchedContracts]
+      };
+    }
+  };
+};
+async function fetchContractABI(contractId, apiClient, debug) {
+  try {
+    if (debug) {
+      console.log(`\u{1F504} Fetching ABI for ${contractId}`);
+    }
+    const contractInfo = await apiClient.getContractInfo(contractId);
+    const abi = parseApiResponse(contractInfo);
+    return {
+      success: true,
+      contractId,
+      abi
+    };
+  } catch (error) {
+    if (error.message?.includes("Contract not found") || error.response?.statusCode === 404) {
+      return {
+        success: false,
+        contractId,
+        error: `Contract not found: ${contractId}`
+      };
+    }
+    if (error.message?.includes("Rate limited") || error.response?.statusCode === 429) {
+      return {
+        success: false,
+        contractId,
+        error: `Rate limited when fetching ${contractId}. Consider using an API key.`
+      };
+    }
+    return {
+      success: false,
+      contractId,
+      error: error.message || "Unknown error"
+    };
+  }
+}
+
+// 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,
+  actions,
+  clarinet,
+  createPlugin,
+  filterByOptions,
+  hasClarinetProject,
+  hiro,
+  react
+};
+//# sourceMappingURL=index.js.map