@secondlayer/cli 1.7.0 → 1.9.0

package/dist/index.js

@@ -74,6 +74,14 @@ import { isValidAddress as _validateStacksAddress } from "@secondlayer/stacks";
 import { getErrorMessage } from "@secondlayer/shared";
 import { toCamelCase } from "@secondlayer/stacks/clarity";
 
+// 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(".");
@@ -86,14 +94,6 @@ function parseContractId(contractId) {
   };
 }
 
-// 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/core/plugin-manager.ts
 var validateStacksAddress = _validateStacksAddress;
 
@@ -361,96 +361,20 @@ import { initSimnet } from "@hirosystems/clarinet-sdk";
 import { toCamelCase as toCamelCase6 } from "@secondlayer/stacks/clarity";
 
 // src/generators/contract.ts
-init_format();
 import {
   toCamelCase as toCamelCase5
 } from "@secondlayer/stacks/clarity";
 
-// src/utils/type-mapping.ts
+// src/utils/clarity-conversion.ts
 import {
-  toCamelCase as toCamelCase2,
+  isAbiBuffer,
   isAbiList,
-  isAbiTuple,
   isAbiOptional,
   isAbiResponse,
-  isAbiBuffer,
   isAbiStringAscii,
-  isAbiStringUtf8
-} 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 (isAbiBuffer(type)) {
-    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
-  }
-  if (isAbiStringAscii(type) || isAbiStringUtf8(type)) {
-    return "string";
-  }
-  if (isAbiOptional(type)) {
-    const innerType = clarityTypeToTS(type.optional);
-    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
-      return `(${innerType}) | null`;
-    }
-    return `${innerType} | null`;
-  }
-  if (isAbiList(type)) {
-    const innerType = clarityTypeToTS(type.list.type);
-    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
-      return `(${innerType})[]`;
-    }
-    return `${innerType}[]`;
-  }
-  if (isAbiTuple(type)) {
-    const fields = type.tuple.map((field) => `${toCamelCase2(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
-    return `{ ${fields} }`;
-  }
-  if (isAbiResponse(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/clarity-conversion.ts
-import {
-  toCamelCase as toCamelCase3,
-  isAbiStringAscii as isAbiStringAscii2,
-  isAbiStringUtf8 as isAbiStringUtf82,
-  isAbiBuffer as isAbiBuffer2,
-  isAbiOptional as isAbiOptional2,
-  isAbiList as isAbiList2,
-  isAbiTuple as isAbiTuple2,
-  isAbiResponse as isAbiResponse2
+  isAbiStringUtf8,
+  isAbiTuple,
+  toCamelCase as toCamelCase2
 } from "@secondlayer/stacks/clarity";
 function generateClarityConversion(argName, argType) {
   const type = argType.type;
@@ -481,13 +405,13 @@ function generateClarityConversion(argName, argType) {
         return `${argName}`;
     }
   }
-  if (isAbiStringAscii2(type)) {
+  if (isAbiStringAscii(type)) {
     return `Cl.stringAscii(${argName})`;
   }
-  if (isAbiStringUtf82(type)) {
+  if (isAbiStringUtf8(type)) {
     return `Cl.stringUtf8(${argName})`;
   }
-  if (isAbiBuffer2(type)) {
+  if (isAbiBuffer(type)) {
     return `(() => {
       const value = ${argName};
       if (value instanceof Uint8Array) {
@@ -518,13 +442,13 @@ function generateClarityConversion(argName, argType) {
       throw new Error(\`Invalid buffer value: \${value}\`);
     })()`;
   }
-  if (isAbiOptional2(type)) {
+  if (isAbiOptional(type)) {
     const innerConversion = generateClarityConversion(argName, {
       type: type.optional
     });
     return `${argName} !== null ? Cl.some(${innerConversion.replace(argName, `${argName}`)}) : Cl.none()`;
   }
-  if (isAbiList2(type)) {
+  if (isAbiList(type)) {
     const innerConversion = generateClarityConversion("item", {
       type: type.list.type
     });
@@ -537,11 +461,11 @@ function generateClarityConversion(argName, argType) {
       return Cl.list(listValue.map(item => ${innerConversion}));
     })()`;
   }
-  if (isAbiTuple2(type)) {
+  if (isAbiTuple(type)) {
     const requiredFields = type.tuple.map((f) => f.name);
     const fieldNames = JSON.stringify(requiredFields);
     const fields = type.tuple.map((field) => {
-      const camelFieldName = toCamelCase3(field.name);
+      const camelFieldName = toCamelCase2(field.name);
       const fieldConversion = generateClarityConversion(`tupleValue.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -557,7 +481,7 @@ function generateClarityConversion(argName, argType) {
       return Cl.tuple({ ${fields} });
     })()`;
   }
-  if (isAbiResponse2(type)) {
+  if (isAbiResponse(type)) {
     const okConversion = generateClarityConversion(`responseValue.ok`, {
       type: type.response.ok
     });
@@ -580,8 +504,91 @@ function generateClarityConversion(argName, argType) {
   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
-import { toCamelCase as toCamelCase4, isAbiTuple as isAbiTuple3 } from "@secondlayer/stacks/clarity";
 function generateArgsSignature(args) {
   if (args.length === 0)
     return "";
@@ -1366,100 +1373,266 @@ ${indentedHelpersCode}
 } as const;`;
   });
 }
-// src/plugins/react/provider/index.ts
+// src/plugins/react/generators/contract.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
+// src/utils/case-conversion.ts
+import { toCamelCase as toCamelCase8 } from "@secondlayer/stacks/clarity";
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
 }
-
-/**
- * Provider component props
- */
-export interface SecondLayerProviderProps {
-  children: React.ReactNode
-  config: SecondLayerReactConfig
+function toPascalCase(str) {
+  return capitalize(toCamelCase8(str));
 }
 
-/**
- * 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'
-  }
+// 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}`;
 }
-
-/**
- * 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>
-  )
+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(", ");
 }
 
-/**
- * Hook to access the SecondLayer configuration
- */
-export function useSecondLayerConfig(): SecondLayerReactConfig {
-  const context = useContext(SecondLayerContext)
+// 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(`
 
-  if (context === undefined) {
-    throw new Error(
-      'useSecondLayerConfig must be used within a SecondLayerProvider. ' +
-      'Make sure to wrap your app with <SecondLayerProvider config={{...}}>'
-    )
+`);
+  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(`
 
-  return context
+`);
+}
+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
+  })
 }`;
-  return formatCode(code);
 }
+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}\`
 
-// src/plugins/react/generators/generic.ts
-init_format();
+      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() {
@@ -1682,6 +1855,7 @@ var USE_CONTRACT_TEMPLATE = `export function useContract() {
 }`;
 
 // src/plugins/react/generators/generic.ts
+init_format();
 var GENERIC_HOOKS = [
   "useAccount",
   "useConnect",
@@ -2171,259 +2345,96 @@ function generateGenericHook(hookName) {
   }
 }
 
-// src/plugins/react/generators/contract.ts
+// src/plugins/react/provider/index.ts
 init_format();
+async function generateProvider() {
+  const code = `/**
+ * Generated SecondLayer React Provider
+ * DO NOT EDIT MANUALLY
+ */
 
-// 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(`
+import React, { createContext, useContext } from 'react'
 
-`);
-  const code = `${imports}
+/**
+ * SecondLayer configuration interface
+ */
+export interface SecondLayerReactConfig {
+  /**
+   * Network to use for API calls
+   */
+  network: 'mainnet' | 'testnet' | 'devnet'
 
-${header}
+  /**
+   * API key for Stacks API (optional)
+   */
+  apiKey?: string
 
-${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(`
+  /**
+   * Base URL for Stacks API (optional override)
+   */
+  apiUrl?: string
 
-`);
+  /**
+   * Default sender address for read-only calls
+   */
+  senderAddress?: string
 }
-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
-  })
-}`;
+/**
+ * Provider component props
+ */
+export interface SecondLayerProviderProps {
+  children: React.ReactNode
+  config: SecondLayerReactConfig
 }
-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])
+/**
+ * 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 {
-    ${toCamelCase8(func.name)},
-    // Expose mutation state
-    isPending: mutation.isPending,
-    isError: mutation.isError,
-    isSuccess: mutation.isSuccess,
-    error: mutation.error,
-    data: mutation.data,
-    reset: mutation.reset
+    network: config.network,
+    apiKey: config.apiKey,
+    apiUrl: config.apiUrl,
+    senderAddress: config.senderAddress || 'SP000000000000000000002Q6VF78'
   }
-}`;
 }
-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()
+/**
+ * Provider component that makes SecondLayer configuration available to hooks
+ */
+export function SecondLayerProvider({ children, config }: SecondLayerProviderProps) {
+  const resolvedConfig = createSecondLayerConfig(config)
 
-  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
-  })
-}`;
+  return (
+    <SecondLayerContext.Provider value={resolvedConfig}>
+      {children}
+    </SecondLayerContext.Provider>
+  )
 }
-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
-  })
+/**
+ * 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
@@ -2723,5 +2734,5 @@ export {
   PluginManager
 };
 
-//# debugId=184A6BEF0A21821664756E2164756E21
+//# debugId=A40A68476DA46C9B64756E2164756E21
 //# sourceMappingURL=index.js.map