@secondlayer/cli 0.2.5 → 0.3.1

package/dist/cli.js

@@ -15702,6 +15702,8 @@ function inferReturnType(body) {
 function parseApiResponse(apiResponse) {
   try {
     const functions = [];
+    const maps = [];
+    const variables = [];
     if (apiResponse.functions) {
       for (const func of apiResponse.functions) {
         const access = func.access === "read_only" ? "read-only" : func.access;
@@ -15716,7 +15718,29 @@ function parseApiResponse(apiResponse) {
         });
       }
     }
-    return { functions };
+    if (apiResponse.maps) {
+      for (const map of apiResponse.maps) {
+        maps.push({
+          name: map.name,
+          key: convertApiType(map.key),
+          value: convertApiType(map.value)
+        });
+      }
+    }
+    if (apiResponse.variables) {
+      for (const variable of apiResponse.variables) {
+        variables.push({
+          name: variable.name,
+          type: convertApiType(variable.type),
+          access: variable.access
+        });
+      }
+    }
+    return {
+      functions,
+      maps: maps.length > 0 ? maps : undefined,
+      variables: variables.length > 0 ? variables : undefined
+    };
   } catch (error) {
     throw new Error(`Failed to parse API response: ${error}`);
   }
@@ -15787,12 +15811,44 @@ var init_clarity = () => {};
 
 // src/generators/contract.ts
 import { format } from "prettier";
+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];
+}`;
+}
 async function generateContractInterface(contracts) {
   const imports = `import { Cl, validateStacksAddress } from '@stacks/transactions'`;
   const header = `/**
  * Generated by @secondlayer/cli
  * DO NOT EDIT MANUALLY
  */`;
+  const networkUtils = generateNetworkUtils();
   const contractsCode = contracts.map((contract) => generateContract(contract)).join(`
 
 `);
@@ -15800,6 +15856,8 @@ async function generateContractInterface(contracts) {
 
 ${header}
 
+${networkUtils}
+
 ${contractsCode}`;
   const formatted = await format(code, {
     parser: "typescript",
@@ -15816,12 +15874,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}
 
@@ -16032,6 +16096,143 @@ 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 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(\`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 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(\`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 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(\`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 });
+}
 var init_contract = () => {};
 
 // src/commands/generate.ts
@@ -16361,7 +16562,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "0.2.5",
+  version: "0.3.1",
   description: "CLI for generating type-safe contract interfaces for the Stacks blockchain",
   type: "module",
   bin: {
@@ -16400,7 +16601,7 @@ var package_default = {
   author: "",
   license: "MIT",
   dependencies: {
-    "@secondlayer/clarity-types": "^0.2.2",
+    "@secondlayer/clarity-types": "^0.3.0",
     "@stacks/transactions": "7.0.6",
     esbuild: "^0.19.0",
     prettier: "^3.1.0"
@@ -16437,5 +16638,5 @@ program.command("init").description("Initialize a new stacks.config.ts file").ac
 });
 program.parse();
 
-//# debugId=C236EDEA54ABBFA664756E2164756E21
+//# debugId=00D09707C564934264756E2164756E21
 //# sourceMappingURL=cli.js.map