@zktx.io/sui-move-builder 0.1.0

package/README.md

@@ -0,0 +1,84 @@
+# @zktx.io/sui-move-builder
+
+Build Move packages in web or Node.js with dependency fetching and dump outputs.
+
+## Install
+
+```bash
+npm install @zktx.io/sui-move-builder
+```
+
+## Quick start (Node.js or browser)
+
+```ts
+import { initMoveCompiler, buildMovePackage } from "@zktx.io/sui-move-builder";
+
+// 1) Load the WASM once
+await initMoveCompiler();
+
+// 2) Prepare files as an in-memory folder (Move.toml + sources/*)
+const files = {
+  "Move.toml": `
+[package]
+name = "hello_world"
+version = "0.0.1"
+
+[addresses]
+hello_world = "0x0"
+`,
+  "sources/hello_world.move": `
+module hello_world::hello_world {
+  // your code...
+}
+`,
+};
+
+// 3) Compile
+const result = await buildMovePackage({ files, dependencies: {} });
+
+if (result.success) {
+  console.log(result.digest);
+  console.log(result.modules); // Base64-encoded Move modules
+} else {
+  console.error(result.error);
+}
+```
+
+## Resolving dependencies from GitHub (optional)
+
+```ts
+import { resolve, GitHubFetcher } from "@zktx.io/sui-move-builder";
+
+const resolution = await resolve(
+  files["Move.toml"],
+  files,
+  new GitHubFetcher()
+);
+
+const filesJson =
+  typeof resolution.files === "string"
+    ? JSON.parse(resolution.files)
+    : resolution.files;
+const depsJson =
+  typeof resolution.dependencies === "string"
+    ? JSON.parse(resolution.dependencies)
+    : resolution.dependencies;
+
+const result = await buildMovePackage({
+  files: filesJson,
+  dependencies: depsJson,
+});
+```
+
+`buildMovePackage` returns:
+
+- `success: true | false`
+- on success: `modules` (Base64), `dependencies`, `digest`
+- on failure: `error` with compiler logs
+
+## Local test page
+
+```
+npm run serve:test   # serves ./test via python -m http.server
+# open http://localhost:8000/test/index.html
+```

package/dist/index.cjs

