n3-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,4046 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/data/ws.ts
+var MarketWS = class {
+  env;
+  WSImpl;
+  url;
+  ws = null;
+  wantsOpen = false;
+  timers = {};
+  backoffMs = 500;
+  maxBackoffMs = 1e4;
+  // key -> set of handlers
+  subs = /* @__PURE__ */ new Map();
+  constructor(env2, WSImpl) {
+    this.env = env2;
+    this.url = env2.wsUrl.replace(/\/$/, "") + "/ws";
+    this.WSImpl = WSImpl ?? globalThis.WebSocket;
+    if (!this.WSImpl) throw new Error("No WebSocket implementation; pass WSImpl (e.g. isomorphic-ws) for Node");
+  }
+  connect() {
+    if (this.ws) return;
+    this.wantsOpen = true;
+    const ws = new this.WSImpl(this.url);
+    this.ws = ws;
+    ws.addEventListener("open", () => {
+      this.backoffMs = 500;
+      for (const key of this.subs.keys()) {
+        try {
+          ws.send(JSON.stringify({ op: "sub", key }));
+        } catch {
+        }
+      }
+      this.timers.ping = setInterval(() => {
+        try {
+          ws.ping?.();
+        } catch {
+        }
+      }, 3e4);
+    });
+    ws.addEventListener("message", (ev) => {
+      let data;
+      try {
+        data = typeof ev.data === "string" ? JSON.parse(ev.data) : JSON.parse(Buffer.from(ev.data).toString("utf8"));
+      } catch {
+        return;
+      }
+      const key = data?.t;
+      const msg = data?.d;
+      if (!key) return;
+      const set = this.subs.get(key);
+      if (!set || set.size === 0) return;
+      for (const fn of set) {
+        try {
+          fn(msg);
+        } catch {
+        }
+      }
+    });
+    const scheduleReconnect = () => {
+      this.ws = null;
+      if (!this.wantsOpen) return;
+      if (this.timers.ping) clearInterval(this.timers.ping);
+      if (this.timers.reconnect) clearTimeout(this.timers.reconnect);
+      this.timers.reconnect = setTimeout(() => this.connect(), this.backoffMs);
+      this.backoffMs = Math.min(this.maxBackoffMs, Math.floor(this.backoffMs * 1.7));
+    };
+    ws.addEventListener("close", scheduleReconnect);
+    ws.addEventListener("error", scheduleReconnect);
+  }
+  /** Subscribe to a raw topic key (e.g. "n3.indicatives:241"). */
+  on(key, fn) {
+    let set = this.subs.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.subs.set(key, set);
+    }
+    set.add(fn);
+    if (!this.ws) this.connect();
+    else try {
+      this.ws.send(JSON.stringify({ op: "sub", key }));
+    } catch {
+    }
+    return {
+      off: () => {
+        const s = this.subs.get(key);
+        if (!s) return;
+        s.delete(fn);
+        if (s.size === 0) {
+          this.subs.delete(key);
+          try {
+            this.ws?.send(JSON.stringify({ op: "unsub", key }));
+          } catch {
+          }
+        }
+      }
+    };
+  }
+  /** Convenience: topic + assetId → "topic:assetId" */
+  onTopic(topic, assetId, fn) {
+    return this.on(`${topic}:${assetId}`, fn);
+  }
+  close() {
+    this.wantsOpen = false;
+    if (this.timers.ping) clearInterval(this.timers.ping);
+    if (this.timers.reconnect) clearTimeout(this.timers.reconnect);
+    try {
+      this.ws?.close();
+    } catch {
+    }
+    this.ws = null;
+  }
+};
+
+// src/data/auth.ts
+import { sign } from "@noble/ed25519";
+function strip0x(s) {
+  return s.startsWith("0x") ? s.slice(2) : s;
+}
+function u8aToHex(u82) {
+  return "0x" + Array.from(u82).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function normalizeKeyHex(x) {
+  if (!x) return void 0;
+  return "0x" + strip0x(x).toLowerCase();
+}
+function makeSigner(input) {
+  const pubkeyHex = normalizeKeyHex(input.pubkeyHex);
+  if (input.signer) {
+    return {
+      pubkeyHex,
+      signMsg: async (msg) => u8aToHex(await input.signer(msg))
+    };
+  }
+  if (input.secretKey) {
+    const sk = input.secretKey;
+    return {
+      pubkeyHex,
+      signMsg: async (msg) => u8aToHex(await sign(msg, sk))
+    };
+  }
+  return { pubkeyHex: void 0, signMsg: void 0 };
+}
+async function buildAuthHeaders(signMsg, pubkeyHex, nonce) {
+  const hdrs = {};
+  if (!signMsg || !pubkeyHex) return hdrs;
+  const sig = await signMsg(new TextEncoder().encode(nonce));
+  hdrs["x-n3-key"] = normalizeKeyHex(pubkeyHex);
+  hdrs["x-n3-sig"] = sig;
+  hdrs["x-n3-nonce"] = nonce;
+  return hdrs;
+}
+
+// src/data/http.ts
+var defaultNonce = () => `${(/* @__PURE__ */ new Date()).toISOString()}-${Math.random().toString(16).slice(2)}`;
+function makeHttp(env2) {
+  const fetchFn = env2.fetchFn ?? globalThis.fetch;
+  if (!fetchFn) throw new Error("No fetch available; pass env.fetchFn");
+  const { signMsg, pubkeyHex } = makeSigner({ pubkeyHex: env2.pubkeyHex, signer: env2.signer, secretKey: env2.secretKey });
+  const makeNonce = env2.makeNonce ?? defaultNonce;
+  async function postJson(url, body) {
+    const nonce = makeNonce();
+    const auth = await buildAuthHeaders(signMsg, pubkeyHex, nonce);
+    const r = await fetchFn(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...auth },
+      body: JSON.stringify(body)
+    });
+    if (!r.ok) {
+      const txt = await r.text().catch(() => "");
+      throw new Error(`HTTP ${r.status} ${txt}`);
+    }
+    return await r.json();
+  }
+  return { postJson };
+}
+
+// src/data/graphql.ts
+function makeGraphQL(env2) {
+  const { postJson } = makeHttp(env2);
+  const url = env2.gqlUrl;
+  async function gql(query, variables) {
+    const res = await postJson(url, { query, variables });
+    if (res.errors?.length) throw new Error(res.errors.map((e) => e.message).join("; "));
+    if (!res.data) throw new Error("no data");
+    return res.data;
+  }
+  return {
+    async batches(assetId, limit = 100) {
+      const q = (
+        /* GraphQL */
+        `
+        query($assetId: String!, $limit: Int) {
+          batches(assetId: $assetId, limit: $limit) {
+            ts assetId extOpsHash nfHash batchId kind opsJson
+          }
+        }`
+      );
+      const d = await gql(q, { assetId: String(assetId), limit });
+      return d.batches;
+    },
+    async indicatives(assetId, sinceSec) {
+      const q = (
+        /* GraphQL */
+        `
+        query($assetId: String!, $sinceSec: Int!) {
+          indicatives(assetId: $assetId, sinceSec: $sinceSec) {
+            ts assetId midPx bidPx askPx spreadBp src
+            mid lo hi liquidityTier rootFrom rootTo
+          }
+        }`
+      );
+      const d = await gql(q, { assetId: String(assetId), sinceSec });
+      return d.indicatives;
+    },
+    async candles(assetId, window, limit = 300) {
+      const q = (
+        /* GraphQL */
+        `
+        query($assetId: String!, $window: String!, $limit: Int) {
+          candles(assetId: $assetId, window: $window, limit: $limit) {
+            ts assetId window o h l c v
+          }
+        }`
+      );
+      const d = await gql(q, { assetId: String(assetId), window, limit });
+      return d.candles;
+    }
+  };
+}
+
+// src/data/_common.ts
+var Topics = {
+  Indicatives: "n3.indicatives",
+  Candles: "n3.candles",
+  Batches: "n3.batches",
+  Depth: "n3.depth",
+  Trades: "n3.trades"
+};
+var topicKey = (topic, assetId) => `${topic}:${assetId}`;
+function makeInfra(env2, WSImpl) {
+  const gql = makeGraphQL(env2);
+  const ws = new MarketWS(env2, WSImpl);
+  return { gql, ws };
+}
+var SubBag = class {
+  subs = [];
+  add(s) {
+    this.subs.push(s);
+    return s;
+  }
+  clear() {
+    for (const s of this.subs) s.off();
+    this.subs = [];
+  }
+};
+
+// src/info/index.ts
+var info_exports = {};
+__export(info_exports, {
+  makeBatchesInfo: () => makeBatchesInfo,
+  makeCandlesInfo: () => makeCandlesInfo,
+  makeDepthInfo: () => makeDepthInfo,
+  makeIndicativesInfo: () => makeIndicativesInfo,
+  makeTradesInfo: () => makeTradesInfo
+});
+
+// src/info/indicatives.ts
+function makeIndicativesInfo(env2) {
+  const { gql } = makeInfra(env2);
+  return {
+    /**
+     * List recent indicatives for an asset since N seconds ago.
+     * Server decides the exact window; you already expose (assetId, sinceSec).
+     */
+    list(assetId, sinceSec) {
+      return gql.indicatives(assetId, sinceSec);
+    },
+    /** Convenience: return the latest indicative (or null if none). */
+    async latest(assetId, sinceSec = 300) {
+      const rows = await gql.indicatives(assetId, sinceSec);
+      return rows.length ? rows[rows.length - 1] : null;
+    }
+  };
+}
+
+// src/info/candles.ts
+function makeCandlesInfo(env2) {
+  const { gql } = makeInfra(env2);
+  return {
+    /** Paginated/limited candles (server decides ordering; usually oldest->newest). */
+    list(assetId, window, limit = 300) {
+      return gql.candles(assetId, window, limit);
+    },
+    /**
+     * Optional: range query if your GraphQL supports it.
+     * If not implemented server-side, remove this or let it throw.
+     */
+    async range(assetId, window, start, end) {
+      if (typeof gql.candlesRange !== "function") {
+        throw new Error("candles.range not supported by server GraphQL");
+      }
+      return gql.candlesRange(assetId, window, start, end);
+    },
+    /** Convenience: last candle (null if missing). */
+    async latest(assetId, window) {
+      const rows = await gql.candles(assetId, window, 1);
+      return rows.length ? rows[rows.length - 1] : null;
+    }
+  };
+}
+
+// src/info/depth.ts
+function makeDepthInfo(env2) {
+  const { gql } = makeInfra(env2);
+  return {
+    /**
+     * If server implements gql.depth(assetId, {start?, end?, limit?}),
+     * this will work. Otherwise we fail loudly to steer devs to WS.
+     */
+    async list(assetId, params = {}) {
+      if (typeof gql.depth !== "function") {
+        throw new Error("depth history not available via GraphQL \u2014 use subscription.depth.stream()");
+      }
+      return gql.depth(assetId, params);
+    }
+  };
+}
+
+// src/info/trades.ts
+function makeTradesInfo(env2) {
+  const { gql } = makeInfra(env2);
+  return {
+    /**
+     * If server implements gql.trades(assetId, {since?, limit?}),
+     * this will work. Otherwise we fail loudly to steer devs to WS.
+     */
+    async list(assetId, params = {}) {
+      if (typeof gql.trades !== "function") {
+        throw new Error("trades history not available via GraphQL \u2014 use subscription.trades.stream()");
+      }
+      return gql.trades(assetId, params);
+    },
+    /** Convenience: last trade (or null). */
+    async latest(assetId) {
+      if (typeof gql.trades !== "function") {
+        throw new Error("trades history not available via GraphQL \u2014 use subscription.trades.stream()");
+      }
+      const rows = await gql.trades(assetId, { limit: 1 });
+      return rows.length ? rows[0] : null;
+    }
+  };
+}
+
+// src/info/batches.ts
+function makeBatchesInfo(env2) {
+  const { gql } = makeInfra(env2);
+  return {
+    /** Latest batches for an asset (or across all if your resolver supports assetId = null). */
+    list(assetId, limit = 100) {
+      return gql.batches(assetId, limit);
+    },
+    /** Convenience: latest one (or null). */
+    async latest(assetId) {
+      const rows = await gql.batches(assetId, 1);
+      return rows.length ? rows[0] : null;
+    }
+  };
+}
+
+// src/subscription/index.ts
+var subscription_exports = {};
+__export(subscription_exports, {
+  makeBatches: () => makeBatches,
+  makeCandles: () => makeCandles,
+  makeDepth: () => makeDepth,
+  makeIndicatives: () => makeIndicatives,
+  makeTrades: () => makeTrades
+});
+
+// src/subscription/indicatives.ts
+function makeIndicatives(env2, WSImpl) {
+  const { gql, ws } = makeInfra(env2, WSImpl);
+  return {
+    /** Historical/Recent indicatives via GraphQL (sinceSec seconds lookback). */
+    list(assetId, sinceSec) {
+      return gql.indicatives(assetId, sinceSec);
+    },
+    /** Live prices via WS. Message has ts, assetId, midPx/bidPx/askPx/spreadBp/src. */
+    stream(assetId, handler) {
+      return ws.onTopic(Topics.Indicatives, assetId, handler);
+    },
+    streamMany(assetIds, handler) {
+      const bag = new SubBag();
+      for (const a of assetIds) {
+        bag.add(ws.on(topicKey(Topics.Indicatives, a), (msg) => handler(String(a), msg)));
+      }
+      return bag;
+    }
+  };
+}
+
+// src/subscription/candles.ts
+function makeCandles(env2, WSImpl) {
+  const { gql, ws } = makeInfra(env2, WSImpl);
+  return {
+    /** Historical candles from GraphQL. */
+    list(assetId, window, limit = 300) {
+      return gql.candles(assetId, window, limit);
+    },
+    /**
+     * Live candles via WS fanout.
+     * Emits raw candle objects exactly as gateway forwards.
+     */
+    stream(assetId, handler) {
+      return ws.onTopic(Topics.Candles, assetId, handler);
+    },
+    /**
+     * Subscribe to multiple assetIds at once; returns a bag you can .clear()
+     */
+    streamMany(assetIds, handler) {
+      const bag = new SubBag();
+      for (const a of assetIds) {
+        bag.add(ws.on(topicKey(Topics.Candles, a), (msg) => handler(String(a), msg)));
+      }
+      return bag;
+    }
+  };
+}
+
+// src/subscription/depth.ts
+function makeDepth(env2, WSImpl) {
+  const { ws } = makeInfra(env2, WSImpl);
+  return {
+    /** Live orderbook rows (snapshots + deltas). You aggregate client-side. */
+    stream(assetId, handler) {
+      return ws.onTopic(Topics.Depth, assetId, handler);
+    },
+    streamMany(assetIds, handler) {
+      const bag = new SubBag();
+      for (const a of assetIds) {
+        bag.add(ws.on(topicKey(Topics.Depth, a), (msg) => handler(String(a), msg)));
+      }
+      return bag;
+    }
+  };
+}
+
+// src/subscription/trades.ts
+function makeTrades(env2, WSImpl) {
+  const { ws } = makeInfra(env2, WSImpl);
+  return {
+    stream(assetId, handler) {
+      return ws.onTopic(Topics.Trades, assetId, handler);
+    },
+    streamMany(assetIds, handler) {
+      const bag = new SubBag();
+      for (const a of assetIds) {
+        bag.add(ws.on(topicKey(Topics.Trades, a), (msg) => handler(String(a), msg)));
+      }
+      return bag;
+    }
+  };
+}
+
+// src/subscription/batches.ts
+function makeBatches(env2, WSImpl) {
+  const { gql, ws } = makeInfra(env2, WSImpl);
+  return {
+    /** Historical batches via GraphQL. */
+    list(assetId, limit = 100) {
+      return gql.batches(assetId, limit);
+    },
+    /** Live batches via WS (preview + submitted). */
+    stream(assetId, handler) {
+      return ws.onTopic(Topics.Batches, assetId, handler);
+    },
+    streamMany(assetIds, handler) {
+      const bag = new SubBag();
+      for (const a of assetIds) {
+        bag.add(ws.on(topicKey(Topics.Batches, a), (msg) => handler(String(a), msg)));
+      }
+      return bag;
+    }
+  };
+}
+
+// src/exchange/index.ts
+var exchange_exports = {};
+__export(exchange_exports, {
+  batchCancel: () => batchCancel,
+  batchModify: () => batchModify,
+  batchOrders: () => batchOrders,
+  cancel: () => cancel,
+  depositERC20: () => depositERC20,
+  depositHYPE: () => depositHYPE,
+  modify: () => modify,
+  submitOrder: () => submitOrder,
+  submitOrderAuto: () => submitOrderAuto,
+  withdraw: () => withdraw,
+  withdrawAuto: () => withdrawAuto
+});
+
+// src/lib/utils/redis.ts
+import Redis from "ioredis";
+
+// src/env.ts
+import "dotenv/config";
+var env = {
+  CHAIN_ID: Number(process.env.CHAIN_ID ?? 0),
+  POOL: process.env.POOL,
+  RPC_URL: process.env.RPC_URL,
+  REDIS_URL: process.env.REDIS_URL,
+  REDIS_STREAM_PREFIX: process.env.REDIS_STREAM_PREFIX ?? "n3",
+  PRIVATE_KEY: process.env.RELAYER_KEY,
+  SEED: process.env.SEED
+};
+for (const [k, v] of Object.entries(env)) {
+  if (!v) throw new Error(`Missing env: ${k}`);
+}
+
+// src/lib/utils/redis.ts
+var redis = new Redis(env.REDIS_URL, {
+  maxRetriesPerRequest: null,
+  enableReadyCheck: true,
+  lazyConnect: false
+});
+async function publishIntent(intent) {
+  const key = `${env.REDIS_STREAM_PREFIX}:intents`;
+  const fields = [];
+  for (const [k, v] of Object.entries(intent)) {
+    fields.push(k, typeof v === "string" ? v : JSON.stringify(v));
+  }
+  return redis.xadd(key, "*", ...fields);
+}
+
+// src/lib/utils/stripForHyperliquid.ts
+function stripForHyperliquid(intent) {
+  const { n3: _omit, ...rest } = intent;
+  return rest;
+}
+
+// src/lib/utils/toUint160Dec.ts
+function toUint160Dec(addr) {
+  if (!addr) throw new Error("empty address");
+  const hex = addr.toLowerCase();
+  if (!hex.startsWith("0x") || hex.length !== 42) throw new Error(`bad address: ${addr}`);
+  return BigInt(hex).toString();
+}
+
+// src/lib/utils/getDomains.ts
+function getDomains(params) {
+  return {
+    domainA: toUint160Dec(params.pool),
+    domainB: String(params.chainIdDec),
+    DOMAIN: String(params.DOMAIN_DEC)
+  };
+}
+
+// src/lib/utils/orderControl.ts
+function buildDomains(domain) {
+  return getDomains({
+    pool: domain.pool,
+    chainIdDec: domain.chainIdDec,
+    DOMAIN_DEC: domain.DOMAIN_DEC
+  });
+}
+function hlEnvelope(action, nonce, signature) {
+  return stripForHyperliquid({
+    action,
+    nonce,
+    signature: signature ?? void 0,
+    n3: {
+      settlement: "",
+      pools: [],
+      hybrid: {
+        internalFirst: false,
+        internalCap: "0",
+        coreCap: "0"
+      },
+      spendNotes: false,
+      rfq: {
+        validUntilMs: 0
+      },
+      core: {
+        route: ""
+      }
+    }
+  });
+}
+function makeIdempotencyKey(op, originalKey, nonce) {
+  return `${op}:${String(originalKey)}:${nonce}`;
+}
+
+// src/exchange/cancel.ts
+async function cancel(params) {
+  const { domain, target, signature, ctx, nonce = Date.now() } = params;
+  const hlReq = hlEnvelope(
+    {
+      type: "cancel",
+      ...target.orderId != null ? { orderId: target.orderId } : {},
+      ...target.clientOid ? { clientOid: target.clientOid } : {},
+      ...target.symbol ? { symbol: target.symbol } : {}
+    },
+    nonce,
+    signature
+  );
+  const domains = buildDomains(domain);
+  const originalKey = target.orderId ?? target.clientOid ?? `${target.symbol ?? "?"}:unknown`;
+  const payload = {
+    type: "control",
+    op: "cancel",
+    version: 1,
+    idempotencyKey: makeIdempotencyKey("cancel", originalKey, nonce),
+    // HL envelope for venue-side cancel
+    intent: {
+      ...hlReq,
+      // Minimal N3 block; explicitly tagged to skip proving/batching
+      n3: {
+        domains,
+        control: { skipProver: true, dropFromBatch: true }
+      }
+    },
+    // Hints for consumers (enclave/batcher/prover)
+    control: {
+      skipProver: true,
+      dropFromBatch: true,
+      removePendingOps: true,
+      target
+    },
+    // Telemetry
+    userAddress: ctx?.userAddress ?? null,
+    receivedAtMs: ctx?.nowMs ?? Date.now()
+  };
+  return publishIntent(payload);
+}
+
+// src/exchange/batchCancel.ts
+async function batchCancel(params) {
+  const { domain, targets, signature, ctx, nonce = Date.now() } = params;
+  if (!targets?.length) throw new Error("batchCancelOrdersIntent: targets required");
+  const byOid = targets.filter((t) => t.orderId != null);
+  const byCloid = targets.filter((t) => t.clientOid);
+  const domains = buildDomains(domain);
+  const publishOne = async (kind) => {
+    const groupKey = `${kind}:${targets.length}:${nonce}`;
+    const hlReq = kind === "oid" ? hlEnvelope(
+      {
+        type: "cancel",
+        cancels: byOid.map((t) => ({ a: void 0, o: Number(t.orderId) }))
+        // a (asset) optional on your side
+      },
+      nonce,
+      signature
+    ) : hlEnvelope(
+      {
+        type: "cancelByCloid",
+        cancels: byCloid.map((t) => ({ asset: void 0, cloid: t.clientOid }))
+      },
+      nonce,
+      signature
+    );
+    const payload = {
+      type: "control",
+      op: "cancelMany",
+      version: 1,
+      idempotencyKey: makeIdempotencyKey("cancelMany", groupKey, nonce),
+      intent: {
+        ...hlReq,
+        n3: {
+          domains,
+          control: { skipProver: true, dropFromBatch: true }
+        }
+      },
+      control: {
+        skipProver: true,
+        dropFromBatch: true,
+        removePendingOps: true,
+        targets
+      },
+      userAddress: ctx?.userAddress ?? null,
+      receivedAtMs: ctx?.nowMs ?? Date.now()
+    };
+    return publishIntent(payload);
+  };
+  const results = [];
+  if (byOid.length) results.push(await publishOne("oid"));
+  if (byCloid.length) results.push(await publishOne("cloid"));
+  return results.length === 1 ? results[0] : results;
+}
+
+// src/exchange/batchModify.ts
+async function batchModify(params) {
+  const { domain, modifies, signature, ctx, nonce = Date.now() } = params;
+  if (!modifies?.length) throw new Error("batchModifyOrdersIntent: modifies required");
+  const hlReq = hlEnvelope(
+    {
+      type: "batchModify",
+      modifies: modifies.map(({ target, order }) => ({
+        ...target.orderId != null ? { oid: Number(target.orderId) } : {},
+        ...target.clientOid ? { cloid: target.clientOid } : {},
+        order
+      }))
+    },
+    nonce,
+    signature
+  );
+  const domains = buildDomains(domain);
+  const payload = {
+    type: "control",
+    op: "batchModify",
+    version: 1,
+    idempotencyKey: makeIdempotencyKey("batchModify", `n=${modifies.length}`, nonce),
+    intent: {
+      ...hlReq,
+      n3: {
+        domains,
+        control: { skipProver: true, dropFromBatch: true }
+      }
+    },
+    control: {
+      skipProver: true,
+      dropFromBatch: true,
+      modifies
+    },
+    userAddress: ctx?.userAddress ?? null,
+    receivedAtMs: ctx?.nowMs ?? Date.now()
+  };
+  return publishIntent(payload);
+}
+
+// src/lib/utils/withN3Defaults.ts
+function withN3Defaults(n3, ctx = {}) {
+  const settlement = n3?.settlement ?? "pool";
+  const pools = {
+    allowPools: n3?.pools?.allowPools ?? (ctx.defaultPools ?? []),
+    denyPools: n3?.pools?.denyPools ?? [],
+    attestations: n3?.pools?.attestations ?? []
+  };
+  const hybrid = {
+    internalFirst: n3?.hybrid?.internalFirst ?? true,
+    internalCap: n3?.hybrid?.internalCap ?? (ctx.size ?? "0"),
+    coreCap: n3?.hybrid?.coreCap ?? (ctx.size ?? "0")
+  };
+  const spendNotes = n3?.spendNotes ?? [];
+  const now = ctx.nowMs ?? Date.now();
+  const rfq = {
+    validUntilMs: n3?.rfq?.validUntilMs ?? now + 5 * 6e4,
+    // default 5 min
+    minFill: n3?.rfq?.minFill ?? "0",
+    slippageBps: n3?.rfq?.slippageBps ?? 0,
+    makerOnlyInternal: n3?.rfq?.makerOnlyInternal ?? false,
+    counterpartyAllow: n3?.rfq?.counterpartyAllow ?? [],
+    counterpartyDeny: n3?.rfq?.counterpartyDeny ?? []
+  };
+  const core = {
+    route: n3?.core?.route ?? "",
+    extData: n3?.core?.extData ?? ""
+  };
+  const meta = n3?.meta ?? {};
+  return { settlement, pools, hybrid, spendNotes, rfq, core, meta };
+}
+
+// src/exchange/batchOrder.ts
+async function batchOrders(params) {
+  const {
+    orders,
+    grouping = "na",
+    builder,
+    n3,
+    domain,
+    ctx,
+    nonce = Date.now(),
+    signature
+  } = params;
+  if (!orders?.length) throw new Error("submitBatchOrdersIntent: orders required");
+  const n3Full = withN3Defaults(n3, {
+    defaultPools: ctx?.defaultPools,
+    nowMs: ctx?.nowMs,
+    size: String(orders.reduce((acc, o) => acc + Number(o.s ?? 0), 0))
+  });
+  const hlRequest = stripForHyperliquid({
+    action: {
+      type: "order",
+      orders,
+      grouping,
+      ...builder ? { builder } : {}
+    },
+    nonce,
+    signature: signature ?? void 0
+  });
+  const domains = getDomains({
+    pool: domain.pool,
+    chainIdDec: domain.chainIdDec,
+    DOMAIN_DEC: domain.DOMAIN_DEC
+  });
+  const payload = {
+    type: "order",
+    version: 1,
+    intent: {
+      ...hlRequest,
+      n3: {
+        settlement: n3Full.settlement,
+        pools: n3Full.pools,
+        hybrid: n3Full.hybrid,
+        spendNotes: n3Full.spendNotes,
+        rfq: n3Full.rfq,
+        core: n3Full.core,
+        meta: n3Full.meta,
+        domains
+      }
+    },
+    // Telemetry
+    userAddress: ctx?.userAddress ?? null,
+    receivedAtMs: ctx?.nowMs ?? Date.now()
+  };
+  return publishIntent(payload);
+}
+
+// src/exchange/modify.ts
+async function modify(params) {
+  const { domain, target, order, signature, ctx, nonce = Date.now() } = params;
+  const hlReq = hlEnvelope(
+    {
+      type: "modify",
+      ...target.orderId != null ? { oid: Number(target.orderId) } : {},
+      ...target.clientOid ? { cloid: target.clientOid } : {},
+      order
+    },
+    nonce,
+    signature
+  );
+  const domains = buildDomains(domain);
+  const originalKey = target.orderId ?? target.clientOid ?? "unknown";
+  const payload = {
+    type: "control",
+    op: "modify",
+    version: 1,
+    idempotencyKey: makeIdempotencyKey("modify", originalKey, nonce),
+    intent: {
+      ...hlReq,
+      n3: {
+        domains,
+        control: { skipProver: true, dropFromBatch: true }
+      }
+    },
+    control: {
+      skipProver: true,
+      dropFromBatch: true,
+      target,
+      order
+    },
+    userAddress: ctx?.userAddress ?? null,
+    receivedAtMs: ctx?.nowMs ?? Date.now()
+  };
+  return publishIntent(payload);
+}
+
+// src/lib/utils/normalizeOrder.ts
+function normalizeOrder(hl, grouping, builder, n3Full, extra) {
+  const tif = "limit" in hl.t ? hl.t.limit.tif : null;
+  const trigger = "trigger" in hl.t ? hl.t.trigger : void 0;
+  const it = {
+    assetId: hl.a,
+    isBuy: hl.b,
+    price: hl.p,
+    size: hl.s,
+    reduceOnly: hl.r,
+    tif,
+    trigger,
+    cloid: hl.c,
+    grouping,
+    builder,
+    settlement: n3Full.settlement,
+    pools: n3Full.pools,
+    hybrid: n3Full.hybrid,
+    spendNotes: n3Full.spendNotes,
+    rfq: n3Full.rfq,
+    core: n3Full.core,
+    internalRemaining: n3Full.hybrid.internalFirst ? n3Full.hybrid.internalCap : "0",
+    coreRemaining: n3Full.hybrid.coreCap,
+    userAddress: extra.userAddress,
+    receivedAtMs: extra.receivedAtMs ?? Date.now()
+  };
+  return it;
+}
+
+// src/lib/utils/notesSelect.ts
+function greedySelectNotes(store, params) {
+  const assetIdBI = BigInt(params.assetId);
+  const need = params.amount;
+  const spendables = store.listSpendable({ assetId: assetIdBI }).filter((n) => n.index != null && !!n.commitment);
+  const sorted = spendables.slice().sort((a, b) => b.amount > a.amount ? 1 : b.amount < a.amount ? -1 : 0);
+  const out = [];
+  let acc = 0n;
+  for (const n of sorted) {
+    out.push(n);
+    acc += n.amount;
+    if (acc >= need) break;
+  }
+  return { notes: out, totalSelected: acc, shortfall: acc >= need ? 0n : need - acc };
+}
+function buildSpendNotesFromStore(store, params) {
+  const sel = greedySelectNotes(store, params);
+  const spendNotes = sel.notes.map((n) => ({
+    commitment: n.commitment,
+    leafIndex: n.index,
+    // anchored by filter above
+    assetId: Number(n.assetId),
+    maxSpend: n.amount.toString()
+    // spend full note; change handled downstream
+  }));
+  return { spendNotes, totalSelected: sel.totalSelected, shortfall: sel.shortfall };
+}
+
+// src/exchange/order.ts
+function toInternalTransferPlan(pl) {
+  const internalTarget = pl.settlement === "pool" ? pl.size : pl.settlement === "hybrid" ? pl.internalRemaining : "0";
+  return {
+    assetId: pl.assetId,
+    internalTarget,
+    spendNotes: pl.spendNotes ?? [],
+    rfq: pl.rfq
+  };
+}
+async function submitOrder(params) {
+  const {
+    hl,
+    grouping,
+    builder,
+    n3,
+    ctx,
+    domain,
+    nonce = Date.now(),
+    signature
+  } = params;
+  const n3Full = withN3Defaults(n3, {
+    defaultPools: ctx?.defaultPools,
+    nowMs: ctx?.nowMs,
+    size: hl.s
+  });
+  const plannable = normalizeOrder(
+    hl,
+    grouping,
+    builder,
+    n3Full,
+    { receivedAtMs: ctx?.nowMs ?? Date.now(), userAddress: ctx?.userAddress }
+  );
+  const hlRequest = stripForHyperliquid({
+    action: {
+      type: "order",
+      orders: [hl],
+      grouping,
+      ...builder ? { builder } : {}
+    },
+    nonce,
+    signature: signature ?? void 0
+  });
+  const domains = getDomains({
+    pool: domain.pool,
+    chainIdDec: domain.chainIdDec,
+    DOMAIN_DEC: domain.DOMAIN_DEC
+  });
+  const intent = {
+    ...hlRequest,
+    n3: {
+      settlement: n3Full.settlement,
+      pools: n3Full.pools,
+      hybrid: n3Full.hybrid,
+      spendNotes: n3Full.spendNotes,
+      rfq: n3Full.rfq,
+      core: n3Full.core,
+      meta: n3Full.meta,
+      domains
+    }
+  };
+  const internalPlan = toInternalTransferPlan(plannable);
+  const payload = {
+    type: "order",
+    version: 1,
+    intent,
+    plannable,
+    internalPlan,
+    userAddress: plannable.userAddress ?? null,
+    receivedAtMs: plannable.receivedAtMs
+  };
+  return publishIntent(payload);
+}
+async function submitOrderAuto(params) {
+  const { store, spend, allowPartial, ...rest } = params;
+  const { spendNotes, totalSelected, shortfall } = buildSpendNotesFromStore(store, spend);
+  if (shortfall > 0n && !allowPartial) {
+    throw new Error(
+      `Insufficient spendable balance for asset ${spend.assetId}. Need ${spend.amount}, have ${totalSelected}.`
+    );
+  }
+  const n3 = {
+    ...rest.n3,
+    spendNotes: [
+      ...rest.n3?.spendNotes ?? [],
+      ...spendNotes
+    ]
+  };
+  return submitOrder({
+    ...rest,
+    n3
+  });
+}
+
+// src/exchange/withdraw3.ts
+import "dotenv/config";
+
+// src/lib/consts/domain.ts
+var POOL = process.env.POOL ?? "0x829f9d77F37BDB3e6519cddc99357f055cb92f97";
+var CHAIN_ID_DEC = 999;
+var DOMAIN_DEC = 42;
+function getDomainEnv(overrides) {
+  const chainIdEnv = Number(process.env.CHAIN_ID ?? 42161);
+  const domainEnv = Number(process.env.DOMAIN_DEC ?? 1);
+  const poolEnv = process.env.POOL ?? "0x0000000000000000000000000000000000000000";
+  return {
+    chainIdDec: overrides?.chainIdDec ?? chainIdEnv,
+    domainDec: overrides?.domainDec ?? domainEnv,
+    pool: overrides?.pool ?? poolEnv
+  };
+}
+
+// src/lib/utils/pureSigner.ts
+import { buildBabyjub, buildEddsa, buildPoseidonReference } from "circomlibjs";
+globalThis.ffjsconfig = { wasm: "disable" };
+process.env.FFJS_FORCE_NO_WASM = "1";
+process.env.FFJSCONFIG = '{"wasm":"disable"}';
+var babyJub = await buildBabyjub();
+var eddsa = await buildEddsa();
+var poseidonRef = await buildPoseidonReference();
+var Fr = babyJub.F;
+function toBI(x) {
+  return typeof x === "bigint" ? x : BigInt(x);
+}
+function be32FromDec(dec) {
+  let x = toBI(dec);
+  const out = new Uint8Array(32);
+  for (let i = 31; i >= 0; i--) {
+    out[i] = Number(x & 0xffn);
+    x >>= 8n;
+  }
+  return out;
+}
+function hexToBytes(hex) {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const s = h.padStart(64, "0");
+  return Uint8Array.from(Buffer.from(s, "hex"));
+}
+function H2(a, b) {
+  return Fr.toObject(poseidonRef([Fr.e(a), Fr.e(b)]));
+}
+function msgHash(domain, chainDec, poolDec, c_in, oldRoot) {
+  return Fr.toObject(
+    poseidonRef([
+      Fr.e(domain),
+      Fr.e(chainDec),
+      Fr.e(poolDec),
+      Fr.e(c_in),
+      Fr.e(oldRoot)
+    ])
+  );
+}
+function poseidonAxAy(Ax, Ay) {
+  return Fr.toObject(
+    poseidonRef([Fr.e(toBI(Ax)), Fr.e(toBI(Ay))])
+  );
+}
+function signPoseidonCompat(prvSeed, M, Ax_from_note, Ay_from_note) {
+  const raw = prvSeed.startsWith("0x") ? hexToBytes(prvSeed) : be32FromDec(prvSeed);
+  if (raw.length !== 32) {
+    throw new Error(`signPoseidonCompat: prvSeed must be 32 bytes, got ${raw.length}`);
+  }
+  const prv = Buffer.from(raw);
+  if (Ax_from_note && Ay_from_note) {
+    const A = eddsa.prv2pub(prv);
+    const Ax = Fr.toObject(A[0]);
+    const Ay = Fr.toObject(A[1]);
+    if (Ax.toString() !== Ax_from_note || Ay.toString() !== Ay_from_note) {
+      console.warn("[warn] prv->pub mismatch", {
+        derivedAx: Ax.toString(),
+        derivedAy: Ay.toString(),
+        noteAx: Ax_from_note,
+        noteAy: Ay_from_note
+      });
+    }
+  }
+  const Mfield = Fr.e(M);
+  const sig = eddsa.signPoseidon(prv, Mfield);
+  const R8x = Fr.toObject(sig.R8[0]);
+  const R8y = Fr.toObject(sig.R8[1]);
+  const S = toBI(sig.S);
+  return { R8x: R8x.toString(), R8y: R8y.toString(), S: S.toString() };
+}
+function verifyPoseidonCompat(Ax, Ay, M, sig) {
+  const A = [babyJub.F.e(toBI(Ax)), babyJub.F.e(toBI(Ay))];
+  const R8 = [babyJub.F.e(toBI(sig.R8x)), babyJub.F.e(toBI(sig.R8y))];
+  const S = toBI(sig.S);
+  return eddsa.verifyPoseidon(M, { R8, S }, A);
+}
+
+// src/lib/utils/poseidon.ts
+import { buildBabyjub as buildBabyjub2, buildPoseidon, buildEddsa as buildEddsa2 } from "circomlibjs";
+var _h2 = null;
+var FR = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+async function babyjubCtx() {
+  const babyjub = await buildBabyjub2();
+  const poseidon = await buildPoseidon();
+  const eddsa3 = await buildEddsa2();
+  const F = babyjub.F;
+  return { babyjub, poseidon, eddsa: eddsa3, F };
+}
+function toField(x) {
+  let v = x % FR;
+  if (v < 0n) v += FR;
+  return v;
+}
+function hexTo32Bytes(hex) {
+  const s = (hex.startsWith("0x") ? hex.slice(2) : hex).padStart(64, "0");
+  const bytes = new Uint8Array(s.length / 2);
+  for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(s.slice(2 * i, 2 * i + 2), 16);
+  return bytes;
+}
+async function genNote(seed) {
+  const { eddsa: eddsa3, poseidon, F } = await babyjubCtx();
+  const rnd = seed ?? BigInt.asUintN(
+    256,
+    BigInt(Date.now()) * 0x100000000n + BigInt(Math.floor(Math.random() * 1e9))
+  );
+  const sk = toField(rnd);
+  const blinding = toField(sk ^ 0xB1E55n);
+  const skHex = "0x" + sk.toString(16).padStart(64, "0");
+  const skBytes = hexTo32Bytes(skHex);
+  const pub = eddsa3.prv2pub(skBytes);
+  const Ax = F.toObject(pub[0]);
+  const Ay = F.toObject(pub[1]);
+  const pubkey = F.toObject(poseidon([Ax, Ay]));
+  return { sk, skBytes, Ax, Ay, pubkey, blinding };
+}
+function makeDepositCommitments(assetId, amount, pubkey, blinding) {
+  if (!_h2) throw new Error("initPoseidon() must be called before makeDepositCommitments");
+  const poseidon = _h2;
+  const hAmt = poseidon(assetId, amount);
+  const hPK = poseidon(pubkey, blinding);
+  const commitment = poseidon(hAmt, hPK);
+  const hItem = poseidon(commitment, hAmt);
+  return { hAmt, commitment, hItem };
+}
+async function initPoseidon() {
+  if (_h2) return;
+  const poseidon = await buildPoseidon();
+  const F = poseidon.F;
+  _h2 = (a, b) => F.toObject(poseidon([a, b]));
+}
+function getH2() {
+  if (!_h2) throw new Error("initPoseidon() must be called before using h2");
+  return _h2;
+}
+
+// src/lib/utils/computeNullifier.ts
+async function computeNullifierExact(params) {
+  await initPoseidon();
+  const H22 = getH2();
+  const inner = H22(params.commit, params.index);
+  const nf = H22(params.sk, inner);
+  return nf;
+}
+
+// src/exchange/withdraw3.ts
+import { buildBabyjub as buildBabyjub3, buildEddsa as buildEddsa3 } from "circomlibjs";
+import crypto2 from "crypto";
+
+// src/lib/utils/fetchPinFromIndexer.ts
+async function fetchPinFromIndexer(indexerUrl, poolAddr) {
+  const q = `
+      query Head($pool: String!) {
+        poolStates(where: { id: $pool }, limit: 1) {
+          items { currentRoot depAppliedHash depAppliedLen nextIndex updatedAt }
+        }
+      }`;
+  const r = await fetch(indexerUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ query: q, variables: { pool: poolAddr.toLowerCase() } })
+  });
+  const j = await r.json();
+  const head = j?.data?.poolStates?.items?.[0];
+  if (!head) throw new Error("indexer head not found for pool");
+  return {
+    depEnqHash: String(head.depAppliedHash),
+    depEnqLen: Number(head.depAppliedLen),
+    nextIndex: Number(head.nextIndex),
+    currentRoot: head.currentRoot,
+    updatedAt: Number(head.updatedAt)
+  };
+}
+
+// src/exchange/withdraw3.ts
+var INDEXER_URL = process.env.INDEXER_URL;
+var PROOF_URL = process.env.PROOF_URL || (INDEXER_URL.endsWith("/graphql") ? INDEXER_URL.replace(/\/graphql$/, "/proof") : `${INDEXER_URL.replace(/\/+$/, "")}/proof`);
+var TREE_DEPTH = Number(process.env.TREE_DEPTH || 20);
+var eddsa2 = await buildEddsa3();
+var babyJub2 = await buildBabyjub3();
+var Fr2 = babyJub2.F;
+function asBytes(x) {
+  if (x instanceof Uint8Array) return x;
+  const a = x;
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer?.(x)) return new Uint8Array(a);
+  if (Array.isArray(a)) return new Uint8Array(a.map((n) => Number(n) & 255));
+  if (a && typeof a === "object") {
+    const keys = Object.keys(a).filter((k) => /^\d+$/.test(k)).map(Number).sort((x2, y) => x2 - y);
+    if (keys.length) {
+      const out = new Uint8Array(keys.length);
+      for (let i = 0; i < keys.length; i++) out[i] = Number(a[keys[i]] ?? 0) & 255;
+      return out;
+    }
+  }
+  return null;
+}
+var bi = (x) => BigInt(x ?? 0);
+var toSeedHex = (u82) => "0x" + Buffer.from(u82).toString("hex");
+var noteCommit = (assetId, amount, pubkey, blinding) => H2(H2(assetId, amount), H2(pubkey, blinding));
+async function fetchProof(index, rootHex) {
+  const url = `${PROOF_URL.replace(/\/+$/, "")}?index=${index}&root=${encodeURIComponent(rootHex)}`;
+  const ctl = new AbortController();
+  const to = setTimeout(() => ctl.abort(), 12e3);
+  try {
+    const r = await fetch(url, { method: "GET", signal: ctl.signal });
+    const j = await r.json().catch(() => null);
+    if (!r.ok) throw new Error(`proof server ${r.status}: ${j?.error ?? r.statusText}`);
+    const pathElements = (j?.pathElements ?? []).map((x) => {
+      const s = String(x);
+      return s.startsWith("0x") ? s : "0x" + BigInt(s).toString(16).padStart(64, "0");
+    });
+    const pathIndex = (j?.pathIndex ?? []).map((x) => Number(x));
+    if (pathElements.length !== TREE_DEPTH || pathIndex.length !== TREE_DEPTH) {
+      throw new Error(`proof length mismatch: got ${pathElements.length}/${pathIndex.length}, expected ${TREE_DEPTH}`);
+    }
+    return { pathElements, pathIndex };
+  } finally {
+    clearTimeout(to);
+  }
+}
+async function withdraw({
+  assetId,
+  amount,
+  toAddress,
+  spends,
+  out0,
+  out1,
+  fee = 0n,
+  relayer = 0n
+}) {
+  const spendsArr = (spends ?? []).map((s) => {
+    const base = {
+      notePubkey: s.notePubkey.toString(),
+      Ax: s.Ax.toString(),
+      Ay: s.Ay.toString(),
+      R8x: s.R8x.toString(),
+      R8y: s.R8y.toString(),
+      S: s.S.toString(),
+      commit: s.commit.toString(),
+      index: s.index.toString(),
+      assetId: s.assetId.toString(),
+      amount: s.amount.toString(),
+      blinding: s.blinding.toString(),
+      sk: s.sk.toString()
+    };
+    if (s.pathElements) base.pathElements = s.pathElements.map((x) => x.toString());
+    if (s.pathIndex) base.pathIndex = s.pathIndex.map((x) => x.toString());
+    return base;
+  });
+  const wd_outAssetIds = [out0?.assetId ?? assetId, out1?.assetId ?? assetId].map(String);
+  const wd_outAmounts = [out0?.amount ?? 0n, out1?.amount ?? 0n].map(String);
+  const wd_outPubkeys = [out0?.pubkey ?? 0n, out1?.pubkey ?? 0n].map(String);
+  const wd_outBlindings = [out0?.blinding ?? 0n, out1?.blinding ?? 0n].map(String);
+  const it = {
+    domain: {
+      pool: POOL.toLowerCase(),
+      chainIdDec: String(CHAIN_ID_DEC),
+      DOMAIN_DEC: String(DOMAIN_DEC)
+    },
+    withdraws: [{
+      select: "1",
+      selected: "1",
+      assetId: assetId.toString(),
+      amount: amount.toString(),
+      // external payout
+      to: toAddress,
+      spends: spendsArr,
+      // NEW: explicit WD outputs & accounting
+      outAssetIds: wd_outAssetIds,
+      outAmounts: wd_outAmounts,
+      outPubkeys: wd_outPubkeys,
+      outBlindings: wd_outBlindings,
+      fee: String(fee ?? 0n),
+      relayer: String(relayer ?? 0n)
+    }]
+  };
+  return publishIntent({
+    type: "withdraw",
+    assetId: assetId.toString(),
+    amount: amount.toString(),
+    toAddress,
+    it,
+    ...it.domain,
+    withdraws: it.withdraws
+  });
+}
+function randU256() {
+  const b = crypto2.randomBytes(32);
+  return BigInt("0x" + Buffer.from(b).toString("hex"));
+}
+async function withdrawAuto({
+  store,
+  assetId,
+  amount,
+  toAddress,
+  allowPartial = false
+}) {
+  const assetIdBI = BigInt(assetId);
+  const spendable = store.listSpendable().filter((n) => String(n.assetId) === String(assetIdBI));
+  const signable = spendable.filter((n) => {
+    try {
+      const skU8 = asBytes(n.secret?.sk);
+      if (!skU8 || skU8.length !== 32) return false;
+      const A = eddsa2.prv2pub(Buffer.from(skU8));
+      const Ax = Fr2.toObject(A[0]).toString();
+      const Ay = Fr2.toObject(A[1]).toString();
+      return Ax === String(n.ownerPub.x) && Ay === String(n.ownerPub.y);
+    } catch {
+      return false;
+    }
+  });
+  if (!allowPartial) {
+    const total = signable.reduce((a, n) => a + BigInt(n.amount), 0n);
+    if (total < amount) throw new Error(`insufficient signable for asset=${assetIdBI} have=${total} need=${amount}`);
+  }
+  const picked = [];
+  for (let sum = 0n, i = 0; i < signable.length && sum < amount; i++) {
+    picked.push(signable[i]);
+    sum += BigInt(signable[i].amount);
+  }
+  if (picked.length > 1 && BigInt(picked[0].amount) >= amount) picked.splice(1);
+  await initPoseidon();
+  const pin = await fetchPinFromIndexer(INDEXER_URL, POOL);
+  const pinnedRootHex = pin.currentRoot;
+  console.log("[sdk] pinnedRootHex", pinnedRootHex);
+  const oldRoot = BigInt(pinnedRootHex);
+  const poolUint160 = BigInt(toUint160Dec(POOL));
+  const chainDec = BigInt(CHAIN_ID_DEC);
+  const domain = BigInt(DOMAIN_DEC);
+  const spends = await Promise.all(picked.map(async (note) => {
+    if (note.index == null) throw new Error(`note ${note.commitment} missing index`);
+    const pubHash = poseidonAxAy(note.ownerPub.x.toString(), note.ownerPub.y.toString());
+    const commitBI = BigInt(note.commitment);
+    const skU8 = asBytes(note.secret?.sk);
+    if (!skU8 || skU8.length !== 32) throw new Error(`note ${note.commitment}: invalid sk`);
+    const prvSeedHex = toSeedHex(skU8);
+    const blU8 = asBytes(note.secret?.blind);
+    if (!blU8) throw new Error(`note ${note.commitment}: missing blinding`);
+    const blBI = BigInt("0x" + Buffer.from(blU8).toString("hex"));
+    const pkBI = bi(pubHash.toString());
+    const commitLocal = noteCommit(bi(note.assetId), bi(note.amount), pkBI, blBI);
+    if (commitLocal !== commitBI) throw new Error(`commit rebuild mismatch ${note.commitment}`);
+    const M = msgHash(domain, chainDec, poolUint160, commitBI, oldRoot);
+    const sig = signPoseidonCompat(prvSeedHex, M, note.ownerPub.x.toString(), note.ownerPub.y.toString());
+    if (!verifyPoseidonCompat(note.ownerPub.x.toString(), note.ownerPub.y.toString(), M, sig)) {
+      throw new Error(`signature verify failed ${note.commitment}`);
+    }
+    const { pathElements, pathIndex } = await fetchProof(Number(note.index), pinnedRootHex);
+    let acc = commitLocal;
+    for (let d = 0; d < TREE_DEPTH; d++) {
+      const sib = bi(pathElements[d]), bit = bi(pathIndex[d]);
+      acc = bit === 0n ? H2(acc, sib) : H2(sib, acc);
+    }
+    if (acc !== oldRoot) {
+      throw new Error(`walk != pinned root (idx=${note.index}) old=${pinnedRootHex} got=0x${acc.toString(16)}`);
+    }
+    return {
+      notePubkey: BigInt(pubHash.toString()),
+      Ax: note.ownerPub.x,
+      Ay: note.ownerPub.y,
+      R8x: BigInt(sig.R8x),
+      R8y: BigInt(sig.R8y),
+      S: BigInt(sig.S),
+      commit: commitBI,
+      index: BigInt(note.index),
+      assetId: BigInt(note.assetId),
+      amount: BigInt(note.amount),
+      blinding: blBI,
+      sk: BigInt("0x" + Buffer.from(skU8).toString("hex")),
+      pathElements,
+      pathIndex
+    };
+  }));
+  const primary = picked[0];
+  const pkHash = poseidonAxAy(primary.ownerPub.x.toString(), primary.ownerPub.y.toString());
+  const inAmt = BigInt(primary.amount);
+  const fee = 0n;
+  const changeAmt = inAmt - amount - fee;
+  if (changeAmt < 0n) throw new Error(`withdraw > note amount (have ${inAmt}, need ${amount}+${fee})`);
+  const out0 = {
+    // change
+    assetId: BigInt(primary.assetId),
+    amount: changeAmt,
+    pubkey: BigInt(pkHash.toString()),
+    blinding: randU256()
+  };
+  const out1 = {
+    // dummy
+    assetId: BigInt(primary.assetId),
+    amount: 0n,
+    pubkey: BigInt(pkHash.toString()),
+    blinding: randU256()
+  };
+  for (const s of spends) {
+    try {
+      const nf = await computeNullifierExact({ commit: s.commit, index: s.index, sk: s.sk });
+      await store.markPending("0x" + nf.toString(16).padStart(64, "0"));
+    } catch {
+    }
+  }
+  return withdraw({
+    assetId: assetIdBI,
+    amount,
+    // becomes wd_extAmount at prover
+    toAddress,
+    spends,
+    out0,
+    out1,
+    fee,
+    relayer: 0n
+  });
+}
+
+// src/exchange/depositERC20.ts
+import { erc20Abi } from "viem";
+
+// src/lib/consts/poolAbi.ts
+import { getAbiItem } from "viem";
+var PrivatePoolAbi = [{ "type": "constructor", "inputs": [{ "name": "batch", "type": "address", "internalType": "contract IVerifier" }, { "name": "domainDec", "type": "uint256", "internalType": "uint256" }], "stateMutability": "nonpayable" }, { "type": "receive", "stateMutability": "payable" }, { "type": "function", "name": "BATCH_ACTIONS_VERIFIER", "inputs": [], "outputs": [{ "name": "", "type": "address", "internalType": "contract IVerifier" }], "stateMutability": "view" }, { "type": "function", "name": "BATCH_MINT", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "DOMAIN", "inputs": [], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "FR", "inputs": [], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "HYPE_ASSET_ID", "inputs": [], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "LEVELS", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "MAXL", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "MAX_NF", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "MAX_OPS", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "N_CO", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "N_IT", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "N_WD", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "ROOT_HISTORY", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "TAIL_RING", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "applyBatchActions", "inputs": [{ "name": "a", "type": "uint256[2]", "internalType": "uint256[2]" }, { "name": "b", "type": "uint256[2][2]", "internalType": "uint256[2][2]" }, { "name": "c", "type": "uint256[2]", "internalType": "uint256[2]" }, { "name": "pub", "type": "uint256[10]", "internalType": "uint256[10]" }, { "name": "ops", "type": "tuple[]", "internalType": "struct PrivatePoolV3.ExtOp[]", "components": [{ "name": "kind", "type": "uint8", "internalType": "uint8" }, { "name": "assetId", "type": "uint256", "internalType": "uint256" }, { "name": "to", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" }] }, { "name": "nfs", "type": "bytes32[]", "internalType": "bytes32[]" }, { "name": "leaves", "type": "uint256[]", "internalType": "uint256[]" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "cancelOwnershipHandover", "inputs": [], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "completeOwnershipHandover", "inputs": [{ "name": "pendingOwner", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "currentRoot", "inputs": [], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "depAppliedHash", "inputs": [], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "depAppliedLen", "inputs": [], "outputs": [{ "name": "", "type": "uint64", "internalType": "uint64" }], "stateMutability": "view" }, { "type": "function", "name": "depEnqHash", "inputs": [], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "depEnqLen", "inputs": [], "outputs": [{ "name": "", "type": "uint64", "internalType": "uint64" }], "stateMutability": "view" }, { "type": "function", "name": "depositERC20", "inputs": [{ "name": "assetId", "type": "uint256", "internalType": "uint256" }, { "name": "amount", "type": "uint256", "internalType": "uint256" }, { "name": "commitment", "type": "uint256", "internalType": "uint256" }, { "name": "token", "type": "address", "internalType": "address" }, { "name": "sys", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "depositHYPE", "inputs": [{ "name": "commitment", "type": "uint256", "internalType": "uint256" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "frontier", "inputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "initZeros", "inputs": [{ "name": "z", "type": "uint256[]", "internalType": "uint256[]" }], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", "name": "isKnownRoot", "inputs": [{ "name": "r", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "bool", "internalType": "bool" }], "stateMutability": "view" }, { "type": "function", "name": "nextIndex", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "owner", "inputs": [], "outputs": [{ "name": "result", "type": "address", "internalType": "address" }], "stateMutability": "view" }, { "type": "function", "name": "ownershipHandoverExpiresAt", "inputs": [{ "name": "pendingOwner", "type": "address", "internalType": "address" }], "outputs": [{ "name": "result", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "poolBalance", "inputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "renounceOwnership", "inputs": [], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "requestOwnershipHandover", "inputs": [], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "rootIndex", "inputs": [], "outputs": [{ "name": "", "type": "uint32", "internalType": "uint32" }], "stateMutability": "view" }, { "type": "function", "name": "roots", "inputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "tailWindow", "inputs": [], "outputs": [{ "name": "hashes", "type": "uint256[]", "internalType": "uint256[]" }, { "name": "lens", "type": "uint64[]", "internalType": "uint64[]" }], "stateMutability": "view" }, { "type": "function", "name": "transferOwnership", "inputs": [{ "name": "newOwner", "type": "address", "internalType": "address" }], "outputs": [], "stateMutability": "payable" }, { "type": "function", "name": "zeros", "inputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }], "stateMutability": "view" }, { "type": "function", "name": "zerosInit", "inputs": [], "outputs": [{ "name": "", "type": "bool", "internalType": "bool" }], "stateMutability": "view" }, { "type": "event", "name": "BatchApplied", "inputs": [{ "name": "oldRoot", "type": "uint256", "indexed": false, "internalType": "uint256" }, { "name": "newRoot", "type": "uint256", "indexed": false, "internalType": "uint256" }, { "name": "oldAppliedLen", "type": "uint64", "indexed": false, "internalType": "uint64" }, { "name": "newAppliedLen", "type": "uint64", "indexed": false, "internalType": "uint64" }, { "name": "oldNextIndex", "type": "uint32", "indexed": false, "internalType": "uint32" }, { "name": "newNextIndex", "type": "uint32", "indexed": false, "internalType": "uint32" }, { "name": "opsCount", "type": "uint256", "indexed": false, "internalType": "uint256" }, { "name": "nfCount", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "event", "name": "Deposit", "inputs": [{ "name": "from", "type": "address", "indexed": true, "internalType": "address" }, { "name": "assetId", "type": "uint256", "indexed": true, "internalType": "uint256" }, { "name": "amount", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "event", "name": "DepositEnqueued", "inputs": [{ "name": "idx", "type": "uint64", "indexed": false, "internalType": "uint64" }, { "name": "from", "type": "address", "indexed": true, "internalType": "address" }, { "name": "assetId", "type": "uint256", "indexed": true, "internalType": "uint256" }, { "name": "amount", "type": "uint256", "indexed": false, "internalType": "uint256" }, { "name": "commitment", "type": "uint256", "indexed": false, "internalType": "uint256" }, { "name": "hItem", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "event", "name": "ExternalOpExecuted", "inputs": [{ "name": "kind", "type": "uint8", "indexed": false, "internalType": "uint8" }, { "name": "assetId", "type": "uint256", "indexed": true, "internalType": "uint256" }, { "name": "to", "type": "address", "indexed": true, "internalType": "address" }, { "name": "amount", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "event", "name": "LeavesInserted", "inputs": [{ "name": "startIndex", "type": "uint32", "indexed": false, "internalType": "uint32" }, { "name": "leaves", "type": "uint256[]", "indexed": false, "internalType": "uint256[]" }], "anonymous": false }, { "type": "event", "name": "NewRoot", "inputs": [{ "name": "root", "type": "uint256", "indexed": false, "internalType": "uint256" }], "anonymous": false }, { "type": "event", "name": "OwnershipHandoverCanceled", "inputs": [{ "name": "pendingOwner", "type": "address", "indexed": true, "internalType": "address" }], "anonymous": false }, { "type": "event", "name": "OwnershipHandoverRequested", "inputs": [{ "name": "pendingOwner", "type": "address", "indexed": true, "internalType": "address" }], "anonymous": false }, { "type": "event", "name": "OwnershipTransferred", "inputs": [{ "name": "oldOwner", "type": "address", "indexed": true, "internalType": "address" }, { "name": "newOwner", "type": "address", "indexed": true, "internalType": "address" }], "anonymous": false }, { "type": "event", "name": "Spent", "inputs": [{ "name": "nf", "type": "bytes32", "indexed": false, "internalType": "bytes32" }], "anonymous": false }, { "type": "error", "name": "AlreadyInitialized", "inputs": [] }, { "type": "error", "name": "BadZeros", "inputs": [] }, { "type": "error", "name": "InsufficientPoolBalance", "inputs": [] }, { "type": "error", "name": "InvalidAsset", "inputs": [] }, { "type": "error", "name": "LeavesIdxMismatch", "inputs": [] }, { "type": "error", "name": "LeavesLenMismatch", "inputs": [] }, { "type": "error", "name": "LeavesRootMismatch", "inputs": [] }, { "type": "error", "name": "NewOwnerIsZeroAddress", "inputs": [] }, { "type": "error", "name": "NfHashMismatch", "inputs": [] }, { "type": "error", "name": "NoHandoverRequest", "inputs": [] }, { "type": "error", "name": "NotInitialized", "inputs": [] }, { "type": "error", "name": "OldIndexMismatch", "inputs": [] }, { "type": "error", "name": "OpsHashMismatch", "inputs": [] }, { "type": "error", "name": "QueueHeadMismatch", "inputs": [] }, { "type": "error", "name": "QueueTailMismatch", "inputs": [] }, { "type": "error", "name": "Reentrancy", "inputs": [] }, { "type": "error", "name": "Unauthorized", "inputs": [] }, { "type": "error", "name": "UnknownOpKind", "inputs": [] }, { "type": "error", "name": "UnknownRoot", "inputs": [] }, { "type": "error", "name": "VerifyFail", "inputs": [] }, { "type": "error", "name": "ZeroAmount", "inputs": [] }, { "type": "error", "name": "ZeroCommitment", "inputs": [] }];
+var EV_NewRoot = getAbiItem({ abi: PrivatePoolAbi, name: "NewRoot" });
+var EV_LeavesInserted = getAbiItem({ abi: PrivatePoolAbi, name: "LeavesInserted" });
+var EV_Spent = getAbiItem({ abi: PrivatePoolAbi, name: "Spent" });
+
+// src/exchange/depositERC20.ts
+function sysAddressFromAssetId(assetId) {
+  const val = 0x20n << 152n | assetId;
+  return `0x${val.toString(16).padStart(40, "0")}`;
+}
+async function depositERC20({
+  clients,
+  pool,
+  chainId,
+  token,
+  assetId,
+  amount,
+  seed,
+  sysAddress,
+  store
+}) {
+  await initPoseidon();
+  const { sk, skBytes, Ax, Ay, pubkey, blinding } = await genNote(seed);
+  const { commitment } = makeDepositCommitments(assetId, amount, pubkey, blinding);
+  const sys = sysAddress ?? sysAddressFromAssetId(assetId);
+  const { publicClient, walletClient, account } = clients;
+  const allowance = await publicClient.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [account.address, pool]
+  });
+  if (allowance < amount) {
+    const { request: request2 } = await publicClient.simulateContract({
+      address: token,
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [pool, amount],
+      account
+    });
+    const h = await walletClient.writeContract(request2);
+    await publicClient.waitForTransactionReceipt({ hash: h });
+  }
+  const { request } = await publicClient.simulateContract({
+    address: pool,
+    abi: PrivatePoolAbi,
+    functionName: "depositERC20",
+    args: [assetId, amount, commitment, token, sys],
+    account
+  });
+  const hash = await walletClient.writeContract(request);
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  const note = {
+    version: 1,
+    commitment: `0x${BigInt(commitment).toString(16).padStart(64, "0")}`,
+    chainId,
+    pool,
+    assetId,
+    amount,
+    ownerPub: { x: BigInt(Ax), y: BigInt(Ay) },
+    notePubkey: BigInt(pubkey),
+    secret: {
+      sk: skBytes,
+      blind: (() => {
+        const hex = BigInt(blinding).toString(16).padStart(64, "0");
+        return Uint8Array.from(Buffer.from(hex, "hex"));
+      })()
+    },
+    status: "STAGED",
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  };
+  if (store) await store.addStagedNotes([note]);
+  return { hash, receipt, note };
+}
+
+// src/exchange/depositHYPE.ts
+var HYPE_ASSET_ID = 150n;
+async function depositHYPE({
+  clients,
+  pool,
+  chainId,
+  amountWei,
+  seed,
+  store
+}) {
+  await initPoseidon();
+  const { sk, skBytes, Ax, Ay, pubkey, blinding } = await genNote(seed);
+  const { commitment } = makeDepositCommitments(HYPE_ASSET_ID, amountWei, pubkey, blinding);
+  const { publicClient, walletClient, account } = clients;
+  const { request } = await publicClient.simulateContract({
+    address: pool,
+    abi: PrivatePoolAbi,
+    functionName: "depositHYPE",
+    args: [commitment],
+    value: amountWei,
+    account
+  });
+  const hash = await walletClient.writeContract(request);
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  const note = {
+    version: 1,
+    commitment: `0x${BigInt(commitment).toString(16).padStart(64, "0")}`,
+    chainId,
+    pool,
+    assetId: HYPE_ASSET_ID,
+    amount: amountWei,
+    ownerPub: { x: BigInt(Ax), y: BigInt(Ay) },
+    notePubkey: BigInt(pubkey),
+    secret: {
+      sk: skBytes,
+      blind: (() => {
+        const hex = BigInt(blinding).toString(16).padStart(64, "0");
+        return Uint8Array.from(Buffer.from(hex, "hex"));
+      })()
+    },
+    status: "STAGED",
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  };
+  if (store) await store.addStagedNotes([note]);
+  return { hash, receipt, note };
+}
+
+// node_modules/@noble/ciphers/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abool(b) {
+  if (typeof b !== "boolean")
+    throw new Error(`boolean expected, not ${b}`);
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+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(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+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);
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  else if (isBytes(data))
+    data = copyBytes(data);
+  else
+    throw new Error("Uint8Array expected, got " + typeof data);
+  return data;
+}
+function checkOpts(defaults, opts) {
+  if (opts == null || typeof opts !== "object")
+    throw new Error("options must be defined");
+  const merged = Object.assign(defaults, opts);
+  return merged;
+}
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+var wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, constructor) => {
+  function wrappedCipher(key, ...args) {
+    abytes(key);
+    if (!isLE)
+      throw new Error("Non little-endian hardware is not yet supported");
+    if (params.nonceLength !== void 0) {
+      const nonce = args[0];
+      if (!nonce)
+        throw new Error("nonce / iv required");
+      if (params.varSizeNonce)
+        abytes(nonce);
+      else
+        abytes(nonce, params.nonceLength);
+    }
+    const tagl = params.tagLength;
+    if (tagl && args[1] !== void 0) {
+      abytes(args[1]);
+    }
+    const cipher = constructor(key, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== void 0) {
+        if (fnLength !== 2)
+          throw new Error("cipher output not supported");
+        abytes(output);
+      }
+    };
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        called = true;
+        abytes(data);
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes(data);
+        if (tagl && data.length < tagl)
+          throw new Error("invalid ciphertext length: smaller than tagLength=" + tagl);
+        checkOutput(cipher.decrypt.length, output);
+        return cipher.decrypt(data, output);
+      }
+    };
+    return wrCipher;
+  }
+  Object.assign(wrappedCipher, params);
+  return wrappedCipher;
+};
+function getOutput(expectedLength, out, onlyAligned = true) {
+  if (out === void 0)
+    return new Uint8Array(expectedLength);
+  if (out.length !== expectedLength)
+    throw new Error("invalid output length, expected " + expectedLength + ", got: " + out.length);
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
+}
+function setBigUint64(view, byteOffset, value, isLE3) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE3);
+  const _32n2 = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n2 & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE3 ? 4 : 0;
+  const l = isLE3 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE3);
+  view.setUint32(byteOffset + l, wl, isLE3);
+}
+function u64Lengths(dataLength, aadLength, isLE3) {
+  abool(isLE3);
+  const num = new Uint8Array(16);
+  const view = createView(num);
+  setBigUint64(view, 0, BigInt(aadLength), isLE3);
+  setBigUint64(view, 8, BigInt(dataLength), isLE3);
+  return num;
+}
+function isAligned32(bytes) {
+  return bytes.byteOffset % 4 === 0;
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(bytes);
+}
+
+// node_modules/@noble/ciphers/esm/_arx.js
+var _utf8ToBytes = (str) => Uint8Array.from(str.split("").map((c) => c.charCodeAt(0)));
+var sigma16 = _utf8ToBytes("expand 16-byte k");
+var sigma32 = _utf8ToBytes("expand 32-byte k");
+var sigma16_32 = u32(sigma16);
+var sigma32_32 = u32(sigma32);
+function rotl(a, b) {
+  return a << b | a >>> 32 - b;
+}
+function isAligned322(b) {
+  return b.byteOffset % 4 === 0;
+}
+var BLOCK_LEN = 64;
+var BLOCK_LEN32 = 16;
+var MAX_COUNTER = 2 ** 32 - 1;
+var U32_EMPTY = new Uint32Array();
+function runCipher(core, sigma, key, nonce, data, output, counter, rounds) {
+  const len = data.length;
+  const block2 = new Uint8Array(BLOCK_LEN);
+  const b32 = u32(block2);
+  const isAligned = isAligned322(data) && isAligned322(output);
+  const d32 = isAligned ? u32(data) : U32_EMPTY;
+  const o32 = isAligned ? u32(output) : U32_EMPTY;
+  for (let pos = 0; pos < len; counter++) {
+    core(sigma, key, nonce, b32, counter, rounds);
+    if (counter >= MAX_COUNTER)
+      throw new Error("arx: counter overflow");
+    const take = Math.min(BLOCK_LEN, len - pos);
+    if (isAligned && take === BLOCK_LEN) {
+      const pos32 = pos / 4;
+      if (pos % 4 !== 0)
+        throw new Error("arx: invalid block position");
+      for (let j = 0, posj; j < BLOCK_LEN32; j++) {
+        posj = pos32 + j;
+        o32[posj] = d32[posj] ^ b32[j];
+      }
+      pos += BLOCK_LEN;
+      continue;
+    }
+    for (let j = 0, posj; j < take; j++) {
+      posj = pos + j;
+      output[posj] = data[posj] ^ block2[j];
+    }
+    pos += take;
+  }
+}
+function createCipher(core, opts) {
+  const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts({ allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 }, opts);
+  if (typeof core !== "function")
+    throw new Error("core must be a function");
+  anumber(counterLength);
+  anumber(rounds);
+  abool(counterRight);
+  abool(allowShortKeys);
+  return (key, nonce, data, output, counter = 0) => {
+    abytes(key);
+    abytes(nonce);
+    abytes(data);
+    const len = data.length;
+    if (output === void 0)
+      output = new Uint8Array(len);
+    abytes(output);
+    anumber(counter);
+    if (counter < 0 || counter >= MAX_COUNTER)
+      throw new Error("arx: counter overflow");
+    if (output.length < len)
+      throw new Error(`arx: output (${output.length}) is shorter than data (${len})`);
+    const toClean = [];
+    let l = key.length;
+    let k;
+    let sigma;
+    if (l === 32) {
+      toClean.push(k = copyBytes(key));
+      sigma = sigma32_32;
+    } else if (l === 16 && allowShortKeys) {
+      k = new Uint8Array(32);
+      k.set(key);
+      k.set(key, 16);
+      sigma = sigma16_32;
+      toClean.push(k);
+    } else {
+      throw new Error(`arx: invalid 32-byte key, got length=${l}`);
+    }
+    if (!isAligned322(nonce))
+      toClean.push(nonce = copyBytes(nonce));
+    const k32 = u32(k);
+    if (extendNonceFn) {
+      if (nonce.length !== 24)
+        throw new Error(`arx: extended nonce must be 24 bytes`);
+      extendNonceFn(sigma, k32, u32(nonce.subarray(0, 16)), k32);
+      nonce = nonce.subarray(16);
+    }
+    const nonceNcLen = 16 - counterLength;
+    if (nonceNcLen !== nonce.length)
+      throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);
+    if (nonceNcLen !== 12) {
+      const nc2 = new Uint8Array(12);
+      nc2.set(nonce, counterRight ? 0 : 12 - nonce.length);
+      nonce = nc2;
+      toClean.push(nonce);
+    }
+    const n32 = u32(nonce);
+    runCipher(core, sigma, k32, n32, data, output, counter, rounds);
+    clean(...toClean);
+    return output;
+  };
+}
+
+// node_modules/@noble/ciphers/esm/_poly1305.js
+var u8to16 = (a, i) => a[i++] & 255 | (a[i++] & 255) << 8;
+var Poly1305 = class {
+  constructor(key) {
+    this.blockLen = 16;
+    this.outputLen = 16;
+    this.buffer = new Uint8Array(16);
+    this.r = new Uint16Array(10);
+    this.h = new Uint16Array(10);
+    this.pad = new Uint16Array(8);
+    this.pos = 0;
+    this.finished = false;
+    key = toBytes(key);
+    abytes(key, 32);
+    const t0 = u8to16(key, 0);
+    const t1 = u8to16(key, 2);
+    const t2 = u8to16(key, 4);
+    const t3 = u8to16(key, 6);
+    const t4 = u8to16(key, 8);
+    const t5 = u8to16(key, 10);
+    const t6 = u8to16(key, 12);
+    const t7 = u8to16(key, 14);
+    this.r[0] = t0 & 8191;
+    this.r[1] = (t0 >>> 13 | t1 << 3) & 8191;
+    this.r[2] = (t1 >>> 10 | t2 << 6) & 7939;
+    this.r[3] = (t2 >>> 7 | t3 << 9) & 8191;
+    this.r[4] = (t3 >>> 4 | t4 << 12) & 255;
+    this.r[5] = t4 >>> 1 & 8190;
+    this.r[6] = (t4 >>> 14 | t5 << 2) & 8191;
+    this.r[7] = (t5 >>> 11 | t6 << 5) & 8065;
+    this.r[8] = (t6 >>> 8 | t7 << 8) & 8191;
+    this.r[9] = t7 >>> 5 & 127;
+    for (let i = 0; i < 8; i++)
+      this.pad[i] = u8to16(key, 16 + 2 * i);
+  }
+  process(data, offset, isLast = false) {
+    const hibit = isLast ? 0 : 1 << 11;
+    const { h, r } = this;
+    const r0 = r[0];
+    const r1 = r[1];
+    const r2 = r[2];
+    const r3 = r[3];
+    const r4 = r[4];
+    const r5 = r[5];
+    const r6 = r[6];
+    const r7 = r[7];
+    const r8 = r[8];
+    const r9 = r[9];
+    const t0 = u8to16(data, offset + 0);
+    const t1 = u8to16(data, offset + 2);
+    const t2 = u8to16(data, offset + 4);
+    const t3 = u8to16(data, offset + 6);
+    const t4 = u8to16(data, offset + 8);
+    const t5 = u8to16(data, offset + 10);
+    const t6 = u8to16(data, offset + 12);
+    const t7 = u8to16(data, offset + 14);
+    let h0 = h[0] + (t0 & 8191);
+    let h1 = h[1] + ((t0 >>> 13 | t1 << 3) & 8191);
+    let h2 = h[2] + ((t1 >>> 10 | t2 << 6) & 8191);
+    let h3 = h[3] + ((t2 >>> 7 | t3 << 9) & 8191);
+    let h4 = h[4] + ((t3 >>> 4 | t4 << 12) & 8191);
+    let h5 = h[5] + (t4 >>> 1 & 8191);
+    let h6 = h[6] + ((t4 >>> 14 | t5 << 2) & 8191);
+    let h7 = h[7] + ((t5 >>> 11 | t6 << 5) & 8191);
+    let h8 = h[8] + ((t6 >>> 8 | t7 << 8) & 8191);
+    let h9 = h[9] + (t7 >>> 5 | hibit);
+    let c = 0;
+    let d0 = c + h0 * r0 + h1 * (5 * r9) + h2 * (5 * r8) + h3 * (5 * r7) + h4 * (5 * r6);
+    c = d0 >>> 13;
+    d0 &= 8191;
+    d0 += h5 * (5 * r5) + h6 * (5 * r4) + h7 * (5 * r3) + h8 * (5 * r2) + h9 * (5 * r1);
+    c += d0 >>> 13;
+    d0 &= 8191;
+    let d1 = c + h0 * r1 + h1 * r0 + h2 * (5 * r9) + h3 * (5 * r8) + h4 * (5 * r7);
+    c = d1 >>> 13;
+    d1 &= 8191;
+    d1 += h5 * (5 * r6) + h6 * (5 * r5) + h7 * (5 * r4) + h8 * (5 * r3) + h9 * (5 * r2);
+    c += d1 >>> 13;
+    d1 &= 8191;
+    let d2 = c + h0 * r2 + h1 * r1 + h2 * r0 + h3 * (5 * r9) + h4 * (5 * r8);
+    c = d2 >>> 13;
+    d2 &= 8191;
+    d2 += h5 * (5 * r7) + h6 * (5 * r6) + h7 * (5 * r5) + h8 * (5 * r4) + h9 * (5 * r3);
+    c += d2 >>> 13;
+    d2 &= 8191;
+    let d3 = c + h0 * r3 + h1 * r2 + h2 * r1 + h3 * r0 + h4 * (5 * r9);
+    c = d3 >>> 13;
+    d3 &= 8191;
+    d3 += h5 * (5 * r8) + h6 * (5 * r7) + h7 * (5 * r6) + h8 * (5 * r5) + h9 * (5 * r4);
+    c += d3 >>> 13;
+    d3 &= 8191;
+    let d4 = c + h0 * r4 + h1 * r3 + h2 * r2 + h3 * r1 + h4 * r0;
+    c = d4 >>> 13;
+    d4 &= 8191;
+    d4 += h5 * (5 * r9) + h6 * (5 * r8) + h7 * (5 * r7) + h8 * (5 * r6) + h9 * (5 * r5);
+    c += d4 >>> 13;
+    d4 &= 8191;
+    let d5 = c + h0 * r5 + h1 * r4 + h2 * r3 + h3 * r2 + h4 * r1;
+    c = d5 >>> 13;
+    d5 &= 8191;
+    d5 += h5 * r0 + h6 * (5 * r9) + h7 * (5 * r8) + h8 * (5 * r7) + h9 * (5 * r6);
+    c += d5 >>> 13;
+    d5 &= 8191;
+    let d6 = c + h0 * r6 + h1 * r5 + h2 * r4 + h3 * r3 + h4 * r2;
+    c = d6 >>> 13;
+    d6 &= 8191;
+    d6 += h5 * r1 + h6 * r0 + h7 * (5 * r9) + h8 * (5 * r8) + h9 * (5 * r7);
+    c += d6 >>> 13;
+    d6 &= 8191;
+    let d7 = c + h0 * r7 + h1 * r6 + h2 * r5 + h3 * r4 + h4 * r3;
+    c = d7 >>> 13;
+    d7 &= 8191;
+    d7 += h5 * r2 + h6 * r1 + h7 * r0 + h8 * (5 * r9) + h9 * (5 * r8);
+    c += d7 >>> 13;
+    d7 &= 8191;
+    let d8 = c + h0 * r8 + h1 * r7 + h2 * r6 + h3 * r5 + h4 * r4;
+    c = d8 >>> 13;
+    d8 &= 8191;
+    d8 += h5 * r3 + h6 * r2 + h7 * r1 + h8 * r0 + h9 * (5 * r9);
+    c += d8 >>> 13;
+    d8 &= 8191;
+    let d9 = c + h0 * r9 + h1 * r8 + h2 * r7 + h3 * r6 + h4 * r5;
+    c = d9 >>> 13;
+    d9 &= 8191;
+    d9 += h5 * r4 + h6 * r3 + h7 * r2 + h8 * r1 + h9 * r0;
+    c += d9 >>> 13;
+    d9 &= 8191;
+    c = (c << 2) + c | 0;
+    c = c + d0 | 0;
+    d0 = c & 8191;
+    c = c >>> 13;
+    d1 += c;
+    h[0] = d0;
+    h[1] = d1;
+    h[2] = d2;
+    h[3] = d3;
+    h[4] = d4;
+    h[5] = d5;
+    h[6] = d6;
+    h[7] = d7;
+    h[8] = d8;
+    h[9] = d9;
+  }
+  finalize() {
+    const { h, pad } = this;
+    const g = new Uint16Array(10);
+    let c = h[1] >>> 13;
+    h[1] &= 8191;
+    for (let i = 2; i < 10; i++) {
+      h[i] += c;
+      c = h[i] >>> 13;
+      h[i] &= 8191;
+    }
+    h[0] += c * 5;
+    c = h[0] >>> 13;
+    h[0] &= 8191;
+    h[1] += c;
+    c = h[1] >>> 13;
+    h[1] &= 8191;
+    h[2] += c;
+    g[0] = h[0] + 5;
+    c = g[0] >>> 13;
+    g[0] &= 8191;
+    for (let i = 1; i < 10; i++) {
+      g[i] = h[i] + c;
+      c = g[i] >>> 13;
+      g[i] &= 8191;
+    }
+    g[9] -= 1 << 13;
+    let mask = (c ^ 1) - 1;
+    for (let i = 0; i < 10; i++)
+      g[i] &= mask;
+    mask = ~mask;
+    for (let i = 0; i < 10; i++)
+      h[i] = h[i] & mask | g[i];
+    h[0] = (h[0] | h[1] << 13) & 65535;
+    h[1] = (h[1] >>> 3 | h[2] << 10) & 65535;
+    h[2] = (h[2] >>> 6 | h[3] << 7) & 65535;
+    h[3] = (h[3] >>> 9 | h[4] << 4) & 65535;
+    h[4] = (h[4] >>> 12 | h[5] << 1 | h[6] << 14) & 65535;
+    h[5] = (h[6] >>> 2 | h[7] << 11) & 65535;
+    h[6] = (h[7] >>> 5 | h[8] << 8) & 65535;
+    h[7] = (h[8] >>> 8 | h[9] << 5) & 65535;
+    let f = h[0] + pad[0];
+    h[0] = f & 65535;
+    for (let i = 1; i < 8; i++) {
+      f = (h[i] + pad[i] | 0) + (f >>> 16) | 0;
+      h[i] = f & 65535;
+    }
+    clean(g);
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes(data);
+    abytes(data);
+    const { 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) {
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(data, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(buffer, 0, false);
+        this.pos = 0;
+      }
+    }
+    return this;
+  }
+  destroy() {
+    clean(this.h, this.r, this.buffer, this.pad);
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, h } = this;
+    let { pos } = this;
+    if (pos) {
+      buffer[pos++] = 1;
+      for (; pos < 16; pos++)
+        buffer[pos] = 0;
+      this.process(buffer, 0, true);
+    }
+    this.finalize();
+    let opos = 0;
+    for (let i = 0; i < 8; i++) {
+      out[opos++] = h[i] >>> 0;
+      out[opos++] = h[i] >>> 8;
+    }
+    return out;
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+};
+function wrapConstructorWithKey(hashCons) {
+  const hashC = (msg, key) => hashCons(key).update(toBytes(msg)).digest();
+  const tmp = hashCons(new Uint8Array(32));
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (key) => hashCons(key);
+  return hashC;
+}
+var poly1305 = wrapConstructorWithKey((key) => new Poly1305(key));
+
+// node_modules/@noble/ciphers/esm/chacha.js
+function chachaCore(s, k, n, out, cnt, rounds = 20) {
+  let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2];
+  let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
+  for (let r = 0; r < rounds; r += 2) {
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 16);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 12);
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 8);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 7);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 16);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 12);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 8);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 7);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 16);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 12);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 8);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 7);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 16);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 12);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 8);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 7);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 16);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 12);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 8);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 7);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 16);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 12);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 8);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 7);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 16);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 12);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 8);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 7);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 16);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 12);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 8);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 7);
+  }
+  let oi = 0;
+  out[oi++] = y00 + x00 | 0;
+  out[oi++] = y01 + x01 | 0;
+  out[oi++] = y02 + x02 | 0;
+  out[oi++] = y03 + x03 | 0;
+  out[oi++] = y04 + x04 | 0;
+  out[oi++] = y05 + x05 | 0;
+  out[oi++] = y06 + x06 | 0;
+  out[oi++] = y07 + x07 | 0;
+  out[oi++] = y08 + x08 | 0;
+  out[oi++] = y09 + x09 | 0;
+  out[oi++] = y10 + x10 | 0;
+  out[oi++] = y11 + x11 | 0;
+  out[oi++] = y12 + x12 | 0;
+  out[oi++] = y13 + x13 | 0;
+  out[oi++] = y14 + x14 | 0;
+  out[oi++] = y15 + x15 | 0;
+}
+function hchacha(s, k, i, o32) {
+  let x00 = s[0], x01 = s[1], x02 = s[2], x03 = s[3], x04 = k[0], x05 = k[1], x06 = k[2], x07 = k[3], x08 = k[4], x09 = k[5], x10 = k[6], x11 = k[7], x12 = i[0], x13 = i[1], x14 = i[2], x15 = i[3];
+  for (let r = 0; r < 20; r += 2) {
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 16);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 12);
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 8);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 7);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 16);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 12);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 8);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 7);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 16);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 12);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 8);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 7);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 16);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 12);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 8);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 7);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 16);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 12);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 8);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 7);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 16);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 12);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 8);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 7);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 16);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 12);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 8);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 7);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 16);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 12);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 8);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 7);
+  }
+  let oi = 0;
+  o32[oi++] = x00;
+  o32[oi++] = x01;
+  o32[oi++] = x02;
+  o32[oi++] = x03;
+  o32[oi++] = x12;
+  o32[oi++] = x13;
+  o32[oi++] = x14;
+  o32[oi++] = x15;
+}
+var chacha20 = /* @__PURE__ */ createCipher(chachaCore, {
+  counterRight: false,
+  counterLength: 4,
+  allowShortKeys: false
+});
+var xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {
+  counterRight: false,
+  counterLength: 8,
+  extendNonceFn: hchacha,
+  allowShortKeys: false
+});
+var ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
+var updatePadded = (h, msg) => {
+  h.update(msg);
+  const left = msg.length % 16;
+  if (left)
+    h.update(ZEROS16.subarray(left));
+};
+var ZEROS32 = /* @__PURE__ */ new Uint8Array(32);
+function computeTag(fn, key, nonce, data, AAD) {
+  const authKey = fn(key, nonce, ZEROS32);
+  const h = poly1305.create(authKey);
+  if (AAD)
+    updatePadded(h, AAD);
+  updatePadded(h, data);
+  const num = u64Lengths(data.length, AAD ? AAD.length : 0, true);
+  h.update(num);
+  const res = h.digest();
+  clean(authKey, num);
+  return res;
+}
+var _poly1305_aead = (xorStream) => (key, nonce, AAD) => {
+  const tagLength = 16;
+  return {
+    encrypt(plaintext, output) {
+      const plength = plaintext.length;
+      output = getOutput(plength + tagLength, output, false);
+      output.set(plaintext);
+      const oPlain = output.subarray(0, -tagLength);
+      xorStream(key, nonce, oPlain, oPlain, 1);
+      const tag = computeTag(xorStream, key, nonce, oPlain, AAD);
+      output.set(tag, plength);
+      clean(tag);
+      return output;
+    },
+    decrypt(ciphertext, output) {
+      output = getOutput(ciphertext.length - tagLength, output, false);
+      const data = ciphertext.subarray(0, -tagLength);
+      const passedTag = ciphertext.subarray(-tagLength);
+      const tag = computeTag(xorStream, key, nonce, data, AAD);
+      if (!equalBytes(passedTag, tag))
+        throw new Error("invalid tag");
+      output.set(ciphertext.subarray(0, -tagLength));
+      xorStream(key, nonce, output, output, 1);
+      clean(tag);
+      return output;
+    }
+  };
+};
+var chacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 12, tagLength: 16 }, _poly1305_aead(chacha20));
+var xchacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 24, tagLength: 16 }, _poly1305_aead(xchacha20));
+
+// node_modules/@noble/hashes/esm/cryptoNode.js
+import * as nc from "crypto";
+var crypto3 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+
+// node_modules/@noble/hashes/esm/utils.js
+function isBytes2(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber2(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes2(b, ...lengths) {
+  if (!isBytes2(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists2(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 aoutput2(out, instance) {
+  abytes2(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u8(arr) {
+  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function u322(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean2(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView2(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+var isLE2 = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+var swap8IfBE = isLE2 ? (n) => n : (n) => byteSwap(n);
+function byteSwap32(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+var swap32IfBE = isLE2 ? (u) => u : byteSwap32;
+var hasHexBuiltin = /* @__PURE__ */ (() => (
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+))();
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  abytes2(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+function utf8ToBytes2(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes2(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes2(data);
+  abytes2(data);
+  return data;
+}
+function kdfInputToBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes2(data);
+  abytes2(data);
+  return data;
+}
+var Hash2 = class {
+};
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+function createOptHasher(hashCons) {
+  const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
+  const tmp = hashCons({});
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  return hashC;
+}
+function randomBytes(bytesLength = 32) {
+  if (crypto3 && typeof crypto3.getRandomValues === "function") {
+    return crypto3.getRandomValues(new Uint8Array(bytesLength));
+  }
+  if (crypto3 && typeof crypto3.randomBytes === "function") {
+    return Uint8Array.from(crypto3.randomBytes(bytesLength));
+  }
+  throw new Error("crypto.getRandomValues must be defined");
+}
+
+// node_modules/@noble/hashes/esm/_md.js
+function setBigUint642(view, byteOffset, value, isLE3) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE3);
+  const _32n2 = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n2 & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE3 ? 4 : 0;
+  const l = isLE3 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE3);
+  view.setUint32(byteOffset + l, wl, isLE3);
+}
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class extends Hash2 {
+  constructor(blockLen, outputLen, padOffset, isLE3) {
+    super();
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE3;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView2(this.buffer);
+  }
+  update(data) {
+    aexists2(this);
+    data = toBytes2(data);
+    abytes2(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 = createView2(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;
+  }
+  digestInto(out) {
+    aexists2(this);
+    aoutput2(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE: isLE3 } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean2(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;
+    setBigUint642(view, blockLen - 8, BigInt(this.length * 8), isLE3);
+    this.process(view, 0);
+    const oview = createView2(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should 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], isLE3);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    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();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// node_modules/@noble/hashes/esm/_u64.js
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+var _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 };
+}
+var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+var rotr32H = (_h, l) => l;
+var rotr32L = (h, _l) => h;
+function add(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+
+// node_modules/@noble/hashes/esm/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+  constructor(outputLen = 32) {
+    super(64, outputLen, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = SHA256_IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G: G2, H } = this;
+    return [A, B, C, D, E, F, G2, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G2, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G2 | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G: G2, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G2) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G2;
+      G2 = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G2 = G2 + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G2, H);
+  }
+  roundClean() {
+    clean2(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean2(this.buffer);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
+
+// node_modules/@noble/hashes/esm/sha256.js
+var sha2562 = sha256;
+
+// src/notes/vault.ts
+function u8ToB64(u82) {
+  if (typeof Buffer !== "undefined") return Buffer.from(u82).toString("base64");
+  let s = "";
+  for (let i = 0; i < u82.length; i++) s += String.fromCharCode(u82[i]);
+  return btoa(s);
+}
+function b64ToU8(b64) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(b64, "base64"));
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function replacer(_k, v) {
+  return typeof v === "bigint" ? `bn:${v.toString()}` : v;
+}
+function reviver(_k, v) {
+  return typeof v === "string" && v.startsWith("bn:") ? BigInt(v.slice(3)) : v;
+}
+function headerOrderA(h) {
+  const { v, createdAt, kdf, seq } = h;
+  const base = { v, createdAt, kdf, seq };
+  if ("prevHashHex" in h) base.prevHashHex = h.prevHashHex;
+  return base;
+}
+function headerOrderB(h) {
+  const { v, createdAt, kdf, seq } = h;
+  const base = { v, createdAt, seq, kdf };
+  if ("prevHashHex" in h) base.prevHashHex = h.prevHashHex;
+  return base;
+}
+function encAADBytes(h) {
+  return new TextEncoder().encode(JSON.stringify(h));
+}
+function encryptBlob(key, body, header) {
+  const plaintext = new TextEncoder().encode(JSON.stringify(body, replacer));
+  const headerBase = { ...header };
+  const hjson = JSON.stringify(headerBase);
+  const hashInput = new TextEncoder().encode(hjson + ":" + plaintext.length);
+  const seqHash = bytesToHex(sha2562(hashInput));
+  const storedHeader = { ...headerBase, prevHashHex: seqHash };
+  const aad = encAADBytes(storedHeader);
+  const nonce = randomBytes(24);
+  const aead = xchacha20poly1305(key, nonce);
+  const ciphertext = aead.encrypt(plaintext, void 0, aad);
+  return {
+    header: storedHeader,
+    nonceB64: u8ToB64(nonce),
+    ciphertextB64: u8ToB64(ciphertext)
+  };
+}
+function decryptBlob(key, blob) {
+  const nonce = b64ToU8(blob.nonceB64);
+  const ciphertext = b64ToU8(blob.ciphertextB64);
+  const tryWithHeader = (hdr) => {
+    try {
+      const aead = xchacha20poly1305(key, nonce);
+      const aad = encAADBytes(hdr);
+      return aead.decrypt(ciphertext, void 0, aad);
+    } catch {
+      return null;
+    }
+  };
+  const candidates = [];
+  candidates.push(blob.header);
+  candidates.push(headerOrderA(blob.header));
+  candidates.push(headerOrderB(blob.header));
+  if (blob.header.prevHashHex != null) {
+    const { prevHashHex, ...rest } = blob.header;
+    candidates.push(rest);
+    candidates.push(headerOrderA(rest));
+    candidates.push(headerOrderB(rest));
+  }
+  let plaintext = null;
+  for (const hdr of candidates) {
+    plaintext = tryWithHeader(hdr);
+    if (plaintext) break;
+  }
+  if (!plaintext) throw new Error("vault decrypt failed (invalid tag)");
+  return JSON.parse(new TextDecoder().decode(plaintext), reviver);
+}
+
+// node_modules/@noble/hashes/esm/_blake.js
+var BSIGMA = /* @__PURE__ */ Uint8Array.from([
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  14,
+  10,
+  4,
+  8,
+  9,
+  15,
+  13,
+  6,
+  1,
+  12,
+  0,
+  2,
+  11,
+  7,
+  5,
+  3,
+  11,
+  8,
+  12,
+  0,
+  5,
+  2,
+  15,
+  13,
+  10,
+  14,
+  3,
+  6,
+  7,
+  1,
+  9,
+  4,
+  7,
+  9,
+  3,
+  1,
+  13,
+  12,
+  11,
+  14,
+  2,
+  6,
+  5,
+  10,
+  4,
+  0,
+  15,
+  8,
+  9,
+  0,
+  5,
+  7,
+  2,
+  4,
+  10,
+  15,
+  14,
+  1,
+  11,
+  12,
+  6,
+  8,
+  3,
+  13,
+  2,
+  12,
+  6,
+  10,
+  0,
+  11,
+  8,
+  3,
+  4,
+  13,
+  7,
+  5,
+  15,
+  14,
+  1,
+  9,
+  12,
+  5,
+  1,
+  15,
+  14,
+  13,
+  4,
+  10,
+  0,
+  7,
+  6,
+  3,
+  9,
+  2,
+  8,
+  11,
+  13,
+  11,
+  7,
+  14,
+  12,
+  1,
+  3,
+  9,
+  5,
+  0,
+  15,
+  4,
+  8,
+  6,
+  2,
+  10,
+  6,
+  15,
+  14,
+  9,
+  11,
+  3,
+  0,
+  8,
+  12,
+  2,
+  13,
+  7,
+  1,
+  4,
+  10,
+  5,
+  10,
+  2,
+  8,
+  4,
+  7,
+  6,
+  1,
+  5,
+  15,
+  11,
+  9,
+  14,
+  3,
+  12,
+  13,
+  0,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  14,
+  10,
+  4,
+  8,
+  9,
+  15,
+  13,
+  6,
+  1,
+  12,
+  0,
+  2,
+  11,
+  7,
+  5,
+  3,
+  // Blake1, unused in others
+  11,
+  8,
+  12,
+  0,
+  5,
+  2,
+  15,
+  13,
+  10,
+  14,
+  3,
+  6,
+  7,
+  1,
+  9,
+  4,
+  7,
+  9,
+  3,
+  1,
+  13,
+  12,
+  11,
+  14,
+  2,
+  6,
+  5,
+  10,
+  4,
+  0,
+  15,
+  8,
+  9,
+  0,
+  5,
+  7,
+  2,
+  4,
+  10,
+  15,
+  14,
+  1,
+  11,
+  12,
+  6,
+  8,
+  3,
+  13,
+  2,
+  12,
+  6,
+  10,
+  0,
+  11,
+  8,
+  3,
+  4,
+  13,
+  7,
+  5,
+  15,
+  14,
+  1,
+  9
+]);
+
+// node_modules/@noble/hashes/esm/blake2.js
+var B2B_IV = /* @__PURE__ */ Uint32Array.from([
+  4089235720,
+  1779033703,
+  2227873595,
+  3144134277,
+  4271175723,
+  1013904242,
+  1595750129,
+  2773480762,
+  2917565137,
+  1359893119,
+  725511199,
+  2600822924,
+  4215389547,
+  528734635,
+  327033209,
+  1541459225
+]);
+var BBUF = /* @__PURE__ */ new Uint32Array(32);
+function G1b(a, b, c, d, msg, x) {
+  const Xl = msg[x], Xh = msg[x + 1];
+  let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1];
+  let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1];
+  let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1];
+  let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1];
+  let ll = add3L(Al, Bl, Xl);
+  Ah = add3H(ll, Ah, Bh, Xh);
+  Al = ll | 0;
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+  ({ Dh, Dl } = { Dh: rotr32H(Dh, Dl), Dl: rotr32L(Dh, Dl) });
+  ({ h: Ch, l: Cl } = add(Ch, Cl, Dh, Dl));
+  ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+  ({ Bh, Bl } = { Bh: rotrSH(Bh, Bl, 24), Bl: rotrSL(Bh, Bl, 24) });
+  BBUF[2 * a] = Al, BBUF[2 * a + 1] = Ah;
+  BBUF[2 * b] = Bl, BBUF[2 * b + 1] = Bh;
+  BBUF[2 * c] = Cl, BBUF[2 * c + 1] = Ch;
+  BBUF[2 * d] = Dl, BBUF[2 * d + 1] = Dh;
+}
+function G2b(a, b, c, d, msg, x) {
+  const Xl = msg[x], Xh = msg[x + 1];
+  let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1];
+  let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1];
+  let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1];
+  let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1];
+  let ll = add3L(Al, Bl, Xl);
+  Ah = add3H(ll, Ah, Bh, Xh);
+  Al = ll | 0;
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+  ({ Dh, Dl } = { Dh: rotrSH(Dh, Dl, 16), Dl: rotrSL(Dh, Dl, 16) });
+  ({ h: Ch, l: Cl } = add(Ch, Cl, Dh, Dl));
+  ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+  ({ Bh, Bl } = { Bh: rotrBH(Bh, Bl, 63), Bl: rotrBL(Bh, Bl, 63) });
+  BBUF[2 * a] = Al, BBUF[2 * a + 1] = Ah;
+  BBUF[2 * b] = Bl, BBUF[2 * b + 1] = Bh;
+  BBUF[2 * c] = Cl, BBUF[2 * c + 1] = Ch;
+  BBUF[2 * d] = Dl, BBUF[2 * d + 1] = Dh;
+}
+function checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {
+  anumber2(keyLen);
+  if (outputLen < 0 || outputLen > keyLen)
+    throw new Error("outputLen bigger than keyLen");
+  const { key, salt, personalization } = opts;
+  if (key !== void 0 && (key.length < 1 || key.length > keyLen))
+    throw new Error("key length must be undefined or 1.." + keyLen);
+  if (salt !== void 0 && salt.length !== saltLen)
+    throw new Error("salt must be undefined or " + saltLen);
+  if (personalization !== void 0 && personalization.length !== persLen)
+    throw new Error("personalization must be undefined or " + persLen);
+}
+var BLAKE2 = class extends Hash2 {
+  constructor(blockLen, outputLen) {
+    super();
+    this.finished = false;
+    this.destroyed = false;
+    this.length = 0;
+    this.pos = 0;
+    anumber2(blockLen);
+    anumber2(outputLen);
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.buffer = new Uint8Array(blockLen);
+    this.buffer32 = u322(this.buffer);
+  }
+  update(data) {
+    aexists2(this);
+    data = toBytes2(data);
+    abytes2(data);
+    const { blockLen, buffer, buffer32 } = this;
+    const len = data.length;
+    const offset = data.byteOffset;
+    const buf = data.buffer;
+    for (let pos = 0; pos < len; ) {
+      if (this.pos === blockLen) {
+        swap32IfBE(buffer32);
+        this.compress(buffer32, 0, false);
+        swap32IfBE(buffer32);
+        this.pos = 0;
+      }
+      const take = Math.min(blockLen - this.pos, len - pos);
+      const dataOffset = offset + pos;
+      if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+        const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+        swap32IfBE(data32);
+        for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+          this.length += blockLen;
+          this.compress(data32, pos32, false);
+        }
+        swap32IfBE(data32);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      this.length += take;
+      pos += take;
+    }
+    return this;
+  }
+  digestInto(out) {
+    aexists2(this);
+    aoutput2(out, this);
+    const { pos, buffer32 } = this;
+    this.finished = true;
+    clean2(this.buffer.subarray(pos));
+    swap32IfBE(buffer32);
+    this.compress(buffer32, 0, true);
+    swap32IfBE(buffer32);
+    const out32 = u322(out);
+    this.get().forEach((v, i) => out32[i] = swap8IfBE(v));
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    const { buffer, length, finished, destroyed, outputLen, pos } = this;
+    to || (to = new this.constructor({ dkLen: outputLen }));
+    to.set(...this.get());
+    to.buffer.set(buffer);
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    to.outputLen = outputLen;
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var BLAKE2b = class extends BLAKE2 {
+  constructor(opts = {}) {
+    const olen = opts.dkLen === void 0 ? 64 : opts.dkLen;
+    super(128, olen);
+    this.v0l = B2B_IV[0] | 0;
+    this.v0h = B2B_IV[1] | 0;
+    this.v1l = B2B_IV[2] | 0;
+    this.v1h = B2B_IV[3] | 0;
+    this.v2l = B2B_IV[4] | 0;
+    this.v2h = B2B_IV[5] | 0;
+    this.v3l = B2B_IV[6] | 0;
+    this.v3h = B2B_IV[7] | 0;
+    this.v4l = B2B_IV[8] | 0;
+    this.v4h = B2B_IV[9] | 0;
+    this.v5l = B2B_IV[10] | 0;
+    this.v5h = B2B_IV[11] | 0;
+    this.v6l = B2B_IV[12] | 0;
+    this.v6h = B2B_IV[13] | 0;
+    this.v7l = B2B_IV[14] | 0;
+    this.v7h = B2B_IV[15] | 0;
+    checkBlake2Opts(olen, opts, 64, 16, 16);
+    let { key, personalization, salt } = opts;
+    let keyLength = 0;
+    if (key !== void 0) {
+      key = toBytes2(key);
+      keyLength = key.length;
+    }
+    this.v0l ^= this.outputLen | keyLength << 8 | 1 << 16 | 1 << 24;
+    if (salt !== void 0) {
+      salt = toBytes2(salt);
+      const slt = u322(salt);
+      this.v4l ^= swap8IfBE(slt[0]);
+      this.v4h ^= swap8IfBE(slt[1]);
+      this.v5l ^= swap8IfBE(slt[2]);
+      this.v5h ^= swap8IfBE(slt[3]);
+    }
+    if (personalization !== void 0) {
+      personalization = toBytes2(personalization);
+      const pers = u322(personalization);
+      this.v6l ^= swap8IfBE(pers[0]);
+      this.v6h ^= swap8IfBE(pers[1]);
+      this.v7l ^= swap8IfBE(pers[2]);
+      this.v7h ^= swap8IfBE(pers[3]);
+    }
+    if (key !== void 0) {
+      const tmp = new Uint8Array(this.blockLen);
+      tmp.set(key);
+      this.update(tmp);
+    }
+  }
+  // prettier-ignore
+  get() {
+    let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+    return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
+  }
+  // prettier-ignore
+  set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
+    this.v0l = v0l | 0;
+    this.v0h = v0h | 0;
+    this.v1l = v1l | 0;
+    this.v1h = v1h | 0;
+    this.v2l = v2l | 0;
+    this.v2h = v2h | 0;
+    this.v3l = v3l | 0;
+    this.v3h = v3h | 0;
+    this.v4l = v4l | 0;
+    this.v4h = v4h | 0;
+    this.v5l = v5l | 0;
+    this.v5h = v5h | 0;
+    this.v6l = v6l | 0;
+    this.v6h = v6h | 0;
+    this.v7l = v7l | 0;
+    this.v7h = v7h | 0;
+  }
+  compress(msg, offset, isLast) {
+    this.get().forEach((v, i) => BBUF[i] = v);
+    BBUF.set(B2B_IV, 16);
+    let { h, l } = fromBig(BigInt(this.length));
+    BBUF[24] = B2B_IV[8] ^ l;
+    BBUF[25] = B2B_IV[9] ^ h;
+    if (isLast) {
+      BBUF[28] = ~BBUF[28];
+      BBUF[29] = ~BBUF[29];
+    }
+    let j = 0;
+    const s = BSIGMA;
+    for (let i = 0; i < 12; i++) {
+      G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+      G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+      G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+      G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+      G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+      G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+      G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+      G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+      G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+      G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+      G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+      G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+      G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+      G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+      G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+      G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+    }
+    this.v0l ^= BBUF[0] ^ BBUF[16];
+    this.v0h ^= BBUF[1] ^ BBUF[17];
+    this.v1l ^= BBUF[2] ^ BBUF[18];
+    this.v1h ^= BBUF[3] ^ BBUF[19];
+    this.v2l ^= BBUF[4] ^ BBUF[20];
+    this.v2h ^= BBUF[5] ^ BBUF[21];
+    this.v3l ^= BBUF[6] ^ BBUF[22];
+    this.v3h ^= BBUF[7] ^ BBUF[23];
+    this.v4l ^= BBUF[8] ^ BBUF[24];
+    this.v4h ^= BBUF[9] ^ BBUF[25];
+    this.v5l ^= BBUF[10] ^ BBUF[26];
+    this.v5h ^= BBUF[11] ^ BBUF[27];
+    this.v6l ^= BBUF[12] ^ BBUF[28];
+    this.v6h ^= BBUF[13] ^ BBUF[29];
+    this.v7l ^= BBUF[14] ^ BBUF[30];
+    this.v7h ^= BBUF[15] ^ BBUF[31];
+    clean2(BBUF);
+  }
+  destroy() {
+    this.destroyed = true;
+    clean2(this.buffer32);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+};
+var blake2b = /* @__PURE__ */ createOptHasher((opts) => new BLAKE2b(opts));
+
+// node_modules/@noble/hashes/esm/argon2.js
+var AT = { Argond2d: 0, Argon2i: 1, Argon2id: 2 };
+var ARGON2_SYNC_POINTS = 4;
+var abytesOrZero = (buf) => {
+  if (buf === void 0)
+    return Uint8Array.of();
+  return kdfInputToBytes(buf);
+};
+function mul(a, b) {
+  const aL = a & 65535;
+  const aH = a >>> 16;
+  const bL = b & 65535;
+  const bH = b >>> 16;
+  const ll = Math.imul(aL, bL);
+  const hl = Math.imul(aH, bL);
+  const lh = Math.imul(aL, bH);
+  const hh = Math.imul(aH, bH);
+  const carry = (ll >>> 16) + (hl & 65535) + lh;
+  const high = hh + (hl >>> 16) + (carry >>> 16) | 0;
+  const low = carry << 16 | ll & 65535;
+  return { h: high, l: low };
+}
+function mul2(a, b) {
+  const { h, l } = mul(a, b);
+  return { h: (h << 1 | l >>> 31) & 4294967295, l: l << 1 & 4294967295 };
+}
+function blamka(Ah, Al, Bh, Bl) {
+  const { h: Ch, l: Cl } = mul2(Al, Bl);
+  const Rll = add3L(Al, Bl, Cl);
+  return { h: add3H(Rll, Ah, Bh, Ch), l: Rll | 0 };
+}
+var A2_BUF = new Uint32Array(256);
+function G(a, b, c, d) {
+  let Al = A2_BUF[2 * a], Ah = A2_BUF[2 * a + 1];
+  let Bl = A2_BUF[2 * b], Bh = A2_BUF[2 * b + 1];
+  let Cl = A2_BUF[2 * c], Ch = A2_BUF[2 * c + 1];
+  let Dl = A2_BUF[2 * d], Dh = A2_BUF[2 * d + 1];
+  ({ h: Ah, l: Al } = blamka(Ah, Al, Bh, Bl));
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+  ({ Dh, Dl } = { Dh: rotr32H(Dh, Dl), Dl: rotr32L(Dh, Dl) });
+  ({ h: Ch, l: Cl } = blamka(Ch, Cl, Dh, Dl));
+  ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+  ({ Bh, Bl } = { Bh: rotrSH(Bh, Bl, 24), Bl: rotrSL(Bh, Bl, 24) });
+  ({ h: Ah, l: Al } = blamka(Ah, Al, Bh, Bl));
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+  ({ Dh, Dl } = { Dh: rotrSH(Dh, Dl, 16), Dl: rotrSL(Dh, Dl, 16) });
+  ({ h: Ch, l: Cl } = blamka(Ch, Cl, Dh, Dl));
+  ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+  ({ Bh, Bl } = { Bh: rotrBH(Bh, Bl, 63), Bl: rotrBL(Bh, Bl, 63) });
+  A2_BUF[2 * a] = Al, A2_BUF[2 * a + 1] = Ah;
+  A2_BUF[2 * b] = Bl, A2_BUF[2 * b + 1] = Bh;
+  A2_BUF[2 * c] = Cl, A2_BUF[2 * c + 1] = Ch;
+  A2_BUF[2 * d] = Dl, A2_BUF[2 * d + 1] = Dh;
+}
+function P(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13, v14, v15) {
+  G(v00, v04, v08, v12);
+  G(v01, v05, v09, v13);
+  G(v02, v06, v10, v14);
+  G(v03, v07, v11, v15);
+  G(v00, v05, v10, v15);
+  G(v01, v06, v11, v12);
+  G(v02, v07, v08, v13);
+  G(v03, v04, v09, v14);
+}
+function block(x, xPos, yPos, outPos, needXor) {
+  for (let i = 0; i < 256; i++)
+    A2_BUF[i] = x[xPos + i] ^ x[yPos + i];
+  for (let i = 0; i < 128; i += 16) {
+    P(i, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9, i + 10, i + 11, i + 12, i + 13, i + 14, i + 15);
+  }
+  for (let i = 0; i < 16; i += 2) {
+    P(i, i + 1, i + 16, i + 17, i + 32, i + 33, i + 48, i + 49, i + 64, i + 65, i + 80, i + 81, i + 96, i + 97, i + 112, i + 113);
+  }
+  if (needXor)
+    for (let i = 0; i < 256; i++)
+      x[outPos + i] ^= A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
+  else
+    for (let i = 0; i < 256; i++)
+      x[outPos + i] = A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
+  clean2(A2_BUF);
+}
+function Hp(A, dkLen) {
+  const A8 = u8(A);
+  const T = new Uint32Array(1);
+  const T8 = u8(T);
+  T[0] = dkLen;
+  if (dkLen <= 64)
+    return blake2b.create({ dkLen }).update(T8).update(A8).digest();
+  const out = new Uint8Array(dkLen);
+  let V = blake2b.create({}).update(T8).update(A8).digest();
+  let pos = 0;
+  out.set(V.subarray(0, 32));
+  pos += 32;
+  for (; dkLen - pos > 64; pos += 32) {
+    const Vh = blake2b.create({}).update(V);
+    Vh.digestInto(V);
+    Vh.destroy();
+    out.set(V.subarray(0, 32), pos);
+  }
+  out.set(blake2b(V, { dkLen: dkLen - pos }), pos);
+  clean2(V, T);
+  return u322(out);
+}
+function indexAlpha(r, s, laneLen, segmentLen, index, randL, sameLane = false) {
+  let area;
+  if (r === 0) {
+    if (s === 0)
+      area = index - 1;
+    else if (sameLane)
+      area = s * segmentLen + index - 1;
+    else
+      area = s * segmentLen + (index == 0 ? -1 : 0);
+  } else if (sameLane)
+    area = laneLen - segmentLen + index - 1;
+  else
+    area = laneLen - segmentLen + (index == 0 ? -1 : 0);
+  const startPos = r !== 0 && s !== ARGON2_SYNC_POINTS - 1 ? (s + 1) * segmentLen : 0;
+  const rel = area - 1 - mul(area, mul(randL, randL).h).h;
+  return (startPos + rel) % laneLen;
+}
+var maxUint32 = Math.pow(2, 32);
+function isU32(num) {
+  return Number.isSafeInteger(num) && num >= 0 && num < maxUint32;
+}
+function argon2Opts(opts) {
+  const merged = {
+    version: 19,
+    dkLen: 32,
+    maxmem: maxUint32 - 1,
+    asyncTick: 10
+  };
+  for (let [k, v] of Object.entries(opts))
+    if (v != null)
+      merged[k] = v;
+  const { dkLen, p, m, t, version, onProgress } = merged;
+  if (!isU32(dkLen) || dkLen < 4)
+    throw new Error("dkLen should be at least 4 bytes");
+  if (!isU32(p) || p < 1 || p >= Math.pow(2, 24))
+    throw new Error("p should be 1 <= p < 2^24");
+  if (!isU32(m))
+    throw new Error("m should be 0 <= m < 2^32");
+  if (!isU32(t) || t < 1)
+    throw new Error("t (iterations) should be 1 <= t < 2^32");
+  if (onProgress !== void 0 && typeof onProgress !== "function")
+    throw new Error("progressCb should be function");
+  if (!isU32(m) || m < 8 * p)
+    throw new Error("memory should be at least 8*p bytes");
+  if (version !== 16 && version !== 19)
+    throw new Error("unknown version=" + version);
+  return merged;
+}
+function argon2Init(password, salt, type, opts) {
+  password = kdfInputToBytes(password);
+  salt = kdfInputToBytes(salt);
+  abytes2(password);
+  abytes2(salt);
+  if (!isU32(password.length))
+    throw new Error("password should be less than 4 GB");
+  if (!isU32(salt.length) || salt.length < 8)
+    throw new Error("salt should be at least 8 bytes and less than 4 GB");
+  if (!Object.values(AT).includes(type))
+    throw new Error("invalid type");
+  let { p, dkLen, m, t, version, key, personalization, maxmem, onProgress, asyncTick } = argon2Opts(opts);
+  key = abytesOrZero(key);
+  personalization = abytesOrZero(personalization);
+  const h = blake2b.create({});
+  const BUF = new Uint32Array(1);
+  const BUF8 = u8(BUF);
+  for (let item of [p, dkLen, m, t, version, type]) {
+    BUF[0] = item;
+    h.update(BUF8);
+  }
+  for (let i of [password, salt, key, personalization]) {
+    BUF[0] = i.length;
+    h.update(BUF8).update(i);
+  }
+  const H0 = new Uint32Array(18);
+  const H0_8 = u8(H0);
+  h.digestInto(H0_8);
+  const lanes = p;
+  const mP = 4 * p * Math.floor(m / (ARGON2_SYNC_POINTS * p));
+  const laneLen = Math.floor(mP / p);
+  const segmentLen = Math.floor(laneLen / ARGON2_SYNC_POINTS);
+  const memUsed = mP * 256;
+  if (!isU32(maxmem) || memUsed > maxmem)
+    throw new Error("mem should be less than 2**32, got: maxmem=" + maxmem + ", memused=" + memUsed);
+  const B = new Uint32Array(memUsed);
+  for (let l = 0; l < p; l++) {
+    const i = 256 * laneLen * l;
+    H0[17] = l;
+    H0[16] = 0;
+    B.set(Hp(H0, 1024), i);
+    H0[16] = 1;
+    B.set(Hp(H0, 1024), i + 256);
+  }
+  let perBlock = () => {
+  };
+  if (onProgress) {
+    const totalBlock = t * ARGON2_SYNC_POINTS * p * segmentLen;
+    const callbackPer = Math.max(Math.floor(totalBlock / 1e4), 1);
+    let blockCnt = 0;
+    perBlock = () => {
+      blockCnt++;
+      if (onProgress && (!(blockCnt % callbackPer) || blockCnt === totalBlock))
+        onProgress(blockCnt / totalBlock);
+    };
+  }
+  clean2(BUF, H0);
+  return { type, mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock, asyncTick };
+}
+function argon2Output(B, p, laneLen, dkLen) {
+  const B_final = new Uint32Array(256);
+  for (let l = 0; l < p; l++)
+    for (let j = 0; j < 256; j++)
+      B_final[j] ^= B[256 * (laneLen * l + laneLen - 1) + j];
+  const res = u8(Hp(B_final, dkLen));
+  clean2(B_final);
+  return res;
+}
+function processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor) {
+  if (offset % laneLen)
+    prev = offset - 1;
+  let randL, randH;
+  if (dataIndependent) {
+    let i128 = index % 128;
+    if (i128 === 0) {
+      address[256 + 12]++;
+      block(address, 256, 2 * 256, 0, false);
+      block(address, 0, 2 * 256, 0, false);
+    }
+    randL = address[2 * i128];
+    randH = address[2 * i128 + 1];
+  } else {
+    const T = 256 * prev;
+    randL = B[T];
+    randH = B[T + 1];
+  }
+  const refLane = r === 0 && s === 0 ? l : randH % lanes;
+  const refPos = indexAlpha(r, s, laneLen, segmentLen, index, randL, refLane == l);
+  const refBlock = laneLen * refLane + refPos;
+  block(B, 256 * prev, 256 * refBlock, offset * 256, needXor);
+}
+function argon2(type, password, salt, opts) {
+  const { mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock } = argon2Init(password, salt, type, opts);
+  const address = new Uint32Array(3 * 256);
+  address[256 + 6] = mP;
+  address[256 + 8] = t;
+  address[256 + 10] = type;
+  for (let r = 0; r < t; r++) {
+    const needXor = r !== 0 && version === 19;
+    address[256 + 0] = r;
+    for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {
+      address[256 + 4] = s;
+      const dataIndependent = type == AT.Argon2i || type == AT.Argon2id && r === 0 && s < 2;
+      for (let l = 0; l < p; l++) {
+        address[256 + 2] = l;
+        address[256 + 12] = 0;
+        let startPos = 0;
+        if (r === 0 && s === 0) {
+          startPos = 2;
+          if (dataIndependent) {
+            address[256 + 12]++;
+            block(address, 256, 2 * 256, 0, false);
+            block(address, 0, 2 * 256, 0, false);
+          }
+        }
+        let offset = l * laneLen + s * segmentLen + startPos;
+        let prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;
+        for (let index = startPos; index < segmentLen; index++, offset++, prev++) {
+          perBlock();
+          processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor);
+        }
+      }
+    }
+  }
+  clean2(address);
+  return argon2Output(B, p, laneLen, dkLen);
+}
+var argon2id = (password, salt, opts) => argon2(AT.Argon2id, password, salt, opts);
+
+// src/notes/store.ts
+var NoteStore = class {
+  constructor(persist) {
+    this.persist = persist;
+  }
+  header = null;
+  body = null;
+  key = null;
+  async unlock(passphrase) {
+    const blob = await this.persist.readBlob();
+    if (!blob) {
+      const salt2 = crypto.getRandomValues(new Uint8Array(16));
+      const key2 = await argon2id(new TextEncoder().encode(passphrase), salt2, {
+        m: 64 * 1024,
+        t: 3,
+        p: 1,
+        dkLen: 32
+      });
+      const header = {
+        v: 1,
+        createdAt: Date.now(),
+        kdf: { algo: "argon2id", params: { m: 64 * 1024, t: 3, p: 1, saltB64: Buffer.from(salt2).toString("base64") } },
+        seq: 1
+      };
+      const body2 = {
+        notes: [],
+        nfs: [],
+        pendingNfs: [],
+        tombstones: [],
+        pendingLinks: [],
+        outByIntent: {}
+      };
+      const enc = encryptBlob(key2, body2, header);
+      await this.persist.writeBlob(enc);
+      this.header = enc.header;
+      this.body = body2;
+      this.key = key2;
+      return;
+    }
+    const { m, t, p, saltB64 } = blob.header.kdf.params;
+    const salt = Buffer.from(saltB64, "base64");
+    const key = await argon2id(new TextEncoder().encode(passphrase), salt, {
+      m,
+      t,
+      p,
+      dkLen: 32
+    });
+    const body = decryptBlob(key, blob);
+    if (!body.pendingLinks) body.pendingLinks = [];
+    if (!body.outByIntent) body.outByIntent = {};
+    this.header = blob.header;
+    this.body = body;
+    this.key = key;
+  }
+  async save() {
+    if (!this.key || !this.header || !this.body) throw new Error("locked");
+    this.header = { ...this.header, seq: this.header.seq + 1 };
+    const enc = encryptBlob(this.key, this.body, this.header);
+    await this.persist.writeBlob(enc);
+    this.header = enc.header;
+  }
+  getBody() {
+    if (!this.body) throw new Error("vault is locked");
+    return this.body;
+  }
+  listSpendable(filter) {
+    const notes = this.getBody().notes.filter((n) => n.status === "SPENDABLE");
+    return filter?.assetId ? notes.filter((n) => n.assetId === filter.assetId) : notes;
+  }
+  getByCommitment(c) {
+    return this.getBody().notes.find((n) => n.commitment === c);
+  }
+  // ----- Planner hooks (call once per plan) -----
+  /** Link an input NF to the input note we’re spending, for auto-SPENT later. */
+  async linkPendingSpend(params) {
+    await this.withTxn((b) => {
+      if (!b.pendingLinks) b.pendingLinks = [];
+      if (!b.pendingNfs) b.pendingNfs = [];
+      const now = Date.now();
+      if (!b.pendingLinks.find((x) => x.nf === params.nf)) {
+        b.pendingLinks.push({ ...params, createdAt: now });
+      }
+      if (!b.pendingNfs.includes(params.nf)) b.pendingNfs.push(params.nf);
+    });
+  }
+  /** Register the output commitments (receive+change) we expect for this intent. */
+  async registerExpectedOutputs(intentId, commitments) {
+    await this.withTxn((b) => {
+      if (!b.outByIntent) b.outByIntent = {};
+      const set = /* @__PURE__ */ new Set([...b.outByIntent[intentId] ?? [], ...commitments]);
+      b.outByIntent[intentId] = [...set];
+    });
+  }
+  async clearExpectedOutputs(intentId) {
+    await this.withTxn((b) => {
+      if (b.outByIntent) delete b.outByIntent[intentId];
+    });
+  }
+  // ----- Notes lifecycle -----
+  /** Stage notes (outputs you locally know you will receive). */
+  async addStagedNotes(notes) {
+    await this.withTxn((b) => {
+      for (const n of notes) {
+        const now = Date.now();
+        const note = {
+          ...n,
+          status: "STAGED",
+          createdAt: n.createdAt ?? now,
+          updatedAt: now
+        };
+        if (!b.notes.find((x) => x.commitment === note.commitment)) {
+          b.notes.push(note);
+        }
+      }
+    });
+  }
+  async listStagedNotes() {
+    const b = this.getBody();
+    return b.notes.filter((n) => n.status === "STAGED");
+  }
+  /** Flip to SPENDABLE once inclusion path is verified. */
+  async markSpendable(commitment, index, root) {
+    await this.withTxn((b) => {
+      const n = b.notes.find((x) => x.commitment === commitment);
+      if (!n) return;
+      n.status = "SPENDABLE";
+      n.index = index;
+      n.root = root;
+      n.rootAtInclusion = root;
+      n.includedAt = n.includedAt ?? Date.now();
+      n.updatedAt = Date.now();
+    });
+  }
+  /** Record observed nullifiers; auto-mark the linked input note SPENT. */
+  async recordSpents(spents) {
+    await this.withTxn((b) => {
+      for (const s of spents) {
+        if (!b.nfs.find((x) => x.nf === s.nf)) {
+          const link = (b.pendingLinks ?? []).find((pl) => pl.nf === s.nf);
+          const merged = { ...s, commitment: s.commitment ?? link?.commitment };
+          b.nfs.push(merged);
+          if (link?.commitment) {
+            const n = b.notes.find((x) => x.commitment === link.commitment);
+            if (n && n.status !== "SPENT") {
+              n.status = "SPENT";
+              n.updatedAt = Date.now();
+              if (!b.tombstones.includes(n.commitment)) b.tombstones.push(n.commitment);
+            }
+          }
+        }
+        b.pendingNfs = (b.pendingNfs ?? []).filter((x) => x !== s.nf);
+        if (b.pendingLinks) b.pendingLinks = b.pendingLinks.filter((x) => x.nf !== s.nf);
+      }
+    });
+  }
+  // Convenience for planners that don’t link (kept for back-compat)
+  async markPending(nf) {
+    const b = this.getBody();
+    if (!b.pendingNfs.includes(nf)) b.pendingNfs.push(nf);
+    await this.save();
+  }
+  async markSpent(commitment, nf, blockNumber) {
+    const b = this.getBody();
+    const n = b.notes.find((x) => x.commitment === commitment);
+    if (n) {
+      n.status = "SPENT";
+      n.updatedAt = Date.now();
+    }
+    b.nfs.push({ nf, commitment, at: Date.now(), blockNumber });
+    if (n && !b.tombstones.includes(commitment)) b.tombstones.push(commitment);
+    b.pendingNfs = b.pendingNfs.filter((x) => x !== nf);
+    if (b.pendingLinks) b.pendingLinks = b.pendingLinks.filter((x) => x.nf !== nf);
+    await this.save();
+  }
+  // Reactor cursor helpers
+  async setLastProcessedBlock(block2) {
+    if (!this.header) throw new Error("vault is locked");
+    this.header = { ...this.header, lastProcessedBlock: block2 };
+    await this.save();
+  }
+  getLastProcessedBlock() {
+    return this.header?.lastProcessedBlock;
+  }
+  // Export / import
+  async exportEncrypted() {
+    const blob = await this.persist.readBlob();
+    if (!blob) throw new Error("no vault");
+    return blob;
+  }
+  async importEncrypted(blob) {
+    const cur = await this.persist.readBlob();
+    if (cur && blob.header.seq < cur.header.seq) throw new Error("rollback detected");
+    await this.persist.writeBlob(blob);
+  }
+  // Best-effort dedupe on startup
+  dedupe() {
+    const b = this.getBody();
+    const seen = /* @__PURE__ */ new Set();
+    b.notes = b.notes.filter(
+      (n) => !seen.has(n.commitment) && (seen.add(n.commitment), true)
+    );
+    if (!b.pendingLinks) b.pendingLinks = [];
+    if (!b.outByIntent) b.outByIntent = {};
+  }
+  /** Atomically mutate & persist. */
+  async withTxn(mutate) {
+    const b = this.getBody();
+    mutate(b);
+    await this.save();
+  }
+};
+
+// src/notes/receiver.ts
+var Receiver = class {
+  constructor(store, chain) {
+    this.store = store;
+    this.chain = chain;
+  }
+  async stageDepositNote(note) {
+    await this.store.addStagedNotes([{ ...note, status: "STAGED" }]);
+  }
+  async stageItOutNotes(notes) {
+    await this.store.addStagedNotes(notes.map((n) => ({ ...n, status: "STAGED" })));
+  }
+  /** One-shot reconcile. Call from a small loop for “always-on”. */
+  async reconcile(fromBlock) {
+    const ev = await this.chain.getEvents(fromBlock);
+    if (ev.spents.length) {
+      await this.store.recordSpents(
+        ev.spents.map((s) => ({ nf: s.nf, blockNumber: s.block, at: Date.now() }))
+      );
+    }
+    const staged = await this.store.listStagedNotes();
+    const includedNow = /* @__PURE__ */ new Set();
+    if (staged.length) {
+      const stagedByCommit = new Map(staged.map((s) => [s.commitment, s]));
+      for (const batch of ev.leaves) {
+        const root = batch.rootAfter ?? ev.newRoots.at(-1)?.root;
+        if (!root) continue;
+        if (!await this.chain.isKnownRoot(root)) continue;
+        for (let i = 0; i < batch.leaves.length; i++) {
+          const c = batch.leaves[i];
+          if (!stagedByCommit.has(c)) continue;
+          const index = batch.start + i;
+          const { path, indices } = await this.chain.getPath(index, root);
+          const ok = this.chain.verifyPath(c, index, root, path, indices);
+          if (!ok) continue;
+          await this.store.markSpendable(c, index, root);
+          includedNow.add(c);
+          stagedByCommit.delete(c);
+        }
+      }
+    }
+    const b = this.store["body"];
+    if (b?.outByIntent) {
+      for (const [intentId, expected] of Object.entries(b.outByIntent)) {
+        if (expected.every((c) => includedNow.has(c))) {
+          await this.store.clearExpectedOutputs(intentId);
+        }
+      }
+    }
+    const maxBlock = Math.max(
+      0,
+      ...ev.newRoots.map((x) => x.block),
+      ...ev.leaves.map((x) => x.block),
+      ...ev.spents.map((x) => x.block)
+    );
+    if (maxBlock > 0) await this.store.setLastProcessedBlock(maxBlock);
+  }
+};
+
+// src/lib/client.ts
+import "dotenv/config";
+var RAW_PK = process.env.RELAYER_KEY;
+var PK = RAW_PK.startsWith("0x") ? RAW_PK : `0x${RAW_PK}`;
+if (PK.length !== 66) {
+  throw new Error(
+    `RELAYER_KEY must be 32-byte hex (0x + 64 hex chars). Got length=${PK.length}.`
+  );
+}
+function toViemFromBlock(fb) {
+  if (fb === void 0) return void 0;
+  return typeof fb === "number" ? BigInt(fb) : fb;
+}
+function toReceiverFromBlock(fb) {
+  if (fb === void 0) return void 0;
+  return typeof fb === "bigint" ? Number(fb) : fb;
+}
+
+// src/index.ts
+var N3SDK = class {
+  env;
+  /** GraphQL-backed info endpoints (historical/state) */
+  info;
+  /** WebSocket fanout (live streams) */
+  subscriptions;
+  /** Hyperliquid-aligned exchange actions */
+  exchange;
+  constructor(env2) {
+    this.env = env2;
+    this.info = {
+      indicatives: makeIndicativesInfo(this.env),
+      candles: makeCandlesInfo(this.env),
+      depth: makeDepthInfo(this.env),
+      trades: makeTradesInfo(this.env),
+      batches: makeBatchesInfo(this.env)
+    };
+    this.subscriptions = {
+      indicatives: makeIndicatives(this.env),
+      candles: makeCandles(this.env),
+      depth: makeDepth(this.env),
+      trades: makeTrades(this.env),
+      batches: makeBatches(this.env)
+    };
+    this.exchange = {
+      order: submitOrder,
+      orderAuto: submitOrderAuto,
+      modify,
+      cancel,
+      batchOrder: batchOrders,
+      batchModify,
+      batchCancel,
+      withdraw,
+      withdrawAuto,
+      depositHYPE,
+      depositERC20
+    };
+  }
+  // -------- Receiver sync loop (Merkle confirmations & NF tracking) --------
+  startReceiverSync(store, clients, fromBlock) {
+    const { pool } = getDomainEnv();
+    const receiverFromBlock = (() => {
+      const persisted = store.getLastProcessedBlock?.();
+      if (typeof persisted === "number" && persisted > 0) return persisted;
+      return toReceiverFromBlock(fromBlock);
+    })();
+    const chainAdapter = {
+      getEvents: async (fbNum) => {
+        const { publicClient } = clients;
+        const from = toViemFromBlock(fbNum);
+        const [newRootsLogs, leavesLogs, spentLogs] = await Promise.all([
+          publicClient.getLogs({ address: pool, event: EV_NewRoot, fromBlock: from }).catch(() => []),
+          publicClient.getLogs({ address: pool, event: EV_LeavesInserted, fromBlock: from }).catch(() => []),
+          publicClient.getLogs({ address: pool, event: EV_Spent, fromBlock: from }).catch(() => [])
+        ]);
+        const newRoots = newRootsLogs.map((l) => ({
+          root: l.args.root,
+          block: Number(l.blockNumber ?? 0n)
+        }));
+        const leaves = leavesLogs.map((l) => ({
+          start: Number(l.args.startIndex ?? 0),
+          leaves: l.args.leaves ?? [],
+          block: Number(l.blockNumber ?? 0n),
+          rootAfter: void 0
+        }));
+        const spents = spentLogs.map((l) => ({
+          nf: l.args.nf,
+          block: Number(l.blockNumber ?? 0n)
+        }));
+        return { newRoots, leaves, spents };
+      },
+      getPath: async () => {
+        throw new Error("getPath not provided \u2014 supply an indexer or pass a custom chain adapter to Receiver.");
+      },
+      isKnownRoot: async (root) => {
+        const { publicClient } = clients;
+        return await publicClient.readContract({
+          address: pool,
+          abi: PrivatePoolAbi,
+          functionName: "isKnownRoot",
+          args: [root]
+        });
+      }
+    };
+    const rx = new Receiver(store, chainAdapter);
+    let stop = false;
+    (async () => {
+      let cursor = receiverFromBlock;
+      while (!stop) {
+        try {
+          await rx.reconcile(typeof cursor === "number" ? cursor : void 0);
+          const np = store.getLastProcessedBlock?.();
+          if (typeof np === "number" && np > 0) cursor = np;
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 3e3));
+      }
+    })();
+    return () => {
+      stop = true;
+    };
+  }
+};
+var index_default = N3SDK;
+export {
+  exchange_exports as Exchange,
+  info_exports as Info,
+  N3SDK,
+  NoteStore,
+  Receiver,
+  subscription_exports as Subscription,
+  Topics,
+  index_default as default,
+  toReceiverFromBlock,
+  toViemFromBlock
+};
+/*! Bundled license information:
+
+@noble/ciphers/esm/utils.js:
+  (*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) *)
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=index.js.map