@secondlayer/cli 8.6.1 → 8.6.3

package/dist/cli.js

@@ -20296,562 +20296,15 @@ var require_out4 = __commonJS((exports, module) => {
   module.exports = FastGlob;
 });
 
-// src/utils/clarity-conversion.ts
-import {
-  isAbiBuffer as isAbiBuffer2,
-  isAbiList,
-  isAbiOptional as isAbiOptional2,
-  isAbiResponse,
-  isAbiStringAscii as isAbiStringAscii2,
-  isAbiStringUtf8 as isAbiStringUtf82,
-  isAbiTuple,
-  toCamelCase as toCamelCase4
-} 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 (isAbiStringAscii2(type)) {
-    return `Cl.stringAscii(${argName})`;
-  }
-  if (isAbiStringUtf82(type)) {
-    return `Cl.stringUtf8(${argName})`;
-  }
-  if (isAbiBuffer2(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 (isAbiOptional2(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 = toCamelCase4(field.name);
-      const fieldConversion = generateClarityConversion(`tupleValue.${camelFieldName}`, { type: field.type });
-      return `"${field.name}": ${fieldConversion}`;
-    }).join(", ");
-    return `(() => {
-      const tupleValue = ${argName};
-      const requiredFields = ${fieldNames};
-      for (const fieldName of requiredFields) {
-        const camelName = fieldName.replace(/-([a-z])/g, (_: string, l: string) => l.toUpperCase());
-        if (!(fieldName in tupleValue) && !(camelName in tupleValue)) {
-          throw new Error(\`Missing tuple field: \${fieldName}\`);
-        }
-      }
-      return Cl.tuple({ ${fields} });
-    })()`;
-  }
-  if (isAbiResponse(type)) {
-    const okConversion = generateClarityConversion("responseValue.ok", {
-      type: type.response.ok
-    });
-    const errConversion = generateClarityConversion("responseValue.err", {
-      type: type.response.error
-    });
-    return `(() => {
-      const responseValue = ${argName};
-      const hasOk = 'ok' in responseValue;
-      const hasErr = 'err' in responseValue;
-      if (hasOk && !hasErr) {
-        return Cl.ok(${okConversion});
-      }
-      if (hasErr && !hasOk) {
-        return Cl.error(${errConversion});
-      }
-      throw new Error("Response must have exactly 'ok' or 'err' property");
-    })()`;
-  }
-  return `${argName}`;
-}
-var init_clarity_conversion = () => {};
-
-// src/utils/type-mapping.ts
-import {
-  isAbiBuffer as isAbiBuffer3,
-  isAbiList as isAbiList2,
-  isAbiOptional as isAbiOptional3,
-  isAbiResponse as isAbiResponse2,
-  isAbiStringAscii as isAbiStringAscii3,
-  isAbiStringUtf8 as isAbiStringUtf83,
-  isAbiTuple as isAbiTuple2,
-  toCamelCase as toCamelCase5
-} 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 (isAbiBuffer3(type)) {
-    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
-  }
-  if (isAbiStringAscii3(type) || isAbiStringUtf83(type)) {
-    return "string";
-  }
-  if (isAbiOptional3(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) => `${toCamelCase5(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
-    return `{ ${fields} }`;
-  }
-  if (isAbiResponse2(type)) {
-    const okType = clarityTypeToTS(type.response.ok);
-    const errType = clarityTypeToTS(type.response.error);
-    return `{ ok: ${okType} } | { err: ${errType} }`;
-  }
-  return "any";
-}
-function getTypeForArg(arg) {
-  return clarityTypeToTS(arg.type);
-}
-var init_type_mapping = () => {};
-
-// src/utils/generator-helpers.ts
-import {
-  isAbiTuple as isAbiTuple3,
-  toCamelCase as toCamelCase6
-} from "@secondlayer/stacks/clarity";
-function generateArgsSignature(args) {
-  if (args.length === 0)
-    return "";
-  const argsTypes = args.map((arg) => {
-    const camelName = toCamelCase6(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.${toCamelCase6(arg.name)}`;
-    return generateClarityConversion(argName, arg);
-  }).join(", ");
-}
-function generateMapKeyConversion(keyType) {
-  if (isAbiTuple3(keyType)) {
-    const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase6(field.name);
-      const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
-      return `"${field.name}": ${fieldConversion}`;
-    }).join(", ");
-    return `Cl.tuple({ ${fields} })`;
-  }
-  return generateClarityConversion("key", { type: keyType });
-}
-var init_generator_helpers = __esm(() => {
-  init_clarity_conversion();
-  init_type_mapping();
-});
-
 // src/generators/contract.ts
 import {
-  toCamelCase as toCamelCase7
-} from "@secondlayer/stacks/clarity";
-function generateNetworkUtils() {
-  return `/**
- * API URLs for different networks
- */
-const API_URLS: Record<'mainnet' | 'testnet' | 'devnet', string> = {
-  mainnet: 'https://api.hiro.so',
-  testnet: 'https://api.testnet.hiro.so',
-  devnet: 'http://localhost:3999'
-};
-
-/**
- * Infer network from Stacks address prefix
- * SP/SM = mainnet, ST/SN = testnet
- */
-function inferNetworkFromAddress(address: string): 'mainnet' | 'testnet' | undefined {
-  if (address.startsWith('SP') || address.startsWith('SM')) return 'mainnet';
-  if (address.startsWith('ST') || address.startsWith('SN')) return 'testnet';
-  return undefined;
-}
-
-/**
- * Get API URL, inferring network from contract address if not specified
- */
-function getApiUrl(
-  contractAddress: string,
-  explicitNetwork?: 'mainnet' | 'testnet' | 'devnet'
-): string {
-  const network = explicitNetwork ?? inferNetworkFromAddress(contractAddress) ?? 'mainnet';
-  return API_URLS[network];
-}`;
-}
-function generateValidationUtils() {
-  return `/**
- * Contract name validation regex
- * Must start with letter, contain only letters, numbers, and hyphens, max 128 chars
- */
-const CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9\\-]{0,127}$/;`;
-}
+  generateContractInterface as buildContractInterface
+} from "@secondlayer/scaffold";
 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 = toCamelCase7(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 = toCamelCase7(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) => toCamelCase7(arg.name)).join(", ");