@@ -0,0 +1,542 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Fetcher: () => Fetcher,
+  GitHubFetcher: () => GitHubFetcher,
+  Resolver: () => Resolver,
+  buildMovePackage: () => buildMovePackage,
+  compileRaw: () => compileRaw,
+  getSuiMoveVersion: () => getSuiMoveVersion,
+  getSuiVersion: () => getSuiVersion,
+  getWasmBindings: () => getWasmBindings,
+  initMoveCompiler: () => initMoveCompiler,
+  parseToml: () => parseToml,
+  resolve: () => resolve
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/tomlParser.ts
+function stripInlineComment(line) {
+  let inQuote = false;
+  let quoteChar = "";
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if ((ch === '"' || ch === "'") && (!inQuote || ch === quoteChar)) {
+      inQuote = !inQuote;
+      quoteChar = ch;
+    }
+    if (!inQuote && ch === "#") {
+      return line.slice(0, i);
+    }
+  }
+  return line;
+}
+function parseScalar(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  const num = Number(trimmed);
+  if (!Number.isNaN(num)) return num;
+  return trimmed;
+}
+function parseInlineTable(value) {
+  const result = {};
+  const inner = value.trim().replace(/^\{/, "").replace(/\}$/, "");
+  let current = "";
+  let inQuote = false;
+  let quoteChar = "";
+  const parts = [];
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if ((ch === '"' || ch === "'") && (!inQuote || ch === quoteChar)) {
+      inQuote = !inQuote;
+      quoteChar = ch;
+    }
+    if (!inQuote && ch === ",") {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) {
+    parts.push(current);
+  }
+  for (const part of parts) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const val = part.slice(eq + 1).trim();
+    result[key] = parseScalar(val);
+  }
+  return result;
+}
+function parseToml(content) {
+  const result = {
+    package: {},
+    dependencies: {},
+    addresses: {}
+  };
+  let section = null;
+  const lines = content.split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = stripInlineComment(rawLine).trim();
+    if (!line) continue;
+    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      section = sectionMatch[1].trim();
+      continue;
+    }
+    const eq = line.indexOf("=");
+    if (eq === -1 || !section) continue;
+    const key = line.slice(0, eq).trim();
+    const value = line.slice(eq + 1).trim();
+    if (section === "package") {
+      result.package[key.replace(/-/g, "_")] = parseScalar(value);
+    } else if (section === "dependencies") {
+      if (value.startsWith("{")) {
+        result.dependencies[key] = parseInlineTable(value);
+      } else {
+        result.dependencies[key] = parseScalar(value);
+      }
+    } else if (section === "addresses") {
+      result.addresses[key] = parseScalar(value);
+    }
+  }
+  return result;
+}
+
+// src/resolver.ts
+var Resolver = class {
+  constructor(fetcher) {
+    this.fetcher = fetcher;
+    this.globalAddresses = {};
+    this.visited = /* @__PURE__ */ new Set();
+    this.dependencyFiles = {};
+    this.systemDepsLoaded = /* @__PURE__ */ new Set();
+  }
+  async resolve(rootMoveToml, rootFiles) {
+    const parsedToml = parseToml(rootMoveToml);
+    if (parsedToml.addresses) {
+      this.mergeAddresses(parsedToml.addresses);
+    }
+    if (parsedToml.dependencies) {
+      await this.resolveDeps(parsedToml.dependencies);
+      await this.injectSystemDepsFromRoot(parsedToml.dependencies);
+    }
+    const finalMoveToml = this.reconstructMoveToml(parsedToml, this.globalAddresses);
+    const finalFiles = { ...rootFiles, "Move.toml": finalMoveToml };
+    return {
+      files: JSON.stringify(finalFiles),
+      dependencies: JSON.stringify(this.dependencyFiles)
+    };
+  }
+  mergeAddresses(addresses) {
+    for (const [name, val] of Object.entries(addresses)) {
+      this.globalAddresses[name] = this.normalizeAddress(val);
+    }
+  }
+  normalizeAddress(addr) {
+    if (!addr) return addr;
+    let clean = addr;
+    if (clean.startsWith("0x")) clean = clean.slice(2);
+    if (/^[0-9a-fA-F]+$/.test(clean)) {
+      return "0x" + clean.padStart(64, "0");
+    }
+    return addr;
+  }
+  async resolveDeps(depsObj, parentContext = null) {
+    for (const [name, depInfo] of Object.entries(depsObj)) {
+      let gitUrl;
+      let rev;
+      let subdir;
+      if (depInfo.git) {
+        gitUrl = depInfo.git;
+        rev = depInfo.rev;
+        subdir = depInfo.subdir;
+      } else if (depInfo.local) {
+        if (!parentContext) continue;
+        gitUrl = parentContext.git;
+        rev = parentContext.rev;
+        subdir = this.resolvePath(parentContext.subdir || "", depInfo.local);
+      } else {
+        continue;
+      }
+      const cacheKey = `${gitUrl}|${rev}|${subdir || ""}`;
+      if (this.visited.has(cacheKey)) continue;
+      this.visited.add(cacheKey);
+      const files = await this.fetcher.fetch(gitUrl, rev, subdir);
+      let pkgMoveToml = null;
+      for (const [path, content] of Object.entries(files)) {
+        if (path.endsWith("Move.toml")) {
+          pkgMoveToml = content;
+          break;
+        }
+      }
+      if (pkgMoveToml) {
+        const parsed = parseToml(pkgMoveToml);
+        if (parsed.addresses) {
+          this.mergeAddresses(parsed.addresses);
+        }
+        if (parsed.dependencies) {
+          await this.resolveDeps(parsed.dependencies, { git: gitUrl, rev, subdir });
+        }
+      }
+      for (const [path, content] of Object.entries(files)) {
+        if (path.endsWith(".move") || path.endsWith("Move.toml")) {
+          const targetPath = `dependencies/${name}/${path}`;
+          this.dependencyFiles[targetPath] = content;
+        }
+      }
+    }
+  }
+  resolvePath(base, relative) {
+    const stack = base.split("/").filter((p) => p && p !== ".");
+    const parts = relative.split("/").filter((p) => p && p !== ".");
+    for (const part of parts) {
+      if (part === "..") {
+        stack.pop();
+      } else {
+        stack.push(part);
+      }
+    }
+    return stack.join("/");
+  }
+  reconstructMoveToml(originalParsed, addresses) {
+    let newToml = `[package]
+name = "${originalParsed.package.name}"
+version = "${originalParsed.package.version}"
+`;
+    if (originalParsed.package.edition) {
+      newToml += `edition = "${originalParsed.package.edition}"
+`;
+    }
+    newToml += `
+[dependencies]
+`;
+    if (originalParsed.dependencies) {
+      for (const [name, info] of Object.entries(originalParsed.dependencies)) {
+        newToml += `${name} = { git = "${info.git}", rev = "${info.rev}" }
+`;
+      }
+    }
+    newToml += `
+[addresses]
+`;
+    for (const [addrName, addrVal] of Object.entries(addresses)) {
+      newToml += `${addrName} = "${addrVal}"
+`;
+    }
+    return newToml;
+  }
+  async injectSystemDepsFromRoot(depsObj) {
+    for (const depInfo of Object.values(depsObj)) {
+      if (!depInfo || !depInfo.git || !depInfo.rev) continue;
+      if (!this.isSuiRepo(depInfo.git)) continue;
+      await this.addImplicitSystemDepsForRepo(depInfo.git, depInfo.rev);
+      return;
+    }
+  }
+  async addImplicitSystemDepsForRepo(gitUrl, rev) {
+    if (!this.isSuiRepo(gitUrl)) return;
+    const cacheKey = `${gitUrl}|${rev}`;
+    if (this.systemDepsLoaded.has(cacheKey)) return;
+    this.systemDepsLoaded.add(cacheKey);
+    const manifestPath = "crates/sui-framework-snapshot/manifest.json";
+    if (!this.fetcher.fetchFile) return;
+    let packages = null;
+    try {
+      const manifestText = await this.fetcher.fetchFile(gitUrl, rev, manifestPath);
+      if (manifestText) {
+        const manifest = JSON.parse(manifestText);
+        const versions = Object.keys(manifest).map((v) => Number(v)).filter((v) => !Number.isNaN(v)).sort((a, b) => a - b);
+        const latestVersion = versions[versions.length - 1];
+        const latest = manifest[String(latestVersion)];
+        if (latest && latest.packages) {
+          packages = latest.packages;
+        }
+      }
+    } catch (e) {
+    }
+    if (!packages) {
+      packages = [
+        { name: "MoveStdlib", id: "0x1" },
+        { name: "Sui", id: "0x2" },
+        { name: "SuiSystem", id: "0x3" },
+        { name: "Bridge", id: "0xb" }
+      ];
+    }
+    for (const pkg of packages) {
+      if (!pkg || !pkg.name || !pkg.id) continue;
+      if (pkg.name === "DeepBook") continue;
+      const targetPath = `dependencies/${pkg.name}/Move.toml`;
+      if (this.dependencyFiles[targetPath]) continue;
+      const moveToml = [
+        "[package]",
+        `name = "${pkg.name}"`,
+        'version = "0.0.0"',
+        `published-at = "${pkg.id}"`,
+        ""
+      ].join("\n");
+      this.dependencyFiles[targetPath] = moveToml;
+    }
+  }
+  isSuiRepo(gitUrl) {
+    return gitUrl.includes("github.com/MystenLabs/sui");
+  }
+};
+async function resolve(rootMoveTomlContent, rootSourceFiles, fetcher) {
+  const resolver = new Resolver(fetcher);
+  return resolver.resolve(rootMoveTomlContent, rootSourceFiles);
+}
+
+// src/fetcher.ts
+var Fetcher = class {
+  /** Fetch a package. Return map of path -> content. */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async fetch(_gitUrl, _rev, _subdir) {
+    throw new Error("Not implemented");
+  }
+  /** Fetch a single file from a repository. */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async fetchFile(_gitUrl, _rev, _path) {
+    throw new Error("Not implemented");
+  }
+};
+var GitHubFetcher = class extends Fetcher {
+  constructor() {
+    super();
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  async fetch(gitUrl, rev, subdir) {
+    const { owner, repo } = this.parseGitUrl(gitUrl);
+    if (!owner || !repo) {
+      throw new Error(`Invalid git URL: ${gitUrl}`);
+    }
+    const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${rev}?recursive=1`;
+    let treeData;
+    try {
+      const resp = await fetch(treeUrl);
+      if (!resp.ok) {
+        if (resp.status === 403 || resp.status === 429) {
+          throw new Error("GitHub API rate limit exceeded.");
+        }
+        throw new Error(`Failed to fetch tree: ${resp.statusText}`);
+      }
+      treeData = await resp.json();
+    } catch (e) {
+      return {};
+    }
+    const files = {};
+    const fetchPromises = [];
+    for (const item of treeData.tree) {
+      if (item.type !== "blob") continue;
+      let relativePath = item.path;
+      if (subdir) {
+        if (!item.path.startsWith(subdir)) continue;
+        relativePath = item.path.slice(subdir.length);
+        if (relativePath.startsWith("/")) {
+          relativePath = relativePath.slice(1);
+        }
+      }
+      if (!relativePath.endsWith(".move") && relativePath !== "Move.toml") {
+        continue;
+      }
+      const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${rev}/${item.path}`;
+      const p = this.fetchContent(rawUrl).then((content) => {
+        if (content) {
+          files[relativePath] = content;
+        }
+      });
+      fetchPromises.push(p);
+    }
+    await Promise.all(fetchPromises);
+    return files;
+  }
+  async fetchFile(gitUrl, rev, path) {
+    const { owner, repo } = this.parseGitUrl(gitUrl);
+    if (!owner || !repo) {
+      throw new Error(`Invalid git URL: ${gitUrl}`);
+    }
+    const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${rev}/${path}`;
+    return this.fetchContent(rawUrl);
+  }
+  async fetchContent(url) {
+    if (this.cache.has(url)) {
+      return this.cache.get(url) ?? null;
+    }
+    try {
+      const resp = await fetch(url);
+      if (!resp.ok) return null;
+      const text = await resp.text();
+      this.cache.set(url, text);
+      return text;
+    } catch (e) {
+      return null;
+    }
+  }
+  parseGitUrl(url) {
+    try {
+      const urlObj = new URL(url);
+      const parts = urlObj.pathname.split("/").filter((p) => p);
+      if (parts.length >= 2) {
+        let repo = parts[1];
+        if (repo.endsWith(".git")) {
+          repo = repo.slice(0, -4);
+        }
+        return { owner: parts[0], repo };
+      }
+    } catch (e) {
+    }
+    return { owner: null, repo: null };
+  }
+};
+
+// src/index.ts
+var import_meta = {};
+var wasmUrl = (() => {
+  try {
+    return new URL("./sui_move_wasm_bg.wasm", import_meta.url);
+  } catch {
+    return "./sui_move_wasm_bg.wasm";
+  }
+})();
+var wasmReady;
+async function loadWasm(customWasm) {
+  if (!wasmReady) {
+    wasmReady = import("./sui_move_wasm.js").then(async (mod) => {
+      await mod.default(customWasm ?? wasmUrl);
+      return mod;
+    });
+  }
+  return wasmReady;
+}
+function toJson(value) {
+  return JSON.stringify(value ?? {});
+}
+function asFailure(err) {
+  const msg = err instanceof Error ? err.message : typeof err === "string" ? err : "Unknown error";
+  return { success: false, error: msg };
+}
+function ensureCompileResult(result) {
+  if (typeof result !== "object" || result === null) {
+    throw new Error("Unexpected compile result shape from wasm");
+  }
+  const asAny = result;
+  if (typeof asAny.success === "function" && typeof asAny.output === "function") {
+    return asAny;
+  }
+  if (typeof asAny.success === "boolean" && typeof asAny.output === "string") {
+    return {
+      success: () => asAny.success,
+      output: () => asAny.output
+    };
+  }
+  throw new Error("Unexpected compile result shape from wasm");
+}
+function parseCompileResult(output) {
+  const toHex = (bytes) => bytes.map((b) => b.toString(16).padStart(2, "0")).join("");
+  try {
+    const parsed = JSON.parse(output);
+    if (!parsed.modules || !parsed.dependencies || !parsed.digest) {
+      throw new Error("missing fields in compiler output");
+    }
+    const digestHex = typeof parsed.digest === "string" ? parsed.digest : toHex(parsed.digest);
+    return {
+      success: true,
+      modules: parsed.modules,
+      dependencies: parsed.dependencies,
+      digest: digestHex
+    };
+  } catch (error) {
+    return asFailure(error);
+  }
+}
+async function initMoveCompiler(options) {
+  await loadWasm(options?.wasm);
+}
+async function buildMovePackage(input) {
+  try {
+    const mod = await loadWasm(input.wasm);
+    const raw = mod.compile(
+      toJson(input.files),
+      toJson(input.dependencies ?? {})
+    );
+    const result = ensureCompileResult(raw);
+    const ok = result.success();
+    const output = result.output();
+    if (!ok) {
+      return asFailure(output);
+    }
+    return parseCompileResult(output);
+  } catch (error) {
+    return asFailure(error);
+  }
+}
+async function getSuiMoveVersion(options) {
+  const mod = await loadWasm(options?.wasm);
+  return mod.sui_move_version();
+}
+async function getSuiVersion(options) {
+  const mod = await loadWasm(options?.wasm);
+  return mod.sui_version();
+}
+async function getWasmBindings(options) {
+  return loadWasm(options?.wasm);
+}
+async function compileRaw(filesJson, depsJson, options) {
+  const mod = await loadWasm(options?.wasm);
+  const result = ensureCompileResult(mod.compile(filesJson, depsJson));
+  return {
+    success: result.success(),
+    output: result.output()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fetcher,
+  GitHubFetcher,
+  Resolver,
+  buildMovePackage,
+  compileRaw,
+  getSuiMoveVersion,
+  getSuiVersion,
+  getWasmBindings,
+  initMoveCompiler,
+  parseToml,
+  resolve
+});
+//# sourceMappingURL=index.cjs.map