@secondlayer/cli 3.3.0 → 3.3.2

package/dist/plugins/index.js

@@ -0,0 +1,2781 @@
+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
+      }
+    });
+    biome.registerProjectFolder();
+  }
+  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 "fs";
+import path from "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/utils/clarity-conversion.ts
+import {
+  isAbiBuffer,
+  isAbiList,
+  isAbiOptional,
+  isAbiResponse,
+  isAbiStringAscii,
+  isAbiStringUtf8,
+  isAbiTuple,
+  toCamelCase as toCamelCase2
+} from "@secondlayer/stacks/clarity";
+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 | undefined];
+          if (!validateStacksAddress(address)) {
+            throw new Error("Invalid Stacks address format");
+          }
+          if (contractName !== undefined) {
+            if (!CONTRACT_NAME_REGEX.test(contractName)) {
+              throw new Error("Invalid contract name format: must start with letter and contain only letters, numbers, and hyphens");
+            }
+            return Cl.contractPrincipal(address, contractName);
+          }
+          return Cl.standardPrincipal(${argName});
+        })()`;
+      default:
+        return `${argName}`;
+    }
+  }
+  if (isAbiStringAscii(type)) {
+    return `Cl.stringAscii(${argName})`;
+  }
+  if (isAbiStringUtf8(type)) {
+    return `Cl.stringUtf8(${argName})`;
+  }
+  if (isAbiBuffer(type)) {
+    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);
+        }
+        const hasNonAscii = value.split('').some(char => char.charCodeAt(0) > 127);
+        if (hasNonAscii) {
+          return Cl.bufferFromUtf8(value);
+        }
+        return Cl.bufferFromAscii(value);
+      }
+      throw new Error(\`Invalid buffer value: \${value}\`);
+    })()`;
+  }
+  if (isAbiOptional(type)) {
+    const innerConversion = generateClarityConversion(argName, {
+      type: type.optional
+    });
+    return `${argName} !== null ? Cl.some(${innerConversion.replace(argName, `${argName}`)}) : Cl.none()`;
+  }
+  if (isAbiList(type)) {
+    const innerConversion = generateClarityConversion("item", {
+      type: type.list.type
+    });
+    const maxLength = type.list.length || 100;
+    return `(() => {
+      const listValue = ${argName};
+      if (listValue.length > ${maxLength}) {
+        throw new Error(\`List length \${listValue.length} exceeds max ${maxLength}\`);
+      }
+      return Cl.list(listValue.map(item => ${innerConversion}));
+    })()`;
+  }
+  if (isAbiTuple(type)) {
+    const requiredFields = type.tuple.map((f) => f.name);
+    const fieldNames = JSON.stringify(requiredFields);
+    const fields = type.tuple.map((field) => {
+      const camelFieldName = toCamelCase2(field.name);
+      const fieldConversion = generateClarityConversion(`tupleValue.${camelFieldName}`, { type: field.type });
+      return `"${field.name}": ${fieldConversion}`;
+    }).join(", ");
+    return `(() => {
+      const tupleValue = ${argName};
+      const requiredFields = ${fieldNames};
+      for (const fieldName of requiredFields) {
+        const camelName = fieldName.replace(/-([a-z])/g, (_: string, l: string) => l.toUpperCase());
+        if (!(fieldName in tupleValue) && !(camelName in tupleValue)) {
+          throw new Error(\`Missing tuple field: \${fieldName}\`);
+        }
+      }
+      return Cl.tuple({ ${fields} });
+    })()`;
+  }
+  if (isAbiResponse(type)) {
+    const okConversion = generateClarityConversion(`responseValue.ok`, {
+      type: type.response.ok
+    });
+    const errConversion = generateClarityConversion(`responseValue.err`, {
+      type: type.response.error
+    });
+    return `(() => {
+      const responseValue = ${argName};
+      const hasOk = 'ok' in responseValue;
+      const hasErr = 'err' in responseValue;
+      if (hasOk && !hasErr) {
+        return Cl.ok(${okConversion});
+      }
+      if (hasErr && !hasOk) {
+        return Cl.error(${errConversion});
+      }
+      throw new Error("Response must have exactly 'ok' or 'err' property");
+    })()`;
+  }
+  return `${argName}`;
+}
+var init_clarity_conversion = () => {};
+
+// src/utils/type-mapping.ts
+import {
+  isAbiBuffer as isAbiBuffer2,
+  isAbiList as isAbiList2,
+  isAbiOptional as isAbiOptional2,
+  isAbiResponse as isAbiResponse2,
+  isAbiStringAscii as isAbiStringAscii2,
+  isAbiStringUtf8 as isAbiStringUtf82,
+  isAbiTuple as isAbiTuple2,
+  toCamelCase as toCamelCase3
+} from "@secondlayer/stacks/clarity";
+function clarityTypeToTS(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: {
+        const typeStr = type;
+        if (typeStr === "none") {
+          return "null";
+        }
+        if (typeStr.includes("string") || typeStr.includes("ascii") || typeStr.includes("utf8")) {
+          return "string";
+        }
+        if (typeStr.includes("buff")) {
+          return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
+        }
+        if (typeStr.includes("uint") || typeStr.includes("int")) {
+          return "bigint";
+        }
+        return "any";
+      }
+    }
+  }
+  if (isAbiBuffer2(type)) {
+    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
+  }
+  if (isAbiStringAscii2(type) || isAbiStringUtf82(type)) {
+    return "string";
+  }
+  if (isAbiOptional2(type)) {
+    const innerType = clarityTypeToTS(type.optional);
+    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
+      return `(${innerType}) | null`;
+    }
+    return `${innerType} | null`;
+  }
+  if (isAbiList2(type)) {
+    const innerType = clarityTypeToTS(type.list.type);
+    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
+      return `(${innerType})[]`;
+    }
+    return `${innerType}[]`;
+  }
+  if (isAbiTuple2(type)) {
+    const fields = type.tuple.map((field) => `${toCamelCase3(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
+    return `{ ${fields} }`;
+  }
+  if (isAbiResponse2(type)) {
+    const okType = clarityTypeToTS(type.response.ok);
+    const errType = clarityTypeToTS(type.response.error);
+    return `{ ok: ${okType} } | { err: ${errType} }`;
+  }
+  return "any";
+}
+function getTypeForArg(arg) {
+  return clarityTypeToTS(arg.type);
+}
+var init_type_mapping = () => {};
+
+// src/utils/generator-helpers.ts
+import {
+  isAbiTuple as isAbiTuple3,
+  toCamelCase as toCamelCase4
+} from "@secondlayer/stacks/clarity";
+function generateArgsSignature(args) {
+  if (args.length === 0)
+    return "";
+  const argsTypes = args.map((arg) => {
+    const camelName = toCamelCase4(arg.name);
+    return `${camelName}: ${getTypeForArg(arg)}`;
+  }).join("; ");
+  return `args: { ${argsTypes} }, `;
+}
+function generateClarityArgs(args) {
+  if (args.length === 0)
+    return "";
+  return args.map((arg) => {
+    const argName = `args.${toCamelCase4(arg.name)}`;
+    return generateClarityConversion(argName, arg);
+  }).join(", ");
+}
+function generateMapKeyConversion(keyType) {
+  if (isAbiTuple3(keyType)) {
+    const fields = keyType.tuple.map((field) => {
+      const camelFieldName = toCamelCase4(field.name);
+      const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
+      return `"${field.name}": ${fieldConversion}`;
+    }).join(", ");
+    return `Cl.tuple({ ${fields} })`;
+  }
+  return generateClarityConversion("key", { type: keyType });
+}
+var init_generator_helpers = __esm(() => {
+  init_clarity_conversion();
+  init_type_mapping();
+});
+
+// src/generators/contract.ts
+import {
+  toCamelCase as toCamelCase5
+} from "@secondlayer/stacks/clarity";
+function generateNetworkUtils() {
+  return `/**
+ * API URLs for different networks
+ */
+const API_URLS: Record<'mainnet' | 'testnet' | 'devnet', string> = {
+  mainnet: 'https://api.hiro.so',
+  testnet: 'https://api.testnet.hiro.so',
+  devnet: 'http://localhost:3999'
+};
+
+/**
+ * Infer network from Stacks address prefix
+ * SP/SM = mainnet, ST/SN = testnet
+ */
+function inferNetworkFromAddress(address: string): 'mainnet' | 'testnet' | undefined {
+  if (address.startsWith('SP') || address.startsWith('SM')) return 'mainnet';
+  if (address.startsWith('ST') || address.startsWith('SN')) return 'testnet';
+  return undefined;
+}
+
+/**
+ * Get API URL, inferring network from contract address if not specified
+ */
+function getApiUrl(
+  contractAddress: string,
+  explicitNetwork?: 'mainnet' | 'testnet' | 'devnet'
+): string {
+  const network = explicitNetwork ?? inferNetworkFromAddress(contractAddress) ?? 'mainnet';
+  return API_URLS[network];
+}`;
+}
+function generateValidationUtils() {
+  return `/**
+ * Contract name validation regex
+ * Must start with letter, contain only letters, numbers, and hyphens, max 128 chars
+ */
+const CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9\\-]{0,127}$/;`;
+}
+async function generateContractInterface(contracts) {
+  const imports = `import { Cl, validateStacksAddress } from '@secondlayer/stacks'`;
+  const header = `/**
+ * Generated by @secondlayer/cli
+ * DO NOT EDIT MANUALLY
+ *
+ * @requires @secondlayer/stacks - Install with: npm install @secondlayer/stacks
+ */`;
+  const validationUtils = generateValidationUtils();
+  const networkUtils = generateNetworkUtils();
+  const contractsCode = contracts.map((contract) => generateContract(contract)).join(`
+
+`);
+  const code = `${imports}
+
+${header}
+
+${validationUtils}
+
+${networkUtils}
+
+${contractsCode}`;
+  return formatCode(code);
+}
+function generateContract(contract) {
+  const { name, address, contractName, abi } = contract;
+  const abiCode = generateAbiConstant(name, abi);
+  const methods = abi.functions.filter((func) => func.access !== "private").map((func) => generateMethod(func, address, contractName)).join(`,
+
+  `);
+  const mapsObject = generateMapsObject(abi.maps || [], address, contractName);
+  const varsObject = generateVarsObject(abi.variables || [], address, contractName);
+  const constantsObject = generateConstantsObject(abi.variables || [], address, contractName);
+  const allMembers = [methods, mapsObject, varsObject, constantsObject].filter(Boolean);
+  const contractCode = `export const ${name} = {
+  address: '${address}',
+  contractAddress: '${address}',
+  contractName: '${contractName}',
+
+  ${allMembers.join(`,
+
+  `)}
+} 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 = toCamelCase5(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 = toCamelCase5(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) => toCamelCase5(arg.name)).join(", ");
+  const argsTypes = func.args.map((arg) => {
+    const camelName = toCamelCase5(arg.name);
+    return `${camelName}: ${getTypeForArg(arg)}`;
+  }).join("; ");
+  const argsArray = func.args.map((arg) => {
+    const argName = toCamelCase5(arg.name);
+    return generateClarityConversion(argName, arg);
+  }).join(", ");
+  const objectAccess = func.args.map((arg) => {
+    const camelName = toCamelCase5(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 generateMapsObject(maps, address, contractName) {
+  if (!maps || maps.length === 0) {
+    return "";
+  }
+  const mapMethods = maps.map((map) => {
+    const methodName = toCamelCase5(map.name);
+    const keyType = getTypeForArg({ type: map.key });
+    const valueType = getTypeForArg({ type: map.value });
+    const keyConversion = generateMapKeyConversion(map.key);
+    return `${methodName}: {
+      async get(key: ${keyType}, options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType} | null> {
+        try {
+          const { cvToJSON, serializeCV } = await import('@secondlayer/stacks/clarity');
+          const baseUrl = getApiUrl('${address}', options?.network);
+          const mapKey = ${keyConversion};
+          const keyHex = serializeCV(mapKey).toString('hex');
+
+          const response = await fetch(
+            \`\${baseUrl}/v2/map_entry/${address}/${contractName}/${map.name}\`,
+            {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify(keyHex)
+            }
+          );
+
+          if (!response.ok) {
+            throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
+          }
+
+          const result = await response.json();
+          if (!result.data || result.data === '0x09') {
+            return null; // none value
+          }
+
+          const { deserializeCV } = await import('@secondlayer/stacks/clarity');
+          const cv = deserializeCV(result.data);
+          const parsed = cvToJSON(cv);
+          // Unwrap the (some ...) wrapper
+          return parsed.value?.value ?? parsed.value ?? null;
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new Error(\`Map access failed for '${map.name}': \${error.message}\`);
+          }
+          throw error;
+        }
+      },
+      keyType: ${JSON.stringify(map.key)} as const,
+      valueType: ${JSON.stringify(map.value)} as const
+    }`;
+  });
+  return `maps: {
+    ${mapMethods.join(`,
+
+    `)}
+  }`;
+}
+function generateVarsObject(variables, address, contractName) {
+  if (!variables || variables.length === 0) {
+    return "";
+  }
+  const dataVars = variables.filter((v) => v.access === "variable");
+  if (dataVars.length === 0) {
+    return "";
+  }
+  const varMethods = dataVars.map((variable) => {
+    const methodName = toCamelCase5(variable.name);
+    const valueType = getTypeForArg({ type: variable.type });
+    return `${methodName}: {
+      async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
+        try {
+          const { cvToJSON, deserializeCV } = await import('@secondlayer/stacks/clarity');
+          const baseUrl = getApiUrl('${address}', options?.network);
+
+          const response = await fetch(
+            \`\${baseUrl}/v2/data_var/${address}/${contractName}/${variable.name}?proof=0\`
+          );
+
+          if (!response.ok) {
+            throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
+          }
+
+          const result = await response.json();
+          const cv = deserializeCV(result.data);
+          const parsed = cvToJSON(cv);
+          return parsed.value ?? parsed;
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new Error(\`Variable access failed for '${variable.name}': \${error.message}\`);
+          }
+          throw error;
+        }
+      },
+      type: ${JSON.stringify(variable.type)} as const
+    }`;
+  });
+  return `vars: {
+    ${varMethods.join(`,
+
+    `)}
+  }`;
+}
+function generateConstantsObject(variables, address, contractName) {
+  if (!variables || variables.length === 0) {
+    return "";
+  }
+  const constants = variables.filter((v) => v.access === "constant");
+  if (constants.length === 0) {
+    return "";
+  }
+  const constMethods = constants.map((constant) => {
+    const methodName = toCamelCase5(constant.name);
+    const valueType = getTypeForArg({ type: constant.type });
+    return `${methodName}: {
+      async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
+        try {
+          const { cvToJSON, deserializeCV } = await import('@secondlayer/stacks/clarity');
+          const baseUrl = getApiUrl('${address}', options?.network);
+
+          const response = await fetch(
+            \`\${baseUrl}/v2/constant_val/${address}/${contractName}/${constant.name}?proof=0\`
+          );
+
+          if (!response.ok) {
+            throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
+          }
+
+          const result = await response.json();
+          const cv = deserializeCV(result.data);
+          const parsed = cvToJSON(cv);
+          return parsed.value ?? parsed;
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new Error(\`Constant access failed for '${constant.name}': \${error.message}\`);
+          }
+          throw error;
+        }
+      },
+      type: ${JSON.stringify(constant.type)} as const
+    }`;
+  });
+  return `constants: {
+    ${constMethods.join(`,
+
+    `)}
+  }`;
+}
+var init_contract = __esm(() => {
+  init_clarity_conversion();
+  init_format();
+  init_generator_helpers();
+  init_type_mapping();
+});
+
+// src/utils/abi-compat.ts
+function normalizeAccess(access) {
+  if (access === "read_only")
+    return "read-only";
+  return access;
+}
+function normalizeType(type) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+      case "bool":
+      case "principal":
+      case "trait_reference":
+        return type;
+      default:
+        return type;
+    }
+  }
+  if (typeof type !== "object" || type === null) {
+    throw new Error(`Invalid ABI type: expected object, got ${typeof type}`);
+  }
+  const typeObj = type;
+  if ("buffer" in typeObj) {
+    const buffer = typeObj.buffer;
+    return {
+      buff: {
+        length: buffer?.length ?? 32
+      }
+    };
+  }
+  if ("buff" in typeObj) {
+    const buff = typeObj.buff;
+    return {
+      buff: {
+        length: buff?.length ?? 32
+      }
+    };
+  }
+  if ("string-ascii" in typeObj) {
+    const strAscii = typeObj["string-ascii"];
+    return {
+      "string-ascii": {
+        length: strAscii?.length ?? 256
+      }
+    };
+  }
+  if ("string-utf8" in typeObj) {
+    const strUtf8 = typeObj["string-utf8"];
+    return {
+      "string-utf8": {
+        length: strUtf8?.length ?? 256
+      }
+    };
+  }
+  if ("response" in typeObj) {
+    const response = typeObj.response;
+    return {
+      response: {
+        ok: normalizeType(response?.ok ?? "bool"),
+        error: normalizeType(response?.error ?? "uint128")
+      }
+    };
+  }
+  if ("optional" in typeObj) {
+    return {
+      optional: normalizeType(typeObj.optional)
+    };
+  }
+  if ("list" in typeObj) {
+    const list = typeObj.list;
+    return {
+      list: {
+        type: normalizeType(list?.type ?? "uint128"),
+        length: list?.length ?? 100
+      }
+    };
+  }
+  if ("tuple" in typeObj) {
+    const tuple = typeObj.tuple;
+    return {
+      tuple: tuple.map((field) => ({
+        name: field.name,
+        type: normalizeType(field.type)
+      }))
+    };
+  }
+  throw new Error(`Unknown ABI type structure: ${JSON.stringify(type)}`);
+}
+function normalizeFunction(func) {
+  const access = normalizeAccess(func.access);
+  const args = func.args ?? [];
+  const outputs = func.outputs;
+  return {
+    name: func.name,
+    access,
+    args: args.map((arg) => ({
+      name: arg.name,
+      type: normalizeType(arg.type)
+    })),
+    outputs: normalizeType(typeof outputs === "object" && outputs !== null && "type" in outputs ? outputs.type : outputs)
+  };
+}
+function normalizeMap(map) {
+  return {
+    name: map.name,
+    key: normalizeType(map.key),
+    value: normalizeType(map.value)
+  };
+}
+function normalizeVariable(variable) {
+  return {
+    name: variable.name,
+    type: normalizeType(variable.type),
+    access: variable.access
+  };
+}
+function normalizeAbi(abi) {
+  if (typeof abi !== "object" || abi === null) {
+    return { functions: [] };
+  }
+  const abiObj = abi;
+  const functions = [];
+  const maps = [];
+  const variables = [];
+  if (Array.isArray(abiObj.functions)) {
+    for (const func of abiObj.functions) {
+      if (typeof func === "object" && func !== null) {
+        functions.push(normalizeFunction(func));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.maps)) {
+    for (const map of abiObj.maps) {
+      if (typeof map === "object" && map !== null) {
+        maps.push(normalizeMap(map));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.variables)) {
+    for (const variable of abiObj.variables) {
+      if (typeof variable === "object" && variable !== null) {
+        variables.push(normalizeVariable(variable));
+      }
+    }
+  }
+  return {
+    functions,
+    maps: maps.length > 0 ? maps : undefined,
+    variables: variables.length > 0 ? variables : undefined
+  };
+}
+
+// src/plugins/index.ts
+init_plugin_manager();
+
+// src/plugins/clarinet/index.ts
+init_contract();
+import { initSimnet } from "@hirosystems/clarinet-sdk";
+import { toCamelCase as toCamelCase6 } from "@secondlayer/stacks/clarity";
+function sanitizeContractName(name) {
+  return toCamelCase6(name);
+}
+async function isUserDefinedContract(contractId, manifestPath) {
+  const { address, contractName } = parseContractId(contractId);
+  try {
+    const { promises: fs2 } = await import("fs");
+    const tomlContent = await fs2.readFile(manifestPath, "utf-8");
+    const contractSectionRegex = /^\[contracts\.([^\]]+)\]/gm;
+    const userContracts = new Set;
+    let match;
+    while ((match = contractSectionRegex.exec(tomlContent)) !== null) {
+      userContracts.add(match[1]);
+    }
+    if (userContracts.has(contractName)) {
+      return true;
+    }
+  } catch (error) {}
+  const systemContractPatterns = [
+    /^pox-\d+$/,
+    /^bns$/,
+    /^costs-\d+$/,
+    /^lockup$/
+  ];
+  if (systemContractPatterns.some((pattern) => pattern.test(contractName))) {
+    return false;
+  }
+  const systemAddresses = [
+    "SP000000000000000000002Q6VF78",
+    "ST000000000000000000002AMW42H"
+  ];
+  if (systemAddresses.includes(address)) {
+    return false;
+  }
+  return true;
+}
+var clarinet = (options = {}) => {
+  const manifestPath = options.path || "./Clarinet.toml";
+  let simnet;
+  return {
+    name: "@secondlayer/cli/plugin-clarinet",
+    version: "1.0.0",
+    async transformConfig(config) {
+      try {
+        simnet = await initSimnet(manifestPath);
+        const contractInterfaces = simnet.getContractsInterfaces();
+        const contracts = [];
+        for (const [contractId, abi] of contractInterfaces) {
+          const { contractName } = parseContractId(contractId);
+          if (!await isUserDefinedContract(contractId, manifestPath)) {
+            if (options.debug) {
+              console.log(`\uD83D\uDEAB Skipping system contract: ${contractId}`);
+            }
+            continue;
+          }
+          if (options.include && !options.include.includes(contractName)) {
+            continue;
+          }
+          if (options.exclude && options.exclude.includes(contractName)) {
+            continue;
+          }
+          const sanitizedName = sanitizeContractName(contractName);
+          contracts.push({
+            name: sanitizedName,
+            address: contractId,
+            abi: 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 (options.debug) {
+          console.warn(`⚠️  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
+init_generator_helpers();
+import { toCamelCase as toCamelCase7 } from "@secondlayer/stacks/clarity";
+function generateReadHelpers(contract, options) {
+  const { abi } = contract;
+  const functions = abi.functions || [];
+  const readOnlyFunctions = functions.filter((f) => f.access === "read-only");
+  if (readOnlyFunctions.length === 0) {
+    return "";
+  }
+  const filteredFunctions = 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 = toCamelCase7(func.name);
+    const argsSignature = generateArgsSignature(func.args);
+    const clarityArgs = generateClarityArgs(func.args);
+    return `async ${methodName}(${argsSignature}options?: {
+      network?: 'mainnet' | 'testnet' | 'devnet';
+      senderAddress?: string;
+    }) {
+      return await fetchCallReadOnlyFunction({
+        contractAddress: '${contract.address}',
+        contractName: '${contract.contractName}',
+        functionName: '${func.name}',
+        functionArgs: [${clarityArgs}],
+        network: options?.network ?? inferNetworkFromAddress('${contract.address}') ?? 'mainnet',
+        senderAddress: options?.senderAddress || 'SP000000000000000000002Q6VF78'
+      });
+    }`;
+  });
+  return `read: {
+    ${helpers.join(`,
+
+    `)}
+  }`;
+}
+function generateWriteHelpers(contract, options) {
+  const { abi } = contract;
+  const functions = abi.functions || [];
+  const envVarName = options.senderKeyEnv ?? "STX_SENDER_KEY";
+  const publicFunctions = functions.filter((f) => f.access === "public");
+  if (publicFunctions.length === 0) {
+    return "";
+  }
+  const filteredFunctions = 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 = toCamelCase7(func.name);
+    const argsSignature = generateArgsSignature(func.args);
+    const clarityArgs = generateClarityArgs(func.args);
+    return `async ${methodName}(${argsSignature}senderKey?: string, options?: {
+      network?: 'mainnet' | 'testnet' | 'devnet';
+      fee?: string | number | undefined;
+      nonce?: bigint;
+      anchorMode?: 1 | 2 | 3; // AnchorMode: OnChainOnly = 1, OffChainOnly = 2, Any = 3
+      postConditions?: PostCondition[];
+      validateWithAbi?: boolean;
+    }) {
+      const resolvedSenderKey = senderKey ?? process.env.${envVarName};
+      if (!resolvedSenderKey) {
+        throw new Error('senderKey required: pass as argument or set ${envVarName} env var');
+      }
+      const { network = 'mainnet', ...txOptions } = options ?? {};
+
+      return await makeContractCall({
+        contractAddress: '${contract.address}',
+        contractName: '${contract.contractName}',
+        functionName: '${func.name}',
+        functionArgs: [${clarityArgs}],
+        senderKey: resolvedSenderKey,
+        network,
+        validateWithAbi: true,
+        ...txOptions
+      });
+    }`;
+  });
+  return `write: {
+    ${helpers.join(`,
+
+    `)}
+  }`;
+}
+async function generateActionHelpers(contract, options) {
+  const readHelpers = generateReadHelpers(contract, options);
+  const writeHelpers = generateWriteHelpers(contract, options);
+  if (!readHelpers && !writeHelpers) {
+    return "";
+  }
+  const helpers = [readHelpers, writeHelpers].filter(Boolean);
+  return helpers.join(`,
+
+`);
+}
+
+// src/plugins/actions/index.ts
+var actions = (options = {}) => {
+  return {
+    name: "@secondlayer/cli/plugin-actions",
+    version: "1.0.0",
+    async generate(context) {
+      const { contracts } = context;
+      const filteredContracts = contracts.filter((contract) => {
+        if (options.include && !options.include.includes(contract.name)) {
+          return false;
+        }
+        if (options.exclude && options.exclude.includes(contract.name)) {
+          return false;
+        }
+        return true;
+      });
+      if (filteredContracts.length === 0) {
+        if (options.debug) {
+          context.logger.debug("Actions plugin: No contracts to process");
+        }
+        return;
+      }
+      if (options.debug) {
+        context.logger.debug(`Actions plugin: Generating read/write helpers for ${filteredContracts.length} contracts`);
+      }
+      const contractHelpers = new Map;
+      for (const contract of filteredContracts) {
+        const actionsCode = await generateActionHelpers(contract, options);
+        if (actionsCode) {
+          contractHelpers.set(contract.name, actionsCode);
+        }
+      }
+      if (contractHelpers.size > 0) {
+        const existingOutput = context.outputs.get("contracts");
+        if (existingOutput) {
+          let modifiedContent = addRequiredImports(existingOutput.content);
+          for (const [contractName, helpersCode] of contractHelpers) {
+            modifiedContent = injectHelpersIntoContract(modifiedContent, contractName, helpersCode);
+          }
+          context.outputs.set("contracts", {
+            ...existingOutput,
+            content: modifiedContent
+          });
+        }
+      }
+    }
+  };
+};
+function addRequiredImports(content) {
+  const stacksImportRegex = /import\s+\{([^}]+)\}\s+from\s+['"]@secondlayer\/stacks['"];/;
+  const match = content.match(stacksImportRegex);
+  if (match) {
+    let updatedContent = content;
+    if (!updatedContent.includes("fetchCallReadOnlyFunction")) {
+      updatedContent = updatedContent.replace(stacksImportRegex, `${match[0]}
+import { fetchCallReadOnlyFunction, makeContractCall } from '@secondlayer/stacks/clarity';`);
+    }
+    if (!updatedContent.includes("type PostCondition")) {
+      updatedContent = updatedContent.replace(stacksImportRegex, `${match[0]}
+import type { PostCondition } from '@secondlayer/stacks';`);
+    }
+    return updatedContent;
+  }
+  return content;
+}
+function injectHelpersIntoContract(content, contractName, helpersCode) {
+  const contractPattern = new RegExp(`(export const ${contractName} = \\{[\\s\\S]*?)\\n\\} as const;`, "g");
+  return content.replace(contractPattern, (_, contractBody) => {
+    const cleanBody = contractBody.replace(/,\s*$/, "");
+    const indentedHelpersCode = helpersCode.split(`
+`).map((line) => {
+      if (line.match(/^[a-zA-Z_$][a-zA-Z0-9_$]*\s*:/)) {
+        return `  ${line}`;
+      }
+      return line;
+    }).join(`
+`);
+    return `${cleanBody},
+
+${indentedHelpersCode}
+} as const;`;
+  });
+}
+// src/plugins/react/generators/contract.ts
+init_format();
+
+// src/utils/case-conversion.ts
+import { toCamelCase as toCamelCase8 } from "@secondlayer/stacks/clarity";
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function toPascalCase(str) {
+  return capitalize(toCamelCase8(str));
+}
+
+// src/plugins/react/generators/utils.ts
+init_type_mapping();
+function generateHookArgsSignature(args) {
+  if (args.length === 0)
+    return "";
+  const argsList = args.map((arg) => `${toCamelCase8(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
+  return `${argsList}`;
+}
+function generateArgsType(args) {
+  if (args.length === 0)
+    return "void";
+  const argsList = args.map((arg) => `${toCamelCase8(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
+  return `{ ${argsList} }`;
+}
+function generateArgNames(args) {
+  if (args.length === 0)
+    return "";
+  return args.map((arg) => toCamelCase8(arg.name)).join(", ");
+}
+function generateEnabledCondition(args) {
+  return args.map((arg) => {
+    const camelName = toCamelCase8(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}: ${toCamelCase8(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'
+import { ${contracts.map((c) => c.name).join(", ")} } from './contracts'`;
+  const header = `/**
+ * Generated contract-specific React hooks
+ * DO NOT EDIT MANUALLY
+ */`;
+  const hooksCode = contracts.map((contract) => generateContractHookMethods(contract, excludeList)).filter(Boolean).join(`
+
+`);
+  const code = `${imports}
+
+${header}
+
+${hooksCode}`;
+  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(toCamelCase8(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(toCamelCase8(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(toCamelCase8(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(toCamelCase8(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(toCamelCase8(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(toCamelCase8(func.name))}`;
+  const argsSignature = generateHookArgsSignature(func.args);
+  const enabledParam = func.args.length > 0 ? ", options?: { enabled?: boolean }" : "options?: { enabled?: boolean }";
+  const returnType = clarityTypeToTS(func.outputs);
+  return `export function ${hookName}(${argsSignature}${enabledParam}) {
+  const config = useSecondLayerConfig()
+
+  return useQuery<${returnType}>({
+    queryKey: ['${func.name}', ${contractName}.address, ${generateArgNames(func.args)}],
+    queryFn: () => ${contractName}.read.${toCamelCase8(func.name)}(${generateArgNames(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(toCamelCase8(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}.${toCamelCase8(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 ${toCamelCase8(func.name)} = useCallback(async (
+    args: ${argsType},
+    options?: {
+      postConditions?: PostCondition[];
+      attachment?: string;
+      onFinish?: (data: any) => void;
+      onCancel?: () => void;
+    }
+  ) => {
+    return mutation.mutateAsync({ args, options })
+  }, [mutation])
+
+  return {
+    ${toCamelCase8(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(toCamelCase8(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.${toCamelCase8(map.name)}.get(key, { network: config.network })
+    },
+    enabled: options?.enabled ?? true
+  })
+}`;
+}
+function generateVarHook(variable, contractVarName, _address, _contractName) {
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase8(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.${toCamelCase8(variable.name)}.get({ network: config.network })
+    },
+    enabled: options?.enabled ?? true
+  })
+}`;
+}
+function generateConstantHook(constant, contractVarName, _address, _contractName) {
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase8(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.${toCamelCase8(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, validateStacksAddress } from '@secondlayer/stacks'
+import type { PostCondition } from '@secondlayer/stacks'
+import type { ExtractFunctionArgs, ExtractFunctionNames, AbiContract } from '@secondlayer/stacks/clarity'
+
+const API_URLS: Record<string, string> = {
+  mainnet: 'https://api.hiro.so',
+  testnet: 'https://api.testnet.hiro.so',
+  devnet: 'http://localhost:3999'
+}
+
+async function fetchTransaction({ txId, network, apiUrl }: { txId: string; network?: string; apiUrl?: string }): Promise<any> {
+  const baseUrl = apiUrl || API_URLS[network || 'mainnet']
+  const response = await fetch(\`\${baseUrl}/extended/v1/tx/\${txId}\`)
+  if (!response.ok) throw new Error(\`Failed to fetch transaction: \${response.statusText}\`)
+  return response.json()
+}
+
+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 (options: { forceWalletSelect?: boolean } = {}) => {
+      // SIP-030 connect
+      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 () => {
+      // 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 () => {
+      const { fetchCallReadOnlyFunction } = await import('@secondlayer/stacks/clarity')
+      
+      // For now, we'll need to handle the args conversion here
+      // In the future, we could integrate with the contract interface for automatic conversion
+      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 = useSecondLayerConfig()
+  
+  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 = 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) {
+  const config = useSecondLayerConfig()
+  
+  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 = 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 || 'SP000000000000000000002Q6VF78'
+  }
+}
+
+/**
+ * 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/testing/generators.ts
+import {
+  isAbiTuple as isAbiTuple4
+} from "@secondlayer/stacks/clarity";
+init_generator_helpers();
+init_type_mapping();
+function generatePublicFunction(func, contractId) {
+  const methodName = toCamelCase8(func.name);
+  const argsSignature = generateArgsSignature(func.args);
+  const clarityArgs = generateClarityArgs(func.args);
+  return `${methodName}: (${argsSignature}caller: string) => {
+      const callerAddr = accounts.get(caller) ?? caller;
+      return simnet.callPublicFn(
+        '${contractId}',
+        '${func.name}',
+        [${clarityArgs}],
+        callerAddr
+      );
+    }`;
+}
+function generateReadOnlyFunction(func, contractId) {
+  const methodName = toCamelCase8(func.name);
+  const argsSignature = generateArgsSignature(func.args);
+  const clarityArgs = generateClarityArgs(func.args);
+  const hasArgs = func.args.length > 0;
+  const argsParam = hasArgs ? argsSignature : "";
+  return `${methodName}: (${argsParam}) => {
+      return simnet.callReadOnlyFn(
+        '${contractId}',
+        '${func.name}',
+        [${clarityArgs}],
+        accounts.get('deployer')!
+      );
+    }`;
+}
+function generatePrivateFunction(func, contractId) {
+  const methodName = toCamelCase8(func.name);
+  const argsSignature = generateArgsSignature(func.args);
+  const clarityArgs = generateClarityArgs(func.args);
+  return `${methodName}: (${argsSignature}caller: string) => {
+      const callerAddr = accounts.get(caller) ?? caller;
+      return simnet.callPrivateFn(
+        '${contractId}',
+        '${func.name}',
+        [${clarityArgs}],
+        callerAddr
+      );
+    }`;
+}
+function generateDataVarHelper(variable, contractId) {
+  const methodName = toCamelCase8(variable.name);
+  return `${methodName}: () => {
+      return simnet.getDataVar('${contractId}', '${variable.name}');
+    }`;
+}
+function getMapKeyType(keyType) {
+  if (isAbiTuple4(keyType)) {
+    const fields = keyType.tuple.map((field) => `${toCamelCase8(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
+    return `{ ${fields} }`;
+  }
+  return getTypeForArg({ type: keyType });
+}
+function generateMapEntryHelper(map, contractId) {
+  const methodName = toCamelCase8(map.name);
+  const keyType = getMapKeyType(map.key);
+  const keyConversion = generateMapKeyConversion(map.key);
+  return `${methodName}: (key: ${keyType}) => {
+      return simnet.getMapEntry(
+        '${contractId}',
+        '${map.name}',
+        ${keyConversion}
+      );
+    }`;
+}
+function generateVarsObject2(variables, contractId) {
+  const dataVars = variables.filter((v) => v.access === "variable");
+  if (dataVars.length === 0) {
+    return "";
+  }
+  const varHelpers = dataVars.map((v) => generateDataVarHelper(v, contractId));
+  return `vars: {
+      ${varHelpers.join(`,
+
+      `)}
+    }`;
+}
+function generateMapsObject2(maps, contractId) {
+  if (maps.length === 0) {
+    return "";
+  }
+  const mapHelpers = maps.map((m) => generateMapEntryHelper(m, contractId));
+  return `maps: {
+      ${mapHelpers.join(`,
+
+      `)}
+    }`;
+}
+function generateContractHelper(contract, options) {
+  const { abi, name, address } = contract;
+  const functions = abi.functions || [];
+  const variables = abi.variables || [];
+  const maps = abi.maps || [];
+  const pascalName = toPascalCase(name);
+  const publicFns = functions.filter((f) => f.access === "public");
+  const readOnlyFns = functions.filter((f) => f.access === "read-only");
+  const privateFns = options.includePrivate ? functions.filter((f) => f.access === "private") : [];
+  const publicHelpers = publicFns.map((f) => generatePublicFunction(f, address));
+  const readOnlyHelpers = readOnlyFns.map((f) => generateReadOnlyFunction(f, address));
+  const privateHelpers = privateFns.map((f) => generatePrivateFunction(f, address));
+  const varsObject = generateVarsObject2(variables, address);
+  const mapsObject = generateMapsObject2(maps, address);
+  const allHelpers = [...publicHelpers, ...readOnlyHelpers, ...privateHelpers];
+  if (varsObject) {
+    allHelpers.push(varsObject);
+  }
+  if (mapsObject) {
+    allHelpers.push(mapsObject);
+  }
+  if (allHelpers.length === 0) {
+    return "";
+  }
+  return `export function get${pascalName}(simnet: Simnet) {
+  const accounts = simnet.getAccounts();
+
+  return {
+    ${allHelpers.join(`,
+
+    `)}
+  };
+}`;
+}
+function generateGetContracts(contracts) {
+  const contractEntries = contracts.map((contract) => {
+    const camelName = toCamelCase8(contract.name);
+    const pascalName = toPascalCase(contract.name);
+    return `${camelName}: get${pascalName}(simnet)`;
+  }).join(`,
+    `);
+  return `export function getContracts(simnet: Simnet) {
+  const accounts = simnet.getAccounts();
+
+  return {
+    accounts,
+    ${contractEntries}
+  };
+}`;
+}
+function generateTypeExports(contracts) {
+  const typeExports = contracts.map((contract) => {
+    const pascalName = toPascalCase(contract.name);
+    return `export type ${pascalName}Helpers = ReturnType<typeof get${pascalName}>;`;
+  }).join(`
+`);
+  return `${typeExports}
+export type Contracts = ReturnType<typeof getContracts>;`;
+}
+async function generateTestingHelpers(contracts, options) {
+  const contractHelpers = contracts.map((contract) => generateContractHelper(contract, options)).filter(Boolean);
+  if (contractHelpers.length === 0) {
+    return `// No contracts with functions to generate helpers for
+export {};`;
+  }
+  const getContractsCode = generateGetContracts(contracts);
+  const typeExports = generateTypeExports(contracts);
+  return `/**
+ * Generated by @secondlayer/cli testing plugin
+ * Type-safe helpers for Clarinet SDK unit tests
+ */
+
+import { type Simnet, Cl } from '@hirosystems/clarinet-sdk';
+
+// ============================================
+// Per-contract factory functions
+// ============================================
+
+${contractHelpers.join(`
+
+`)}
+
+// ============================================
+// Convenience: all contracts at once
+// ============================================
+
+${getContractsCode}
+
+// ============================================
+// Type exports
+// ============================================
+
+${typeExports}
+`;
+}
+
+// src/plugins/testing/index.ts
+var testing = (options = {}) => {
+  return {
+    name: "@secondlayer/cli/plugin-testing",
+    version: "1.0.0",
+    async generate(context) {
+      const { contracts } = context;
+      const filteredContracts = contracts.filter((contract) => {
+        if (options.include && !options.include.includes(contract.name)) {
+          return false;
+        }
+        if (options.exclude && options.exclude.includes(contract.name)) {
+          return false;
+        }
+        return true;
+      });
+      if (filteredContracts.length === 0) {
+        if (options.debug) {
+          context.logger.debug("Testing plugin: No contracts to process");
+        }
+        return;
+      }
+      if (options.debug) {
+        context.logger.debug(`Testing plugin: Generating helpers for ${filteredContracts.length} contracts`);
+      }
+      const testingCode = await generateTestingHelpers(filteredContracts, options);
+      const outputPath = options.out || "./src/generated/testing.ts";
+      context.addOutput("testing", {
+        path: outputPath,
+        content: testingCode,
+        type: "utils"
+      });
+      if (options.debug) {
+        context.logger.debug(`Testing plugin: Generated helpers for ${filteredContracts.length} contracts`);
+      }
+    }
+  };
+};
+
+// src/plugins/index.ts
+function filterByOptions(items, options = {}) {
+  let filtered = items;
+  if (options.include && options.include.length > 0) {
+    filtered = filtered.filter((item) => options.include.some((pattern) => item.name.includes(pattern) || item.name.match(new RegExp(pattern))));
+  }
+  if (options.exclude && options.exclude.length > 0) {
+    filtered = filtered.filter((item) => !options.exclude.some((pattern) => item.name.includes(pattern) || item.name.match(new RegExp(pattern))));
+  }
+  return filtered;
+}
+function createPlugin(name, version, implementation) {
+  return {
+    name,
+    version,
+    ...implementation
+  };
+}
+export {
+  testing,
+  react,
+  hasClarinetProject,
+  filterByOptions,
+  createPlugin,
+  clarinet,
+  actions,
+  PluginManager
+};
+
+//# debugId=CF062C27A0D1420964756E2164756E21
+//# sourceMappingURL=index.js.map