-  const argsTypes = func.args.map((arg) => {
-    const camelName = toCamelCase7(arg.name);
-    return `${camelName}: ${getTypeForArg(arg)}`;
-  }).join("; ");
-  const argsArray = func.args.map((arg) => {
-    const argName = toCamelCase7(arg.name);
-    return generateClarityConversion(argName, arg);
-  }).join(", ");
-  const objectAccess = func.args.map((arg) => {
-    const camelName = toCamelCase7(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 = toCamelCase7(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 = toCamelCase7(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 = toCamelCase7(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(`,
-
-    `)}
-  }`;
+  return formatCode(buildContractInterface(contracts));
 }
 var init_contract = __esm(() => {
-  init_clarity_conversion();
   init_format();
-  init_generator_helpers();
-  init_type_mapping();
 });
 
 // src/utils/config.ts
@@ -32098,7 +31551,7 @@ __export(exports_generate, {
 });
 import path11 from "node:path";
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { toCamelCase as toCamelCase8 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase4 } from "@secondlayer/stacks/clarity";
 function isContractAddress(input5) {
   const contractIdPattern = /^(SP|ST|SM|SN)[A-Z0-9]{38,}\.[a-zA-Z][a-zA-Z0-9-]*$/;
   return contractIdPattern.test(input5);
@@ -32159,7 +31612,7 @@ async function buildConfigFromInputs(parsedInputs, outPath, apiKey, defaultAddre
       const apiClient = new StacksApiClient(network, apiKey);
       const contractInfo = await apiClient.getContractInfo(contractId);
       const abi = parseApiResponse(contractInfo);
-      const name = toCamelCase8(contractName);
+      const name = toCamelCase4(contractName);
       contracts.push({
         name,
         address: contractId,
@@ -32354,7 +31807,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "8.6.1",
+  version: "8.6.3",
   repository: {
     type: "git",
     url: "git+https://github.com/ryanwaits/secondlayer.git",
@@ -32403,9 +31856,10 @@ var package_default = {
   dependencies: {
     "@inquirer/prompts": "^8.2.0",
     "@secondlayer/bundler": "^0.3.7",
-    "@secondlayer/sdk": "^6.16.0",
-    "@secondlayer/shared": "^6.27.0",
-    "@secondlayer/stacks": "^2.3.0",
+    "@secondlayer/scaffold": "^1.1.0",
+    "@secondlayer/sdk": "^6.19.0",
+    "@secondlayer/shared": "^6.28.0",
+    "@secondlayer/stacks": "^2.4.0",
     "@secondlayer/subgraphs": "^3.10.0",
     "@biomejs/js-api": "^0.7.0",
     "@biomejs/wasm-nodejs": "^1.9.0",
@@ -34631,9 +34085,11 @@ import { dirname as dirname5, join as join7, resolve as resolve2 } from "node:pa
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { confirm as confirm3 } from "@inquirer/prompts";
 import { ByoBreakingChangeError } from "@secondlayer/sdk";
+import { TRAIT_STANDARDS } from "@secondlayer/stacks/clarity";
 
 // src/generators/subgraph-scaffold.ts
 init_format();
+import { generateTraitSubgraph } from "@secondlayer/scaffold";
 import { classifyContract } from "@secondlayer/stacks/clarity";
 
 // src/generators/clarity-to-subgraph.ts
@@ -34710,7 +34166,7 @@ ${handlers}
 }
 function tokenScaffold(name, source) {
   const isFt = source.type === "ft_transfer";
-  const scope = source.trait ? `trait: '${source.trait}'` : `assetIdentifier: '${source.assetIdentifier}'`;
+  const scope = `assetIdentifier: '${source.assetIdentifier}'`;
   const cols = isFt ? `        sender: { type: 'principal' },
         recipient: { type: 'principal' },
         amount: { type: 'uint' },
@@ -34774,9 +34230,7 @@ ${cols || "        sender: { type: 'principal' }"}
 }
 async function generateSubgraphScaffold(input2) {
   if (input2.trait) {
-    const name2 = input2.subgraphName ?? `${input2.trait}-transfers`;
-    const type = input2.trait === "sip-009" ? "nft_transfer" : "ft_transfer";
-    return formatCode(tokenScaffold(name2, { type, trait: input2.trait }));
+    return formatCode(generateTraitSubgraph({ trait: input2.trait, name: input2.subgraphName }));
   }
   const { contractId, abi } = input2;
   if (!contractId || !abi) {
@@ -36348,8 +35802,8 @@ Examples:
         process.exit(1);
       }
       const trait = options2.trait;
-      if (trait && !["sip-009", "sip-010", "sip-013"].includes(trait)) {
-        error("--trait must be one of: sip-009, sip-010, sip-013");
+      if (trait && !TRAIT_STANDARDS.includes(trait)) {
+        error(`--trait must be one of: ${TRAIT_STANDARDS.join(", ")}`);
         process.exit(1);
       }
       if (!trait && !contractAddress) {
@@ -38458,5 +37912,5 @@ registerAccountCommand(program);
 registerKeysCommand(program);
 program.parse();
 
-//# debugId=2E1CD81E99BBC74264756E2164756E21
+//# debugId=FD969C75B9A203B164756E2164756E21
 //# sourceMappingURL=cli.js.map