@secondlayer/cli 0.1.0 → 0.2.0

package/dist/plugins/index.cjs

@@ -1,2622 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/plugins/index.ts
-var plugins_exports = {};
-__export(plugins_exports, {
-  PluginManager: () => PluginManager,
-  actions: () => actions,
-  clarinet: () => clarinet,
-  createPlugin: () => createPlugin,
-  filterByOptions: () => filterByOptions,
-  hasClarinetProject: () => hasClarinetProject,
-  hiro: () => hiro,
-  react: () => react
-});
-module.exports = __toCommonJS(plugins_exports);
-
-// src/core/plugin-manager.ts
-var import_prettier = require("prettier");
-var import_fs = require("fs");
-var import_path = __toESM(require("path"), 1);
-var import_transactions = require("@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 = import_path.default.resolve(process.cwd(), output.path);
-        await this.utils.ensureDir(import_path.default.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 (0, import_transactions.validateStacksAddress)(address.split(".")[0]);
-      },
-      parseContractId: (contractId) => {
-        const [address, contractName] = contractId.split(".");
-        return { address, contractName };
-      },
-      formatCode: async (code) => {
-        return (0, import_prettier.format)(code, {
-          parser: "typescript",
-          singleQuote: true,
-          semi: true,
-          printWidth: 100,
-          trailingComma: "es5"
-        });
-      },
-      resolvePath: (relativePath) => {
-        return import_path.default.resolve(process.cwd(), relativePath);
-      },
-      fileExists: async (filePath) => {
-        try {
-          await import_fs.promises.access(filePath);
-          return true;
-        } catch {
-          return false;
-        }
-      },
-      readFile: async (filePath) => {
-        return import_fs.promises.readFile(filePath, "utf-8");
-      },
-      writeFile: async (filePath, content) => {
-        await import_fs.promises.writeFile(filePath, content, "utf-8");
-      },
-      ensureDir: async (dirPath) => {
-        await import_fs.promises.mkdir(dirPath, { recursive: true });
-      }
-    };
-  }
-};
-
-// src/plugins/clarinet/index.ts
-var import_clarinet_sdk = require("@hirosystems/clarinet-sdk");
-
-// src/generators/contract.ts
-var import_prettier2 = require("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 (0, import_prettier2.format)(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 (0, import_clarinet_sdk.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
-var import_prettier3 = require("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 (0, import_prettier3.format)(code, {
-    parser: "typescript",
-    singleQuote: true,
-    semi: false,
-    printWidth: 100,
-    trailingComma: "es5"
-  });
-  return formatted;
-}
-
-// src/plugins/react/generators/generic.ts
-var import_prettier4 = require("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 (0, import_prettier4.format)(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
-var import_prettier5 = require("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 (0, import_prettier5.format)(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
-var import_got = __toESM(require("got"), 1);
-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 (0, import_got.default)(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 (0, import_got.default)(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
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PluginManager,
-  actions,
-  clarinet,
-  createPlugin,
-  filterByOptions,
-  hasClarinetProject,
-  hiro,
-  react
-});
-//# sourceMappingURL=index.cjs.map