@secondlayer/cli 3.3.0 → 3.3.1

package/dist/index.js

@@ -14,7 +14,6 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/utils/format.ts
 var exports_format = {};
@@ -67,6 +66,14 @@ async function formatCode(code) {
 var biome = null;
 var init_format = () => {};
 
+// src/utils/config.ts
+import { randomBytes } from "crypto";
+import { promises as fs2 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { tmpdir } from "os";
+import path2 from "path";
+import { pathToFileURL } from "url";
+
 // src/core/plugin-manager.ts
 import { promises as fs } from "fs";
 import path from "path";
@@ -356,2383 +363,15 @@ ${JSON.stringify(content, null, 2)}`;
     };
   }
 }
-// src/plugins/clarinet/index.ts
-import { initSimnet } from "@hirosystems/clarinet-sdk";
-import { toCamelCase as toCamelCase6 } from "@secondlayer/stacks/clarity";
-
-// src/generators/contract.ts
-import {
-  toCamelCase as toCamelCase5
-} from "@secondlayer/stacks/clarity";
-
-// 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}`;
-}
-
-// src/generators/contract.ts
-init_format();
-
-// src/utils/generator-helpers.ts
-import {
-  isAbiTuple as isAbiTuple3,
-  toCamelCase as toCamelCase4
-} from "@secondlayer/stacks/clarity";
-
-// 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);
-}
-
-// src/utils/generator-helpers.ts
-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 });
-}
-
-// src/generators/contract.ts
-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(`,
-
-    `)}
-  }`;
-}
-
-// 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/clarinet/index.ts
-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
-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
-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";
-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
-  };
+// src/utils/config.ts
+function defineConfig(configOrDefiner) {
+  return configOrDefiner;
 }
 export {
-  testing,
-  react,
-  hasClarinetProject,
-  filterByOptions,
-  createPlugin,
-  clarinet,
-  actions,
+  defineConfig,
   PluginManager
 };
 
-//# debugId=A40A68476DA46C9B64756E2164756E21
+//# debugId=6FDA39721A22F05264756E2164756E21
 //# sourceMappingURL=index.js.map