@secondlayer/cli 0.2.5 → 0.3.0

package/dist/index.js

@@ -345,12 +345,18 @@ function generateContract(contract) {
   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}',
-  
-  ${methods}
+
+  ${allMembers.join(`,
+
+  `)}
 } as const`;
   return `${abiCode}
 
@@ -561,6 +567,158 @@ function generateClarityConversion(argName, argType) {
   }
   return `${argName}`;
 }
+function generateMapsObject(maps, address, contractName) {
+  if (!maps || maps.length === 0) {
+    return "";
+  }
+  const mapMethods = maps.map((map) => {
+    const methodName = toCamelCase(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> {
+        const { cvToJSON, serializeCV } = await import('@stacks/transactions');
+        const apiUrls: Record<string, string> = {
+          mainnet: 'https://api.hiro.so',
+          testnet: 'https://api.testnet.hiro.so',
+          devnet: 'http://localhost:3999'
+        };
+        const baseUrl = apiUrls[options?.network || 'mainnet'];
+        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(\`Failed to fetch map entry: \${response.statusText}\`);
+        }
+
+        const result = await response.json();
+        if (!result.data || result.data === '0x09') {
+          return null; // none value
+        }
+
+        const { deserializeCV } = await import('@stacks/transactions');
+        const cv = deserializeCV(result.data);
+        const parsed = cvToJSON(cv);
+        // Unwrap the (some ...) wrapper
+        return parsed.value?.value ?? parsed.value ?? null;
+      },
+      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 = toCamelCase(variable.name);
+    const valueType = getTypeForArg({ type: variable.type });
+    return `${methodName}: {
+      async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
+        const { cvToJSON, deserializeCV } = await import('@stacks/transactions');
+        const apiUrls: Record<string, string> = {
+          mainnet: 'https://api.hiro.so',
+          testnet: 'https://api.testnet.hiro.so',
+          devnet: 'http://localhost:3999'
+        };
+        const baseUrl = apiUrls[options?.network || 'mainnet'];
+
+        const response = await fetch(
+          \`\${baseUrl}/v2/data_var/${address}/${contractName}/${variable.name}?proof=0\`
+        );
+
+        if (!response.ok) {
+          throw new Error(\`Failed to fetch data var: \${response.statusText}\`);
+        }
+
+        const result = await response.json();
+        const cv = deserializeCV(result.data);
+        const parsed = cvToJSON(cv);
+        return parsed.value ?? parsed;
+      },
+      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 = toCamelCase(constant.name);
+    const valueType = getTypeForArg({ type: constant.type });
+    return `${methodName}: {
+      async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
+        const { cvToJSON, deserializeCV } = await import('@stacks/transactions');
+        const apiUrls: Record<string, string> = {
+          mainnet: 'https://api.hiro.so',
+          testnet: 'https://api.testnet.hiro.so',
+          devnet: 'http://localhost:3999'
+        };
+        const baseUrl = apiUrls[options?.network || 'mainnet'];
+
+        const response = await fetch(
+          \`\${baseUrl}/v2/constant_val/${address}/${contractName}/${constant.name}?proof=0\`
+        );
+
+        if (!response.ok) {
+          throw new Error(\`Failed to fetch constant: \${response.statusText}\`);
+        }
+
+        const result = await response.json();
+        const cv = deserializeCV(result.data);
+        const parsed = cvToJSON(cv);
+        return parsed.value ?? parsed;
+      },
+      type: ${JSON.stringify(constant.type)} as const
+    }`;
+  });
+  return `constants: {
+    ${constMethods.join(`,
+
+    `)}
+  }`;
+}
+function generateMapKeyConversion(keyType) {
+  if (keyType.tuple) {
+    const fields = keyType.tuple.map((field) => {
+      const camelFieldName = toCamelCase(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/plugins/clarinet/index.ts
 function toCamelCase2(str) {
@@ -904,7 +1062,7 @@ function generateWriteHelpers(contract, options) {
       fee?: string | number | undefined;
       nonce?: bigint;
       anchorMode?: 1 | 2 | 3; // AnchorMode: OnChainOnly = 1, OffChainOnly = 2, Any = 3
-      postConditions?: any[]; // TODO: Add proper PostCondition types
+      postConditions?: PostCondition[];
       validateWithAbi?: boolean;
     }) {
       const { senderKey, network = 'mainnet', ...txOptions } = options;
@@ -988,17 +1146,27 @@ var actions = (options = {}) => {
   };
 };
 function addRequiredImports(content) {
-  if (content.includes("fetchCallReadOnlyFunction") && content.includes("makeContractCall")) {
-    return content;
-  }
   const transactionsImportRegex = /import\s+\{([^}]+)\}\s+from\s+['"]@stacks\/transactions['"];/;
   const match = content.match(transactionsImportRegex);
   if (match) {
     const existingImports = match[1].trim();
-    const newImports = ["fetchCallReadOnlyFunction", "makeContractCall"].filter((imp) => !existingImports.includes(imp)).join(", ");
+    const requiredImports = [
+      "fetchCallReadOnlyFunction",
+      "makeContractCall"
+    ];
+    const newImports = requiredImports.filter((imp) => !existingImports.includes(imp)).join(", ");
     if (newImports) {
       const updatedImport = `import { ${existingImports}, ${newImports} } from '@stacks/transactions';`;
-      return content.replace(transactionsImportRegex, updatedImport);
+      let updatedContent = content.replace(transactionsImportRegex, updatedImport);
+      if (!updatedContent.includes("type PostCondition")) {
+        updatedContent = updatedContent.replace(updatedImport, `${updatedImport}
+import type { PostCondition } from '@stacks/transactions';`);
+      }
+      return updatedContent;
+    }
+    if (!content.includes("type PostCondition")) {
+      return content.replace(transactionsImportRegex, `${match[0]}
+import type { PostCondition } from '@stacks/transactions';`);
     }
   }
   return content;
@@ -1144,6 +1312,7 @@ import { useState, useCallback } from 'react'
 import { useStacksConfig } from './provider'
 import { connect, disconnect, isConnected, request, openContractCall as stacksOpenContractCall } from '@stacks/connect'
 import { Cl, validateStacksAddress } from '@stacks/transactions'
+import type { PostCondition } from '@stacks/transactions'
 import type { ExtractFunctionArgs, ExtractFunctionNames, ClarityContract } from '@secondlayer/clarity-types'`;
   const header = `/**
  * Generated generic Stacks React hooks
@@ -1471,7 +1640,7 @@ function generateGenericHook(hookName) {
     functionName: string;
     functionArgs: any[]; // Pre-converted Clarity values
     network?: string;
-    postConditions?: any[];
+    postConditions?: PostCondition[];
     attachment?: string;
     onFinish?: (data: any) => void;
     onCancel?: () => void;
@@ -1547,7 +1716,7 @@ function generateGenericHook(hookName) {
     abi: T;
     functionArgs: ExtractFunctionArgs<T, FN>;
     network?: string;
-    postConditions?: any[];
+    postConditions?: PostCondition[];
     attachment?: string;
     onFinish?: (data: any) => void;
     onCancel?: () => void;
@@ -1868,7 +2037,7 @@ function generateGenericHook(hookName) {
       contractName: string;
       codeBody: string;
       network?: string;
-      postConditions?: any[];
+      postConditions?: PostCondition[];
       onFinish?: (data: any) => void;
       onCancel?: () => void;
     }) => {
@@ -1905,7 +2074,7 @@ function generateGenericHook(hookName) {
     contractName: string;
     codeBody: string;
     network?: string;
-    postConditions?: any[];
+    postConditions?: PostCondition[];
     onFinish?: (data: any) => void;
     onCancel?: () => void;
   }) => {
@@ -1981,18 +2150,30 @@ function mapClarityTypeToTS(clarityType) {
       return "boolean";
     if (clarityType?.string || clarityType?.ascii)
       return "string";
+    if (clarityType?.["string-ascii"] || clarityType?.["string-utf8"])
+      return "string";
     if (clarityType?.buff)
       return "Uint8Array";
     if (clarityType?.optional) {
       const innerType = mapClarityTypeToTS(clarityType.optional);
       return `${innerType} | null`;
     }
-    if (clarityType?.response)
-      return "any";
-    if (clarityType?.tuple)
-      return "any";
-    if (clarityType?.list)
-      return "any[]";
+    if (clarityType?.response) {
+      const okType = mapClarityTypeToTS(clarityType.response.ok);
+      const errType = mapClarityTypeToTS(clarityType.response.error);
+      return `{ ok: ${okType} } | { err: ${errType} }`;
+    }
+    if (clarityType?.tuple) {
+      const fields = clarityType.tuple.map((field) => `${toCamelCase4(field.name)}: ${mapClarityTypeToTS(field.type)}`).join("; ");
+      return `{ ${fields} }`;
+    }
+    if (clarityType?.list) {
+      const innerType = mapClarityTypeToTS(clarityType.list.type);
+      if (innerType.includes(" | ")) {
+        return `(${innerType})[]`;
+      }
+      return `${innerType}[]`;
+    }
     return "any";
   }
   if (clarityType.includes("uint") || clarityType.includes("int"))
@@ -2009,12 +2190,6 @@ function mapClarityTypeToTS(clarityType) {
     const innerType = clarityType.replace(/optional\s*/, "").trim();
     return `${mapClarityTypeToTS(innerType)} | null`;
   }
-  if (clarityType.includes("response"))
-    return "any";
-  if (clarityType.includes("tuple"))
-    return "any";
-  if (clarityType.includes("list"))
-    return "any[]";
   return "any";
 }
 function generateObjectArgs(args) {
@@ -2029,6 +2204,7 @@ async function generateContractHooks(contracts, excludeList = []) {
 import { useCallback } from 'react'
 import { useStacksConfig } from './provider'
 import { request, openContractCall as stacksOpenContractCall } from '@stacks/connect'
+import type { PostCondition } from '@stacks/transactions'
 import { ${contracts.map((c) => c.name).join(", ")} } from './contracts'`;
   const header = `/**
  * Generated contract-specific React hooks
@@ -2052,8 +2228,10 @@ ${hooksCode}`;
   return formatted;
 }
 function generateContractHookMethods(contract, excludeList) {
-  const { abi, name } = contract;
+  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" || f.access === "read-only");
   const publicFunctions = functions.filter((f) => f.access === "public");
   const readHooks = readOnlyFunctions.map((func) => {
@@ -2070,7 +2248,30 @@ function generateContractHookMethods(contract, excludeList) {
     }
     return generateWriteHook(func, name);
   }).filter(Boolean);
-  const allHooks = [...readHooks, ...writeHooks];
+  const mapHooks = maps.map((map) => {
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(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(toCamelCase4(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(toCamelCase4(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 "";
   }
@@ -2082,12 +2283,13 @@ function generateReadHook(func, contractName) {
   const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase4(func.name))}`;
   const argsSignature = generateHookArgsSignature(func.args);
   const enabledParam = func.args.length > 0 ? ", options?: { enabled?: boolean }" : "options?: { enabled?: boolean }";
+  const returnType = mapClarityTypeToTS(func.outputs);
   return `export function ${hookName}(${argsSignature}${enabledParam}) {
   const config = useStacksConfig()
-  
-  return useQuery({
+
+  return useQuery<${returnType}>({
     queryKey: ['${func.name}', ${contractName}.address, ${generateQueryKeyArgs(func.args)}],
-    queryFn: () => ${contractName}.read.${toCamelCase4(func.name)}(${generateFunctionCallArgs(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{ 
+    queryFn: () => ${contractName}.read.${toCamelCase4(func.name)}(${generateFunctionCallArgs(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
       network: config.network,
       senderAddress: config.senderAddress || 'SP000000000000000000002Q6VF78'
     }),
@@ -2107,7 +2309,7 @@ function generateWriteHook(func, contractName) {
     mutationFn: async (params: {
       args: ${argsType};
       options?: {
-        postConditions?: any[];
+        postConditions?: PostCondition[];
         attachment?: string;
         onFinish?: (data: any) => void;
         onCancel?: () => void;
@@ -2165,9 +2367,9 @@ function generateWriteHook(func, contractName) {
   })
 
   const ${toCamelCase4(func.name)} = useCallback(async (
-    args: ${argsType}, 
+    args: ${argsType},
     options?: {
-      postConditions?: any[];
+      postConditions?: PostCondition[];
       attachment?: string;
       onFinish?: (data: any) => void;
       onCancel?: () => void;
@@ -2188,6 +2390,53 @@ function generateWriteHook(func, contractName) {
   }
 }`;
 }
+function generateMapHook(map, contractVarName, _address, _contractName) {
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(map.name))}`;
+  const keyType = mapClarityTypeToTS(map.key);
+  const valueType = mapClarityTypeToTS(map.value);
+  return `export function ${hookName}(key: ${keyType}, options?: { enabled?: boolean }) {
+  const config = useStacksConfig()
+
+  return useQuery<${valueType} | null>({
+    queryKey: ['${contractVarName}', '${map.name}', 'map', key, config.network],
+    queryFn: async () => {
+      return ${contractVarName}.maps.${toCamelCase4(map.name)}.get(key, { network: config.network })
+    },
+    enabled: options?.enabled ?? true
+  })
+}`;
+}
+function generateVarHook(variable, contractVarName, _address, _contractName) {
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(variable.name))}`;
+  const valueType = mapClarityTypeToTS(variable.type);
+  return `export function ${hookName}(options?: { enabled?: boolean }) {
+  const config = useStacksConfig()
+
+  return useQuery<${valueType}>({
+    queryKey: ['${contractVarName}', '${variable.name}', 'var', config.network],
+    queryFn: async () => {
+      return ${contractVarName}.vars.${toCamelCase4(variable.name)}.get({ network: config.network })
+    },
+    enabled: options?.enabled ?? true
+  })
+}`;
+}
+function generateConstantHook(constant, contractVarName, _address, _contractName) {
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(constant.name))}`;
+  const valueType = mapClarityTypeToTS(constant.type);
+  return `export function ${hookName}(options?: { enabled?: boolean }) {
+  const config = useStacksConfig()
+
+  return useQuery<${valueType}>({
+    queryKey: ['${contractVarName}', '${constant.name}', 'constant', config.network],
+    queryFn: async () => {
+      return ${contractVarName}.constants.${toCamelCase4(constant.name)}.get({ network: config.network })
+    },
+    enabled: options?.enabled ?? true,
+    staleTime: Infinity // Constants never change
+  })
+}`;
+}
 
 // src/plugins/react/index.ts
 var react = (options = {}) => {
@@ -2441,7 +2690,7 @@ function getMapKeyType(keyType) {
   }
   return getTypeForArg3({ type: keyType });
 }
-function generateMapKeyConversion(keyType) {
+function generateMapKeyConversion2(keyType) {
   if (keyType.tuple) {
     const fields = keyType.tuple.map((field) => {
       const camelFieldName = toCamelCase5(field.name);
@@ -2455,7 +2704,7 @@ function generateMapKeyConversion(keyType) {
 function generateMapEntryHelper(map, contractId) {
   const methodName = toCamelCase5(map.name);
   const keyType = getMapKeyType(map.key);
-  const keyConversion = generateMapKeyConversion(map.key);
+  const keyConversion = generateMapKeyConversion2(map.key);
   return `${methodName}: (key: ${keyType}) => {
       return simnet.getMapEntry(
         '${contractId}',
@@ -2464,7 +2713,7 @@ function generateMapEntryHelper(map, contractId) {
       );
     }`;
 }
-function generateVarsObject(variables, contractId) {
+function generateVarsObject2(variables, contractId) {
   const dataVars = variables.filter((v) => v.access === "variable");
   if (dataVars.length === 0) {
     return "";
@@ -2476,7 +2725,7 @@ function generateVarsObject(variables, contractId) {
       `)}
     }`;
 }
-function generateMapsObject(maps, contractId) {
+function generateMapsObject2(maps, contractId) {
   if (maps.length === 0) {
     return "";
   }
@@ -2499,8 +2748,8 @@ function generateContractHelper(contract, options) {
   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 = generateVarsObject(variables, address);
-  const mapsObject = generateMapsObject(maps, address);
+  const varsObject = generateVarsObject2(variables, address);
+  const mapsObject = generateMapsObject2(maps, address);
   const allHelpers = [...publicHelpers, ...readOnlyHelpers, ...privateHelpers];
   if (varsObject) {
     allHelpers.push(varsObject);
@@ -2651,5 +2900,5 @@ export {
   PluginManager
 };
 
-//# debugId=CABE7BED1349452C64756E2164756E21
+//# debugId=3D064257DAF105D164756E2164756E21
 //# sourceMappingURL=index.js.map