@themoltnet/legreffier 0.5.0 → 0.6.0

package/dist/index.js

@@ -7,7 +7,7 @@ import { useState, useEffect, useReducer, useRef } from "react";
 import figlet from "figlet";
 import { readFile, writeFile, mkdir, chmod, rm } from "node:fs/promises";
 import { homedir } from "node:os";
-import { createHash, randomBytes as randomBytes$1 } from "crypto";
+import { randomBytes as randomBytes$2, createHash } from "crypto";
 import { parse, stringify } from "smol-toml";
 import open from "open";
 const colors = {
@@ -350,13 +350,13 @@ function CliSummaryBox({
     }
   ) });
 }
-const jsonBodySerializer$1 = {
+const jsonBodySerializer = {
   bodySerializer: (body) => JSON.stringify(
     body,
     (_key, value) => typeof value === "bigint" ? value.toString() : value
   )
 };
-const createSseClient$1 = ({
+const createSseClient = ({
   onRequest,
   onSseError,
   onSseEvent,
@@ -490,7 +490,7 @@ const createSseClient$1 = ({
   const stream = createStream();
   return { stream };
 };
-const separatorArrayExplode$1 = (style) => {
+const separatorArrayExplode = (style) => {
   switch (style) {
     case "label":
       return ".";
@@ -502,7 +502,7 @@ const separatorArrayExplode$1 = (style) => {
       return "&";
   }
 };
-const separatorArrayNoExplode$1 = (style) => {
+const separatorArrayNoExplode = (style) => {
   switch (style) {
     case "form":
       return ",";
@@ -514,7 +514,7 @@ const separatorArrayNoExplode$1 = (style) => {
       return ",";
   }
 };
-const separatorObjectExplode$1 = (style) => {
+const separatorObjectExplode = (style) => {
   switch (style) {
     case "label":
       return ".";
@@ -526,7 +526,7 @@ const separatorObjectExplode$1 = (style) => {
       return "&";
   }
 };
-const serializeArrayParam$1 = ({
+const serializeArrayParam = ({
   allowReserved,
   explode,
   name: name2,
@@ -534,7 +534,7 @@ const serializeArrayParam$1 = ({
   value
 }) => {
   if (!explode) {
-    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode$1(style));
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
     switch (style) {
       case "label":
         return `.${joinedValues2}`;
@@ -546,12 +546,12 @@ const serializeArrayParam$1 = ({
         return `${name2}=${joinedValues2}`;
     }
   }
-  const separator = separatorArrayExplode$1(style);
+  const separator = separatorArrayExplode(style);
   const joinedValues = value.map((v) => {
     if (style === "label" || style === "simple") {
       return allowReserved ? v : encodeURIComponent(v);
     }
-    return serializePrimitiveParam$1({
+    return serializePrimitiveParam({
       allowReserved,
       name: name2,
       value: v
@@ -559,7 +559,7 @@ const serializeArrayParam$1 = ({
   }).join(separator);
   return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
 };
-const serializePrimitiveParam$1 = ({
+const serializePrimitiveParam = ({
   allowReserved,
   name: name2,
   value
@@ -574,7 +574,7 @@ const serializePrimitiveParam$1 = ({
   }
   return `${name2}=${allowReserved ? value : encodeURIComponent(value)}`;
 };
-const serializeObjectParam$1 = ({
+const serializeObjectParam = ({
   allowReserved,
   explode,
   name: name2,
@@ -606,9 +606,9 @@ const serializeObjectParam$1 = ({
         return joinedValues2;
     }
   }
-  const separator = separatorObjectExplode$1(style);
+  const separator = separatorObjectExplode(style);
   const joinedValues = Object.entries(value).map(
-    ([key, v]) => serializePrimitiveParam$1({
+    ([key, v]) => serializePrimitiveParam({
       allowReserved,
       name: style === "deepObject" ? `${name2}[${key}]` : key,
       value: v
@@ -616,10 +616,10 @@ const serializeObjectParam$1 = ({
   ).join(separator);
   return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
 };
-const PATH_PARAM_RE$1 = /\{[^{}]+\}/g;
-const defaultPathSerializer$1 = ({ path, url: _url }) => {
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
   let url = _url;
-  const matches = _url.match(PATH_PARAM_RE$1);
+  const matches = _url.match(PATH_PARAM_RE);
   if (matches) {
     for (const match of matches) {
       let explode = false;
@@ -643,14 +643,14 @@ const defaultPathSerializer$1 = ({ path, url: _url }) => {
       if (Array.isArray(value)) {
         url = url.replace(
           match,
-          serializeArrayParam$1({ explode, name: name2, style, value })
+          serializeArrayParam({ explode, name: name2, style, value })
         );
         continue;
       }
       if (typeof value === "object") {
         url = url.replace(
           match,
-          serializeObjectParam$1({
+          serializeObjectParam({
             explode,
             name: name2,
             style,
@@ -663,7 +663,7 @@ const defaultPathSerializer$1 = ({ path, url: _url }) => {
       if (style === "matrix") {
         url = url.replace(
           match,
-          `;${serializePrimitiveParam$1({
+          `;${serializePrimitiveParam({
             name: name2,
             value
           })}`
@@ -678,7 +678,7 @@ const defaultPathSerializer$1 = ({ path, url: _url }) => {
   }
   return url;
 };
-const getUrl$1 = ({
+const getUrl = ({
   baseUrl,
   path,
   query,
@@ -688,7 +688,7 @@ const getUrl$1 = ({
   const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
   let url = (baseUrl ?? "") + pathUrl;
   if (path) {
-    url = defaultPathSerializer$1({ path, url });
+    url = defaultPathSerializer({ path, url });
   }
   let search = query ? querySerializer(query) : "";
   if (search.startsWith("?")) {
@@ -699,7 +699,7 @@ const getUrl$1 = ({
   }
   return url;
 };
-function getValidRequestBody$1(options) {
+function getValidRequestBody(options) {
   const hasBody = options.body !== void 0;
   const isSerializedBody = hasBody && options.bodySerializer;
   if (isSerializedBody) {
@@ -714,7 +714,7 @@ function getValidRequestBody$1(options) {
   }
   return void 0;
 }
-const getAuthToken$1 = async (auth, callback) => {
+const getAuthToken = async (auth, callback) => {
   const token = typeof callback === "function" ? await callback(auth) : callback;
   if (!token) {
     return;
@@ -727,7 +727,7 @@ const getAuthToken$1 = async (auth, callback) => {
   }
   return token;
 };
-const createQuerySerializer$1 = ({
+const createQuerySerializer = ({
   parameters = {},
   ...args
 } = {}) => {
@@ -741,7 +741,7 @@ const createQuerySerializer$1 = ({
         }
         const options = parameters[name2] || args;
         if (Array.isArray(value)) {
-          const serializedArray = serializeArrayParam$1({
+          const serializedArray = serializeArrayParam({
             allowReserved: options.allowReserved,
             explode: true,
             name: name2,
@@ -751,7 +751,7 @@ const createQuerySerializer$1 = ({
           });
           if (serializedArray) search.push(serializedArray);
         } else if (typeof value === "object") {
-          const serializedObject = serializeObjectParam$1({
+          const serializedObject = serializeObjectParam({
             allowReserved: options.allowReserved,
             explode: true,
             name: name2,
@@ -761,7 +761,7 @@ const createQuerySerializer$1 = ({
           });
           if (serializedObject) search.push(serializedObject);
         } else {
-          const serializedPrimitive = serializePrimitiveParam$1({
+          const serializedPrimitive = serializePrimitiveParam({
             allowReserved: options.allowReserved,
             name: name2,
             value
@@ -774,7 +774,7 @@ const createQuerySerializer$1 = ({
   };
   return querySerializer;
 };
-const getParseAs$1 = (contentType) => {
+const getParseAs = (contentType) => {
   if (!contentType) {
     return "stream";
   }
@@ -798,7 +798,7 @@ const getParseAs$1 = (contentType) => {
   }
   return;
 };
-const checkForExistence$1 = (options, name2) => {
+const checkForExistence = (options, name2) => {
   if (!name2) {
     return false;
   }
@@ -807,15 +807,15 @@ const checkForExistence$1 = (options, name2) => {
   }
   return false;
 };
-const setAuthParams$1 = async ({
+const setAuthParams = async ({
   security,
   ...options
 }) => {
   for (const auth of security) {
-    if (checkForExistence$1(options, auth.name)) {
+    if (checkForExistence(options, auth.name)) {
       continue;
     }
-    const token = await getAuthToken$1(auth, options.auth);
+    const token = await getAuthToken(auth, options.auth);
     if (!token) {
       continue;
     }
@@ -837,35 +837,35 @@ const setAuthParams$1 = async ({
     }
   }
 };
-const buildUrl$1 = (options) => getUrl$1({
+const buildUrl = (options) => getUrl({
   baseUrl: options.baseUrl,
   path: options.path,
   query: options.query,
-  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer$1(options.querySerializer),
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
   url: options.url
 });
-const mergeConfigs$1 = (a, b) => {
+const mergeConfigs = (a, b) => {
   const config = { ...a, ...b };
   if (config.baseUrl?.endsWith("/")) {
     config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
   }
-  config.headers = mergeHeaders$1(a.headers, b.headers);
+  config.headers = mergeHeaders(a.headers, b.headers);
   return config;
 };
-const headersEntries$1 = (headers) => {
+const headersEntries = (headers) => {
   const entries = [];
   headers.forEach((value, key) => {
     entries.push([key, value]);
   });
   return entries;
 };
-const mergeHeaders$1 = (...headers) => {
+const mergeHeaders = (...headers) => {
   const mergedHeaders = new Headers();
   for (const header of headers) {
     if (!header) {
       continue;
     }
-    const iterator = header instanceof Headers ? headersEntries$1(header) : Object.entries(header);
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
     for (const [key, value] of iterator) {
       if (value === null) {
         mergedHeaders.delete(key);
@@ -883,7 +883,7 @@ const mergeHeaders$1 = (...headers) => {
   }
   return mergedHeaders;
 };
-let Interceptors$1 = class Interceptors {
+class Interceptors {
   fns = [];
   clear() {
     this.fns = [];
@@ -916,13 +916,13 @@ let Interceptors$1 = class Interceptors {
     this.fns.push(fn);
     return this.fns.length - 1;
   }
-};
-const createInterceptors$1 = () => ({
-  error: new Interceptors$1(),
-  request: new Interceptors$1(),
-  response: new Interceptors$1()
+}
+const createInterceptors = () => ({
+  error: new Interceptors(),
+  request: new Interceptors(),
+  response: new Interceptors()
 });
-const defaultQuerySerializer$1 = createQuerySerializer$1({
+const defaultQuerySerializer = createQuerySerializer({
   allowReserved: false,
   array: {
     explode: true,
@@ -933,34 +933,34 @@ const defaultQuerySerializer$1 = createQuerySerializer$1({
     style: "deepObject"
   }
 });
-const defaultHeaders$1 = {
+const defaultHeaders = {
   "Content-Type": "application/json"
 };
-const createConfig$1 = (override = {}) => ({
-  ...jsonBodySerializer$1,
-  headers: defaultHeaders$1,
+const createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
   parseAs: "auto",
-  querySerializer: defaultQuerySerializer$1,
+  querySerializer: defaultQuerySerializer,
   ...override
 });
-const createClient$1 = (config = {}) => {
-  let _config = mergeConfigs$1(createConfig$1(), config);
+const createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
   const getConfig = () => ({ ..._config });
   const setConfig = (config2) => {
-    _config = mergeConfigs$1(_config, config2);
+    _config = mergeConfigs(_config, config2);
     return getConfig();
   };
-  const interceptors = createInterceptors$1();
+  const interceptors = createInterceptors();
   const beforeRequest = async (options) => {
     const opts = {
       ..._config,
       ...options,
       fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders$1(_config.headers, options.headers),
+      headers: mergeHeaders(_config.headers, options.headers),
       serializedBody: void 0
     };
     if (opts.security) {
-      await setAuthParams$1({
+      await setAuthParams({
         ...opts,
         security: opts.security
       });
@@ -974,7 +974,7 @@ const createClient$1 = (config = {}) => {
     if (opts.body === void 0 || opts.serializedBody === "") {
       opts.headers.delete("Content-Type");
     }
-    const url = buildUrl$1(opts);
+    const url = buildUrl(opts);
     return { opts, url };
   };
   const request = async (options) => {
@@ -982,7 +982,7 @@ const createClient$1 = (config = {}) => {
     const requestInit = {
       redirect: "follow",
       ...opts,
-      body: getValidRequestBody$1(opts)
+      body: getValidRequestBody(opts)
     };
     let request2 = new Request(url, requestInit);
     for (const fn of interceptors.request.fns) {
@@ -1026,7 +1026,7 @@ const createClient$1 = (config = {}) => {
       response
     };
     if (response.ok) {
-      const parseAs = (opts.parseAs === "auto" ? getParseAs$1(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
       if (response.status === 204 || response.headers.get("Content-Length") === "0") {
         let emptyData;
         switch (parseAs) {
@@ -1104,7 +1104,7 @@ const createClient$1 = (config = {}) => {
   const makeMethodFn = (method) => (options) => request({ ...options, method });
   const makeSseFn = (method) => async (options) => {
     const { opts, url } = await beforeRequest(options);
-    return createSseClient$1({
+    return createSseClient({
       ...opts,
       body: opts.body,
       headers: opts.headers,
@@ -1122,7 +1122,7 @@ const createClient$1 = (config = {}) => {
     });
   };
   return {
-    buildUrl: buildUrl$1,
+    buildUrl,
     connect: makeMethodFn("CONNECT"),
     delete: makeMethodFn("DELETE"),
     get: makeMethodFn("GET"),
@@ -1149,8 +1149,8 @@ const createClient$1 = (config = {}) => {
     trace: makeMethodFn("TRACE")
   };
 };
-const client = createClient$1(
-  createConfig$1({ baseUrl: "https://api.themolt.net" })
+const client = createClient(
+  createConfig({ baseUrl: "https://api.themolt.net" })
 );
 const startLegreffierOnboarding = (options) => (options.client ?? client).post({
   url: "/public/legreffier/start",
@@ -1161,1377 +1161,2353 @@ const startLegreffierOnboarding = (options) => (options.client ?? client).post({
   }
 });
 const getLegreffierOnboardingStatus = (options) => (options.client ?? client).get({ url: "/public/legreffier/status/{workflowId}", ...options });
-/*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
-const ed25519_CURVE = {
-  p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
-  n: 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn,
-  a: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffecn,
-  d: 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n,
-  Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an,
-  Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n
-};
-const { p: P, n: N, Gx, Gy, a: _a, d: _d } = ed25519_CURVE;
-const h = 8n;
-const L = 32;
-const L2 = 64;
-const err = (m = "") => {
-  throw new Error(m);
-};
-const isBig = (n) => typeof n === "bigint";
-const isStr = (s) => typeof s === "string";
-const isBytes = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-const abytes = (a, l) => !isBytes(a) || typeof l === "number" && l > 0 && a.length !== l ? err("Uint8Array expected") : a;
-const u8n = (len) => new Uint8Array(len);
-const u8fr = (buf) => Uint8Array.from(buf);
-const padh = (n, pad) => n.toString(16).padStart(pad, "0");
-const bytesToHex = (b) => Array.from(abytes(b)).map((e) => padh(e, 2)).join("");
-const C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
-const _ch = (ch) => {
-  if (ch >= C._0 && ch <= C._9)
-    return ch - C._0;
-  if (ch >= C.A && ch <= C.F)
-    return ch - (C.A - 10);
-  if (ch >= C.a && ch <= C.f)
-    return ch - (C.a - 10);
+class MoltNetError extends Error {
+  code;
+  statusCode;
+  detail;
+  constructor(message, options) {
+    super(message);
+    this.name = "MoltNetError";
+    this.code = options.code;
+    this.statusCode = options.statusCode;
+    this.detail = options.detail;
+  }
+}
+function problemToError(problem, statusCode) {
+  return new MoltNetError(problem.title ?? "Request failed", {
+    code: problem.type ?? problem.code ?? "UNKNOWN",
+    statusCode,
+    detail: problem.detail
+  });
+}
+async function writeMcpConfig(mcpConfig, dir2) {
+  const targetDir = dir2 ?? process.cwd();
+  const filePath = join(targetDir, ".mcp.json");
+  let existing = {};
+  try {
+    const content = await readFile(filePath, "utf-8");
+    existing = JSON.parse(content);
+  } catch {
+  }
+  const merged = {
+    ...existing,
+    mcpServers: {
+      ...existing.mcpServers ?? {},
+      ...mcpConfig.mcpServers
+    }
+  };
+  await writeFile(filePath, JSON.stringify(merged, null, 2) + "\n");
+  return filePath;
+}
+function getConfigDir() {
+  return join(homedir(), ".config", "moltnet");
+}
+function getConfigPath(configDir) {
+  return join(configDir ?? getConfigDir(), "moltnet.json");
+}
+async function readConfig(configDir) {
+  const dir2 = configDir ?? getConfigDir();
+  try {
+    const content = await readFile(join(dir2, "moltnet.json"), "utf-8");
+    return JSON.parse(content);
+  } catch {
+  }
+  try {
+    const content = await readFile(join(dir2, "credentials.json"), "utf-8");
+    console.warn("Warning: credentials.json is deprecated. New writes use moltnet.json. Support will be removed in 3 minor versions.");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeConfig(config, configDir) {
+  const dir2 = configDir ?? getConfigDir();
+  await mkdir(dir2, { recursive: true });
+  const filePath = join(dir2, "moltnet.json");
+  await writeFile(filePath, JSON.stringify(config, null, 2) + "\n", {
+    mode: 384
+  });
+  await chmod(filePath, 384);
+  return filePath;
+}
+async function updateConfigSection(section, data, configDir) {
+  const config = await readConfig(configDir);
+  if (!config) {
+    throw new Error("No config found — run `moltnet register` first");
+  }
+  const existing = config[section] ?? {};
+  const updated = { ...existing, ...data };
+  Object.assign(config, { [section]: updated });
+  await writeConfig(config, configDir);
+}
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes$1(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n, title = "") {
+  if (!Number.isSafeInteger(n) || n < 0) {
+    const prefix = title && `"${title}" `;
+    throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+  }
+}
+function abytes$1(value, length, title = "") {
+  const bytes = isBytes$1(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes$1(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+const hasHexBuiltin = /* @__PURE__ */ (() => (
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+))();
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex$1(bytes) {
+  abytes$1(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function asciiToBase16(ch) {
+  if (ch >= asciis._0 && ch <= asciis._9)
+    return ch - asciis._0;
+  if (ch >= asciis.A && ch <= asciis.F)
+    return ch - (asciis.A - 10);
+  if (ch >= asciis.a && ch <= asciis.f)
+    return ch - (asciis.a - 10);
   return;
-};
-const hexToBytes = (hex) => {
-  const e = "hex invalid";
-  if (!isStr(hex))
-    return err(e);
+}
+function hexToBytes$1(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  if (hasHexBuiltin)
+    return Uint8Array.fromHex(hex);
   const hl = hex.length;
   const al = hl / 2;
   if (hl % 2)
-    return err(e);
-  const array = u8n(al);
+    throw new Error("hex string expected, got unpadded hex of length " + hl);
+  const array = new Uint8Array(al);
   for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
-    const n1 = _ch(hex.charCodeAt(hi));
-    const n2 = _ch(hex.charCodeAt(hi + 1));
-    if (n1 === void 0 || n2 === void 0)
-      return err(e);
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === void 0 || n2 === void 0) {
+      const char = hex[hi] + hex[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
     array[ai] = n1 * 16 + n2;
   }
   return array;
-};
-const toU8 = (a, len) => abytes(isStr(a) ? hexToBytes(a) : u8fr(abytes(a)), len);
-const cr = () => globalThis?.crypto;
-const subtle = () => cr()?.subtle ?? err("crypto.subtle must be defined");
-const concatBytes = (...arrs) => {
-  const r = u8n(arrs.reduce((sum, a) => sum + abytes(a).length, 0));
-  let pad = 0;
-  arrs.forEach((a) => {
-    r.set(a, pad);
+}
+function concatBytes$1(...arrays) {
+  let sum = 0;
+  for (let i = 0; i < arrays.length; i++) {
+    const a = arrays[i];
+    abytes$1(a);
+    sum += a.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i = 0, pad = 0; i < arrays.length; i++) {
+    const a = arrays[i];
+    res.set(a, pad);
     pad += a.length;
-  });
-  return r;
-};
-const randomBytes = (len = L) => {
-  const c = cr();
-  return c.getRandomValues(u8n(len));
-};
-const big = BigInt;
-const arange = (n, min, max, msg = "bad number: out of range") => isBig(n) && min <= n && n < max ? n : err(msg);
-const M = (a, b = P) => {
-  const r = a % b;
-  return r >= 0n ? r : b + r;
-};
-const modN = (a) => M(a, N);
-const invert = (num, md) => {
-  if (num === 0n || md <= 0n)
-    err("no inverse n=" + num + " mod=" + md);
-  let a = M(num, md), b = md, x = 0n, u = 1n;
-  while (a !== 0n) {
-    const q = b / a, r = b % a;
-    const m = x - u * q;
-    b = a, a = r, x = u, u = m;
   }
-  return b === 1n ? M(x, md) : err("no inverse");
-};
-const callHash = (name2) => {
-  const fn = etc[name2];
-  if (typeof fn !== "function")
-    err("hashes." + name2 + " not set");
-  return fn;
-};
-const apoint = (p) => p instanceof Point ? p : err("Point expected");
-const B256 = 2n ** 256n;
-class Point {
-  static BASE;
-  static ZERO;
-  ex;
-  ey;
-  ez;
-  et;
-  constructor(ex, ey, ez, et) {
-    const max = B256;
-    this.ex = arange(ex, 0n, max);
-    this.ey = arange(ey, 0n, max);
-    this.ez = arange(ez, 1n, max);
-    this.et = arange(et, 0n, max);
-    Object.freeze(this);
+  return res;
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+function randomBytes$1(bytesLength = 32) {
+  const cr2 = typeof globalThis === "object" ? globalThis.crypto : null;
+  if (typeof cr2?.getRandomValues !== "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return cr2.getRandomValues(new Uint8Array(bytesLength));
+}
+const oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+class HashMD {
+  blockLen;
+  outputLen;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes$1(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
   }
-  static fromAffine(p) {
-    return new Point(p.x, p.y, 1n, M(p.x * p.y));
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to ||= new this.constructor();
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
   }
-  /** RFC8032 5.1.3: Uint8Array to Point. */
-  static fromBytes(hex, zip215 = false) {
-    const d = _d;
-    const normed = u8fr(abytes(hex, L));
-    const lastByte = hex[31];
-    normed[31] = lastByte & -129;
-    const y = bytesToNumLE(normed);
-    const max = zip215 ? B256 : P;
-    arange(y, 0n, max);
-    const y2 = M(y * y);
-    const u = M(y2 - 1n);
-    const v = M(d * y2 + 1n);
-    let { isValid, value: x } = uvRatio(u, v);
-    if (!isValid)
-      err("bad point: y not sqrt");
-    const isXOdd = (x & 1n) === 1n;
-    const isLastByteOdd = (lastByte & 128) !== 0;
-    if (!zip215 && x === 0n && isLastByteOdd)
-      err("bad point: x==0, isLastByteOdd");
-    if (isLastByteOdd !== isXOdd)
-      x = M(-x);
-    return new Point(x, y, 1n, M(x * y));
+}
+const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]);
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h: h2, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h2, l];
+  }
+  return [Ah, Al];
+}
+const shrSH = (h2, _l, s) => h2 >>> s;
+const shrSL = (h2, l, s) => h2 << 32 - s | l >>> s;
+const rotrSH = (h2, l, s) => h2 >>> s | l << 32 - s;
+const rotrSL = (h2, l, s) => h2 << 32 - s | l >>> s;
+const rotrBH = (h2, l, s) => h2 << 64 - s | l >>> s - 32;
+const rotrBL = (h2, l, s) => h2 >>> s - 32 | l << 64 - s;
+function add(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+const K512 = /* @__PURE__ */ (() => split([
+  "0x428a2f98d728ae22",
+  "0x7137449123ef65cd",
+  "0xb5c0fbcfec4d3b2f",
+  "0xe9b5dba58189dbbc",
+  "0x3956c25bf348b538",
+  "0x59f111f1b605d019",
+  "0x923f82a4af194f9b",
+  "0xab1c5ed5da6d8118",
+  "0xd807aa98a3030242",
+  "0x12835b0145706fbe",
+  "0x243185be4ee4b28c",
+  "0x550c7dc3d5ffb4e2",
+  "0x72be5d74f27b896f",
+  "0x80deb1fe3b1696b1",
+  "0x9bdc06a725c71235",
+  "0xc19bf174cf692694",
+  "0xe49b69c19ef14ad2",
+  "0xefbe4786384f25e3",
+  "0x0fc19dc68b8cd5b5",
+  "0x240ca1cc77ac9c65",
+  "0x2de92c6f592b0275",
+  "0x4a7484aa6ea6e483",
+  "0x5cb0a9dcbd41fbd4",
+  "0x76f988da831153b5",
+  "0x983e5152ee66dfab",
+  "0xa831c66d2db43210",
+  "0xb00327c898fb213f",
+  "0xbf597fc7beef0ee4",
+  "0xc6e00bf33da88fc2",
+  "0xd5a79147930aa725",
+  "0x06ca6351e003826f",
+  "0x142929670a0e6e70",
+  "0x27b70a8546d22ffc",
+  "0x2e1b21385c26c926",
+  "0x4d2c6dfc5ac42aed",
+  "0x53380d139d95b3df",
+  "0x650a73548baf63de",
+  "0x766a0abb3c77b2a8",
+  "0x81c2c92e47edaee6",
+  "0x92722c851482353b",
+  "0xa2bfe8a14cf10364",
+  "0xa81a664bbc423001",
+  "0xc24b8b70d0f89791",
+  "0xc76c51a30654be30",
+  "0xd192e819d6ef5218",
+  "0xd69906245565a910",
+  "0xf40e35855771202a",
+  "0x106aa07032bbd1b8",
+  "0x19a4c116b8d2d0c8",
+  "0x1e376c085141ab53",
+  "0x2748774cdf8eeb99",
+  "0x34b0bcb5e19b48a8",
+  "0x391c0cb3c5c95a63",
+  "0x4ed8aa4ae3418acb",
+  "0x5b9cca4f7763e373",
+  "0x682e6ff3d6b2b8a3",
+  "0x748f82ee5defb2fc",
+  "0x78a5636f43172f60",
+  "0x84c87814a1f0ab72",
+  "0x8cc702081a6439ec",
+  "0x90befffa23631e28",
+  "0xa4506cebde82bde9",
+  "0xbef9a3f7b2c67915",
+  "0xc67178f2e372532b",
+  "0xca273eceea26619c",
+  "0xd186b8c721c0c207",
+  "0xeada7dd6cde0eb1e",
+  "0xf57d4f7fee6ed178",
+  "0x06f067aa72176fba",
+  "0x0a637dc5a2c898a6",
+  "0x113f9804bef90dae",
+  "0x1b710b35131c471b",
+  "0x28db77f523047d84",
+  "0x32caab7b40c72493",
+  "0x3c9ebe0a15c9bebc",
+  "0x431d67c49c100d4c",
+  "0x4cc5d4becb3e42b6",
+  "0x597f299cfc657e2a",
+  "0x5fcb6fab3ad6faec",
+  "0x6c44198c4a475817"
+].map((n) => BigInt(n))))();
+const SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
+const SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
+const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+class SHA2_64B extends HashMD {
+  constructor(outputLen) {
+    super(128, outputLen, 16, false);
+  }
+  // prettier-ignore
+  get() {
+    const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+  }
+  // prettier-ignore
+  set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+    this.Ah = Ah | 0;
+    this.Al = Al | 0;
+    this.Bh = Bh | 0;
+    this.Bl = Bl | 0;
+    this.Ch = Ch | 0;
+    this.Cl = Cl | 0;
+    this.Dh = Dh | 0;
+    this.Dl = Dl | 0;
+    this.Eh = Eh | 0;
+    this.El = El | 0;
+    this.Fh = Fh | 0;
+    this.Fl = Fl | 0;
+    this.Gh = Gh | 0;
+    this.Gl = Gl | 0;
+    this.Hh = Hh | 0;
+    this.Hl = Hl | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4) {
+      SHA512_W_H[i] = view.getUint32(offset);
+      SHA512_W_L[i] = view.getUint32(offset += 4);
+    }
+    for (let i = 16; i < 80; i++) {
+      const W15h = SHA512_W_H[i - 15] | 0;
+      const W15l = SHA512_W_L[i - 15] | 0;
+      const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+      const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+      const W2h = SHA512_W_H[i - 2] | 0;
+      const W2l = SHA512_W_L[i - 2] | 0;
+      const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+      const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+      const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+      const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+      SHA512_W_H[i] = SUMh | 0;
+      SHA512_W_L[i] = SUMl | 0;
+    }
+    let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    for (let i = 0; i < 80; i++) {
+      const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+      const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+      const CHIh = Eh & Fh ^ ~Eh & Gh;
+      const CHIl = El & Fl ^ ~El & Gl;
+      const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+      const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+      const T1l = T1ll | 0;
+      const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+      const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+      const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+      const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+      Hh = Gh | 0;
+      Hl = Gl | 0;
+      Gh = Fh | 0;
+      Gl = Fl | 0;
+      Fh = Eh | 0;
+      Fl = El | 0;
+      ({ h: Eh, l: El } = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+      Dh = Ch | 0;
+      Dl = Cl | 0;
+      Ch = Bh | 0;
+      Cl = Bl | 0;
+      Bh = Ah | 0;
+      Bl = Al | 0;
+      const All = add3L(T1l, sigma0l, MAJl);
+      Ah = add3H(All, T1h, sigma0h, MAJh);
+      Al = All | 0;
+    }
+    ({ h: Ah, l: Al } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+    ({ h: Bh, l: Bl } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+    ({ h: Ch, l: Cl } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+    ({ h: Dh, l: Dl } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+    ({ h: Eh, l: El } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+    ({ h: Fh, l: Fl } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+    ({ h: Gh, l: Gl } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+    ({ h: Hh, l: Hl } = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+    this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+  }
+  roundClean() {
+    clean(SHA512_W_H, SHA512_W_L);
+  }
+  destroy() {
+    clean(this.buffer);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
   }
-  /** Checks if the point is valid and on-curve. */
-  assertValidity() {
-    const a = _a;
-    const d = _d;
-    const p = this;
-    if (p.is0())
-      throw new Error("bad point: ZERO");
-    const { ex: X, ey: Y, ez: Z, et: T } = p;
-    const X2 = M(X * X);
-    const Y2 = M(Y * Y);
-    const Z2 = M(Z * Z);
-    const Z4 = M(Z2 * Z2);
-    const aX2 = M(X2 * a);
-    const left = M(Z2 * M(aX2 + Y2));
-    const right = M(Z4 + M(d * M(X2 * Y2)));
-    if (left !== right)
-      throw new Error("bad point: equation left != right (1)");
-    const XY = M(X * Y);
-    const ZT = M(Z * T);
-    if (XY !== ZT)
-      throw new Error("bad point: equation left != right (2)");
-    return this;
+}
+class _SHA512 extends SHA2_64B {
+  Ah = SHA512_IV[0] | 0;
+  Al = SHA512_IV[1] | 0;
+  Bh = SHA512_IV[2] | 0;
+  Bl = SHA512_IV[3] | 0;
+  Ch = SHA512_IV[4] | 0;
+  Cl = SHA512_IV[5] | 0;
+  Dh = SHA512_IV[6] | 0;
+  Dl = SHA512_IV[7] | 0;
+  Eh = SHA512_IV[8] | 0;
+  El = SHA512_IV[9] | 0;
+  Fh = SHA512_IV[10] | 0;
+  Fl = SHA512_IV[11] | 0;
+  Gh = SHA512_IV[12] | 0;
+  Gl = SHA512_IV[13] | 0;
+  Hh = SHA512_IV[14] | 0;
+  Hl = SHA512_IV[15] | 0;
+  constructor() {
+    super(64);
   }
-  /** Equality check: compare points P&Q. */
-  equals(other) {
-    const { ex: X1, ey: Y1, ez: Z1 } = this;
-    const { ex: X2, ey: Y2, ez: Z2 } = apoint(other);
-    const X1Z2 = M(X1 * Z2);
-    const X2Z1 = M(X2 * Z1);
-    const Y1Z2 = M(Y1 * Z2);
-    const Y2Z1 = M(Y2 * Z1);
-    return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+}
+const sha512 = /* @__PURE__ */ createHasher(
+  () => new _SHA512(),
+  /* @__PURE__ */ oidNist(3)
+);
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _0n$3 = /* @__PURE__ */ BigInt(0);
+const _1n$4 = /* @__PURE__ */ BigInt(1);
+function abool(value, title = "") {
+  if (typeof value !== "boolean") {
+    const prefix = title && `"${title}" `;
+    throw new Error(prefix + "expected boolean, got type=" + typeof value);
+  }
+  return value;
+}
+function abignumber(n) {
+  if (typeof n === "bigint") {
+    if (!isPosBig(n))
+      throw new Error("positive bigint expected, got " + n);
+  } else
+    anumber(n);
+  return n;
+}
+function hexToNumber(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  return hex === "" ? _0n$3 : BigInt("0x" + hex);
+}
+function bytesToNumberBE(bytes) {
+  return hexToNumber(bytesToHex$1(bytes));
+}
+function bytesToNumberLE(bytes) {
+  return hexToNumber(bytesToHex$1(copyBytes(abytes$1(bytes)).reverse()));
+}
+function numberToBytesBE(n, len) {
+  anumber(len);
+  n = abignumber(n);
+  const res = hexToBytes$1(n.toString(16).padStart(len * 2, "0"));
+  if (res.length !== len)
+    throw new Error("number too large");
+  return res;
+}
+function numberToBytesLE(n, len) {
+  return numberToBytesBE(n, len).reverse();
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(bytes);
+}
+const isPosBig = (n) => typeof n === "bigint" && _0n$3 <= n;
+function inRange(n, min, max) {
+  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+}
+function aInRange(title, n, min, max) {
+  if (!inRange(n, min, max))
+    throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
+}
+const bitMask = (n) => (_1n$4 << BigInt(n)) - _1n$4;
+function validateObject(object, fields = {}, optFields = {}) {
+  if (!object || typeof object !== "object")
+    throw new Error("expected valid options object");
+  function checkField(fieldName, expectedType, isOpt) {
+    const val = object[fieldName];
+    if (isOpt && val === void 0)
+      return;
+    const current = typeof val;
+    if (current !== expectedType || val === null)
+      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+  }
+  const iter = (f, isOpt) => Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt));
+  iter(fields, false);
+  iter(optFields, true);
+}
+function memoized(fn) {
+  const map = /* @__PURE__ */ new WeakMap();
+  return (arg, ...args) => {
+    const val = map.get(arg);
+    if (val !== void 0)
+      return val;
+    const computed = fn(arg, ...args);
+    map.set(arg, computed);
+    return computed;
+  };
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _0n$2 = /* @__PURE__ */ BigInt(0), _1n$3 = /* @__PURE__ */ BigInt(1), _2n$2 = /* @__PURE__ */ BigInt(2);
+const _3n = /* @__PURE__ */ BigInt(3), _4n = /* @__PURE__ */ BigInt(4), _5n$1 = /* @__PURE__ */ BigInt(5);
+const _7n = /* @__PURE__ */ BigInt(7), _8n$2 = /* @__PURE__ */ BigInt(8), _9n = /* @__PURE__ */ BigInt(9);
+const _16n = /* @__PURE__ */ BigInt(16);
+function mod(a, b) {
+  const result = a % b;
+  return result >= _0n$2 ? result : b + result;
+}
+function pow2$1(x, power, modulo) {
+  let res = x;
+  while (power-- > _0n$2) {
+    res *= res;
+    res %= modulo;
   }
-  is0() {
-    return this.equals(I);
+  return res;
+}
+function invert$1(number, modulo) {
+  if (number === _0n$2)
+    throw new Error("invert: expected non-zero number");
+  if (modulo <= _0n$2)
+    throw new Error("invert: expected positive modulus, got " + modulo);
+  let a = mod(number, modulo);
+  let b = modulo;
+  let x = _0n$2, u = _1n$3;
+  while (a !== _0n$2) {
+    const q = b / a;
+    const r = b % a;
+    const m = x - u * q;
+    b = a, a = r, x = u, u = m;
   }
-  /** Flip point over y coordinate. */
-  negate() {
-    return new Point(M(-this.ex), this.ey, this.ez, M(-this.et));
+  const gcd = b;
+  if (gcd !== _1n$3)
+    throw new Error("invert: does not exist");
+  return mod(x, modulo);
+}
+function assertIsSquare(Fp, root, n) {
+  if (!Fp.eql(Fp.sqr(root), n))
+    throw new Error("Cannot find square root");
+}
+function sqrt3mod4(Fp, n) {
+  const p1div4 = (Fp.ORDER + _1n$3) / _4n;
+  const root = Fp.pow(n, p1div4);
+  assertIsSquare(Fp, root, n);
+  return root;
+}
+function sqrt5mod8(Fp, n) {
+  const p5div8 = (Fp.ORDER - _5n$1) / _8n$2;
+  const n2 = Fp.mul(n, _2n$2);
+  const v = Fp.pow(n2, p5div8);
+  const nv = Fp.mul(n, v);
+  const i = Fp.mul(Fp.mul(nv, _2n$2), v);
+  const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
+  assertIsSquare(Fp, root, n);
+  return root;
+}
+function sqrt9mod16(P2) {
+  const Fp_ = Field(P2);
+  const tn = tonelliShanks(P2);
+  const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
+  const c2 = tn(Fp_, c1);
+  const c3 = tn(Fp_, Fp_.neg(c1));
+  const c4 = (P2 + _7n) / _16n;
+  return (Fp, n) => {
+    let tv1 = Fp.pow(n, c4);
+    let tv2 = Fp.mul(tv1, c1);
+    const tv3 = Fp.mul(tv1, c2);
+    const tv4 = Fp.mul(tv1, c3);
+    const e1 = Fp.eql(Fp.sqr(tv2), n);
+    const e2 = Fp.eql(Fp.sqr(tv3), n);
+    tv1 = Fp.cmov(tv1, tv2, e1);
+    tv2 = Fp.cmov(tv4, tv3, e2);
+    const e3 = Fp.eql(Fp.sqr(tv2), n);
+    const root = Fp.cmov(tv1, tv2, e3);
+    assertIsSquare(Fp, root, n);
+    return root;
+  };
+}
+function tonelliShanks(P2) {
+  if (P2 < _3n)
+    throw new Error("sqrt is not defined for small field");
+  let Q = P2 - _1n$3;
+  let S = 0;
+  while (Q % _2n$2 === _0n$2) {
+    Q /= _2n$2;
+    S++;
+  }
+  let Z = _2n$2;
+  const _Fp = Field(P2);
+  while (FpLegendre(_Fp, Z) === 1) {
+    if (Z++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  }
+  if (S === 1)
+    return sqrt3mod4;
+  let cc = _Fp.pow(Z, Q);
+  const Q1div2 = (Q + _1n$3) / _2n$2;
+  return function tonelliSlow(Fp, n) {
+    if (Fp.is0(n))
+      return n;
+    if (FpLegendre(Fp, n) !== 1)
+      throw new Error("Cannot find square root");
+    let M2 = S;
+    let c = Fp.mul(Fp.ONE, cc);
+    let t = Fp.pow(n, Q);
+    let R = Fp.pow(n, Q1div2);
+    while (!Fp.eql(t, Fp.ONE)) {
+      if (Fp.is0(t))
+        return Fp.ZERO;
+      let i = 1;
+      let t_tmp = Fp.sqr(t);
+      while (!Fp.eql(t_tmp, Fp.ONE)) {
+        i++;
+        t_tmp = Fp.sqr(t_tmp);
+        if (i === M2)
+          throw new Error("Cannot find square root");
+      }
+      const exponent = _1n$3 << BigInt(M2 - i - 1);
+      const b = Fp.pow(c, exponent);
+      M2 = i;
+      c = Fp.sqr(b);
+      t = Fp.mul(t, c);
+      R = Fp.mul(R, b);
+    }
+    return R;
+  };
+}
+function FpSqrt(P2) {
+  if (P2 % _4n === _3n)
+    return sqrt3mod4;
+  if (P2 % _8n$2 === _5n$1)
+    return sqrt5mod8;
+  if (P2 % _16n === _9n)
+    return sqrt9mod16(P2);
+  return tonelliShanks(P2);
+}
+const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n$3) === _1n$3;
+const FIELD_FIELDS = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function validateField(field) {
+  const initial = {
+    ORDER: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  };
+  const opts = FIELD_FIELDS.reduce((map, val) => {
+    map[val] = "function";
+    return map;
+  }, initial);
+  validateObject(field, opts);
+  return field;
+}
+function FpPow(Fp, num, power) {
+  if (power < _0n$2)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (power === _0n$2)
+    return Fp.ONE;
+  if (power === _1n$3)
+    return num;
+  let p = Fp.ONE;
+  let d = num;
+  while (power > _0n$2) {
+    if (power & _1n$3)
+      p = Fp.mul(p, d);
+    d = Fp.sqr(d);
+    power >>= _1n$3;
+  }
+  return p;
+}
+function FpInvertBatch(Fp, nums, passZero = false) {
+  const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : void 0);
+  const multipliedAcc = nums.reduce((acc, num, i) => {
+    if (Fp.is0(num))
+      return acc;
+    inverted[i] = acc;
+    return Fp.mul(acc, num);
+  }, Fp.ONE);
+  const invertedAcc = Fp.inv(multipliedAcc);
+  nums.reduceRight((acc, num, i) => {
+    if (Fp.is0(num))
+      return acc;
+    inverted[i] = Fp.mul(acc, inverted[i]);
+    return Fp.mul(acc, num);
+  }, invertedAcc);
+  return inverted;
+}
+function FpLegendre(Fp, n) {
+  const p1mod2 = (Fp.ORDER - _1n$3) / _2n$2;
+  const powered = Fp.pow(n, p1mod2);
+  const yes = Fp.eql(powered, Fp.ONE);
+  const zero = Fp.eql(powered, Fp.ZERO);
+  const no = Fp.eql(powered, Fp.neg(Fp.ONE));
+  if (!yes && !zero && !no)
+    throw new Error("invalid Legendre symbol result");
+  return yes ? 1 : zero ? 0 : -1;
+}
+function nLength(n, nBitLength) {
+  if (nBitLength !== void 0)
+    anumber(nBitLength);
+  const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
+  const nByteLength = Math.ceil(_nBitLength / 8);
+  return { nBitLength: _nBitLength, nByteLength };
+}
+class _Field {
+  ORDER;
+  BITS;
+  BYTES;
+  isLE;
+  ZERO = _0n$2;
+  ONE = _1n$3;
+  _lengths;
+  _sqrt;
+  // cached sqrt
+  _mod;
+  constructor(ORDER, opts = {}) {
+    if (ORDER <= _0n$2)
+      throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
+    let _nbitLength = void 0;
+    this.isLE = false;
+    if (opts != null && typeof opts === "object") {
+      if (typeof opts.BITS === "number")
+        _nbitLength = opts.BITS;
+      if (typeof opts.sqrt === "function")
+        this.sqrt = opts.sqrt;
+      if (typeof opts.isLE === "boolean")
+        this.isLE = opts.isLE;
+      if (opts.allowedLengths)
+        this._lengths = opts.allowedLengths?.slice();
+      if (typeof opts.modFromBytes === "boolean")
+        this._mod = opts.modFromBytes;
+    }
+    const { nBitLength, nByteLength } = nLength(ORDER, _nbitLength);
+    if (nByteLength > 2048)
+      throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+    this.ORDER = ORDER;
+    this.BITS = nBitLength;
+    this.BYTES = nByteLength;
+    this._sqrt = void 0;
+    Object.preventExtensions(this);
   }
-  /** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
-  double() {
-    const { ex: X1, ey: Y1, ez: Z1 } = this;
-    const a = _a;
-    const A = M(X1 * X1);
-    const B = M(Y1 * Y1);
-    const C2 = M(2n * M(Z1 * Z1));
-    const D = M(a * A);
-    const x1y1 = X1 + Y1;
-    const E = M(M(x1y1 * x1y1) - A - B);
-    const G2 = D + B;
-    const F = G2 - C2;
-    const H = D - B;
-    const X3 = M(E * F);
-    const Y3 = M(G2 * H);
-    const T3 = M(E * H);
-    const Z3 = M(F * G2);
-    return new Point(X3, Y3, Z3, T3);
+  create(num) {
+    return mod(num, this.ORDER);
   }
-  /** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
-  add(other) {
-    const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
-    const { ex: X2, ey: Y2, ez: Z2, et: T2 } = apoint(other);
-    const a = _a;
-    const d = _d;
-    const A = M(X1 * X2);
-    const B = M(Y1 * Y2);
-    const C2 = M(T1 * d * T2);
-    const D = M(Z1 * Z2);
-    const E = M((X1 + Y1) * (X2 + Y2) - A - B);
-    const F = M(D - C2);
-    const G2 = M(D + C2);
-    const H = M(B - a * A);
-    const X3 = M(E * F);
-    const Y3 = M(G2 * H);
-    const T3 = M(E * H);
-    const Z3 = M(F * G2);
-    return new Point(X3, Y3, Z3, T3);
+  isValid(num) {
+    if (typeof num !== "bigint")
+      throw new Error("invalid field element: expected bigint, got " + typeof num);
+    return _0n$2 <= num && num < this.ORDER;
   }
-  /**
-   * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
-   * Uses {@link wNAF} for base point.
-   * Uses fake point to mitigate side-channel leakage.
-   * @param n scalar by which point is multiplied
-   * @param safe safe mode guards against timing attacks; unsafe mode is faster
-   */
-  multiply(n, safe = true) {
-    if (!safe && (n === 0n || this.is0()))
-      return I;
-    arange(n, 1n, N);
-    if (n === 1n)
-      return this;
-    if (this.equals(G))
-      return wNAF(n).p;
-    let p = I;
-    let f = G;
-    for (let d = this; n > 0n; d = d.double(), n >>= 1n) {
-      if (n & 1n)
-        p = p.add(d);
-      else if (safe)
-        f = f.add(d);
-    }
-    return p;
+  is0(num) {
+    return num === _0n$2;
   }
-  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
-  toAffine() {
-    const { ex: x, ey: y, ez: z } = this;
-    if (this.equals(I))
-      return { x: 0n, y: 1n };
-    const iz = invert(z, P);
-    if (M(z * iz) !== 1n)
-      err("invalid inverse");
-    return { x: M(x * iz), y: M(y * iz) };
+  // is valid and invertible
+  isValidNot0(num) {
+    return !this.is0(num) && this.isValid(num);
   }
-  toBytes() {
-    const { x, y } = this.assertValidity().toAffine();
-    const b = numTo32bLE(y);
-    b[31] |= x & 1n ? 128 : 0;
-    return b;
+  isOdd(num) {
+    return (num & _1n$3) === _1n$3;
   }
-  toHex() {
-    return bytesToHex(this.toBytes());
+  neg(num) {
+    return mod(-num, this.ORDER);
   }
-  // encode to hex string
-  clearCofactor() {
-    return this.multiply(big(h), false);
+  eql(lhs, rhs) {
+    return lhs === rhs;
   }
-  isSmallOrder() {
-    return this.clearCofactor().is0();
+  sqr(num) {
+    return mod(num * num, this.ORDER);
   }
-  isTorsionFree() {
-    let p = this.multiply(N / 2n, false).double();
-    if (N % 2n)
-      p = p.add(this);
-    return p.is0();
+  add(lhs, rhs) {
+    return mod(lhs + rhs, this.ORDER);
   }
-  static fromHex(hex, zip215) {
-    return Point.fromBytes(toU8(hex), zip215);
+  sub(lhs, rhs) {
+    return mod(lhs - rhs, this.ORDER);
   }
-  get x() {
-    return this.toAffine().x;
+  mul(lhs, rhs) {
+    return mod(lhs * rhs, this.ORDER);
   }
-  get y() {
-    return this.toAffine().y;
+  pow(num, power) {
+    return FpPow(this, num, power);
   }
-  toRawBytes() {
-    return this.toBytes();
+  div(lhs, rhs) {
+    return mod(lhs * invert$1(rhs, this.ORDER), this.ORDER);
+  }
+  // Same as above, but doesn't normalize
+  sqrN(num) {
+    return num * num;
+  }
+  addN(lhs, rhs) {
+    return lhs + rhs;
+  }
+  subN(lhs, rhs) {
+    return lhs - rhs;
+  }
+  mulN(lhs, rhs) {
+    return lhs * rhs;
+  }
+  inv(num) {
+    return invert$1(num, this.ORDER);
+  }
+  sqrt(num) {
+    if (!this._sqrt)
+      this._sqrt = FpSqrt(this.ORDER);
+    return this._sqrt(this, num);
+  }
+  toBytes(num) {
+    return this.isLE ? numberToBytesLE(num, this.BYTES) : numberToBytesBE(num, this.BYTES);
+  }
+  fromBytes(bytes, skipValidation = false) {
+    abytes$1(bytes);
+    const { _lengths: allowedLengths, BYTES, isLE, ORDER, _mod: modFromBytes } = this;
+    if (allowedLengths) {
+      if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) {
+        throw new Error("Field.fromBytes: expected " + allowedLengths + " bytes, got " + bytes.length);
+      }
+      const padded = new Uint8Array(BYTES);
+      padded.set(bytes, isLE ? 0 : padded.length - bytes.length);
+      bytes = padded;
+    }
+    if (bytes.length !== BYTES)
+      throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length);
+    let scalar = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
+    if (modFromBytes)
+      scalar = mod(scalar, ORDER);
+    if (!skipValidation) {
+      if (!this.isValid(scalar))
+        throw new Error("invalid field element: outside of range 0..ORDER");
+    }
+    return scalar;
+  }
+  // TODO: we don't need it here, move out to separate fn
+  invertBatch(lst) {
+    return FpInvertBatch(this, lst);
+  }
+  // We can't move this out because Fp6, Fp12 implement it
+  // and it's unclear what to return in there.
+  cmov(a, b, condition) {
+    return condition ? b : a;
   }
 }
-const G = new Point(Gx, Gy, 1n, M(Gx * Gy));
-const I = new Point(0n, 1n, 1n, 0n);
-Point.BASE = G;
-Point.ZERO = I;
-const numTo32bLE = (num) => hexToBytes(padh(arange(num, 0n, B256), L2)).reverse();
-const bytesToNumLE = (b) => big("0x" + bytesToHex(u8fr(abytes(b)).reverse()));
-const pow2 = (x, power) => {
-  let r = x;
-  while (power-- > 0n) {
-    r *= r;
-    r %= P;
+function Field(ORDER, opts = {}) {
+  return new _Field(ORDER, opts);
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _0n$1 = /* @__PURE__ */ BigInt(0);
+const _1n$2 = /* @__PURE__ */ BigInt(1);
+function negateCt(condition, item) {
+  const neg = item.negate();
+  return condition ? neg : item;
+}
+function normalizeZ(c, points) {
+  const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));
+  return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));
+}
+function validateW(W2, bits) {
+  if (!Number.isSafeInteger(W2) || W2 <= 0 || W2 > bits)
+    throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W2);
+}
+function calcWOpts(W2, scalarBits2) {
+  validateW(W2, scalarBits2);
+  const windows = Math.ceil(scalarBits2 / W2) + 1;
+  const windowSize = 2 ** (W2 - 1);
+  const maxNumber = 2 ** W2;
+  const mask = bitMask(W2);
+  const shiftBy = BigInt(W2);
+  return { windows, windowSize, mask, maxNumber, shiftBy };
+}
+function calcOffsets(n, window, wOpts) {
+  const { windowSize, mask, maxNumber, shiftBy } = wOpts;
+  let wbits = Number(n & mask);
+  let nextN = n >> shiftBy;
+  if (wbits > windowSize) {
+    wbits -= maxNumber;
+    nextN += _1n$2;
+  }
+  const offsetStart = window * windowSize;
+  const offset = offsetStart + Math.abs(wbits) - 1;
+  const isZero = wbits === 0;
+  const isNeg = wbits < 0;
+  const isNegF = window % 2 !== 0;
+  const offsetF = offsetStart;
+  return { nextN, offset, isZero, isNeg, isNegF, offsetF };
+}
+const pointPrecomputes = /* @__PURE__ */ new WeakMap();
+const pointWindowSizes = /* @__PURE__ */ new WeakMap();
+function getW(P2) {
+  return pointWindowSizes.get(P2) || 1;
+}
+function assert0(n) {
+  if (n !== _0n$1)
+    throw new Error("invalid wNAF");
+}
+let wNAF$1 = class wNAF {
+  BASE;
+  ZERO;
+  Fn;
+  bits;
+  // Parametrized with a given Point class (not individual point)
+  constructor(Point2, bits) {
+    this.BASE = Point2.BASE;
+    this.ZERO = Point2.ZERO;
+    this.Fn = Point2.Fn;
+    this.bits = bits;
+  }
+  // non-const time multiplication ladder
+  _unsafeLadder(elm, n, p = this.ZERO) {
+    let d = elm;
+    while (n > _0n$1) {
+      if (n & _1n$2)
+        p = p.add(d);
+      d = d.double();
+      n >>= _1n$2;
+    }
+    return p;
   }
-  return r;
-};
-const pow_2_252_3 = (x) => {
-  const x2 = x * x % P;
-  const b2 = x2 * x % P;
-  const b4 = pow2(b2, 2n) * b2 % P;
-  const b5 = pow2(b4, 1n) * x % P;
-  const b10 = pow2(b5, 5n) * b5 % P;
-  const b20 = pow2(b10, 10n) * b10 % P;
-  const b40 = pow2(b20, 20n) * b20 % P;
-  const b80 = pow2(b40, 40n) * b40 % P;
-  const b160 = pow2(b80, 80n) * b80 % P;
-  const b240 = pow2(b160, 80n) * b80 % P;
-  const b250 = pow2(b240, 10n) * b10 % P;
-  const pow_p_5_8 = pow2(b250, 2n) * x % P;
-  return { pow_p_5_8, b2 };
-};
-const RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n;
-const uvRatio = (u, v) => {
-  const v3 = M(v * v * v);
-  const v7 = M(v3 * v3 * v);
-  const pow = pow_2_252_3(u * v7).pow_p_5_8;
-  let x = M(u * v3 * pow);
-  const vx2 = M(v * x * x);
+  /**
+   * Creates a wNAF precomputation window. Used for caching.
+   * Default window size is set by `utils.precompute()` and is equal to 8.
+   * Number of precomputed points depends on the curve size:
+   * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+   * - 𝑊 is the window size
+   * - 𝑛 is the bitlength of the curve order.
+   * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+   * @param point Point instance
+   * @param W window size
+   * @returns precomputed point tables flattened to a single array
+   */
+  precomputeWindow(point, W2) {
+    const { windows, windowSize } = calcWOpts(W2, this.bits);
+    const points = [];
+    let p = point;
+    let base = p;
+    for (let window = 0; window < windows; window++) {
+      base = p;
+      points.push(base);
+      for (let i = 1; i < windowSize; i++) {
+        base = base.add(p);
+        points.push(base);
+      }
+      p = base.double();
+    }
+    return points;
+  }
+  /**
+   * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+   * More compact implementation:
+   * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
+   * @returns real and fake (for const-time) points
+   */
+  wNAF(W2, precomputes, n) {
+    if (!this.Fn.isValid(n))
+      throw new Error("invalid scalar");
+    let p = this.ZERO;
+    let f = this.BASE;
+    const wo = calcWOpts(W2, this.bits);
+    for (let window = 0; window < wo.windows; window++) {
+      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
+      n = nextN;
+      if (isZero) {
+        f = f.add(negateCt(isNegF, precomputes[offsetF]));
+      } else {
+        p = p.add(negateCt(isNeg, precomputes[offset]));
+      }
+    }
+    assert0(n);
+    return { p, f };
+  }
+  /**
+   * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+   * @param acc accumulator point to add result of multiplication
+   * @returns point
+   */
+  wNAFUnsafe(W2, precomputes, n, acc = this.ZERO) {
+    const wo = calcWOpts(W2, this.bits);
+    for (let window = 0; window < wo.windows; window++) {
+      if (n === _0n$1)
+        break;
+      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
+      n = nextN;
+      if (isZero) {
+        continue;
+      } else {
+        const item = precomputes[offset];
+        acc = acc.add(isNeg ? item.negate() : item);
+      }
+    }
+    assert0(n);
+    return acc;
+  }
+  getPrecomputes(W2, point, transform) {
+    let comp = pointPrecomputes.get(point);
+    if (!comp) {
+      comp = this.precomputeWindow(point, W2);
+      if (W2 !== 1) {
+        if (typeof transform === "function")
+          comp = transform(comp);
+        pointPrecomputes.set(point, comp);
+      }
+    }
+    return comp;
+  }
+  cached(point, scalar, transform) {
+    const W2 = getW(point);
+    return this.wNAF(W2, this.getPrecomputes(W2, point, transform), scalar);
+  }
+  unsafe(point, scalar, transform, prev) {
+    const W2 = getW(point);
+    if (W2 === 1)
+      return this._unsafeLadder(point, scalar, prev);
+    return this.wNAFUnsafe(W2, this.getPrecomputes(W2, point, transform), scalar, prev);
+  }
+  // We calculate precomputes for elliptic curve point multiplication
+  // using windowed method. This specifies window size and
+  // stores precomputed values. Usually only base point would be precomputed.
+  createCache(P2, W2) {
+    validateW(W2, this.bits);
+    pointWindowSizes.set(P2, W2);
+    pointPrecomputes.delete(P2);
+  }
+  hasCache(elm) {
+    return getW(elm) !== 1;
+  }
+};
+function createField(order, field, isLE) {
+  if (field) {
+    if (field.ORDER !== order)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    validateField(field);
+    return field;
+  } else {
+    return Field(order, { isLE });
+  }
+}
+function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
+  if (FpFnLE === void 0)
+    FpFnLE = type === "edwards";
+  if (!CURVE || typeof CURVE !== "object")
+    throw new Error(`expected valid ${type} CURVE object`);
+  for (const p of ["p", "n", "h"]) {
+    const val = CURVE[p];
+    if (!(typeof val === "bigint" && val > _0n$1))
+      throw new Error(`CURVE.${p} must be positive bigint`);
+  }
+  const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);
+  const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);
+  const _b = "d";
+  const params = ["Gx", "Gy", "a", _b];
+  for (const p of params) {
+    if (!Fp.isValid(CURVE[p]))
+      throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);
+  }
+  CURVE = Object.freeze(Object.assign({}, CURVE));
+  return { CURVE, Fp, Fn };
+}
+function createKeygen(randomSecretKey, getPublicKey2) {
+  return function keygen(seed) {
+    const secretKey = randomSecretKey(seed);
+    return { secretKey, publicKey: getPublicKey2(secretKey) };
+  };
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _0n = BigInt(0), _1n$1 = BigInt(1), _2n$1 = BigInt(2), _8n$1 = BigInt(8);
+function isEdValidXY(Fp, CURVE, x, y) {
+  const x2 = Fp.sqr(x);
+  const y2 = Fp.sqr(y);
+  const left = Fp.add(Fp.mul(CURVE.a, x2), y2);
+  const right = Fp.add(Fp.ONE, Fp.mul(CURVE.d, Fp.mul(x2, y2)));
+  return Fp.eql(left, right);
+}
+function edwards(params, extraOpts = {}) {
+  const validated = createCurveFields("edwards", params, extraOpts, extraOpts.FpFnLE);
+  const { Fp, Fn } = validated;
+  let CURVE = validated.CURVE;
+  const { h: cofactor } = CURVE;
+  validateObject(extraOpts, {}, { uvRatio: "function" });
+  const MASK = _2n$1 << BigInt(Fn.BYTES * 8) - _1n$1;
+  const modP = (n) => Fp.create(n);
+  const uvRatio2 = extraOpts.uvRatio || ((u, v) => {
+    try {
+      return { isValid: true, value: Fp.sqrt(Fp.div(u, v)) };
+    } catch (e) {
+      return { isValid: false, value: _0n };
+    }
+  });
+  if (!isEdValidXY(Fp, CURVE, CURVE.Gx, CURVE.Gy))
+    throw new Error("bad curve params: generator point");
+  function acoord(title, n, banZero = false) {
+    const min = banZero ? _1n$1 : _0n;
+    aInRange("coordinate " + title, n, min, MASK);
+    return n;
+  }
+  function aedpoint(other) {
+    if (!(other instanceof Point2))
+      throw new Error("EdwardsPoint expected");
+  }
+  const toAffineMemo = memoized((p, iz) => {
+    const { X, Y, Z } = p;
+    const is0 = p.is0();
+    if (iz == null)
+      iz = is0 ? _8n$1 : Fp.inv(Z);
+    const x = modP(X * iz);
+    const y = modP(Y * iz);
+    const zz = Fp.mul(Z, iz);
+    if (is0)
+      return { x: _0n, y: _1n$1 };
+    if (zz !== _1n$1)
+      throw new Error("invZ was invalid");
+    return { x, y };
+  });
+  const assertValidMemo = memoized((p) => {
+    const { a, d } = CURVE;
+    if (p.is0())
+      throw new Error("bad point: ZERO");
+    const { X, Y, Z, T } = p;
+    const X2 = modP(X * X);
+    const Y2 = modP(Y * Y);
+    const Z2 = modP(Z * Z);
+    const Z4 = modP(Z2 * Z2);
+    const aX2 = modP(X2 * a);
+    const left = modP(Z2 * modP(aX2 + Y2));
+    const right = modP(Z4 + modP(d * modP(X2 * Y2)));
+    if (left !== right)
+      throw new Error("bad point: equation left != right (1)");
+    const XY = modP(X * Y);
+    const ZT = modP(Z * T);
+    if (XY !== ZT)
+      throw new Error("bad point: equation left != right (2)");
+    return true;
+  });
+  class Point2 {
+    // base / generator point
+    static BASE = new Point2(CURVE.Gx, CURVE.Gy, _1n$1, modP(CURVE.Gx * CURVE.Gy));
+    // zero / infinity / identity point
+    static ZERO = new Point2(_0n, _1n$1, _1n$1, _0n);
+    // 0, 1, 1, 0
+    // math field
+    static Fp = Fp;
+    // scalar field
+    static Fn = Fn;
+    X;
+    Y;
+    Z;
+    T;
+    constructor(X, Y, Z, T) {
+      this.X = acoord("x", X);
+      this.Y = acoord("y", Y);
+      this.Z = acoord("z", Z, true);
+      this.T = acoord("t", T);
+      Object.freeze(this);
+    }
+    static CURVE() {
+      return CURVE;
+    }
+    static fromAffine(p) {
+      if (p instanceof Point2)
+        throw new Error("extended point not allowed");
+      const { x, y } = p || {};
+      acoord("x", x);
+      acoord("y", y);
+      return new Point2(x, y, _1n$1, modP(x * y));
+    }
+    // Uses algo from RFC8032 5.1.3.
+    static fromBytes(bytes, zip215 = false) {
+      const len = Fp.BYTES;
+      const { a, d } = CURVE;
+      bytes = copyBytes(abytes$1(bytes, len, "point"));
+      abool(zip215, "zip215");
+      const normed = copyBytes(bytes);
+      const lastByte = bytes[len - 1];
+      normed[len - 1] = lastByte & -129;
+      const y = bytesToNumberLE(normed);
+      const max = zip215 ? MASK : Fp.ORDER;
+      aInRange("point.y", y, _0n, max);
+      const y2 = modP(y * y);
+      const u = modP(y2 - _1n$1);
+      const v = modP(d * y2 - a);
+      let { isValid, value: x } = uvRatio2(u, v);
+      if (!isValid)
+        throw new Error("bad point: invalid y coordinate");
+      const isXOdd = (x & _1n$1) === _1n$1;
+      const isLastByteOdd = (lastByte & 128) !== 0;
+      if (!zip215 && x === _0n && isLastByteOdd)
+        throw new Error("bad point: x=0 and x_0=1");
+      if (isLastByteOdd !== isXOdd)
+        x = modP(-x);
+      return Point2.fromAffine({ x, y });
+    }
+    static fromHex(hex, zip215 = false) {
+      return Point2.fromBytes(hexToBytes$1(hex), zip215);
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    precompute(windowSize = 8, isLazy = true) {
+      wnaf.createCache(this, windowSize);
+      if (!isLazy)
+        this.multiply(_2n$1);
+      return this;
+    }
+    // Useful in fromAffine() - not for fromBytes(), which always created valid points.
+    assertValidity() {
+      assertValidMemo(this);
+    }
+    // Compare one point to another.
+    equals(other) {
+      aedpoint(other);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      const { X: X2, Y: Y2, Z: Z2 } = other;
+      const X1Z2 = modP(X1 * Z2);
+      const X2Z1 = modP(X2 * Z1);
+      const Y1Z2 = modP(Y1 * Z2);
+      const Y2Z1 = modP(Y2 * Z1);
+      return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+    }
+    is0() {
+      return this.equals(Point2.ZERO);
+    }
+    negate() {
+      return new Point2(modP(-this.X), this.Y, this.Z, modP(-this.T));
+    }
+    // Fast algo for doubling Extended Point.
+    // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd
+    // Cost: 4M + 4S + 1*a + 6add + 1*2.
+    double() {
+      const { a } = CURVE;
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      const A = modP(X1 * X1);
+      const B = modP(Y1 * Y1);
+      const C2 = modP(_2n$1 * modP(Z1 * Z1));
+      const D = modP(a * A);
+      const x1y1 = X1 + Y1;
+      const E = modP(modP(x1y1 * x1y1) - A - B);
+      const G2 = D + B;
+      const F = G2 - C2;
+      const H = D - B;
+      const X3 = modP(E * F);
+      const Y3 = modP(G2 * H);
+      const T3 = modP(E * H);
+      const Z3 = modP(F * G2);
+      return new Point2(X3, Y3, Z3, T3);
+    }
+    // Fast algo for adding 2 Extended Points.
+    // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd
+    // Cost: 9M + 1*a + 1*d + 7add.
+    add(other) {
+      aedpoint(other);
+      const { a, d } = CURVE;
+      const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
+      const { X: X2, Y: Y2, Z: Z2, T: T2 } = other;
+      const A = modP(X1 * X2);
+      const B = modP(Y1 * Y2);
+      const C2 = modP(T1 * d * T2);
+      const D = modP(Z1 * Z2);
+      const E = modP((X1 + Y1) * (X2 + Y2) - A - B);
+      const F = D - C2;
+      const G2 = D + C2;
+      const H = modP(B - a * A);
+      const X3 = modP(E * F);
+      const Y3 = modP(G2 * H);
+      const T3 = modP(E * H);
+      const Z3 = modP(F * G2);
+      return new Point2(X3, Y3, Z3, T3);
+    }
+    subtract(other) {
+      return this.add(other.negate());
+    }
+    // Constant-time multiplication.
+    multiply(scalar) {
+      if (!Fn.isValidNot0(scalar))
+        throw new Error("invalid scalar: expected 1 <= sc < curve.n");
+      const { p, f } = wnaf.cached(this, scalar, (p2) => normalizeZ(Point2, p2));
+      return normalizeZ(Point2, [p, f])[0];
+    }
+    // Non-constant-time multiplication. Uses double-and-add algorithm.
+    // It's faster, but should only be used when you don't care about
+    // an exposed private key e.g. sig verification.
+    // Does NOT allow scalars higher than CURVE.n.
+    // Accepts optional accumulator to merge with multiply (important for sparse scalars)
+    multiplyUnsafe(scalar, acc = Point2.ZERO) {
+      if (!Fn.isValid(scalar))
+        throw new Error("invalid scalar: expected 0 <= sc < curve.n");
+      if (scalar === _0n)
+        return Point2.ZERO;
+      if (this.is0() || scalar === _1n$1)
+        return this;
+      return wnaf.unsafe(this, scalar, (p) => normalizeZ(Point2, p), acc);
+    }
+    // Checks if point is of small order.
+    // If you add something to small order point, you will have "dirty"
+    // point with torsion component.
+    // Multiplies point by cofactor and checks if the result is 0.
+    isSmallOrder() {
+      return this.multiplyUnsafe(cofactor).is0();
+    }
+    // Multiplies point by curve order and checks if the result is 0.
+    // Returns `false` is the point is dirty.
+    isTorsionFree() {
+      return wnaf.unsafe(this, CURVE.n).is0();
+    }
+    // Converts Extended point to default (x, y) coordinates.
+    // Can accept precomputed Z^-1 - for example, from invertBatch.
+    toAffine(invertedZ) {
+      return toAffineMemo(this, invertedZ);
+    }
+    clearCofactor() {
+      if (cofactor === _1n$1)
+        return this;
+      return this.multiplyUnsafe(cofactor);
+    }
+    toBytes() {
+      const { x, y } = this.toAffine();
+      const bytes = Fp.toBytes(y);
+      bytes[bytes.length - 1] |= x & _1n$1 ? 128 : 0;
+      return bytes;
+    }
+    toHex() {
+      return bytesToHex$1(this.toBytes());
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+  }
+  const wnaf = new wNAF$1(Point2, Fn.BITS);
+  Point2.BASE.precompute(8);
+  return Point2;
+}
+function eddsa(Point2, cHash, eddsaOpts = {}) {
+  if (typeof cHash !== "function")
+    throw new Error('"hash" function param is required');
+  validateObject(eddsaOpts, {}, {
+    adjustScalarBytes: "function",
+    randomBytes: "function",
+    domain: "function",
+    prehash: "function",
+    mapToCurve: "function"
+  });
+  const { prehash } = eddsaOpts;
+  const { BASE, Fp, Fn } = Point2;
+  const randomBytes2 = eddsaOpts.randomBytes || randomBytes$1;
+  const adjustScalarBytes2 = eddsaOpts.adjustScalarBytes || ((bytes) => bytes);
+  const domain = eddsaOpts.domain || ((data, ctx, phflag) => {
+    abool(phflag, "phflag");
+    if (ctx.length || phflag)
+      throw new Error("Contexts/pre-hash are not supported");
+    return data;
+  });
+  function modN_LE(hash) {
+    return Fn.create(bytesToNumberLE(hash));
+  }
+  function getPrivateScalar(key) {
+    const len = lengths.secretKey;
+    abytes$1(key, lengths.secretKey, "secretKey");
+    const hashed = abytes$1(cHash(key), 2 * len, "hashedSecretKey");
+    const head = adjustScalarBytes2(hashed.slice(0, len));
+    const prefix = hashed.slice(len, 2 * len);
+    const scalar = modN_LE(head);
+    return { head, prefix, scalar };
+  }
+  function getExtendedPublicKey2(secretKey) {
+    const { head, prefix, scalar } = getPrivateScalar(secretKey);
+    const point = BASE.multiply(scalar);
+    const pointBytes = point.toBytes();
+    return { head, prefix, scalar, point, pointBytes };
+  }
+  function getPublicKey2(secretKey) {
+    return getExtendedPublicKey2(secretKey).pointBytes;
+  }
+  function hashDomainToScalar(context = Uint8Array.of(), ...msgs) {
+    const msg = concatBytes$1(...msgs);
+    return modN_LE(cHash(domain(msg, abytes$1(context, void 0, "context"), !!prehash)));
+  }
+  function sign(msg, secretKey, options = {}) {
+    msg = abytes$1(msg, void 0, "message");
+    if (prehash)
+      msg = prehash(msg);
+    const { prefix, scalar, pointBytes } = getExtendedPublicKey2(secretKey);
+    const r = hashDomainToScalar(options.context, prefix, msg);
+    const R = BASE.multiply(r).toBytes();
+    const k = hashDomainToScalar(options.context, R, pointBytes, msg);
+    const s = Fn.create(r + k * scalar);
+    if (!Fn.isValid(s))
+      throw new Error("sign failed: invalid s");
+    const rs = concatBytes$1(R, Fn.toBytes(s));
+    return abytes$1(rs, lengths.signature, "result");
+  }
+  const verifyOpts = { zip215: true };
+  function verify(sig, msg, publicKey, options = verifyOpts) {
+    const { context, zip215 } = options;
+    const len = lengths.signature;
+    sig = abytes$1(sig, len, "signature");
+    msg = abytes$1(msg, void 0, "message");
+    publicKey = abytes$1(publicKey, lengths.publicKey, "publicKey");
+    if (zip215 !== void 0)
+      abool(zip215, "zip215");
+    if (prehash)
+      msg = prehash(msg);
+    const mid = len / 2;
+    const r = sig.subarray(0, mid);
+    const s = bytesToNumberLE(sig.subarray(mid, len));
+    let A, R, SB;
+    try {
+      A = Point2.fromBytes(publicKey, zip215);
+      R = Point2.fromBytes(r, zip215);
+      SB = BASE.multiplyUnsafe(s);
+    } catch (error) {
+      return false;
+    }
+    if (!zip215 && A.isSmallOrder())
+      return false;
+    const k = hashDomainToScalar(context, R.toBytes(), A.toBytes(), msg);
+    const RkA = R.add(A.multiplyUnsafe(k));
+    return RkA.subtract(SB).clearCofactor().is0();
+  }
+  const _size = Fp.BYTES;
+  const lengths = {
+    secretKey: _size,
+    publicKey: _size,
+    signature: 2 * _size,
+    seed: _size
+  };
+  function randomSecretKey(seed = randomBytes2(lengths.seed)) {
+    return abytes$1(seed, lengths.seed, "seed");
+  }
+  function isValidSecretKey(key) {
+    return isBytes$1(key) && key.length === Fn.BYTES;
+  }
+  function isValidPublicKey(key, zip215) {
+    try {
+      return !!Point2.fromBytes(key, zip215);
+    } catch (error) {
+      return false;
+    }
+  }
+  const utils2 = {
+    getExtendedPublicKey: getExtendedPublicKey2,
+    randomSecretKey,
+    isValidSecretKey,
+    isValidPublicKey,
+    /**
+     * Converts ed public key to x public key. Uses formula:
+     * - ed25519:
+     *   - `(u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x)`
+     *   - `(x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1))`
+     * - ed448:
+     *   - `(u, v) = ((y-1)/(y+1), sqrt(156324)*u/x)`
+     *   - `(x, y) = (sqrt(156324)*u/v, (1+u)/(1-u))`
+     */
+    toMontgomery(publicKey) {
+      const { y } = Point2.fromBytes(publicKey);
+      const size = lengths.publicKey;
+      const is25519 = size === 32;
+      if (!is25519 && size !== 57)
+        throw new Error("only defined for 25519 and 448");
+      const u = is25519 ? Fp.div(_1n$1 + y, _1n$1 - y) : Fp.div(y - _1n$1, y + _1n$1);
+      return Fp.toBytes(u);
+    },
+    toMontgomerySecret(secretKey) {
+      const size = lengths.secretKey;
+      abytes$1(secretKey, size);
+      const hashed = cHash(secretKey.subarray(0, size));
+      return adjustScalarBytes2(hashed).subarray(0, size);
+    }
+  };
+  return Object.freeze({
+    keygen: createKeygen(randomSecretKey, getPublicKey2),
+    getPublicKey: getPublicKey2,
+    sign,
+    verify,
+    utils: utils2,
+    Point: Point2,
+    lengths
+  });
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _1n = BigInt(1), _2n = BigInt(2);
+const _5n = BigInt(5), _8n = BigInt(8);
+const ed25519_CURVE_p = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed");
+const ed25519_CURVE$1 = /* @__PURE__ */ (() => ({
+  p: ed25519_CURVE_p,
+  n: BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed"),
+  h: _8n,
+  a: BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec"),
+  d: BigInt("0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3"),
+  Gx: BigInt("0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a"),
+  Gy: BigInt("0x6666666666666666666666666666666666666666666666666666666666666658")
+}))();
+function ed25519_pow_2_252_3(x) {
+  const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
+  const P2 = ed25519_CURVE_p;
+  const x2 = x * x % P2;
+  const b2 = x2 * x % P2;
+  const b4 = pow2$1(b2, _2n, P2) * b2 % P2;
+  const b5 = pow2$1(b4, _1n, P2) * x % P2;
+  const b10 = pow2$1(b5, _5n, P2) * b5 % P2;
+  const b20 = pow2$1(b10, _10n, P2) * b10 % P2;
+  const b40 = pow2$1(b20, _20n, P2) * b20 % P2;
+  const b80 = pow2$1(b40, _40n, P2) * b40 % P2;
+  const b160 = pow2$1(b80, _80n, P2) * b80 % P2;
+  const b240 = pow2$1(b160, _80n, P2) * b80 % P2;
+  const b250 = pow2$1(b240, _10n, P2) * b10 % P2;
+  const pow_p_5_8 = pow2$1(b250, _2n, P2) * x % P2;
+  return { pow_p_5_8, b2 };
+}
+function adjustScalarBytes(bytes) {
+  bytes[0] &= 248;
+  bytes[31] &= 127;
+  bytes[31] |= 64;
+  return bytes;
+}
+const ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
+function uvRatio$1(u, v) {
+  const P2 = ed25519_CURVE_p;
+  const v3 = mod(v * v * v, P2);
+  const v7 = mod(v3 * v3 * v, P2);
+  const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
+  let x = mod(u * v3 * pow, P2);
+  const vx2 = mod(v * x * x, P2);
   const root1 = x;
-  const root2 = M(x * RM1);
+  const root2 = mod(x * ED25519_SQRT_M1, P2);
   const useRoot1 = vx2 === u;
-  const useRoot2 = vx2 === M(-u);
-  const noRoot = vx2 === M(-u * RM1);
+  const useRoot2 = vx2 === mod(-u, P2);
+  const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P2);
   if (useRoot1)
     x = root1;
   if (useRoot2 || noRoot)
     x = root2;
-  if ((M(x) & 1n) === 1n)
-    x = M(-x);
+  if (isNegativeLE(x, P2))
+    x = mod(-x, P2);
   return { isValid: useRoot1 || useRoot2, value: x };
+}
+const ed25519_Point = /* @__PURE__ */ edwards(ed25519_CURVE$1, { uvRatio: uvRatio$1 });
+function ed(opts) {
+  return eddsa(ed25519_Point, sha512, Object.assign({ adjustScalarBytes }, opts));
+}
+const ed25519 = /* @__PURE__ */ ed({});
+/*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
+const ed25519_CURVE = {
+  p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
+  n: 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn,
+  a: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffecn,
+  d: 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n,
+  Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an,
+  Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n
 };
-const modL_LE = (hash) => modN(bytesToNumLE(hash));
-const sha512a = (...m) => etc.sha512Async(...m);
-const sha512s = (...m) => callHash("sha512Sync")(...m);
-const hash2extK = (hashed) => {
-  const head = hashed.slice(0, L);
-  head[0] &= 248;
-  head[31] &= 127;
-  head[31] |= 64;
-  const prefix = hashed.slice(L, L2);
-  const scalar = modL_LE(head);
-  const point = G.multiply(scalar);
-  const pointBytes = point.toBytes();
-  return { head, prefix, scalar, point, pointBytes };
-};
-const getExtendedPublicKeyAsync = (priv) => sha512a(toU8(priv, L)).then(hash2extK);
-const getExtendedPublicKey = (priv) => hash2extK(sha512s(toU8(priv, L)));
-const getPublicKeyAsync = (priv) => getExtendedPublicKeyAsync(priv).then((p) => p.pointBytes);
-const getPublicKey = (priv) => getExtendedPublicKey(priv).pointBytes;
-const hashFinishA = (res) => sha512a(res.hashable).then(res.finish);
-const _sign = (e, rBytes, msg) => {
-  const { pointBytes: P2, scalar: s } = e;
-  const r = modL_LE(rBytes);
-  const R = G.multiply(r).toBytes();
-  const hashable = concatBytes(R, P2, msg);
-  const finish = (hashed) => {
-    const S = modN(r + modL_LE(hashed) * s);
-    return abytes(concatBytes(R, numTo32bLE(S)), L2);
-  };
-  return { hashable, finish };
+const { p: P, n: N, Gx, Gy, a: _a, d: _d } = ed25519_CURVE;
+const h = 8n;
+const L = 32;
+const L2 = 64;
+const err = (m = "") => {
+  throw new Error(m);
 };
-const signAsync = async (msg, privKey) => {
-  const m = toU8(msg);
-  const e = await getExtendedPublicKeyAsync(privKey);
-  const rBytes = await sha512a(e.prefix, m);
-  return hashFinishA(_sign(e, rBytes, m));
+const isBig = (n) => typeof n === "bigint";
+const isStr = (s) => typeof s === "string";
+const isBytes = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+const abytes = (a, l) => !isBytes(a) || typeof l === "number" && l > 0 && a.length !== l ? err("Uint8Array expected") : a;
+const u8n = (len) => new Uint8Array(len);
+const u8fr = (buf) => Uint8Array.from(buf);
+const padh = (n, pad) => n.toString(16).padStart(pad, "0");
+const bytesToHex = (b) => Array.from(abytes(b)).map((e) => padh(e, 2)).join("");
+const C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+const _ch = (ch) => {
+  if (ch >= C._0 && ch <= C._9)
+    return ch - C._0;
+  if (ch >= C.A && ch <= C.F)
+    return ch - (C.A - 10);
+  if (ch >= C.a && ch <= C.f)
+    return ch - (C.a - 10);
+  return;
 };
-const veriOpts = { zip215: true };
-const _verify = (sig, msg, pub, opts = veriOpts) => {
-  sig = toU8(sig, L2);
-  msg = toU8(msg);
-  pub = toU8(pub, L);
-  const { zip215 } = opts;
-  let A;
-  let R;
-  let s;
-  let SB;
-  let hashable = Uint8Array.of();
-  try {
-    A = Point.fromHex(pub, zip215);
-    R = Point.fromHex(sig.slice(0, L), zip215);
-    s = bytesToNumLE(sig.slice(L, L2));
-    SB = G.multiply(s, false);
-    hashable = concatBytes(R.toBytes(), A.toBytes(), msg);
-  } catch (error) {
+const hexToBytes = (hex) => {
+  const e = "hex invalid";
+  if (!isStr(hex))
+    return err(e);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    return err(e);
+  const array = u8n(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = _ch(hex.charCodeAt(hi));
+    const n2 = _ch(hex.charCodeAt(hi + 1));
+    if (n1 === void 0 || n2 === void 0)
+      return err(e);
+    array[ai] = n1 * 16 + n2;
   }
-  const finish = (hashed) => {
-    if (SB == null)
-      return false;
-    if (!zip215 && A.isSmallOrder())
-      return false;
-    const k = modL_LE(hashed);
-    const RkA = R.add(A.multiply(k, false));
-    return RkA.add(SB.negate()).clearCofactor().is0();
-  };
-  return { hashable, finish };
+  return array;
 };
-const verifyAsync = async (s, m, p, opts = veriOpts) => hashFinishA(_verify(s, m, p, opts));
-const etc = {
-  sha512Async: async (...messages) => {
-    const s = subtle();
-    const m = concatBytes(...messages);
-    return u8n(await s.digest("SHA-512", m.buffer));
-  },
-  sha512Sync: void 0,
-  bytesToHex,
-  hexToBytes,
-  concatBytes,
-  mod: M,
-  invert,
-  randomBytes
+const toU8 = (a, len) => abytes(isStr(a) ? hexToBytes(a) : u8fr(abytes(a)), len);
+const cr = () => globalThis?.crypto;
+const subtle = () => cr()?.subtle ?? err("crypto.subtle must be defined");
+const concatBytes = (...arrs) => {
+  const r = u8n(arrs.reduce((sum, a) => sum + abytes(a).length, 0));
+  let pad = 0;
+  arrs.forEach((a) => {
+    r.set(a, pad);
+    pad += a.length;
+  });
+  return r;
 };
-const utils = {
-  getExtendedPublicKeyAsync,
-  getExtendedPublicKey,
-  randomPrivateKey: () => randomBytes(L),
-  precompute: (w = 8, p = G) => {
-    p.multiply(3n);
-    return p;
-  }
-  // no-op
+const randomBytes = (len = L) => {
+  const c = cr();
+  return c.getRandomValues(u8n(len));
 };
-const W = 8;
-const scalarBits = 256;
-const pwindows = Math.ceil(scalarBits / W) + 1;
-const pwindowSize = 2 ** (W - 1);
-const precompute = () => {
-  const points = [];
-  let p = G;
-  let b = p;
-  for (let w = 0; w < pwindows; w++) {
-    b = p;
-    points.push(b);
-    for (let i = 1; i < pwindowSize; i++) {
-      b = b.add(p);
-      points.push(b);
-    }
-    p = b.double();
-  }
-  return points;
-};
-let Gpows = void 0;
-const ctneg = (cnd, p) => {
-  const n = p.negate();
-  return cnd ? n : p;
+const big = BigInt;
+const arange = (n, min, max, msg = "bad number: out of range") => isBig(n) && min <= n && n < max ? n : err(msg);
+const M = (a, b = P) => {
+  const r = a % b;
+  return r >= 0n ? r : b + r;
 };
-const wNAF = (n) => {
-  const comp = Gpows || (Gpows = precompute());
-  let p = I;
-  let f = G;
-  const pow_2_w = 2 ** W;
-  const maxNum = pow_2_w;
-  const mask = big(pow_2_w - 1);
-  const shiftBy = big(W);
-  for (let w = 0; w < pwindows; w++) {
-    let wbits = Number(n & mask);
-    n >>= shiftBy;
-    if (wbits > pwindowSize) {
-      wbits -= maxNum;
-      n += 1n;
-    }
-    const off = w * pwindowSize;
-    const offF = off;
-    const offP = off + Math.abs(wbits) - 1;
-    const isEven = w % 2 !== 0;
-    const isNeg = wbits < 0;
-    if (wbits === 0) {
-      f = f.add(ctneg(isEven, comp[offF]));
-    } else {
-      p = p.add(ctneg(isNeg, comp[offP]));
-    }
+const modN = (a) => M(a, N);
+const invert = (num, md) => {
+  if (num === 0n || md <= 0n)
+    err("no inverse n=" + num + " mod=" + md);
+  let a = M(num, md), b = md, x = 0n, u = 1n;
+  while (a !== 0n) {
+    const q = b / a, r = b % a;
+    const m = x - u * q;
+    b = a, a = r, x = u, u = m;
   }
-  return { p, f };
-};
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-const jsonBodySerializer = {
-  bodySerializer: (body) => JSON.stringify(
-    body,
-    (_key, value) => typeof value === "bigint" ? value.toString() : value
-  )
-};
-const createSseClient = ({
-  onRequest,
-  onSseError,
-  onSseEvent,
-  responseTransformer,
-  responseValidator,
-  sseDefaultRetryDelay,
-  sseMaxRetryAttempts,
-  sseMaxRetryDelay,
-  sseSleepFn,
-  url,
-  ...options
-}) => {
-  let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  const createStream = async function* () {
-    let retryDelay = sseDefaultRetryDelay ?? 3e3;
-    let attempt = 0;
-    const signal = options.signal ?? new AbortController().signal;
-    while (true) {
-      if (signal.aborted) break;
-      attempt++;
-      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
-      if (lastEventId !== void 0) {
-        headers.set("Last-Event-ID", lastEventId);
-      }
-      try {
-        const requestInit = {
-          redirect: "follow",
-          ...options,
-          body: options.serializedBody,
-          headers,
-          signal
-        };
-        let request = new Request(url, requestInit);
-        if (onRequest) {
-          request = await onRequest(url, requestInit);
-        }
-        const _fetch = options.fetch ?? globalThis.fetch;
-        const response = await _fetch(request);
-        if (!response.ok)
-          throw new Error(
-            `SSE failed: ${response.status} ${response.statusText}`
-          );
-        if (!response.body) throw new Error("No body in SSE response");
-        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-        let buffer = "";
-        const abortHandler = () => {
-          try {
-            reader.cancel();
-          } catch {
-          }
-        };
-        signal.addEventListener("abort", abortHandler);
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            buffer += value;
-            buffer = buffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-            const chunks = buffer.split("\n\n");
-            buffer = chunks.pop() ?? "";
-            for (const chunk of chunks) {
-              const lines = chunk.split("\n");
-              const dataLines = [];
-              let eventName;
-              for (const line of lines) {
-                if (line.startsWith("data:")) {
-                  dataLines.push(line.replace(/^data:\s*/, ""));
-                } else if (line.startsWith("event:")) {
-                  eventName = line.replace(/^event:\s*/, "");
-                } else if (line.startsWith("id:")) {
-                  lastEventId = line.replace(/^id:\s*/, "");
-                } else if (line.startsWith("retry:")) {
-                  const parsed = Number.parseInt(
-                    line.replace(/^retry:\s*/, ""),
-                    10
-                  );
-                  if (!Number.isNaN(parsed)) {
-                    retryDelay = parsed;
-                  }
-                }
-              }
-              let data;
-              let parsedJson = false;
-              if (dataLines.length) {
-                const rawData = dataLines.join("\n");
-                try {
-                  data = JSON.parse(rawData);
-                  parsedJson = true;
-                } catch {
-                  data = rawData;
-                }
-              }
-              if (parsedJson) {
-                if (responseValidator) {
-                  await responseValidator(data);
-                }
-                if (responseTransformer) {
-                  data = await responseTransformer(data);
-                }
-              }
-              onSseEvent == null ? void 0 : onSseEvent({
-                data,
-                event: eventName,
-                id: lastEventId,
-                retry: retryDelay
-              });
-              if (dataLines.length) {
-                yield data;
-              }
-            }
-          }
-        } finally {
-          signal.removeEventListener("abort", abortHandler);
-          reader.releaseLock();
-        }
-        break;
-      } catch (error) {
-        onSseError == null ? void 0 : onSseError(error);
-        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
-          break;
-        }
-        const backoff = Math.min(
-          retryDelay * 2 ** (attempt - 1),
-          sseMaxRetryDelay ?? 3e4
-        );
-        await sleep(backoff);
-      }
-    }
-  };
-  const stream = createStream();
-  return { stream };
+  return b === 1n ? M(x, md) : err("no inverse");
 };
-const separatorArrayExplode = (style) => {
-  switch (style) {
-    case "label":
-      return ".";
-    case "matrix":
-      return ";";
-    case "simple":
-      return ",";
-    default:
-      return "&";
-  }
+const callHash = (name2) => {
+  const fn = etc[name2];
+  if (typeof fn !== "function")
+    err("hashes." + name2 + " not set");
+  return fn;
 };
-const separatorArrayNoExplode = (style) => {
-  switch (style) {
-    case "form":
-      return ",";
-    case "pipeDelimited":
-      return "|";
-    case "spaceDelimited":
-      return "%20";
-    default:
-      return ",";
+const apoint = (p) => p instanceof Point ? p : err("Point expected");
+const B256 = 2n ** 256n;
+class Point {
+  static BASE;
+  static ZERO;
+  ex;
+  ey;
+  ez;
+  et;
+  constructor(ex, ey, ez, et) {
+    const max = B256;
+    this.ex = arange(ex, 0n, max);
+    this.ey = arange(ey, 0n, max);
+    this.ez = arange(ez, 1n, max);
+    this.et = arange(et, 0n, max);
+    Object.freeze(this);
   }
-};
-const separatorObjectExplode = (style) => {
-  switch (style) {
-    case "label":
-      return ".";
-    case "matrix":
-      return ";";
-    case "simple":
-      return ",";
-    default:
-      return "&";
+  static fromAffine(p) {
+    return new Point(p.x, p.y, 1n, M(p.x * p.y));
   }
-};
-const serializeArrayParam = ({
-  allowReserved,
-  explode,
-  name: name2,
-  style,
-  value
-}) => {
-  if (!explode) {
-    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
-    switch (style) {
-      case "label":
-        return `.${joinedValues2}`;
-      case "matrix":
-        return `;${name2}=${joinedValues2}`;
-      case "simple":
-        return joinedValues2;
-      default:
-        return `${name2}=${joinedValues2}`;
-    }
-  }
-  const separator = separatorArrayExplode(style);
-  const joinedValues = value.map((v) => {
-    if (style === "label" || style === "simple") {
-      return allowReserved ? v : encodeURIComponent(v);
-    }
-    return serializePrimitiveParam({
-      allowReserved,
-      name: name2,
-      value: v
-    });
-  }).join(separator);
-  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
-};
-const serializePrimitiveParam = ({
-  allowReserved,
-  name: name2,
-  value
-}) => {
-  if (value === void 0 || value === null) {
-    return "";
-  }
-  if (typeof value === "object") {
-    throw new Error(
-      "Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these."
-    );
+  /** RFC8032 5.1.3: Uint8Array to Point. */
+  static fromBytes(hex, zip215 = false) {
+    const d = _d;
+    const normed = u8fr(abytes(hex, L));
+    const lastByte = hex[31];
+    normed[31] = lastByte & -129;
+    const y = bytesToNumLE(normed);
+    const max = zip215 ? B256 : P;
+    arange(y, 0n, max);
+    const y2 = M(y * y);
+    const u = M(y2 - 1n);
+    const v = M(d * y2 + 1n);
+    let { isValid, value: x } = uvRatio(u, v);
+    if (!isValid)
+      err("bad point: y not sqrt");
+    const isXOdd = (x & 1n) === 1n;
+    const isLastByteOdd = (lastByte & 128) !== 0;
+    if (!zip215 && x === 0n && isLastByteOdd)
+      err("bad point: x==0, isLastByteOdd");
+    if (isLastByteOdd !== isXOdd)
+      x = M(-x);
+    return new Point(x, y, 1n, M(x * y));
   }
-  return `${name2}=${allowReserved ? value : encodeURIComponent(value)}`;
-};
-const serializeObjectParam = ({
-  allowReserved,
-  explode,
-  name: name2,
-  style,
-  value,
-  valueOnly
-}) => {
-  if (value instanceof Date) {
-    return valueOnly ? value.toISOString() : `${name2}=${value.toISOString()}`;
+  /** Checks if the point is valid and on-curve. */
+  assertValidity() {
+    const a = _a;
+    const d = _d;
+    const p = this;
+    if (p.is0())
+      throw new Error("bad point: ZERO");
+    const { ex: X, ey: Y, ez: Z, et: T } = p;
+    const X2 = M(X * X);
+    const Y2 = M(Y * Y);
+    const Z2 = M(Z * Z);
+    const Z4 = M(Z2 * Z2);
+    const aX2 = M(X2 * a);
+    const left = M(Z2 * M(aX2 + Y2));
+    const right = M(Z4 + M(d * M(X2 * Y2)));
+    if (left !== right)
+      throw new Error("bad point: equation left != right (1)");
+    const XY = M(X * Y);
+    const ZT = M(Z * T);
+    if (XY !== ZT)
+      throw new Error("bad point: equation left != right (2)");
+    return this;
   }
-  if (style !== "deepObject" && !explode) {
-    let values2 = [];
-    Object.entries(value).forEach(([key, v]) => {
-      values2 = [
-        ...values2,
-        key,
-        allowReserved ? v : encodeURIComponent(v)
-      ];
-    });
-    const joinedValues2 = values2.join(",");
-    switch (style) {
-      case "form":
-        return `${name2}=${joinedValues2}`;
-      case "label":
-        return `.${joinedValues2}`;
-      case "matrix":
-        return `;${name2}=${joinedValues2}`;
-      default:
-        return joinedValues2;
-    }
+  /** Equality check: compare points P&Q. */
+  equals(other) {
+    const { ex: X1, ey: Y1, ez: Z1 } = this;
+    const { ex: X2, ey: Y2, ez: Z2 } = apoint(other);
+    const X1Z2 = M(X1 * Z2);
+    const X2Z1 = M(X2 * Z1);
+    const Y1Z2 = M(Y1 * Z2);
+    const Y2Z1 = M(Y2 * Z1);
+    return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
   }
-  const separator = separatorObjectExplode(style);
-  const joinedValues = Object.entries(value).map(
-    ([key, v]) => serializePrimitiveParam({
-      allowReserved,
-      name: style === "deepObject" ? `${name2}[${key}]` : key,
-      value: v
-    })
-  ).join(separator);
-  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
-};
-const PATH_PARAM_RE = /\{[^{}]+\}/g;
-const defaultPathSerializer = ({ path, url: _url }) => {
-  let url = _url;
-  const matches = _url.match(PATH_PARAM_RE);
-  if (matches) {
-    for (const match of matches) {
-      let explode = false;
-      let name2 = match.substring(1, match.length - 1);
-      let style = "simple";
-      if (name2.endsWith("*")) {
-        explode = true;
-        name2 = name2.substring(0, name2.length - 1);
-      }
-      if (name2.startsWith(".")) {
-        name2 = name2.substring(1);
-        style = "label";
-      } else if (name2.startsWith(";")) {
-        name2 = name2.substring(1);
-        style = "matrix";
-      }
-      const value = path[name2];
-      if (value === void 0 || value === null) {
-        continue;
-      }
-      if (Array.isArray(value)) {
-        url = url.replace(
-          match,
-          serializeArrayParam({ explode, name: name2, style, value })
-        );
-        continue;
-      }
-      if (typeof value === "object") {
-        url = url.replace(
-          match,
-          serializeObjectParam({
-            explode,
-            name: name2,
-            style,
-            value,
-            valueOnly: true
-          })
-        );
-        continue;
-      }
-      if (style === "matrix") {
-        url = url.replace(
-          match,
-          `;${serializePrimitiveParam({
-            name: name2,
-            value
-          })}`
-        );
-        continue;
-      }
-      const replaceValue = encodeURIComponent(
-        style === "label" ? `.${value}` : value
-      );
-      url = url.replace(match, replaceValue);
-    }
+  is0() {
+    return this.equals(I);
   }
-  return url;
-};
-const getUrl = ({
-  baseUrl,
-  path,
-  query,
-  querySerializer,
-  url: _url
-}) => {
-  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
-  let url = (baseUrl ?? "") + pathUrl;
-  if (path) {
-    url = defaultPathSerializer({ path, url });
+  /** Flip point over y coordinate. */
+  negate() {
+    return new Point(M(-this.ex), this.ey, this.ez, M(-this.et));
   }
-  let search = query ? querySerializer(query) : "";
-  if (search.startsWith("?")) {
-    search = search.substring(1);
+  /** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
+  double() {
+    const { ex: X1, ey: Y1, ez: Z1 } = this;
+    const a = _a;
+    const A = M(X1 * X1);
+    const B = M(Y1 * Y1);
+    const C2 = M(2n * M(Z1 * Z1));
+    const D = M(a * A);
+    const x1y1 = X1 + Y1;
+    const E = M(M(x1y1 * x1y1) - A - B);
+    const G2 = D + B;
+    const F = G2 - C2;
+    const H = D - B;
+    const X3 = M(E * F);
+    const Y3 = M(G2 * H);
+    const T3 = M(E * H);
+    const Z3 = M(F * G2);
+    return new Point(X3, Y3, Z3, T3);
   }
-  if (search) {
-    url += `?${search}`;
+  /** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
+  add(other) {
+    const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
+    const { ex: X2, ey: Y2, ez: Z2, et: T2 } = apoint(other);
+    const a = _a;
+    const d = _d;
+    const A = M(X1 * X2);
+    const B = M(Y1 * Y2);
+    const C2 = M(T1 * d * T2);
+    const D = M(Z1 * Z2);
+    const E = M((X1 + Y1) * (X2 + Y2) - A - B);
+    const F = M(D - C2);
+    const G2 = M(D + C2);
+    const H = M(B - a * A);
+    const X3 = M(E * F);
+    const Y3 = M(G2 * H);
+    const T3 = M(E * H);
+    const Z3 = M(F * G2);
+    return new Point(X3, Y3, Z3, T3);
   }
-  return url;
-};
-function getValidRequestBody(options) {
-  const hasBody = options.body !== void 0;
-  const isSerializedBody = hasBody && options.bodySerializer;
-  if (isSerializedBody) {
-    if ("serializedBody" in options) {
-      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
-      return hasSerializedBody ? options.serializedBody : null;
+  /**
+   * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
+   * Uses {@link wNAF} for base point.
+   * Uses fake point to mitigate side-channel leakage.
+   * @param n scalar by which point is multiplied
+   * @param safe safe mode guards against timing attacks; unsafe mode is faster
+   */
+  multiply(n, safe = true) {
+    if (!safe && (n === 0n || this.is0()))
+      return I;
+    arange(n, 1n, N);
+    if (n === 1n)
+      return this;
+    if (this.equals(G))
+      return wNAF2(n).p;
+    let p = I;
+    let f = G;
+    for (let d = this; n > 0n; d = d.double(), n >>= 1n) {
+      if (n & 1n)
+        p = p.add(d);
+      else if (safe)
+        f = f.add(d);
     }
-    return options.body !== "" ? options.body : null;
-  }
-  if (hasBody) {
-    return options.body;
+    return p;
   }
-  return void 0;
-}
-const getAuthToken = async (auth, callback) => {
-  const token = typeof callback === "function" ? await callback(auth) : callback;
-  if (!token) {
-    return;
+  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+  toAffine() {
+    const { ex: x, ey: y, ez: z } = this;
+    if (this.equals(I))
+      return { x: 0n, y: 1n };
+    const iz = invert(z, P);
+    if (M(z * iz) !== 1n)
+      err("invalid inverse");
+    return { x: M(x * iz), y: M(y * iz) };
   }
-  if (auth.scheme === "bearer") {
-    return `Bearer ${token}`;
+  toBytes() {
+    const { x, y } = this.assertValidity().toAffine();
+    const b = numTo32bLE(y);
+    b[31] |= x & 1n ? 128 : 0;
+    return b;
   }
-  if (auth.scheme === "basic") {
-    return `Basic ${btoa(token)}`;
+  toHex() {
+    return bytesToHex(this.toBytes());
   }
-  return token;
-};
-const createQuerySerializer = ({
-  parameters = {},
-  ...args
-} = {}) => {
-  const querySerializer = (queryParams) => {
-    const search = [];
-    if (queryParams && typeof queryParams === "object") {
-      for (const name2 in queryParams) {
-        const value = queryParams[name2];
-        if (value === void 0 || value === null) {
-          continue;
-        }
-        const options = parameters[name2] || args;
-        if (Array.isArray(value)) {
-          const serializedArray = serializeArrayParam({
-            allowReserved: options.allowReserved,
-            explode: true,
-            name: name2,
-            style: "form",
-            value,
-            ...options.array
-          });
-          if (serializedArray) search.push(serializedArray);
-        } else if (typeof value === "object") {
-          const serializedObject = serializeObjectParam({
-            allowReserved: options.allowReserved,
-            explode: true,
-            name: name2,
-            style: "deepObject",
-            value,
-            ...options.object
-          });
-          if (serializedObject) search.push(serializedObject);
-        } else {
-          const serializedPrimitive = serializePrimitiveParam({
-            allowReserved: options.allowReserved,
-            name: name2,
-            value
-          });
-          if (serializedPrimitive) search.push(serializedPrimitive);
-        }
-      }
-    }
-    return search.join("&");
-  };
-  return querySerializer;
-};
-const getParseAs = (contentType) => {
-  var _a2;
-  if (!contentType) {
-    return "stream";
+  // encode to hex string
+  clearCofactor() {
+    return this.multiply(big(h), false);
   }
-  const cleanContent = (_a2 = contentType.split(";")[0]) == null ? void 0 : _a2.trim();
-  if (!cleanContent) {
-    return;
+  isSmallOrder() {
+    return this.clearCofactor().is0();
   }
-  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
-    return "json";
+  isTorsionFree() {
+    let p = this.multiply(N / 2n, false).double();
+    if (N % 2n)
+      p = p.add(this);
+    return p.is0();
   }
-  if (cleanContent === "multipart/form-data") {
-    return "formData";
+  static fromHex(hex, zip215) {
+    return Point.fromBytes(toU8(hex), zip215);
   }
-  if (["application/", "audio/", "image/", "video/"].some(
-    (type) => cleanContent.startsWith(type)
-  )) {
-    return "blob";
+  get x() {
+    return this.toAffine().x;
   }
-  if (cleanContent.startsWith("text/")) {
-    return "text";
+  get y() {
+    return this.toAffine().y;
   }
-  return;
-};
-const checkForExistence = (options, name2) => {
-  var _a2, _b;
-  if (!name2) {
-    return false;
+  toRawBytes() {
+    return this.toBytes();
   }
-  if (options.headers.has(name2) || ((_a2 = options.query) == null ? void 0 : _a2[name2]) || ((_b = options.headers.get("Cookie")) == null ? void 0 : _b.includes(`${name2}=`))) {
-    return true;
+}
+const G = new Point(Gx, Gy, 1n, M(Gx * Gy));
+const I = new Point(0n, 1n, 1n, 0n);
+Point.BASE = G;
+Point.ZERO = I;
+const numTo32bLE = (num) => hexToBytes(padh(arange(num, 0n, B256), L2)).reverse();
+const bytesToNumLE = (b) => big("0x" + bytesToHex(u8fr(abytes(b)).reverse()));
+const pow2 = (x, power) => {
+  let r = x;
+  while (power-- > 0n) {
+    r *= r;
+    r %= P;
   }
-  return false;
+  return r;
 };
-const setAuthParams = async ({
-  security,
-  ...options
-}) => {
-  for (const auth of security) {
-    if (checkForExistence(options, auth.name)) {
-      continue;
-    }
-    const token = await getAuthToken(auth, options.auth);
-    if (!token) {
-      continue;
-    }
-    const name2 = auth.name ?? "Authorization";
-    switch (auth.in) {
-      case "query":
-        if (!options.query) {
-          options.query = {};
-        }
-        options.query[name2] = token;
-        break;
-      case "cookie":
-        options.headers.append("Cookie", `${name2}=${token}`);
-        break;
-      case "header":
-      default:
-        options.headers.set(name2, token);
-        break;
-    }
-  }
+const pow_2_252_3 = (x) => {
+  const x2 = x * x % P;
+  const b2 = x2 * x % P;
+  const b4 = pow2(b2, 2n) * b2 % P;
+  const b5 = pow2(b4, 1n) * x % P;
+  const b10 = pow2(b5, 5n) * b5 % P;
+  const b20 = pow2(b10, 10n) * b10 % P;
+  const b40 = pow2(b20, 20n) * b20 % P;
+  const b80 = pow2(b40, 40n) * b40 % P;
+  const b160 = pow2(b80, 80n) * b80 % P;
+  const b240 = pow2(b160, 80n) * b80 % P;
+  const b250 = pow2(b240, 10n) * b10 % P;
+  const pow_p_5_8 = pow2(b250, 2n) * x % P;
+  return { pow_p_5_8, b2 };
 };
-const buildUrl = (options) => getUrl({
-  baseUrl: options.baseUrl,
-  path: options.path,
-  query: options.query,
-  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
-  url: options.url
-});
-const mergeConfigs = (a, b) => {
-  var _a2;
-  const config = { ...a, ...b };
-  if ((_a2 = config.baseUrl) == null ? void 0 : _a2.endsWith("/")) {
-    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
-  }
-  config.headers = mergeHeaders(a.headers, b.headers);
-  return config;
+const RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n;
+const uvRatio = (u, v) => {
+  const v3 = M(v * v * v);
+  const v7 = M(v3 * v3 * v);
+  const pow = pow_2_252_3(u * v7).pow_p_5_8;
+  let x = M(u * v3 * pow);
+  const vx2 = M(v * x * x);
+  const root1 = x;
+  const root2 = M(x * RM1);
+  const useRoot1 = vx2 === u;
+  const useRoot2 = vx2 === M(-u);
+  const noRoot = vx2 === M(-u * RM1);
+  if (useRoot1)
+    x = root1;
+  if (useRoot2 || noRoot)
+    x = root2;
+  if ((M(x) & 1n) === 1n)
+    x = M(-x);
+  return { isValid: useRoot1 || useRoot2, value: x };
 };
-const headersEntries = (headers) => {
-  const entries = [];
-  headers.forEach((value, key) => {
-    entries.push([key, value]);
-  });
-  return entries;
+const modL_LE = (hash) => modN(bytesToNumLE(hash));
+const sha512a = (...m) => etc.sha512Async(...m);
+const sha512s = (...m) => callHash("sha512Sync")(...m);
+const hash2extK = (hashed) => {
+  const head = hashed.slice(0, L);
+  head[0] &= 248;
+  head[31] &= 127;
+  head[31] |= 64;
+  const prefix = hashed.slice(L, L2);
+  const scalar = modL_LE(head);
+  const point = G.multiply(scalar);
+  const pointBytes = point.toBytes();
+  return { head, prefix, scalar, point, pointBytes };
 };
-const mergeHeaders = (...headers) => {
-  const mergedHeaders = new Headers();
-  for (const header of headers) {
-    if (!header) {
-      continue;
-    }
-    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
-    for (const [key, value] of iterator) {
-      if (value === null) {
-        mergedHeaders.delete(key);
-      } else if (Array.isArray(value)) {
-        for (const v of value) {
-          mergedHeaders.append(key, v);
-        }
-      } else if (value !== void 0) {
-        mergedHeaders.set(
-          key,
-          typeof value === "object" ? JSON.stringify(value) : value
-        );
-      }
-    }
-  }
-  return mergedHeaders;
+const getExtendedPublicKeyAsync = (priv) => sha512a(toU8(priv, L)).then(hash2extK);
+const getExtendedPublicKey = (priv) => hash2extK(sha512s(toU8(priv, L)));
+const getPublicKeyAsync = (priv) => getExtendedPublicKeyAsync(priv).then((p) => p.pointBytes);
+const getPublicKey = (priv) => getExtendedPublicKey(priv).pointBytes;
+const hashFinishA = (res) => sha512a(res.hashable).then(res.finish);
+const _sign = (e, rBytes, msg) => {
+  const { pointBytes: P2, scalar: s } = e;
+  const r = modL_LE(rBytes);
+  const R = G.multiply(r).toBytes();
+  const hashable = concatBytes(R, P2, msg);
+  const finish = (hashed) => {
+    const S = modN(r + modL_LE(hashed) * s);
+    return abytes(concatBytes(R, numTo32bLE(S)), L2);
+  };
+  return { hashable, finish };
 };
-class Interceptors2 {
-  constructor() {
-    __publicField(this, "fns", []);
-  }
-  clear() {
-    this.fns = [];
-  }
-  eject(id) {
-    const index = this.getInterceptorIndex(id);
-    if (this.fns[index]) {
-      this.fns[index] = null;
-    }
-  }
-  exists(id) {
-    const index = this.getInterceptorIndex(id);
-    return Boolean(this.fns[index]);
-  }
-  getInterceptorIndex(id) {
-    if (typeof id === "number") {
-      return this.fns[id] ? id : -1;
-    }
-    return this.fns.indexOf(id);
-  }
-  update(id, fn) {
-    const index = this.getInterceptorIndex(id);
-    if (this.fns[index]) {
-      this.fns[index] = fn;
-      return id;
-    }
-    return false;
-  }
-  use(fn) {
-    this.fns.push(fn);
-    return this.fns.length - 1;
-  }
-}
-const createInterceptors = () => ({
-  error: new Interceptors2(),
-  request: new Interceptors2(),
-  response: new Interceptors2()
-});
-const defaultQuerySerializer = createQuerySerializer({
-  allowReserved: false,
-  array: {
-    explode: true,
-    style: "form"
-  },
-  object: {
-    explode: true,
-    style: "deepObject"
-  }
-});
-const defaultHeaders = {
-  "Content-Type": "application/json"
+const signAsync = async (msg, privKey) => {
+  const m = toU8(msg);
+  const e = await getExtendedPublicKeyAsync(privKey);
+  const rBytes = await sha512a(e.prefix, m);
+  return hashFinishA(_sign(e, rBytes, m));
 };
-const createConfig = (override = {}) => ({
-  ...jsonBodySerializer,
-  headers: defaultHeaders,
-  parseAs: "auto",
-  querySerializer: defaultQuerySerializer,
-  ...override
-});
-const createClient = (config = {}) => {
-  let _config = mergeConfigs(createConfig(), config);
-  const getConfig = () => ({ ..._config });
-  const setConfig = (config2) => {
-    _config = mergeConfigs(_config, config2);
-    return getConfig();
-  };
-  const interceptors = createInterceptors();
-  const beforeRequest = async (options) => {
-    const opts = {
-      ..._config,
-      ...options,
-      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders(_config.headers, options.headers),
-      serializedBody: void 0
-    };
-    if (opts.security) {
-      await setAuthParams({
-        ...opts,
-        security: opts.security
-      });
-    }
-    if (opts.requestValidator) {
-      await opts.requestValidator(opts);
-    }
-    if (opts.body !== void 0 && opts.bodySerializer) {
-      opts.serializedBody = opts.bodySerializer(opts.body);
-    }
-    if (opts.body === void 0 || opts.serializedBody === "") {
-      opts.headers.delete("Content-Type");
-    }
-    const url = buildUrl(opts);
-    return { opts, url };
-  };
-  const request = async (options) => {
-    const { opts, url } = await beforeRequest(options);
-    const requestInit = {
-      redirect: "follow",
-      ...opts,
-      body: getValidRequestBody(opts)
-    };
-    let request2 = new Request(url, requestInit);
-    for (const fn of interceptors.request.fns) {
-      if (fn) {
-        request2 = await fn(request2, opts);
-      }
-    }
-    const _fetch = opts.fetch;
-    let response;
-    try {
-      response = await _fetch(request2);
-    } catch (error2) {
-      let finalError2 = error2;
-      for (const fn of interceptors.error.fns) {
-        if (fn) {
-          finalError2 = await fn(
-            error2,
-            void 0,
-            request2,
-            opts
-          );
-        }
-      }
-      finalError2 = finalError2 || {};
-      if (opts.throwOnError) {
-        throw finalError2;
-      }
-      return opts.responseStyle === "data" ? void 0 : {
-        error: finalError2,
-        request: request2,
-        response: void 0
-      };
-    }
-    for (const fn of interceptors.response.fns) {
-      if (fn) {
-        response = await fn(response, request2, opts);
-      }
-    }
-    const result = {
-      request: request2,
-      response
-    };
-    if (response.ok) {
-      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
-      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
-        let emptyData;
-        switch (parseAs) {
-          case "arrayBuffer":
-          case "blob":
-          case "text":
-            emptyData = await response[parseAs]();
-            break;
-          case "formData":
-            emptyData = new FormData();
-            break;
-          case "stream":
-            emptyData = response.body;
-            break;
-          case "json":
-          default:
-            emptyData = {};
-            break;
-        }
-        return opts.responseStyle === "data" ? emptyData : {
-          data: emptyData,
-          ...result
-        };
-      }
-      let data;
-      switch (parseAs) {
-        case "arrayBuffer":
-        case "blob":
-        case "formData":
-        case "json":
-        case "text":
-          data = await response[parseAs]();
-          break;
-        case "stream":
-          return opts.responseStyle === "data" ? response.body : {
-            data: response.body,
-            ...result
-          };
-      }
-      if (parseAs === "json") {
-        if (opts.responseValidator) {
-          await opts.responseValidator(data);
-        }
-        if (opts.responseTransformer) {
-          data = await opts.responseTransformer(data);
-        }
-      }
-      return opts.responseStyle === "data" ? data : {
-        data,
-        ...result
-      };
-    }
-    const textError = await response.text();
-    let jsonError;
-    try {
-      jsonError = JSON.parse(textError);
-    } catch {
-    }
-    const error = jsonError ?? textError;
-    let finalError = error;
-    for (const fn of interceptors.error.fns) {
-      if (fn) {
-        finalError = await fn(error, response, request2, opts);
-      }
-    }
-    finalError = finalError || {};
-    if (opts.throwOnError) {
-      throw finalError;
-    }
-    return opts.responseStyle === "data" ? void 0 : {
-      error: finalError,
-      ...result
-    };
-  };
-  const makeMethodFn = (method) => (options) => request({ ...options, method });
-  const makeSseFn = (method) => async (options) => {
-    const { opts, url } = await beforeRequest(options);
-    return createSseClient({
-      ...opts,
-      body: opts.body,
-      headers: opts.headers,
-      method,
-      onRequest: async (url2, init) => {
-        let request2 = new Request(url2, init);
-        for (const fn of interceptors.request.fns) {
-          if (fn) {
-            request2 = await fn(request2, opts);
-          }
-        }
-        return request2;
-      },
-      url
-    });
-  };
-  return {
-    buildUrl,
-    connect: makeMethodFn("CONNECT"),
-    delete: makeMethodFn("DELETE"),
-    get: makeMethodFn("GET"),
-    getConfig,
-    head: makeMethodFn("HEAD"),
-    interceptors,
-    options: makeMethodFn("OPTIONS"),
-    patch: makeMethodFn("PATCH"),
-    post: makeMethodFn("POST"),
-    put: makeMethodFn("PUT"),
-    request,
-    setConfig,
-    sse: {
-      connect: makeSseFn("CONNECT"),
-      delete: makeSseFn("DELETE"),
-      get: makeSseFn("GET"),
-      head: makeSseFn("HEAD"),
-      options: makeSseFn("OPTIONS"),
-      patch: makeSseFn("PATCH"),
-      post: makeSseFn("POST"),
-      put: makeSseFn("PUT"),
-      trace: makeSseFn("TRACE")
-    },
-    trace: makeMethodFn("TRACE")
+const veriOpts = { zip215: true };
+const _verify = (sig, msg, pub, opts = veriOpts) => {
+  sig = toU8(sig, L2);
+  msg = toU8(msg);
+  pub = toU8(pub, L);
+  const { zip215 } = opts;
+  let A;
+  let R;
+  let s;
+  let SB;
+  let hashable = Uint8Array.of();
+  try {
+    A = Point.fromHex(pub, zip215);
+    R = Point.fromHex(sig.slice(0, L), zip215);
+    s = bytesToNumLE(sig.slice(L, L2));
+    SB = G.multiply(s, false);
+    hashable = concatBytes(R.toBytes(), A.toBytes(), msg);
+  } catch (error) {
+  }
+  const finish = (hashed) => {
+    if (SB == null)
+      return false;
+    if (!zip215 && A.isSmallOrder())
+      return false;
+    const k = modL_LE(hashed);
+    const RkA = R.add(A.multiply(k, false));
+    return RkA.add(SB.negate()).clearCofactor().is0();
   };
+  return { hashable, finish };
 };
-createClient(
-  createConfig({ baseUrl: "https://api.themolt.net" })
-);
-class MoltNetError extends Error {
-  constructor(message, options) {
-    super(message);
-    __publicField(this, "code");
-    __publicField(this, "statusCode");
-    __publicField(this, "detail");
-    this.name = "MoltNetError";
-    this.code = options.code;
-    this.statusCode = options.statusCode;
-    this.detail = options.detail;
+const verifyAsync = async (s, m, p, opts = veriOpts) => hashFinishA(_verify(s, m, p, opts));
+const etc = {
+  sha512Async: async (...messages) => {
+    const s = subtle();
+    const m = concatBytes(...messages);
+    return u8n(await s.digest("SHA-512", m.buffer));
+  },
+  sha512Sync: void 0,
+  bytesToHex,
+  hexToBytes,
+  concatBytes,
+  mod: M,
+  invert,
+  randomBytes
+};
+const utils = {
+  getExtendedPublicKeyAsync,
+  getExtendedPublicKey,
+  randomPrivateKey: () => randomBytes(L),
+  precompute: (w = 8, p = G) => {
+    p.multiply(3n);
+    return p;
   }
-}
-function problemToError(problem, statusCode) {
-  return new MoltNetError(problem.title ?? "Request failed", {
-    code: problem.type ?? problem.code ?? "UNKNOWN",
-    statusCode,
-    detail: problem.detail
-  });
-}
-async function writeMcpConfig(mcpConfig, dir2) {
-  const targetDir = dir2 ?? process.cwd();
-  const filePath = join(targetDir, ".mcp.json");
-  let existing = {};
-  try {
-    const content = await readFile(filePath, "utf-8");
-    existing = JSON.parse(content);
-  } catch {
+  // no-op
+};
+const W = 8;
+const scalarBits = 256;
+const pwindows = Math.ceil(scalarBits / W) + 1;
+const pwindowSize = 2 ** (W - 1);
+const precompute = () => {
+  const points = [];
+  let p = G;
+  let b = p;
+  for (let w = 0; w < pwindows; w++) {
+    b = p;
+    points.push(b);
+    for (let i = 1; i < pwindowSize; i++) {
+      b = b.add(p);
+      points.push(b);
+    }
+    p = b.double();
   }
-  const merged = {
-    ...existing,
-    mcpServers: {
-      ...existing.mcpServers ?? {},
-      ...mcpConfig.mcpServers
+  return points;
+};
+let Gpows = void 0;
+const ctneg = (cnd, p) => {
+  const n = p.negate();
+  return cnd ? n : p;
+};
+const wNAF2 = (n) => {
+  const comp = Gpows || (Gpows = precompute());
+  let p = I;
+  let f = G;
+  const pow_2_w = 2 ** W;
+  const maxNum = pow_2_w;
+  const mask = big(pow_2_w - 1);
+  const shiftBy = big(W);
+  for (let w = 0; w < pwindows; w++) {
+    let wbits = Number(n & mask);
+    n >>= shiftBy;
+    if (wbits > pwindowSize) {
+      wbits -= maxNum;
+      n += 1n;
+    }
+    const off = w * pwindowSize;
+    const offF = off;
+    const offP = off + Math.abs(wbits) - 1;
+    const isEven = w % 2 !== 0;
+    const isNeg = wbits < 0;
+    if (wbits === 0) {
+      f = f.add(ctneg(isEven, comp[offF]));
+    } else {
+      p = p.add(ctneg(isNeg, comp[offP]));
     }
-  };
-  await writeFile(filePath, JSON.stringify(merged, null, 2) + "\n");
-  return filePath;
-}
-function getConfigDir() {
-  return join(homedir(), ".config", "moltnet");
-}
-function getConfigPath(configDir) {
-  return join(configDir ?? getConfigDir(), "moltnet.json");
-}
-async function readConfig(configDir) {
-  const dir2 = configDir ?? getConfigDir();
-  try {
-    const content = await readFile(join(dir2, "moltnet.json"), "utf-8");
-    return JSON.parse(content);
-  } catch {
   }
-  try {
-    const content = await readFile(join(dir2, "credentials.json"), "utf-8");
-    console.warn(
-      "Warning: credentials.json is deprecated. New writes use moltnet.json. Support will be removed in 3 minor versions."
+  return { p, f };
+};
+etc.sha512Sync = (...m) => {
+  const hash = createHash("sha512");
+  m.forEach((msg) => hash.update(msg));
+  return hash.digest();
+};
+const DOMAIN_PREFIX = "moltnet:v1";
+function buildSigningBytes(message, nonce) {
+  const msgHash = createHash("sha256").update(Buffer.from(message, "utf-8")).digest();
+  const nonceBytes = Buffer.from(nonce, "utf-8");
+  const prefix = Buffer.from(DOMAIN_PREFIX, "utf-8");
+  const buf = Buffer.alloc(
+    prefix.length + 4 + msgHash.length + 4 + nonceBytes.length
+  );
+  let offset = 0;
+  prefix.copy(buf, offset);
+  offset += prefix.length;
+  buf.writeUInt32BE(msgHash.length, offset);
+  offset += 4;
+  msgHash.copy(buf, offset);
+  offset += msgHash.length;
+  buf.writeUInt32BE(nonceBytes.length, offset);
+  offset += 4;
+  nonceBytes.copy(buf, offset);
+  return new Uint8Array(buf);
+}
+const cryptoService = {
+  /**
+   * Generate a new Ed25519 keypair
+   */
+  async generateKeyPair() {
+    const privateKeyBytes = utils.randomPrivateKey();
+    const publicKeyBytes = await getPublicKeyAsync(privateKeyBytes);
+    const privateKey = Buffer.from(privateKeyBytes).toString("base64");
+    const publicKey = `ed25519:${Buffer.from(publicKeyBytes).toString("base64")}`;
+    const fingerprint = this.generateFingerprint(publicKeyBytes);
+    return { publicKey, privateKey, fingerprint };
+  },
+  /**
+   * Generate human-readable fingerprint from public key
+   * Format: A1B2-C3D4-E5F6-G7H8 (first 16 hex chars of SHA256)
+   */
+  generateFingerprint(publicKeyBytes) {
+    const hash = createHash("sha256").update(publicKeyBytes).digest("hex");
+    const segments = hash.slice(0, 16).toUpperCase().match(/.{4}/g) ?? [];
+    return segments.join("-");
+  },
+  /**
+   * Parse public key from string format
+   */
+  parsePublicKey(publicKey) {
+    const base64 = publicKey.replace(/^ed25519:/, "");
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  },
+  /**
+   * Sign a message with private key
+   */
+  async sign(message, privateKeyBase64) {
+    const privateKeyBytes = new Uint8Array(
+      Buffer.from(privateKeyBase64, "base64")
+    );
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = await signAsync(messageBytes, privateKeyBytes);
+    return Buffer.from(signature).toString("base64");
+  },
+  /**
+   * Verify a signature against a message and public key
+   */
+  async verify(message, signature, publicKey) {
+    try {
+      const publicKeyBytes = this.parsePublicKey(publicKey);
+      const signatureBytes = new Uint8Array(Buffer.from(signature, "base64"));
+      const messageBytes = new TextEncoder().encode(message);
+      return await verifyAsync(signatureBytes, messageBytes, publicKeyBytes);
+    } catch {
+      return false;
+    }
+  },
+  /**
+   * Sign a (message, nonce) pair using deterministic pre-hash.
+   * Uses buildSigningBytes for domain separation and canonical serialization.
+   */
+  async signWithNonce(message, nonce, privateKeyBase64) {
+    const privateKeyBytes = new Uint8Array(
+      Buffer.from(privateKeyBase64, "base64")
+    );
+    const signingBytes = buildSigningBytes(message, nonce);
+    const signature = await signAsync(signingBytes, privateKeyBytes);
+    return Buffer.from(signature).toString("base64");
+  },
+  /**
+   * Verify a signature produced by signWithNonce.
+   */
+  async verifyWithNonce(message, nonce, signature, publicKey) {
+    try {
+      const publicKeyBytes = this.parsePublicKey(publicKey);
+      const signatureBytes = new Uint8Array(Buffer.from(signature, "base64"));
+      const signingBytes = buildSigningBytes(message, nonce);
+      return await verifyAsync(signatureBytes, signingBytes, publicKeyBytes);
+    } catch {
+      return false;
+    }
+  },
+  /**
+   * Create a signed message object
+   */
+  async createSignedMessage(message, privateKeyBase64, publicKey) {
+    const signature = await this.sign(message, privateKeyBase64);
+    return { message, signature, publicKey };
+  },
+  /**
+   * Verify a signed message object
+   */
+  async verifySignedMessage(signedMessage) {
+    return this.verify(
+      signedMessage.message,
+      signedMessage.signature,
+      signedMessage.publicKey
+    );
+  },
+  /**
+   * Generate a random challenge for authentication
+   */
+  generateChallenge() {
+    return `moltnet:challenge:${randomBytes$2(32).toString("hex")}:${Date.now()}`;
+  },
+  /**
+   * Derive public key from private key
+   */
+  async derivePublicKey(privateKeyBase64) {
+    const privateKeyBytes = new Uint8Array(
+      Buffer.from(privateKeyBase64, "base64")
     );
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-async function writeConfig(config, configDir) {
-  const dir2 = configDir ?? getConfigDir();
-  await mkdir(dir2, { recursive: true });
-  const filePath = join(dir2, "moltnet.json");
-  await writeFile(filePath, JSON.stringify(config, null, 2) + "\n", {
-    mode: 384
-  });
-  await chmod(filePath, 384);
-  return filePath;
-}
-async function updateConfigSection(section, data, configDir) {
-  const config = await readConfig(configDir);
-  if (!config) {
-    throw new Error("No config found — run `moltnet register` first");
+    const publicKeyBytes = await getPublicKeyAsync(privateKeyBytes);
+    return `ed25519:${Buffer.from(publicKeyBytes).toString("base64")}`;
+  },
+  /**
+   * Get fingerprint from public key string
+   */
+  getFingerprintFromPublicKey(publicKey) {
+    const publicKeyBytes = this.parsePublicKey(publicKey);
+    return this.generateFingerprint(publicKeyBytes);
+  },
+  /**
+   * Derive an X25519 private key from an Ed25519 private key seed.
+   * Uses SHA-512 expansion + clamping per RFC 7748 / RFC 8032.
+   */
+  deriveX25519PrivateKey(ed25519PrivateKeyBase64) {
+    const seed = new Uint8Array(Buffer.from(ed25519PrivateKeyBase64, "base64"));
+    const x25519Priv = ed25519.utils.toMontgomerySecret(seed);
+    return Buffer.from(x25519Priv).toString("base64");
+  },
+  /**
+   * Derive an X25519 public key from an Ed25519 public key.
+   * Uses the Edwards → Montgomery birational map.
+   */
+  deriveX25519PublicKey(ed25519PublicKey) {
+    const edPubBytes = this.parsePublicKey(ed25519PublicKey);
+    const x25519Pub = ed25519.utils.toMontgomery(edPubBytes);
+    return `x25519:${Buffer.from(x25519Pub).toString("base64")}`;
+  },
+  /**
+   * Create a proof of identity ownership (for DCR metadata)
+   */
+  async createIdentityProof(identityId, privateKeyBase64) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const message = `moltnet:register:${identityId}:${timestamp}`;
+    const signature = await this.sign(message, privateKeyBase64);
+    return { message, signature, timestamp };
+  },
+  /**
+   * Verify an identity proof
+   */
+  async verifyIdentityProof(proof, publicKey, expectedIdentityId) {
+    const isValid = await this.verify(
+      proof.message,
+      proof.signature,
+      publicKey
+    );
+    if (!isValid) return false;
+    const expectedPrefix = `moltnet:register:${expectedIdentityId}:`;
+    if (!proof.message.startsWith(expectedPrefix)) return false;
+    const proofTime = new Date(proof.timestamp).getTime();
+    const now = Date.now();
+    const fiveMinutes = 5 * 60 * 1e3;
+    if (now - proofTime > fiveMinutes) return false;
+    return true;
   }
-  const existing = config[section] ?? {};
-  const updated = { ...existing, ...data };
-  Object.assign(config, { [section]: updated });
-  await writeConfig(config, configDir);
-}
-etc.sha512Sync = (...m) => {
-  const hash = createHash("sha512");
-  m.forEach((msg) => hash.update(msg));
-  return hash.digest();
 };
 if (!etc.sha512Sync) {
   etc.sha512Sync = (...m) => {
@@ -2637,25 +3613,19 @@ function toSSHPrivateKey(seedBase64) {
   ].join("\n");
 }
 async function exportSSHKey(opts) {
-  const config = await readConfig(opts == null ? void 0 : opts.configDir);
+  const config = await readConfig(opts?.configDir);
   if (!config) {
-    throw new Error(
-      `No config found at ${getConfigPath(opts == null ? void 0 : opts.configDir)} — run \`moltnet register\` first`
-    );
+    throw new Error(`No config found at ${getConfigPath(opts?.configDir)} — run \`moltnet register\` first`);
   }
   const privateKeySSH = toSSHPrivateKey(config.keys.private_key);
   const publicKeySSH = toSSHPublicKey(config.keys.public_key);
-  const outputDir = (opts == null ? void 0 : opts.outputDir) ?? join((opts == null ? void 0 : opts.configDir) ?? getConfigDir(), "ssh");
+  const outputDir = opts?.outputDir ?? join(opts?.configDir ?? getConfigDir(), "ssh");
   await mkdir(outputDir, { recursive: true });
   const privatePath = join(outputDir, "id_ed25519");
   const publicPath = join(outputDir, "id_ed25519.pub");
   await writeFile(privatePath, privateKeySSH, { mode: 384 });
   await writeFile(publicPath, publicKeySSH, { mode: 420 });
-  await updateConfigSection(
-    "ssh",
-    { private_key_path: privatePath, public_key_path: publicPath },
-    opts == null ? void 0 : opts.configDir
-  );
+  await updateConfigSection("ssh", { private_key_path: privatePath, public_key_path: publicPath }, opts?.configDir);
   return { privatePath, publicPath };
 }
 const POLL_INTERVAL_MS = 5e3;
@@ -2673,7 +3643,7 @@ function toErrorMessage(err2) {
 }
 const POLL_TIMEOUT_MS = 5 * 60 * 1e3;
 function makeClient(baseUrl) {
-  return createClient$1({ baseUrl });
+  return createClient({ baseUrl });
 }
 async function startOnboarding(baseUrl, body) {
   const client2 = makeClient(baseUrl);
@@ -3216,183 +4186,6 @@ async function runGitSetupPhase(opts) {
   );
   dispatch({ type: "step", key: "gitSetup", status: "done" });
 }
-etc.sha512Sync = (...m) => {
-  const hash = createHash("sha512");
-  m.forEach((msg) => hash.update(msg));
-  return hash.digest();
-};
-const DOMAIN_PREFIX = "moltnet:v1";
-function buildSigningBytes(message, nonce) {
-  const msgHash = createHash("sha256").update(Buffer.from(message, "utf-8")).digest();
-  const nonceBytes = Buffer.from(nonce, "utf-8");
-  const prefix = Buffer.from(DOMAIN_PREFIX, "utf-8");
-  const buf = Buffer.alloc(
-    prefix.length + 4 + msgHash.length + 4 + nonceBytes.length
-  );
-  let offset = 0;
-  prefix.copy(buf, offset);
-  offset += prefix.length;
-  buf.writeUInt32BE(msgHash.length, offset);
-  offset += 4;
-  msgHash.copy(buf, offset);
-  offset += msgHash.length;
-  buf.writeUInt32BE(nonceBytes.length, offset);
-  offset += 4;
-  nonceBytes.copy(buf, offset);
-  return new Uint8Array(buf);
-}
-const cryptoService = {
-  /**
-   * Generate a new Ed25519 keypair
-   */
-  async generateKeyPair() {
-    const privateKeyBytes = utils.randomPrivateKey();
-    const publicKeyBytes = await getPublicKeyAsync(privateKeyBytes);
-    const privateKey = Buffer.from(privateKeyBytes).toString("base64");
-    const publicKey = `ed25519:${Buffer.from(publicKeyBytes).toString("base64")}`;
-    const fingerprint = this.generateFingerprint(publicKeyBytes);
-    return { publicKey, privateKey, fingerprint };
-  },
-  /**
-   * Generate human-readable fingerprint from public key
-   * Format: A1B2-C3D4-E5F6-G7H8 (first 16 hex chars of SHA256)
-   */
-  generateFingerprint(publicKeyBytes) {
-    const hash = createHash("sha256").update(publicKeyBytes).digest("hex");
-    const segments = hash.slice(0, 16).toUpperCase().match(/.{4}/g) ?? [];
-    return segments.join("-");
-  },
-  /**
-   * Parse public key from string format
-   */
-  parsePublicKey(publicKey) {
-    const base64 = publicKey.replace(/^ed25519:/, "");
-    return new Uint8Array(Buffer.from(base64, "base64"));
-  },
-  /**
-   * Sign a message with private key
-   */
-  async sign(message, privateKeyBase64) {
-    const privateKeyBytes = new Uint8Array(
-      Buffer.from(privateKeyBase64, "base64")
-    );
-    const messageBytes = new TextEncoder().encode(message);
-    const signature = await signAsync(messageBytes, privateKeyBytes);
-    return Buffer.from(signature).toString("base64");
-  },
-  /**
-   * Verify a signature against a message and public key
-   */
-  async verify(message, signature, publicKey) {
-    try {
-      const publicKeyBytes = this.parsePublicKey(publicKey);
-      const signatureBytes = new Uint8Array(Buffer.from(signature, "base64"));
-      const messageBytes = new TextEncoder().encode(message);
-      return await verifyAsync(signatureBytes, messageBytes, publicKeyBytes);
-    } catch {
-      return false;
-    }
-  },
-  /**
-   * Sign a (message, nonce) pair using deterministic pre-hash.
-   * Uses buildSigningBytes for domain separation and canonical serialization.
-   */
-  async signWithNonce(message, nonce, privateKeyBase64) {
-    const privateKeyBytes = new Uint8Array(
-      Buffer.from(privateKeyBase64, "base64")
-    );
-    const signingBytes = buildSigningBytes(message, nonce);
-    const signature = await signAsync(signingBytes, privateKeyBytes);
-    return Buffer.from(signature).toString("base64");
-  },
-  /**
-   * Verify a signature produced by signWithNonce.
-   */
-  async verifyWithNonce(message, nonce, signature, publicKey) {
-    try {
-      const publicKeyBytes = this.parsePublicKey(publicKey);
-      const signatureBytes = new Uint8Array(Buffer.from(signature, "base64"));
-      const signingBytes = buildSigningBytes(message, nonce);
-      return await verifyAsync(signatureBytes, signingBytes, publicKeyBytes);
-    } catch {
-      return false;
-    }
-  },
-  /**
-   * Create a signed message object
-   */
-  async createSignedMessage(message, privateKeyBase64, publicKey) {
-    const signature = await this.sign(message, privateKeyBase64);
-    return { message, signature, publicKey };
-  },
-  /**
-   * Verify a signed message object
-   */
-  async verifySignedMessage(signedMessage) {
-    return this.verify(
-      signedMessage.message,
-      signedMessage.signature,
-      signedMessage.publicKey
-    );
-  },
-  /**
-   * Generate a random challenge for authentication
-   */
-  generateChallenge() {
-    return `moltnet:challenge:${randomBytes$1(32).toString("hex")}:${Date.now()}`;
-  },
-  /**
-   * Derive public key from private key
-   */
-  async derivePublicKey(privateKeyBase64) {
-    const privateKeyBytes = new Uint8Array(
-      Buffer.from(privateKeyBase64, "base64")
-    );
-    const publicKeyBytes = await getPublicKeyAsync(privateKeyBytes);
-    return `ed25519:${Buffer.from(publicKeyBytes).toString("base64")}`;
-  },
-  /**
-   * Get fingerprint from public key string
-   */
-  getFingerprintFromPublicKey(publicKey) {
-    const publicKeyBytes = this.parsePublicKey(publicKey);
-    return this.generateFingerprint(publicKeyBytes);
-  },
-  /**
-   * Create a proof of identity ownership (for DCR metadata)
-   */
-  async createIdentityProof(identityId, privateKeyBase64) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const message = `moltnet:register:${identityId}:${timestamp}`;
-    const signature = await this.sign(message, privateKeyBase64);
-    return { message, signature, timestamp };
-  },
-  /**
-   * Verify an identity proof
-   */
-  async verifyIdentityProof(proof, publicKey, expectedIdentityId) {
-    const isValid = await this.verify(
-      proof.message,
-      proof.signature,
-      publicKey
-    );
-    if (!isValid) return false;
-    const expectedPrefix = `moltnet:register:${expectedIdentityId}:`;
-    if (!proof.message.startsWith(expectedPrefix)) return false;
-    const proofTime = new Date(proof.timestamp).getTime();
-    const now = Date.now();
-    const fiveMinutes = 5 * 60 * 1e3;
-    if (now - proofTime > fiveMinutes) return false;
-    return true;
-  }
-};
-if (!etc.sha512Sync) {
-  etc.sha512Sync = (...m) => {
-    const hash = createHash("sha512");
-    m.forEach((msg) => hash.update(msg));
-    return hash.digest();
-  };
-}
 async function runIdentityPhase(opts) {
   const { apiUrl: apiUrl2, agentName, configDir, dispatch } = opts;
   const existingConfig = await readConfig(configDir);