@secondlayer/cli 14.0.0 → 14.0.1

package/README.md

@@ -196,6 +196,12 @@ secondlayer codegen contracts "./contracts/*.clar" -o ./src/generated.ts
 secondlayer codegen contracts --watch   # regenerate on .clar / config / Clarinet.toml changes
 ```
 
+Where the types come from matters. A bare `.clar` path is read as source, and
+source only declares argument, map, and data-var types — a function's return
+type comes out of Clarity's type checker, so it generates as `any`. A deployed
+contract id or the `clarinet()` plugin (below) carries a real ABI, so returns
+are exact too. Prefer those where you can.
+
 Config-driven:
 
 ```bash

package/dist/cli.js

@@ -8831,57 +8831,111 @@ var init_contract = __esm(() => {
 // src/parsers/clarity.ts
 import { promises as fs2 } from "node:fs";
 import { normalizeAbi } from "@secondlayer/stacks/clarity";
-async function parseClarityFile(filePath) {
-  try {
-    const content = await fs2.readFile(filePath, "utf-8");
-    const result = parseClarityContent(content);
-    if (result.functions.length === 0) {
-      console.warn(`⚠️  No functions found in ${filePath}. For complex contracts, deploy first and use the contract address instead.`);
-    }
-    return result;
-  } catch (error2) {
-    throw new Error(`Unable to parse ${filePath}. For complex contracts, deploy first and use the contract address instead.
-Original error: ${error2}`);
-  }
+function isWhitespace(char) {
+  return char === " " || char === "\t" || char === "\r" || char === `
+`;
 }
-function parseClarityContent(content) {
-  const functions = [];
-  const functionRegex = /\(define-(public|read-only|private)\s+\(([^)]+)\)([\s\S]*?)\)\s*$/gm;
-  let match = functionRegex.exec(content);
-  while (match !== null) {
-    const [, access, signature, body] = match;
-    const func = parseFunctionSignature(signature, access, body);
-    if (func) {
-      functions.push(func);
+function isCommentStart(source, index) {
+  return source[index] === ";" && source[index + 1] === ";";
+}
+function tokenize(source) {
+  const tokens = [];
+  let i = 0;
+  while (i < source.length) {
+    const char = source[i];
+    if (isCommentStart(source, i)) {
+      while (i < source.length && source[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (isWhitespace(char)) {
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      let end2 = i + 1;
+      while (end2 < source.length && source[end2] !== '"') {
+        if (source[end2] === "\\")
+          end2++;
+        end2++;
+      }
+      tokens.push(source.slice(i, Math.min(end2 + 1, source.length)));
+      i = end2 + 1;
+      continue;
+    }
+    if (DELIMITERS.has(char)) {
+      tokens.push(char);
+      i++;
+      continue;
     }
-    match = functionRegex.exec(content);
+    let end = i;
+    while (end < source.length && !isWhitespace(source[end]) && !DELIMITERS.has(source[end]) && source[end] !== '"' && !isCommentStart(source, end)) {
+      end++;
+    }
+    tokens.push(source.slice(i, end));
+    i = end;
   }
-  return { functions };
+  return tokens;
 }
-function parseFunctionSignature(signature, access, body) {
-  const parts = signature.trim().split(/\s+/);
-  const name = parts[0];
-  const args = [];
-  for (let i = 1;i < parts.length; i += 2) {
-    if (parts[i] && parts[i + 1]) {
-      const argName = parts[i].replace(/[()]/g, "");
-      const argType = parseType(parts[i + 1]);
-      if (argType) {
-        args.push({ name: argName, type: argType });
-      }
+function readForms(source) {
+  const tokens = tokenize(source);
+  let pos = 0;
+  function readNode() {
+    const token = tokens[pos];
+    if (token === undefined)
+      return null;
+    if (token === "(") {
+      pos++;
+      return { kind: "list", items: readList() };
+    }
+    if (token === "{") {
+      pos++;
+      return { kind: "tuple", fields: readTupleFields() };
+    }
+    if (DELIMITERS.has(token)) {
+      pos++;
+      return null;
     }
+    pos++;
+    return { kind: "atom", value: token };
+  }
+  function readList() {
+    const items = [];
+    while (pos < tokens.length && tokens[pos] !== ")") {
+      const node = readNode();
+      if (node)
+        items.push(node);
+    }
+    pos++;
+    return items;
+  }
+  function readTupleFields() {
+    const fields = [];
+    while (pos < tokens.length && tokens[pos] !== "}") {
+      const name = tokens[pos];
+      pos++;
+      if (name === "," || name === ":")
+        continue;
+      if (tokens[pos] === ":")
+        pos++;
+      const value = readNode();
+      if (value)
+        fields.push({ name, value });
+    }
+    pos++;
+    return fields;
   }
-  const outputs = inferReturnType(body);
-  return {
-    name,
-    access,
-    args,
-    outputs
-  };
+  const forms = [];
+  while (pos < tokens.length) {
+    const node = readNode();
+    if (node)
+      forms.push(node);
+  }
+  return forms;
 }
-function parseType(typeStr) {
-  const cleaned = typeStr.replace(/[()]/g, "").trim();
-  switch (cleaned) {
+function atomToAbi(value) {
+  switch (value) {
     case "uint":
     case "uint128":
       return "uint128";
@@ -8893,35 +8947,201 @@ function parseType(typeStr) {
     case "principal":
       return "principal";
     case "trait_reference":
-      return "principal";
+      return "trait_reference";
+    default:
+      return value.startsWith("<") ? "trait_reference" : UNKNOWN;
+  }
+}
+function readLength(node) {
+  if (node?.kind !== "atom")
+    return null;
+  const length = Number.parseInt(node.value, 10);
+  return Number.isSafeInteger(length) && length >= 0 ? length : null;
+}
+function readFieldPairs(nodes) {
+  return nodes.flatMap((node) => {
+    if (node.kind !== "list")
+      return [];
+    const [name, type] = node.items;
+    if (name?.kind !== "atom" || !type)
+      return [];
+    return [{ name: name.value, type: typeToAbi(type) }];
+  });
+}
+function typeToAbi(node) {
+  if (node.kind === "atom")
+    return atomToAbi(node.value);
+  if (node.kind === "tuple") {
+    return {
+      tuple: node.fields.map((field) => ({
+        name: field.name,
+        type: typeToAbi(field.value)
+      }))
+    };
+  }
+  const [head, ...args] = node.items;
+  if (!head)
+    return UNKNOWN;
+  if (head.kind !== "atom") {
+    const fields = readFieldPairs(node.items);
+    return fields.length > 0 ? { tuple: fields } : UNKNOWN;
+  }
+  switch (head.value) {
+    case "string-ascii": {
+      const length = readLength(args[0]);
+      return length === null ? UNKNOWN : { "string-ascii": { length } };
+    }
+    case "string-utf8": {
+      const length = readLength(args[0]);
+      return length === null ? UNKNOWN : { "string-utf8": { length } };
+    }
+    case "buff": {
+      const length = readLength(args[0]);
+      return length === null ? UNKNOWN : { buff: { length } };
+    }
+    case "optional":
+      return args[0] ? { optional: typeToAbi(args[0]) } : UNKNOWN;
+    case "list": {
+      const length = readLength(args[0]);
+      if (length === null || !args[1])
+        return UNKNOWN;
+      return { list: { length, type: typeToAbi(args[1]) } };
+    }
+    case "response":
+      return args[0] && args[1] ? { response: { ok: typeToAbi(args[0]), error: typeToAbi(args[1]) } } : UNKNOWN;
+    case "tuple": {
+      const fields = readFieldPairs(args);
+      return fields.length > 0 ? { tuple: fields } : UNKNOWN;
+    }
     default:
-      if (cleaned.startsWith("string-ascii")) {
-        return { "string-ascii": { length: 256 } };
+      return UNKNOWN;
+  }
+}
+function toFunction(form, access) {
+  const signature = form[1];
+  if (signature?.kind !== "list")
+    return null;
+  const [nameNode, ...argNodes] = signature.items;
+  if (nameNode?.kind !== "atom")
+    return null;
+  const args = argNodes.flatMap((node) => {
+    if (node.kind !== "list")
+      return [];
+    const [name, type] = node.items;
+    if (name?.kind !== "atom" || !type)
+      return [];
+    return [{ name: name.value, type: typeToAbi(type) }];
+  });
+  return {
+    name: nameNode.value,
+    access,
+    args,
+    outputs: access === "public" ? { response: { ok: UNKNOWN, error: UNKNOWN } } : UNKNOWN
+  };
+}
+function toMap(form) {
+  const [, nameNode, key, value] = form;
+  if (nameNode?.kind !== "atom" || !key || !value)
+    return null;
+  return { name: nameNode.value, key: typeToAbi(key), value: typeToAbi(value) };
+}
+function toVariable(form) {
+  const [, nameNode, type] = form;
+  if (nameNode?.kind !== "atom" || !type)
+    return null;
+  return { name: nameNode.value, type: typeToAbi(type), access: "variable" };
+}
+function toFungibleToken(form) {
+  const nameNode = form[1];
+  if (nameNode?.kind !== "atom")
+    return null;
+  return { name: nameNode.value };
+}
+function toNonFungibleToken(form) {
+  const [, nameNode, type] = form;
+  if (nameNode?.kind !== "atom")
+    return null;
+  return { name: nameNode.value, type: type ? typeToAbi(type) : UNKNOWN };
+}
+function parseClarityContent(content) {
+  const functions = [];
+  const maps = [];
+  const variables = [];
+  const fungibleTokens = [];
+  const nonFungibleTokens = [];
+  const implementedTraits = [];
+  for (const form of readForms(content)) {
+    if (form.kind !== "list")
+      continue;
+    const head = form.items[0];
+    if (head?.kind !== "atom")
+      continue;
+    const access = FUNCTION_ACCESS[head.value];
+    if (access) {
+      const func = toFunction(form.items, access);
+      if (func)
+        functions.push(func);
+      continue;
+    }
+    switch (head.value) {
+      case "define-map": {
+        const map = toMap(form.items);
+        if (map)
+          maps.push(map);
+        break;
       }
-      if (cleaned.startsWith("string-utf8")) {
-        return { "string-utf8": { length: 256 } };
+      case "define-data-var": {
+        const variable = toVariable(form.items);
+        if (variable)
+          variables.push(variable);
+        break;
       }
-      if (cleaned.startsWith("buff")) {
-        return { buff: { length: 32 } };
+      case "define-fungible-token": {
+        const token = toFungibleToken(form.items);
+        if (token)
+          fungibleTokens.push(token);
+        break;
       }
-      return "uint128";
-  }
-}
-function inferReturnType(body) {
-  if (body.includes("(ok")) {
-    if (body.includes("(err")) {
-      return {
-        response: {
-          ok: "bool",
-          error: "uint128"
+      case "define-non-fungible-token": {
+        const token = toNonFungibleToken(form.items);
+        if (token)
+          nonFungibleTokens.push(token);
+        break;
+      }
+      case "impl-trait": {
+        const trait = form.items[1];
+        if (trait?.kind === "atom") {
+          implementedTraits.push(trait.value.replace(/^'/, ""));
         }
-      };
+        break;
+      }
     }
   }
-  if (body.includes("true") || body.includes("false")) {
-    return "bool";
+  return {
+    functions,
+    ...maps.length > 0 && { maps },
+    ...variables.length > 0 && { variables },
+    ...fungibleTokens.length > 0 && { fungible_tokens: fungibleTokens },
+    ...nonFungibleTokens.length > 0 && {
+      non_fungible_tokens: nonFungibleTokens
+    },
+    ...implementedTraits.length > 0 && {
+      implemented_traits: implementedTraits
+    }
+  };
+}
+async function parseClarityFile(filePath) {
+  try {
+    const content = await fs2.readFile(filePath, "utf-8");
+    const result = parseClarityContent(content);
+    if (result.functions.length === 0) {
+      console.warn(`⚠️  No functions found in ${filePath}. For complex contracts, deploy first and use the contract address instead.`);
+    }
+    return result;
+  } catch (error2) {
+    throw new Error(`Unable to parse ${filePath}. For complex contracts, deploy first and use the contract address instead.
+Original error: ${error2}`);
   }
-  return "bool";
 }
 function parseApiResponse(apiResponse) {
   try {
@@ -8930,7 +9150,15 @@ function parseApiResponse(apiResponse) {
     throw new Error(`Failed to parse API response: ${error2}`);
   }
 }
-var init_clarity = () => {};
+var DELIMITERS, UNKNOWN = "unknown", FUNCTION_ACCESS;
+var init_clarity = __esm(() => {
+  DELIMITERS = new Set(["(", ")", "{", "}", ",", ":"]);
+  FUNCTION_ACCESS = {
+    "define-public": "public",
+    "define-read-only": "read-only",
+    "define-private": "private"
+  };
+});
 
 // ../../node_modules/@sindresorhus/is/dist/index.js
 function isTypedArrayName(name) {
@@ -20969,10 +21197,10 @@ var isTemplateString = (templates) => Array.isArray(templates) && Array.isArray(
   }
   const nextTokens = [];
   let templateStart = 0;
-  const leadingWhitespaces = DELIMITERS.has(rawTemplate[0]);
+  const leadingWhitespaces = DELIMITERS2.has(rawTemplate[0]);
   for (let templateIndex = 0, rawIndex = 0;templateIndex < template.length; templateIndex += 1, rawIndex += 1) {
     const rawCharacter = rawTemplate[rawIndex];
-    if (DELIMITERS.has(rawCharacter)) {
+    if (DELIMITERS2.has(rawCharacter)) {
       if (templateStart !== templateIndex) {
         nextTokens.push(template.slice(templateStart, templateIndex));
       }
@@ -20995,7 +21223,7 @@ var isTemplateString = (templates) => Array.isArray(templates) && Array.isArray(
     nextTokens.push(template.slice(templateStart));
   }
   return { nextTokens, leadingWhitespaces, trailingWhitespaces };
-}, DELIMITERS, ESCAPE_LENGTH, concatTokens = (tokens, nextTokens, isSeparated) => isSeparated || tokens.length === 0 || nextTokens.length === 0 ? [...tokens, ...nextTokens] : [
+}, DELIMITERS2, ESCAPE_LENGTH, concatTokens = (tokens, nextTokens, isSeparated) => isSeparated || tokens.length === 0 || nextTokens.length === 0 ? [...tokens, ...nextTokens] : [
   ...tokens.slice(0, -1),
   `${tokens.at(-1)}${nextTokens[0]}`,
   ...nextTokens.slice(1)
@@ -21028,7 +21256,7 @@ var isTemplateString = (templates) => Array.isArray(templates) && Array.isArray(
 };
 var init_template = __esm(() => {
   init_uint_array();
-  DELIMITERS = new Set([" ", "\t", "\r", `
+  DELIMITERS2 = new Set([" ", "\t", "\r", `
 `]);
   ESCAPE_LENGTH = { x: 3, u: 5 };
 });
@@ -27907,6 +28135,9 @@ async function buildConfigFromInputs(parsedInputs, outPath, apiKey, defaultAddre
    Generated contract addresses won't match deployed addresses.
    Set defaultAddress in config or use deployed contract addresses.`));
   }
+  if (parsedInputs.files.length > 0) {
+    console.warn(source_default.yellow("⚠️  Return types can't be read from Clarity source and will be `any`.\n   Use the clarinet() plugin or a deployed contract id for exact types."));
+  }
   for (const file of parsedInputs.files) {
     const abi = await parseClarityFile(file);
     const name = deriveContractName(file);
@@ -36546,7 +36777,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "14.0.0",
+  version: "14.0.1",
   description: "Run a Stacks index on your own hardware — set it up, restore verified history, and keep it current.",
   repository: {
     type: "git",
@@ -36593,7 +36824,7 @@ var package_default = {
     "@secondlayer/scaffold": "^1.5.5",
     "@secondlayer/sdk": "^10.0.0",
     "@secondlayer/shared": "^11.2.0",
-    "@secondlayer/stacks": "^5.0.0",
+    "@secondlayer/stacks": "^5.0.1",
     "@secondlayer/subgraphs": "^4.1.1",
     esbuild: "^0.27.4",
     react: "^19.1.0",
@@ -42515,5 +42746,5 @@ program.commandsGroup("Archive:");
 registerCreditsCommand(program);
 program.parse();
 
-//# debugId=80EA4C7A072B2FCB64756E2164756E21
+//# debugId=70015BE103AF7D4B64756E2164756E21
 //# sourceMappingURL=cli.js.map