@secondlayer/cli 14.3.1 → 15.0.0

package/dist/plugins/index.js

@@ -1,1755 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/types/plugin.ts
-function isClarinetContract(c) {
-  return "_clarinetSource" in c && c._clarinetSource === true;
-}
-function isDirectFileContract(c) {
-  return "_directFile" in c && c._directFile === true;
-}
-
-// src/utils/contract-id.ts
-function parseContractId(contractId) {
-  const dotIndex = contractId.indexOf(".");
-  if (dotIndex === -1) {
-    throw new Error(`Invalid contract ID: "${contractId}" (expected "address.contractName")`);
-  }
-  return {
-    address: contractId.slice(0, dotIndex),
-    contractName: contractId.slice(dotIndex + 1)
-  };
-}
-
-// src/utils/format.ts
-var exports_format = {};
-__export(exports_format, {
-  formatCode: () => formatCode
-});
-import { Biome, Distribution } from "@biomejs/js-api";
-async function getBiome() {
-  if (!biome) {
-    biome = await Biome.create({
-      distribution: Distribution.NODE
-    });
-    biome.applyConfiguration({
-      formatter: {
-        enabled: true,
-        indentStyle: "tab",
-        lineWidth: 80
-      },
-      javascript: {
-        formatter: {
-          semicolons: "always",
-          quoteStyle: "single"
-        }
-      },
-      organizeImports: {
-        enabled: true
-      },
-      linter: {
-        enabled: true
-      },
-      assists: {
-        enabled: true
-      }
-    });
-  }
-  return biome;
-}
-async function formatCode(code) {
-  const b = await getBiome();
-  const linted = b.lintContent(code, {
-    filePath: "generated.ts",
-    fixFileMode: "SafeFixes"
-  });
-  const formatted = b.formatContent(linted.content, {
-    filePath: "generated.ts"
-  });
-  return formatted.content;
-}
-var biome = null;
-var init_format = () => {};
-
-// src/core/plugin-manager.ts
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { isValidAddress as _validateStacksAddress } from "@secondlayer/stacks";
-import { getErrorMessage } from "@secondlayer/shared";
-import { toCamelCase } from "@secondlayer/stacks/clarity";
-
-class PluginManager {
-  plugins = [];
-  logger;
-  utils;
-  executionContext;
-  constructor() {
-    this.logger = this.createLogger();
-    this.utils = this.createUtils();
-    this.executionContext = {
-      phase: "config",
-      startTime: Date.now(),
-      results: new Map
-    };
-  }
-  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}`);
-  }
-  getPlugins() {
-    return [...this.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) {
-          this.recordHookResult(plugin.name, "transformConfig", {
-            success: false,
-            error: error instanceof Error ? error : new Error(getErrorMessage(error))
-          });
-          throw new Error(`Plugin "${plugin.name}" failed during config transformation: ${getErrorMessage(error)}`);
-        }
-      }
-    }
-    const resolvedConfig = {
-      ...transformedConfig,
-      plugins: this.plugins
-    };
-    return resolvedConfig;
-  }
-  async transformContracts(contracts, _config) {
-    const processedContracts = [];
-    for (let contract of contracts) {
-      if (isClarinetContract(contract) && contract.abi) {
-        processedContracts.push(this.contractToProcessed(contract, "clarinet"));
-        continue;
-      }
-      if (isDirectFileContract(contract) && contract.abi) {
-        processedContracts.push(this.contractToProcessed(contract, "direct"));
-        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) {
-            this.recordHookResult(plugin.name, "transformContract", {
-              success: false,
-              error: error instanceof Error ? error : new Error(getErrorMessage(error))
-            });
-            this.logger.warn(`Plugin "${plugin.name}" failed to transform contract: ${getErrorMessage(error)}`);
-          }
-        }
-      }
-      if (contract.abi) {
-        processedContracts.push(this.contractToProcessed(contract, "api"));
-      }
-    }
-    return processedContracts;
-  }
-  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) {
-          this.recordHookResult(plugin.name, hookName, {
-            success: false,
-            error: error instanceof Error ? error : new Error(getErrorMessage(error))
-          });
-          this.logger.error(`Plugin "${plugin.name}" failed during ${hookName}: ${getErrorMessage(error)}`);
-        }
-      }
-    }
-  }
-  async executeGeneration(contracts, config) {
-    this.executionContext.phase = "generate";
-    const outputs = 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;
-  }
-  async transformOutputs(outputs) {
-    this.executionContext.phase = "output";
-    const transformedOutputs = new Map;
-    for (const [key, output] of outputs) {
-      let transformedContent = output.content;
-      for (const plugin of this.plugins) {
-        if (plugin.transformOutput) {
-          this.executionContext.currentPlugin = plugin;
-          try {
-            transformedContent = await plugin.transformOutput(transformedContent, output.type || "other");
-            this.recordHookResult(plugin.name, "transformOutput", {
-              success: true
-            });
-          } catch (error) {
-            this.recordHookResult(plugin.name, "transformOutput", {
-              success: false,
-              error: error instanceof Error ? error : new Error(getErrorMessage(error))
-            });
-            this.logger.warn(`Plugin "${plugin.name}" failed to transform output: ${getErrorMessage(error)}`);
-          }
-        }
-      }
-      transformedOutputs.set(key, {
-        ...output,
-        content: transformedContent
-      });
-    }
-    return transformedOutputs;
-  }
-  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) {
-        this.logger.error(`Failed to write ${output.path}: ${getErrorMessage(error)}`);
-        throw error;
-      }
-    }
-  }
-  getExecutionResults() {
-    return new Map(this.executionContext.results);
-  }
-  contractToProcessed(contract, source) {
-    const address = typeof contract.address === "string" ? contract.address : "";
-    const parsed = parseContractId(address);
-    return {
-      name: contract.name || parsed.contractName || "unknown",
-      address: parsed.address || "unknown",
-      contractName: parsed.contractName || contract.name || "unknown",
-      abi: contract.abi,
-      source: source === "api" ? "api" : "local",
-      metadata: contract.metadata ?? { source }
-    };
-  }
-  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
-    });
-  }
-  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);
-  }
-  createLogger() {
-    return {
-      info: (message) => console.log(`ℹ️  ${message}`),
-      warn: (message) => console.warn(`⚠️  ${message}`),
-      error: (message) => console.error(`❌ ${message}`),
-      debug: (message) => {
-        if (process.env.DEBUG) {
-          console.log(`\uD83D\uDC1B ${message}`);
-        }
-      },
-      success: (message) => console.log(`✅ ${message}`)
-    };
-  }
-  createUtils() {
-    return {
-      toCamelCase,
-      toKebabCase: (str) => {
-        return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-      },
-      validateAddress: (address) => {
-        return validateStacksAddress(parseContractId(address).address);
-      },
-      parseContractId: (contractId) => {
-        return parseContractId(contractId);
-      },
-      formatCode: async (code) => {
-        const { formatCode: formatCode2 } = await Promise.resolve().then(() => (init_format(), exports_format));
-        return formatCode2(code);
-      },
-      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 });
-      }
-    };
-  }
-}
-var validateStacksAddress;
-var init_plugin_manager = __esm(() => {
-  validateStacksAddress = _validateStacksAddress;
-});
-
-// src/generators/contract.ts
-import {
-  generateContractInterface as buildContractInterface
-} from "@secondlayer/scaffold";
-async function generateContractInterface(contracts) {
-  return formatCode(buildContractInterface(contracts));
-}
-var init_contract = __esm(() => {
-  init_format();
-});
-
-// src/utils/case-conversion.ts
-import { toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-function toPascalCase(str) {
-  return capitalize(toCamelCase3(str));
-}
-var init_case_conversion = () => {};
-
-// src/plugins/index.ts
-init_plugin_manager();
-
-// src/plugins/clarinet/index.ts
-init_contract();
-import { toCamelCase as toCamelCase2 } from "@secondlayer/stacks/clarity";
-import { normalizeAbi } from "@secondlayer/stacks/clarity";
-import { initSimnet } from "@stacks/clarinet-sdk";
-
-// src/utils/constants.ts
-var DEFAULT_SENDER_ADDRESS = "SP000000000000000000002Q6VF78";
-// src/plugins/shared.ts
-function matchesContractFilters(name, options) {
-  if (options.include && !options.include.includes(name)) {
-    return false;
-  }
-  if (options.exclude?.includes(name)) {
-    return false;
-  }
-  return true;
-}
-
-// src/plugins/clarinet/index.ts
-function sanitizeContractName(name) {
-  return toCamelCase2(name);
-}
-async function readManifestInfo(manifestPath) {
-  try {
-    const { promises: fs2 } = await import("node:fs");
-    const tomlContent = await fs2.readFile(manifestPath, "utf-8");
-    const projectContracts = new Set;
-    const contractSectionRegex = /^\[contracts\.([^\]]+)\]/gm;
-    let match = contractSectionRegex.exec(tomlContent);
-    while (match !== null) {
-      projectContracts.add(match[1]);
-      match = contractSectionRegex.exec(tomlContent);
-    }
-    const requirementIds = new Set;
-    const requirementRegex = /contract_id\s*=\s*["']([^"']+)["']/g;
-    match = requirementRegex.exec(tomlContent);
-    while (match !== null) {
-      requirementIds.add(match[1]);
-      match = requirementRegex.exec(tomlContent);
-    }
-    return { projectContracts, requirementIds };
-  } catch {
-    return null;
-  }
-}
-function classifyContract(contractId, manifest) {
-  const { address, contractName } = parseContractId(contractId);
-  if (manifest) {
-    if (manifest.projectContracts.has(contractName))
-      return "project";
-    if (manifest.requirementIds.has(contractId))
-      return "requirement";
-    return "system";
-  }
-  const systemContractPatterns = [
-    /^pox-\d+$/,
-    /^bns$/,
-    /^costs-\d+$/,
-    /^lockup$/,
-    /^signer-manager$/
-  ];
-  if (systemContractPatterns.some((pattern) => pattern.test(contractName))) {
-    return "system";
-  }
-  const systemAddresses = [
-    DEFAULT_SENDER_ADDRESS,
-    "ST000000000000000000002AMW42H"
-  ];
-  if (systemAddresses.includes(address)) {
-    return "system";
-  }
-  return "project";
-}
-var clarinet = (options = {}) => {
-  const manifestPath = options.path || "./Clarinet.toml";
-  let simnet;
-  return {
-    name: "@secondlayer/cli/plugin-clarinet",
-    version: "1.0.0",
-    async transformConfig(config) {
-      try {
-        simnet = await initSimnet(manifestPath);
-        const contractInterfaces = simnet.getContractsInterfaces();
-        const contracts = [];
-        const manifest = await readManifestInfo(manifestPath);
-        const includeRequirements = options.includeRequirements ?? true;
-        for (const [contractId, abi] of contractInterfaces) {
-          const { contractName } = parseContractId(contractId);
-          const kind = classifyContract(contractId, manifest);
-          if (kind === "system" || kind === "requirement" && !includeRequirements) {
-            if (options.debug) {
-              console.log(`\uD83D\uDEAB Skipping ${kind} contract: ${contractId}`);
-            }
-            continue;
-          }
-          if (!matchesContractFilters(contractName, options)) {
-            continue;
-          }
-          const sanitizedName = sanitizeContractName(contractName);
-          contracts.push({
-            name: sanitizedName,
-            address: contractId,
-            abi: normalizeAbi(abi),
-            _clarinetSource: true
-          });
-        }
-        if (options.debug) {
-          console.log(`\uD83D\uDD0D Clarinet plugin found ${contracts.length} user-defined contracts`);
-        }
-        return {
-          ...config,
-          contracts: [...config.contracts || [], ...contracts]
-        };
-      } catch (error) {
-        const err = error;
-        if (await hasClarinetProject(manifestPath)) {
-          console.warn(`⚠️  Clarinet plugin: found ${manifestPath} but failed to load contracts: ${err.message}`);
-        } else if (options.debug) {
-          console.warn(`⚠️  Clarinet plugin: no manifest at ${manifestPath}, skipping`);
-        }
-        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("node:fs");
-    await fs2.access(path2);
-    return true;
-  } catch {
-    return false;
-  }
-}
-// src/plugins/react/generators/contract.ts
-init_format();
-
-// src/plugins/react/generators/utils.ts
-init_case_conversion();
-
-// src/utils/type-mapping.ts
-import {
-  clarityTypeToTS,
-  generateArgsTypeSignature,
-  getTypeForArg
-} from "@secondlayer/scaffold";
-
-// src/plugins/react/generators/utils.ts
-function generateHookArgsSignature(args) {
-  if (args.length === 0)
-    return "";
-  const argsList = args.map((arg) => `${toCamelCase3(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
-  return `${argsList}`;
-}
-function generateArgsType(args) {
-  if (args.length === 0)
-    return "void";
-  const argsList = args.map((arg) => `${toCamelCase3(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
-  return `{ ${argsList} }`;
-}
-function generateArgNames(args) {
-  if (args.length === 0)
-    return "";
-  return args.map((arg) => toCamelCase3(arg.name)).join(", ");
-}
-function generateEnabledCondition(args) {
-  return args.map((arg) => {
-    const camelName = toCamelCase3(arg.name);
-    const type = clarityTypeToTS(arg.type);
-    if (type === "string")
-      return `!!${camelName}`;
-    if (type === "bigint")
-      return `${camelName} !== undefined`;
-    return `${camelName} !== undefined`;
-  }).join(" && ");
-}
-function generateObjectArgs(args) {
-  if (args.length === 0)
-    return "";
-  return args.map((arg) => `${arg.name}: ${toCamelCase3(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 { useSecondLayerConfig } from './provider'
-import { request } from '@secondlayer/stacks/connect'
-import type { PostCondition } from '@secondlayer/stacks/postconditions'
-import { ${contracts.map((c) => c.name).join(", ")} } from './contracts'
-
-const API_URLS: Record<string, string> = {
-  mainnet: 'https://api.hiro.so',
-  testnet: 'https://api.testnet.hiro.so',
-  devnet: 'http://localhost:3999'
-}
-
-async function readContractCall(params: {
-  contractAddress: string;
-  contractName: string;
-  functionName: string;
-  functionArgs: any[];
-  outputType: any;
-  senderAddress: string;
-  network?: string;
-  apiUrl?: string;
-}): Promise<any> {
-  const { serializeCV, deserializeCV, clarityValueToJS } = await import('@secondlayer/stacks/clarity')
-  // Untyped call: outputType is a runtime ABI value; relating the generic
-  // signature (even via a direct cast) explodes into deep instantiation on
-  // the AbiType union, so route the cast through unknown.
-  const toJS = clarityValueToJS as unknown as (type: any, cv: any) => any
-  const baseUrl = params.apiUrl || API_URLS[params.network || 'mainnet']
-  const response = await fetch(
-    \`\${baseUrl}/v2/contracts/call-read/\${params.contractAddress}/\${params.contractName}/\${params.functionName}\`,
-    {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        sender: params.senderAddress,
-        arguments: params.functionArgs.map((arg: any) => \`0x\${serializeCV(arg)}\`)
-      })
-    }
-  )
-  if (!response.ok) throw new Error(\`Read-only call failed: \${response.statusText}\`)
-  const data = await response.json()
-  if (!data.okay) throw new Error(data.cause ?? 'Read-only call failed')
-  return toJS(params.outputType, deserializeCV(data.result))
-}`;
-  const header = `/**
- * Generated contract-specific React hooks
- * DO NOT EDIT MANUALLY
- */`;
-  const hooksCode = contracts.map((contract) => generateContractHookMethods(contract, excludeList)).filter(Boolean).join(`
-
-`);
-  const code = `${imports}
-
-${header}
-
-${hooksCode}`;
-  return formatCode(code);
-}
-function generateContractHookMethods(contract, excludeList) {
-  const { abi, name, address, contractName } = contract;
-  const functions = abi.functions || [];
-  const maps = abi.maps || [];
-  const variables = abi.variables || [];
-  const readOnlyFunctions = functions.filter((f) => f.access === "read-only");
-  const publicFunctions = functions.filter((f) => f.access === "public");
-  const readHooks = readOnlyFunctions.map((func) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(func.name))}`;
-    if (excludeList.includes(hookName)) {
-      return null;
-    }
-    return generateReadHook(func, name);
-  }).filter(Boolean);
-  const writeHooks = publicFunctions.map((func) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(func.name))}`;
-    if (excludeList.includes(hookName)) {
-      return null;
-    }
-    return generateWriteHook(func, name);
-  }).filter(Boolean);
-  const mapHooks = maps.map((map) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(map.name))}`;
-    if (excludeList.includes(hookName)) {
-      return null;
-    }
-    return generateMapHook(map, name, address, contractName);
-  }).filter(Boolean);
-  const dataVars = variables.filter((v) => v.access === "variable");
-  const varHooks = dataVars.map((variable) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(variable.name))}`;
-    if (excludeList.includes(hookName)) {
-      return null;
-    }
-    return generateVarHook(variable, name, address, contractName);
-  }).filter(Boolean);
-  const constants = variables.filter((v) => v.access === "constant");
-  const constantHooks = constants.map((constant) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(constant.name))}`;
-    if (excludeList.includes(hookName)) {
-      return null;
-    }
-    return generateConstantHook(constant, name, address, contractName);
-  }).filter(Boolean);
-  const allHooks = [
-    ...readHooks,
-    ...writeHooks,
-    ...mapHooks,
-    ...varHooks,
-    ...constantHooks
-  ];
-  if (allHooks.length === 0) {
-    return "";
-  }
-  return allHooks.join(`
-
-`);
-}
-function generateReadHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase3(func.name))}`;
-  const argsSignature = generateHookArgsSignature(func.args);
-  const enabledParam = func.args.length > 0 ? ", options?: { enabled?: boolean }" : "options?: { enabled?: boolean }";
-  const returnType = clarityTypeToTS(func.outputs);
-  const callArgs = func.args.length > 0 ? `{ ${generateObjectArgs(func.args)} }` : "";
-  return `export function ${hookName}(${argsSignature}${enabledParam}) {
-  const config = useSecondLayerConfig()
-
-  return useQuery<${returnType}>({
-    queryKey: ['${func.name}', ${contractName}.address, ${generateArgNames(func.args)}],
-    queryFn: async () => {
-      const call = ${contractName}.${toCamelCase3(func.name)}(${callArgs})
-      return await readContractCall({
-        ...call,
-        outputType: ${JSON.stringify(func.outputs)},
-        network: config.network,
-        apiUrl: config.apiUrl,
-        senderAddress: config.senderAddress || '${DEFAULT_SENDER_ADDRESS}'
-      }) as ${returnType}
-    },
-    ${func.args.length > 0 ? `enabled: ${generateEnabledCondition(func.args)} && (options?.enabled ?? true),` : ""}
-    ...options
-  })
-}`;
-}
-function generateWriteHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase3(func.name))}`;
-  const argsType = generateArgsType(func.args);
-  return `export function ${hookName}() {
-  const config = useSecondLayerConfig()
-  const queryClient = useQueryClient()
-  
-  const mutation = useMutation({
-    mutationFn: async (params: {
-      args: ${argsType};
-      options?: {
-        postConditions?: PostCondition[];
-        attachment?: string;
-        onFinish?: (data: any) => void;
-        onCancel?: () => void;
-      };
-    }) => {
-      const { args, options = {} } = params
-      const contractCallData = ${contractName}.${toCamelCase3(func.name)}(args)
-      const { contractAddress, contractName: name, functionName, functionArgs } = contractCallData
-      const network = config.network || 'mainnet'
-      const contract = \`\${contractAddress}.\${name}\`
-
-      const result = await request('stx_callContract', {
-        contract,
-        functionName,
-        functionArgs,
-        network,
-        ...options
-      })
-
-      options.onFinish?.(result)
-      return result
-    },
-    onSuccess: () => {
-      // Invalidate relevant queries on success
-      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
-    },
-    onError: (error) => {
-      console.error('Contract call failed:', error)
-    }
-  })
-
-  const ${toCamelCase3(func.name)} = useCallback(async (
-    args: ${argsType},
-    options?: {
-      postConditions?: PostCondition[];
-      attachment?: string;
-      onFinish?: (data: any) => void;
-      onCancel?: () => void;
-    }
-  ) => {
-    return mutation.mutateAsync({ args, options })
-  }, [mutation])
-
-  return {
-    ${toCamelCase3(func.name)},
-    // Expose mutation state
-    isPending: mutation.isPending,
-    isError: mutation.isError,
-    isSuccess: mutation.isSuccess,
-    error: mutation.error,
-    data: mutation.data,
-    reset: mutation.reset
-  }
-}`;
-}
-function generateMapHook(map, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase3(map.name))}`;
-  const keyType = clarityTypeToTS(map.key);
-  const valueType = clarityTypeToTS(map.value);
-  return `export function ${hookName}(key: ${keyType}, options?: { enabled?: boolean }) {
-  const config = useSecondLayerConfig()
-
-  return useQuery<${valueType} | null>({
-    queryKey: ['${contractVarName}', '${map.name}', 'map', key, config.network],
-    queryFn: async () => {
-      return ${contractVarName}.maps.${toCamelCase3(map.name)}.get(key, { network: config.network })
-    },
-    enabled: options?.enabled ?? true
-  })
-}`;
-}
-function generateVarHook(variable, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase3(variable.name))}`;
-  const valueType = clarityTypeToTS(variable.type);
-  return `export function ${hookName}(options?: { enabled?: boolean }) {
-  const config = useSecondLayerConfig()
-
-  return useQuery<${valueType}>({
-    queryKey: ['${contractVarName}', '${variable.name}', 'var', config.network],
-    queryFn: async () => {
-      return ${contractVarName}.vars.${toCamelCase3(variable.name)}.get({ network: config.network })
-    },
-    enabled: options?.enabled ?? true
-  })
-}`;
-}
-function generateConstantHook(constant, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase3(constant.name))}`;
-  const valueType = clarityTypeToTS(constant.type);
-  return `export function ${hookName}(options?: { enabled?: boolean }) {
-  const config = useSecondLayerConfig()
-
-  return useQuery<${valueType}>({
-    queryKey: ['${contractVarName}', '${constant.name}', 'constant', config.network],
-    queryFn: async () => {
-      return ${contractVarName}.constants.${toCamelCase3(constant.name)}.get({ network: config.network })
-    },
-    enabled: options?.enabled ?? true,
-    staleTime: Infinity // Constants never change
-  })
-}`;
-}
-
-// src/generators/templates/use-contract.ts
-var USE_CONTRACT_TEMPLATE = `export function useContract() {
-  const config = useSecondLayerConfig()
-  const queryClient = useQueryClient()
-  const [isRequestPending, setIsRequestPending] = useState(false)
-
-  // Helper function to convert JS values to Clarity values based on ABI
-  const convertArgsWithAbi = (args: any, abiArgs: any[]): any[] => {
-    if (!abiArgs || abiArgs.length === 0) return []
-
-    return abiArgs.map((abiArg, index) => {
-      const argValue = Array.isArray(args)
-        ? args[index]
-        : args[abiArg.name] || args[abiArg.name.replace(/-/g, '').replace(/_/g, '')]
-      return convertJSValueToClarityValue(argValue, abiArg.type)
-    })
-  }
-
-  // Helper function to convert buffer values with auto-detection
-  const convertBufferValue = (value: any): any => {
-    // Direct Uint8Array
-    if (value instanceof Uint8Array) {
-      return Cl.buffer(value)
-    }
-
-    // Object notation with explicit type
-    if (typeof value === 'object' && value !== null && value.type && value.value) {
-      switch (value.type) {
-        case 'ascii':
-          return Cl.bufferFromAscii(value.value)
-        case 'utf8':
-          return Cl.bufferFromUtf8(value.value)
-        case 'hex':
-          return Cl.bufferFromHex(value.value)
-        default:
-          throw new Error(\`Unsupported buffer type: \${value.type}\`)
-      }
-    }
-
-    // Auto-detect string type
-    if (typeof value === 'string') {
-      // 1. Check for hex (0x prefix or pure hex pattern)
-      if (value.startsWith('0x') || /^[0-9a-fA-F]+$/.test(value)) {
-        return Cl.bufferFromHex(value)
-      }
-
-      // 2. Check for non-ASCII characters (UTF-8)
-      if (!/^[\\x00-\\x7F]*$/.test(value)) {
-        return Cl.bufferFromUtf8(value)
-      }
-
-      // 3. Default to ASCII for simple ASCII strings
-      return Cl.bufferFromAscii(value)
-    }
-
-    throw new Error(\`Invalid buffer value: \${value}\`)
-  }
-
-  // Helper function to convert a single JS value to ClarityValue
-  const convertJSValueToClarityValue = (value: any, type: any): any => {
-    if (typeof type === 'string') {
-      switch (type) {
-        case 'uint128':
-          return Cl.uint(value)
-        case 'int128':
-          return Cl.int(value)
-        case 'bool':
-          return Cl.bool(value)
-        case 'principal':
-          if (!validateStacksAddress(value.split('.')[0])) {
-            throw new Error('Invalid Stacks address format')
-          }
-          if (value.includes('.')) {
-            const [address, contractName] = value.split('.')
-            return Cl.contractPrincipal(address, contractName)
-          } else {
-            return Cl.standardPrincipal(value)
-          }
-        default:
-          return value
-      }
-    }
-
-    if (type['string-ascii']) {
-      return Cl.stringAscii(value)
-    }
-
-    if (type['string-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 - pre-converted Clarity values
-  const legacyOpenContractCall = useCallback(async (params: {
-    contractAddress: string;
-    contractName: string;
-    functionName: string;
-    functionArgs: any[];
-    network?: string;
-    postConditions?: PostCondition[];
-    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}\`
-
-      const result = await request('stx_callContract', {
-        contract,
-        functionName,
-        functionArgs,
-        network,
-        ...options
-      })
-
-      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
-      onFinish?.(result)
-      return result
-    } catch (error) {
-      console.error('Contract call failed:', error)
-      throw error instanceof Error ? error : new Error('Contract call failed')
-    } finally {
-      setIsRequestPending(false)
-    }
-  }, [config.network, queryClient])
-
-  // Enhanced function - requires ABI, auto-converts JS values
-  const openContractCall = useCallback(async <
-    T extends AbiContract,
-    FN extends ExtractFunctionNames<T>
-  >(params: {
-    contractAddress: string;
-    contractName: string;
-    functionName: FN;
-    abi: T;
-    functionArgs: ExtractFunctionArgs<T, FN>;
-    network?: string;
-    postConditions?: PostCondition[];
-    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}\`
-
-      const abiFunction = findFunctionInAbi(abi, functionName)
-      if (!abiFunction) {
-        throw new Error(\`Function '\${functionName}' not found in ABI\`)
-      }
-
-      const processedArgs = convertArgsWithAbi(functionArgs, abiFunction.args || [])
-
-      const result = await request('stx_callContract', {
-        contract,
-        functionName,
-        functionArgs: processedArgs,
-        network,
-        ...options
-      })
-
-      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
-      onFinish?.(result)
-      return result
-    } catch (error) {
-      console.error('Contract call failed:', error)
-      throw error instanceof Error ? error : new Error('Contract call failed')
-    } finally {
-      setIsRequestPending(false)
-    }
-  }, [config.network, queryClient])
-
-  return {
-    legacyOpenContractCall,
-    openContractCall,
-    isRequestPending
-  }
-}`;
-
-// src/plugins/react/generators/generic.ts
-init_format();
-var GENERIC_HOOKS = [
-  "useAccount",
-  "useConnect",
-  "useDisconnect",
-  "useNetwork",
-  "useContract",
-  "useOpenSTXTransfer",
-  "useSignMessage",
-  "useDeployContract",
-  "useReadContract",
-  "useTransaction",
-  "useBlock",
-  "useAccountTransactions",
-  "useWaitForTransaction"
-];
-async function generateGenericHooks(excludeList = []) {
-  const hooksToGenerate = GENERIC_HOOKS.filter((hookName) => !excludeList.includes(hookName));
-  const imports = `import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { useState, useCallback } from 'react'
-import { useSecondLayerConfig } from './provider'
-import { connect, disconnect, isConnected, request } from '@secondlayer/stacks/connect'
-import { Cl } from '@secondlayer/stacks/clarity'
-import type { ExtractFunctionArgs, ExtractFunctionNames, AbiContract } from '@secondlayer/stacks/clarity'
-import type { PostCondition } from '@secondlayer/stacks/postconditions'
-import { validateStacksAddress } from '@secondlayer/stacks/utils'
-import { createPublicClient, http } from '@secondlayer/stacks'
-import { getTransaction, waitForTransactionReceipt } from '@secondlayer/stacks/actions'
-
-const API_URLS: Record<string, string> = {
-  mainnet: 'https://api.hiro.so',
-  testnet: 'https://api.testnet.hiro.so',
-  devnet: 'http://localhost:3999'
-}
-
-function getStacksClient({ network, apiUrl }: { network?: string; apiUrl?: string }) {
-  return createPublicClient({ transport: http(apiUrl || API_URLS[network || 'mainnet']) })
-}
-
-async function callReadOnly(params: {
-  contractAddress: string;
-  contractName: string;
-  functionName: string;
-  functionArgs: any[];
-  senderAddress: string;
-  network?: string;
-  apiUrl?: string;
-}): Promise<any> {
-  const { serializeCV, deserializeCV } = await import('@secondlayer/stacks/clarity')
-  const baseUrl = params.apiUrl || API_URLS[params.network || 'mainnet']
-  const response = await fetch(
-    \`\${baseUrl}/v2/contracts/call-read/\${params.contractAddress}/\${params.contractName}/\${params.functionName}\`,
-    {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        sender: params.senderAddress,
-        arguments: params.functionArgs.map((arg: any) => \`0x\${serializeCV(arg)}\`)
-      })
-    }
-  )
-  if (!response.ok) throw new Error(\`Read-only call failed: \${response.statusText}\`)
-  const data = await response.json()
-  if (!data.okay) throw new Error(data.cause ?? 'Read-only call failed')
-  return deserializeCV(data.result)
-}
-
-async function fetchBlock({ height, network, apiUrl }: { height: number; network?: string; apiUrl?: string }): Promise<any> {
-  const baseUrl = apiUrl || API_URLS[network || 'mainnet']
-  const response = await fetch(\`\${baseUrl}/extended/v1/block/by_height/\${height}\`)
-  if (!response.ok) throw new Error(\`Failed to fetch block: \${response.statusText}\`)
-  return response.json()
-}
-
-async function fetchAccountTransactions({ address, network, apiUrl }: { address: string; network?: string; apiUrl?: string }): Promise<any> {
-  const baseUrl = apiUrl || API_URLS[network || 'mainnet']
-  const response = await fetch(\`\${baseUrl}/extended/v1/address/\${address}/transactions\`)
-  if (!response.ok) throw new Error(\`Failed to fetch transactions: \${response.statusText}\`)
-  return response.json()
-}`;
-  const header = `/**
- * Generated generic Stacks React hooks
- * DO NOT EDIT MANUALLY
- */`;
-  const hooksCode = hooksToGenerate.map((hookName) => generateGenericHook(hookName)).filter(Boolean).join(`
-
-`);
-  const code = `${imports}
-
-${header}
-
-${hooksCode}`;
-  return formatCode(code);
-}
-function generateGenericHook(hookName) {
-  switch (hookName) {
-    case "useAccount":
-      return `export function useAccount() {
-  const config = useSecondLayerConfig()
-  
-  return useQuery({
-    queryKey: ['stacks-account', config.network],
-    queryFn: async () => {
-      try {
-        // Check if already connected
-        const connected = isConnected()
-        
-        if (!connected) {
-          return {
-            address: undefined,
-            addresses: undefined,
-            isConnected: false,
-            isConnecting: false,
-            isDisconnected: true,
-            status: 'disconnected' as const
-          }
-        }
-
-        // Get addresses via SIP-030
-        const result = await request('stx_getAddresses')
-        
-        if (!result || !result.addresses || result.addresses.length === 0) {
-          return {
-            address: undefined,
-            addresses: undefined,
-            isConnected: false,
-            isConnecting: false,
-            isDisconnected: true,
-            status: 'disconnected' as const
-          }
-        }
-
-        // Extract STX addresses from the response
-        const stxAddresses = result.addresses
-          .filter((addr: any) => addr.address.startsWith('SP') || addr.address.startsWith('ST'))
-          .map((addr: any) => addr.address)
-
-        return {
-          address: stxAddresses[0] || undefined,
-          addresses: stxAddresses,
-          isConnected: true,
-          isConnecting: false,
-          isDisconnected: false,
-          status: 'connected' as const
-        }
-      } catch (error) {
-        // Handle case where wallet is not available or user rejected
-        return {
-          address: undefined,
-          addresses: undefined,
-          isConnected: false,
-          isConnecting: false,
-          isDisconnected: true,
-          status: 'disconnected' as const
-        }
-      }
-    },
-    refetchOnWindowFocus: false,
-    retry: false,
-    staleTime: 1000 * 60 * 5, // 5 minutes
-    refetchInterval: 1000 * 30, // Refetch every 30 seconds to detect wallet changes
-  })
-}`;
-    case "useConnect":
-      return `export function useConnect() {
-  const queryClient = useQueryClient()
-  
-  const mutation = useMutation({
-    mutationFn: async () => {
-      // SIP-030 connect
-      return await connect()
-    },
-    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: () => {
-      return mutation.mutate(undefined)
-    },
-    connectAsync: async () => {
-      return mutation.mutateAsync(undefined)
-    },
-    // Expose all the mutation state
-    isPending: mutation.isPending,
-    isError: mutation.isError,
-    isSuccess: mutation.isSuccess,
-    error: mutation.error,
-    data: mutation.data,
-    reset: mutation.reset,
-    // Keep the original mutate/mutateAsync for advanced users
-    mutate: mutation.mutate,
-    mutateAsync: mutation.mutateAsync
-  }
-}`;
-    case "useDisconnect":
-      return `export function useDisconnect() {
-  const queryClient = useQueryClient()
-  
-  const mutation = useMutation({
-    mutationFn: async () => {
-      // SIP-030 disconnect
-      return await disconnect()
-    },
-    onSuccess: () => {
-      // Clear all cached data on disconnect
-      queryClient.clear()
-    },
-    onError: (error) => {
-      console.error('Disconnect failed:', error)
-    }
-  })
-
-  return {
-    // Custom disconnect function
-    disconnect: () => {
-      return mutation.mutate()
-    },
-    disconnectAsync: async () => {
-      return mutation.mutateAsync()
-    },
-    // Expose all the mutation state
-    isPending: mutation.isPending,
-    isError: mutation.isError,
-    isSuccess: mutation.isSuccess,
-    error: mutation.error,
-    data: mutation.data,
-    reset: mutation.reset,
-    // Keep the original mutate/mutateAsync for advanced users
-    mutate: mutation.mutate,
-    mutateAsync: mutation.mutateAsync
-  }
-}`;
-    case "useNetwork":
-      return `export function useNetwork() {
-  const config = useSecondLayerConfig()
-  
-  return useQuery({
-    queryKey: ['stacks-network', config.network],
-    queryFn: async () => {
-      // Currently read-only from config
-      // Future: Use request('stx_getNetworks') when wallet support improves
-      const network = config.network
-      
-      return {
-        network,
-        isMainnet: network === 'mainnet',
-        isTestnet: network === 'testnet', 
-        isDevnet: network === 'devnet',
-        // Future: Add switchNetwork when wallets support stx_networkChange
-        // switchNetwork: async (newNetwork: string) => {
-        //   return await request('wallet_changeNetwork', { network: newNetwork })
-        // }
-      }
-    },
-    staleTime: Infinity, // Network config rarely changes
-    refetchOnWindowFocus: false,
-    retry: false
-  })
-}`;
-    case "useContract":
-      return USE_CONTRACT_TEMPLATE;
-    case "useReadContract":
-      return `export function useReadContract<TArgs = any, TResult = any>(params: {
-  contractAddress: string;
-  contractName: string;
-  functionName: string;
-  args?: TArgs;
-  network?: 'mainnet' | 'testnet' | 'devnet';
-  enabled?: boolean;
-}) {
-  const config = useSecondLayerConfig()
-  
-  return useQuery<TResult>({
-    queryKey: ['read-contract', params.contractAddress, params.contractName, params.functionName, params.args, params.network || config.network],
-    queryFn: async () => {
-      // Args must already be ClarityValues (build them with Cl.* or a generated
-      // contract method's descriptor). Positional array, ABI declaration order.
-      let functionArgs: any[] = []
-
-      if (params.args) {
-        if (Array.isArray(params.args)) {
-          functionArgs = params.args
-        } else if (typeof params.args === 'object') {
-          functionArgs = Object.values(params.args)
-        } else {
-          functionArgs = [params.args]
-        }
-      }
-
-      return await callReadOnly({
-        contractAddress: params.contractAddress,
-        contractName: params.contractName,
-        functionName: params.functionName,
-        functionArgs,
-        network: params.network || config.network || 'mainnet',
-        apiUrl: config.apiUrl,
-        senderAddress: config.senderAddress || '${DEFAULT_SENDER_ADDRESS}'
-      }) as TResult
-    },
-    enabled: params.enabled ?? true
-  })
-}`;
-    case "useTransaction":
-      return `export function useTransaction(txId?: string) {
-  const config = useSecondLayerConfig()
-
-  return useQuery({
-    queryKey: ['transaction', txId, config.network],
-    queryFn: () => getTransaction(getStacksClient(config), { txid: txId! }),
-    enabled: !!txId
-  })
-}`;
-    case "useBlock":
-      return `export function useBlock(height?: number) {
-  const config = useSecondLayerConfig()
-  
-  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 = useSecondLayerConfig()
-  
-  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, options?: { confirmations?: number }) {
-  const config = useSecondLayerConfig()
-
-  // waitForTransactionReceipt polls internally (reorg-tolerant, typed
-  // abort/drop/timeout rejections) — no react-query refetchInterval needed.
-  return useQuery({
-    queryKey: ['wait-for-transaction', txId, config.network, options?.confirmations],
-    queryFn: () => waitForTransactionReceipt(getStacksClient(config), {
-      txid: txId!,
-      confirmations: options?.confirmations
-    }),
-    enabled: !!txId,
-    retry: false,
-    staleTime: Infinity
-  })
-}`;
-    case "useOpenSTXTransfer":
-      return `export function useOpenSTXTransfer() {
-  const config = useSecondLayerConfig()
-  const queryClient = useQueryClient()
-
-  const mutation = useMutation({
-    mutationFn: async (params: {
-      recipient: string;
-      amount: string | number;
-      memo?: string;
-      network?: string;
-    }) => {
-      const { recipient, amount, memo } = params
-      const network = params.network || config.network || 'mainnet'
-
-      return await request('stx_transferStx', {
-        recipient,
-        amount: amount.toString(),
-        memo,
-        network,
-      })
-    },
-    onSuccess: () => {
-      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;
-  }) => {
-    return mutation.mutateAsync(params)
-  }, [mutation])
-
-  return {
-    openSTXTransfer,
-    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 = useSecondLayerConfig()
-
-  const mutation = useMutation({
-    mutationFn: async (params: {
-      message: string;
-      network?: string;
-    }) => {
-      const { message } = params
-      const network = params.network || config.network || 'mainnet'
-
-      return await request('stx_signMessage', {
-        message,
-        network,
-      })
-    },
-    onError: (error) => {
-      console.error('Message signing failed:', error)
-    }
-  })
-
-  const signMessage = useCallback(async (params: {
-    message: string;
-    network?: string;
-  }) => {
-    return mutation.mutateAsync(params)
-  }, [mutation])
-
-  return {
-    signMessage,
-    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 = useSecondLayerConfig()
-  const queryClient = useQueryClient()
-
-  const mutation = useMutation({
-    mutationFn: async (params: {
-      contractName: string;
-      codeBody: string;
-      network?: string;
-    }) => {
-      const { contractName, codeBody } = params
-      const network = params.network || config.network || 'mainnet'
-
-      return await request('stx_deployContract', {
-        name: contractName,
-        clarityCode: codeBody,
-        network,
-      })
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['stacks-account'] })
-    },
-    onError: (error) => {
-      console.error('Contract deployment failed:', error)
-    }
-  })
-
-  const deployContract = useCallback(async (params: {
-    contractName: string;
-    codeBody: string;
-    network?: string;
-  }) => {
-    return mutation.mutateAsync(params)
-  }, [mutation])
-
-  return {
-    deployContract,
-    isPending: mutation.isPending,
-    isError: mutation.isError,
-    isSuccess: mutation.isSuccess,
-    error: mutation.error,
-    data: mutation.data,
-    reset: mutation.reset
-  }
-}`;
-    default:
-      return "";
-  }
-}
-
-// src/plugins/react/provider/index.ts
-init_format();
-async function generateProvider() {
-  const code = `/**
- * Generated SecondLayer React Provider
- * DO NOT EDIT MANUALLY
- */
-
-import React, { createContext, useContext } from 'react'
-
-/**
- * SecondLayer configuration interface
- */
-export interface SecondLayerReactConfig {
-  /**
-   * 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 SecondLayerProviderProps {
-  children: React.ReactNode
-  config: SecondLayerReactConfig
-}
-
-/**
- * React context for SecondLayer configuration
- */
-const SecondLayerContext = createContext<SecondLayerReactConfig | undefined>(undefined)
-SecondLayerContext.displayName = 'SecondLayerContext'
-
-/**
- * Create a SecondLayer React configuration with defaults
- */
-export function createSecondLayerConfig(config: SecondLayerReactConfig): SecondLayerReactConfig {
-  return {
-    network: config.network,
-    apiKey: config.apiKey,
-    apiUrl: config.apiUrl,
-    senderAddress: config.senderAddress || '${DEFAULT_SENDER_ADDRESS}'
-  }
-}
-
-/**
- * Provider component that makes SecondLayer configuration available to hooks
- */
-export function SecondLayerProvider({ children, config }: SecondLayerProviderProps) {
-  const resolvedConfig = createSecondLayerConfig(config)
-
-  return (
-    <SecondLayerContext.Provider value={resolvedConfig}>
-      {children}
-    </SecondLayerContext.Provider>
-  )
-}
-
-/**
- * Hook to access the SecondLayer configuration
- */
-export function useSecondLayerConfig(): SecondLayerReactConfig {
-  const context = useContext(SecondLayerContext)
-
-  if (context === undefined) {
-    throw new Error(
-      'useSecondLayerConfig must be used within a SecondLayerProvider. ' +
-      'Make sure to wrap your app with <SecondLayerProvider config={{...}}>'
-    )
-  }
-
-  return context
-}`;
-  return formatCode(code);
-}
-
-// src/plugins/react/index.ts
-var react = (options = {}) => {
-  const excludeList = options.exclude || [];
-  return {
-    name: "@secondlayer/cli/plugin-react",
-    version: "1.0.0",
-    async generate(context) {
-      if (options.debug) {
-        context.logger.debug(`React plugin generating hooks (excluding: ${excludeList.join(", ") || "none"})`);
-      }
-      const provider = await generateProvider();
-      context.addOutput("provider", {
-        path: "./src/generated/provider.tsx",
-        content: provider,
-        type: "config"
-      });
-      const genericHooks = await generateGenericHooks(excludeList);
-      context.addOutput("generic-hooks", {
-        path: "./src/generated/hooks.ts",
-        content: genericHooks,
-        type: "hooks"
-      });
-      if (context.contracts.length > 0) {
-        const contractHooks = await generateContractHooks(context.contracts, excludeList);
-        if (contractHooks.trim()) {
-          context.addOutput("contract-hooks", {
-            path: "./src/generated/contract-hooks.ts",
-            content: contractHooks,
-            type: "hooks"
-          });
-        }
-      }
-      if (options.debug) {
-        context.logger.success(`React plugin generated ${context.contracts.length} contract hook sets`);
-      }
-    }
-  };
-};
-
-// src/plugins/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 {
-  react,
-  hasClarinetProject,
-  filterByOptions,
-  createPlugin,
-  clarinet,
-  PluginManager
-};
-
-//# debugId=3858A2BEFB777D7764756E2164756E21
-//# sourceMappingURL=index.js.map