@unicitylabs/sphere-sdk 0.14.0-dev.1 → 0.14.0-dev.2

package/dist/modules/payments-v2/index.js

@@ -0,0 +1,4231 @@
+// modules/payments-v2/stores.ts
+function createScopedKV(storage, network, chainPubkey) {
+  const prefix = `pv2:${network}:${chainPubkey}:`;
+  return {
+    async get(key) {
+      const raw = await storage.get(prefix + key);
+      if (raw === null || raw === void 0) return null;
+      return typeof raw === "string" ? JSON.parse(raw) : raw;
+    },
+    async set(key, value) {
+      await storage.set(prefix + key, JSON.stringify(value));
+    },
+    async remove(key) {
+      await storage.remove(prefix + key);
+    }
+  };
+}
+var STORE_KEYS = {
+  intentBackstop: "intents",
+  checkpointCache: "checkpoints",
+  deliveryJournal: "delivery-journal",
+  mintJournal: "mint-journal",
+  shortfalls: "shortfalls",
+  settlingLinks: "settling",
+  streamCursor: (s) => `cursor:${s}`,
+  epochLatch: "epoch-latch"
+};
+
+// node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
+    if (!bytes)
+      throw new TypeError(message);
+    throw new RangeError(message);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new RangeError('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.canXOF = tmp.canXOF;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+var oidNist = (suffix) => ({
+  // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.
+  // Larger suffix values would need base-128 OID encoding and a different length byte.
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// node_modules/@noble/hashes/_md.js
+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 {
+  blockLen;
+  outputLen;
+  canXOF = false;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE2) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE2;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE: isLE2 } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE2);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE2);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to ||= new this.constructor();
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// node_modules/@noble/hashes/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 SHA2_32B = class extends HashMD {
+  constructor(outputLen) {
+    super(64, outputLen, 8, false);
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, 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 = G | 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, 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, G) + 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 = G;
+      G = 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;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.destroyed = true;
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var _SHA256 = class extends SHA2_32B {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  A = SHA256_IV[0] | 0;
+  B = SHA256_IV[1] | 0;
+  C = SHA256_IV[2] | 0;
+  D = SHA256_IV[3] | 0;
+  E = SHA256_IV[4] | 0;
+  F = SHA256_IV[5] | 0;
+  G = SHA256_IV[6] | 0;
+  H = SHA256_IV[7] | 0;
+  constructor() {
+    super(32);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
+
+// core/crypto.ts
+import * as bip39 from "bip39";
+import CryptoJS from "crypto-js";
+
+// core/errors.ts
+var SphereError = class extends Error {
+  code;
+  cause;
+  /**
+   * #441 deferred-paid linkage: the transferId of the possibly-committed send,
+   * stamped by `sendOnce` before the error leaves so a payment-request consumer
+   * can durably journal request→transfer and resolve 'paid' only when that
+   * transfer actually completes (never optimistically). Present ONLY on
+   * possibly-committed outcomes ({@link isPossiblyCommittedSendOutcome}).
+   */
+  transferId;
+  constructor(message, code, cause) {
+    super(message);
+    this.name = "SphereError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+var PartialSendConflictError = class extends SphereError {
+  /**
+   * The FIRST partial attempt's transferId — its intent stays open for resume,
+   * and it is the §6 handoff anchor. NOTE: `send()` may re-plan the remainder across
+   * SEVERAL internal attempts before giving up, so {@link committedTokenIds} can
+   * span MULTIPLE transferIds — they do NOT all map to this single id.
+   */
+  transferId;
+  /**
+   * Source token ids whose spend already certified on-chain (and whose finished
+   * output blob is journaled for delivery). Their value has already been
+   * delivered; NEVER re-send these. May accumulate across several internal
+   * remainder-re-plan attempts (so not all are journaled under {@link transferId}).
+   */
+  committedTokenIds;
+  /**
+   * The still-undelivered portion (base units, decimal string) — `send()` could
+   * not COMPLETE it from the remaining live sources (insufficient funds or a
+   * transient error; see `cause`). Re-plan ONLY this amount, under a new
+   * transferId; the delivered legs converge via the recipient's §6 claim.
+   */
+  remainingAmount;
+  constructor(message, transferId, committedTokenIds, remainingAmount, cause) {
+    super(message, "SEND_PARTIALLY_COMPLETED", cause);
+    this.name = "PartialSendConflictError";
+    this.transferId = transferId;
+    this.committedTokenIds = [...committedTokenIds];
+    this.remainingAmount = remainingAmount;
+  }
+};
+var POSSIBLY_COMMITTED_SEND_CODES = /* @__PURE__ */ new Set([
+  "SEND_SYNC_PENDING",
+  "CERTIFICATION_UNCONFIRMED",
+  "CHECKPOINT_PERSIST_FAILED",
+  "SPLIT_CHECKPOINT_LOST",
+  "CHECKPOINT_TRUSTBASE_MISMATCH",
+  "SEND_PARTIALLY_COMPLETED"
+]);
+function isPossiblyCommittedSendOutcome(err) {
+  return isSphereError(err) && POSSIBLY_COMMITTED_SEND_CODES.has(err.code);
+}
+function isSphereError(err) {
+  return err instanceof SphereError;
+}
+
+// core/crypto.ts
+var CURVE_ORDER = BigInt(
+  "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"
+);
+function hexToBytes(hex) {
+  const matches = hex.match(/../g);
+  if (!matches) {
+    return new Uint8Array(0);
+  }
+  return Uint8Array.from(matches.map((x) => parseInt(x, 16)));
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// core/uuid.ts
+function randomUUID() {
+  const c = globalThis.crypto;
+  if (typeof c !== "undefined" && typeof c.randomUUID === "function") {
+    return c.randomUUID();
+  }
+  const b = c.getRandomValues(new Uint8Array(16));
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const h = Array.from(b, (x) => x.toString(16).padStart(2, "0"));
+  return `${h[0]}${h[1]}${h[2]}${h[3]}-${h[4]}${h[5]}-${h[6]}${h[7]}-${h[8]}${h[9]}-${h[10]}${h[11]}${h[12]}${h[13]}${h[14]}${h[15]}`;
+}
+
+// token-engine/sdk.ts
+import { StateTransitionClient } from "@unicitylabs/state-transition-sdk/lib/StateTransitionClient.js";
+import { AggregatorClient } from "@unicitylabs/state-transition-sdk/lib/api/AggregatorClient.js";
+import { NetworkId } from "@unicitylabs/state-transition-sdk/lib/api/NetworkId.js";
+import { CertificationData } from "@unicitylabs/state-transition-sdk/lib/api/CertificationData.js";
+import { CertificationResponse, CertificationStatus } from "@unicitylabs/state-transition-sdk/lib/api/CertificationResponse.js";
+import { StateId } from "@unicitylabs/state-transition-sdk/lib/api/StateId.js";
+import { InclusionProof } from "@unicitylabs/state-transition-sdk/lib/api/InclusionProof.js";
+import { InclusionProofResponse } from "@unicitylabs/state-transition-sdk/lib/api/InclusionProofResponse.js";
+import { RootTrustBase } from "@unicitylabs/state-transition-sdk/lib/api/bft/RootTrustBase.js";
+import { waitInclusionProof } from "@unicitylabs/state-transition-sdk/lib/util/InclusionProofUtils.js";
+import { InclusionProofVerificationStatus } from "@unicitylabs/state-transition-sdk/lib/transaction/verification/rule/InclusionProofVerificationRule.js";
+import { Token } from "@unicitylabs/state-transition-sdk/lib/transaction/Token.js";
+import { MintTransaction } from "@unicitylabs/state-transition-sdk/lib/transaction/MintTransaction.js";
+import { TransferTransaction } from "@unicitylabs/state-transition-sdk/lib/transaction/TransferTransaction.js";
+import { CertifiedMintTransaction } from "@unicitylabs/state-transition-sdk/lib/transaction/CertifiedMintTransaction.js";
+import { CertifiedTransferTransaction } from "@unicitylabs/state-transition-sdk/lib/transaction/CertifiedTransferTransaction.js";
+import { TokenId } from "@unicitylabs/state-transition-sdk/lib/transaction/TokenId.js";
+import { TokenType } from "@unicitylabs/state-transition-sdk/lib/transaction/TokenType.js";
+import { TokenSalt } from "@unicitylabs/state-transition-sdk/lib/transaction/TokenSalt.js";
+import { StateMask } from "@unicitylabs/state-transition-sdk/lib/transaction/StateMask.js";
+import { MintJustificationVerifierService } from "@unicitylabs/state-transition-sdk/lib/transaction/verification/MintJustificationVerifierService.js";
+import { TokenIssuanceVerifierService } from "@unicitylabs/state-transition-sdk/lib/transaction/verification/TokenIssuanceVerifierService.js";
+import { VerificationContext } from "@unicitylabs/state-transition-sdk/lib/transaction/verification/VerificationContext.js";
+import { WorkerTokenVerifier } from "@unicitylabs/state-transition-sdk/lib/transaction/verification/worker/WorkerTokenVerifier.js";
+import { EncodedPredicate } from "@unicitylabs/state-transition-sdk/lib/predicate/EncodedPredicate.js";
+import { SignaturePredicate } from "@unicitylabs/state-transition-sdk/lib/predicate/builtin/SignaturePredicate.js";
+import { SignaturePredicateUnlockScript } from "@unicitylabs/state-transition-sdk/lib/predicate/builtin/SignaturePredicateUnlockScript.js";
+import { BurnPredicate } from "@unicitylabs/state-transition-sdk/lib/predicate/builtin/BurnPredicate.js";
+import { PredicateVerifierService } from "@unicitylabs/state-transition-sdk/lib/predicate/verification/PredicateVerifierService.js";
+import { SigningService } from "@unicitylabs/state-transition-sdk/lib/crypto/secp256k1/SigningService.js";
+import { Signature } from "@unicitylabs/state-transition-sdk/lib/crypto/secp256k1/Signature.js";
+import { MintSigningService } from "@unicitylabs/state-transition-sdk/lib/crypto/MintSigningService.js";
+import { HashAlgorithm } from "@unicitylabs/state-transition-sdk/lib/crypto/hash/HashAlgorithm.js";
+import { DataHash } from "@unicitylabs/state-transition-sdk/lib/crypto/hash/DataHash.js";
+import { DataHasher } from "@unicitylabs/state-transition-sdk/lib/crypto/hash/DataHasher.js";
+import { DataHasherFactory } from "@unicitylabs/state-transition-sdk/lib/crypto/hash/DataHasherFactory.js";
+import { CborSerializer } from "@unicitylabs/state-transition-sdk/lib/serialization/cbor/CborSerializer.js";
+import { CborDeserializer } from "@unicitylabs/state-transition-sdk/lib/serialization/cbor/CborDeserializer.js";
+import { CborError } from "@unicitylabs/state-transition-sdk/lib/serialization/cbor/CborError.js";
+import { Asset } from "@unicitylabs/state-transition-sdk/lib/payment/asset/Asset.js";
+import { AssetId } from "@unicitylabs/state-transition-sdk/lib/payment/asset/AssetId.js";
+import { PaymentAssetCollection } from "@unicitylabs/state-transition-sdk/lib/payment/asset/PaymentAssetCollection.js";
+import { TokenSplit } from "@unicitylabs/state-transition-sdk/lib/payment/TokenSplit.js";
+import { SplitTokenRequest } from "@unicitylabs/state-transition-sdk/lib/payment/SplitTokenRequest.js";
+import { SplitToken } from "@unicitylabs/state-transition-sdk/lib/payment/SplitToken.js";
+import { SplitAllocationProof } from "@unicitylabs/state-transition-sdk/lib/payment/SplitAllocationProof.js";
+import { SplitMintJustification } from "@unicitylabs/state-transition-sdk/lib/payment/SplitMintJustification.js";
+import { SplitMintJustificationVerifier } from "@unicitylabs/state-transition-sdk/lib/payment/SplitMintJustificationVerifier.js";
+import { VerificationStatus } from "@unicitylabs/state-transition-sdk/lib/verification/VerificationStatus.js";
+import { VerificationResult } from "@unicitylabs/state-transition-sdk/lib/verification/VerificationResult.js";
+import { HexConverter } from "@unicitylabs/state-transition-sdk/lib/util/HexConverter.js";
+import { BigintConverter } from "@unicitylabs/state-transition-sdk/lib/util/BigintConverter.js";
+import { BitString } from "@unicitylabs/state-transition-sdk/lib/util/BitString.js";
+
+// token-engine/token-blob.ts
+var TOKEN_BLOB_VERSION = 1;
+
+// modules/payments-v2/machine/journal.ts
+var MAX_DELIVERY_ATTEMPTS = 6;
+var RATE_LIMIT_DEFER_MS = 3e4;
+var ATTENTION_DELIVERY_DEFERRED = "delivery:deferred";
+var ATTENTION_DELIVERY_UNDELIVERABLE = "delivery:undeliverable";
+var ATTENTION_CHECKPOINT_STUCK = "split:checkpoint-stuck";
+var ATTENTION_SYNC_PENDING = "sync:pending";
+function wireShape(err) {
+  return err !== null && typeof err === "object" ? err : null;
+}
+function isRateLimited(err) {
+  const e = wireShape(err);
+  if (e === null) return false;
+  return e.status === 429 || e.statusCode === 429 || e.code === "QUOTA_EXCEEDED" || e.code === "RATE_LIMITED";
+}
+function isValidationReject(err) {
+  const e = wireShape(err);
+  if (e === null) return false;
+  return e.status === 422 || e.statusCode === 422 || e.code === "VALIDATION" || e.code === "VALIDATION_FAILED";
+}
+var chainRegistry = /* @__PURE__ */ new WeakMap();
+var replayRegistry = /* @__PURE__ */ new WeakMap();
+function registryFor(registry, kv) {
+  let perKv = registry.get(kv);
+  if (perKv === void 0) {
+    perKv = /* @__PURE__ */ new Map();
+    registry.set(kv, perKv);
+  }
+  return perKv;
+}
+var ListStore = class {
+  constructor(kv, storeKey, keyOf) {
+    this.kv = kv;
+    this.storeKey = storeKey;
+    this.keyOf = keyOf;
+  }
+  list() {
+    return this.chained(() => this.read());
+  }
+  getByKey(key) {
+    return this.chained(async () => (await this.read()).find((e) => this.keyOf(e) === key));
+  }
+  /** Upsert; a byte-identical re-save is a no-op (content-idempotent). */
+  upsert(entry) {
+    return this.mutate((list) => {
+      const key = this.keyOf(entry);
+      const at = list.findIndex((e) => this.keyOf(e) === key);
+      if (at >= 0 && JSON.stringify(list[at]) === JSON.stringify(entry)) return { result: void 0 };
+      const next = [...list];
+      if (at >= 0) next[at] = entry;
+      else next.push(entry);
+      return { list: next, result: void 0 };
+    });
+  }
+  removeByKey(key) {
+    return this.mutate((list) => {
+      const next = list.filter((e) => this.keyOf(e) !== key);
+      return next.length === list.length ? { result: void 0 } : { list: next, result: void 0 };
+    });
+  }
+  patch(key, fn) {
+    return this.mutate((list) => {
+      const at = list.findIndex((e) => this.keyOf(e) === key);
+      if (at < 0) return { result: void 0 };
+      const next = [...list];
+      next[at] = fn(next[at]);
+      return { list: next, result: next[at] };
+    });
+  }
+  mutate(fn) {
+    return this.chained(async () => {
+      const { list, result } = fn(await this.read());
+      if (list !== void 0) await this.kv.set(this.storeKey, list);
+      return result;
+    });
+  }
+  chained(run) {
+    const perKv = registryFor(chainRegistry, this.kv);
+    const prev = perKv.get(this.storeKey) ?? Promise.resolve();
+    const next = prev.then(run, run);
+    perKv.set(
+      this.storeKey,
+      next.then(
+        () => void 0,
+        () => void 0
+      )
+    );
+    return next;
+  }
+  async read() {
+    return await this.kv.get(this.storeKey) ?? [];
+  }
+};
+var BackstopStore = class extends ListStore {
+  constructor(kv) {
+    super(kv, STORE_KEYS.intentBackstop, (e) => e.transferId);
+  }
+  save(entry) {
+    return this.upsert(entry);
+  }
+  async setDisposition(transferId, disposition) {
+    await this.patch(transferId, (e) => ({ ...e, disposition }));
+  }
+  drop(transferId) {
+    return this.removeByKey(transferId);
+  }
+  get(transferId) {
+    return this.getByKey(transferId);
+  }
+};
+var DeliveryJournal = class extends ListStore {
+  constructor(kv) {
+    super(kv, STORE_KEYS.deliveryJournal, (e) => `${e.transferId}:${String(e.opIndex)}`);
+  }
+  record(entry) {
+    return this.upsert(entry);
+  }
+  async byTransfer(transferId) {
+    const mine = (await this.list()).filter((e) => e.transferId === transferId);
+    return new Map(mine.map((e) => [e.opIndex, e]));
+  }
+  remove(transferId, opIndex) {
+    return this.removeByKey(`${transferId}:${String(opIndex)}`);
+  }
+  /** 429 deferral: pushes deferredUntil out WITHOUT touching the poison budget. */
+  async defer(transferId, opIndex, until) {
+    await this.patch(`${transferId}:${String(opIndex)}`, (e) => ({ ...e, deferredUntil: until }));
+  }
+  /** Genuine failure: attempts++, poisoning (undeliverable) at the budget. */
+  async recordFailure(transferId, opIndex, attention) {
+    const updated = await this.patch(`${transferId}:${String(opIndex)}`, (e) => {
+      if (e.undeliverable === true) return e;
+      const attempts = e.attempts + 1;
+      return attempts >= MAX_DELIVERY_ATTEMPTS ? { ...e, attempts, undeliverable: true } : { ...e, attempts };
+    });
+    const poisoned = updated?.undeliverable === true;
+    if (poisoned && updated.attempts === MAX_DELIVERY_ATTEMPTS) {
+      attention(transferId, ATTENTION_DELIVERY_UNDELIVERABLE, `op ${String(opIndex)} after ${String(updated.attempts)} attempts`);
+    }
+    return poisoned;
+  }
+  /** Single-flight per (kv, store); concurrent calls coalesce onto one pass. */
+  replay(deps) {
+    const perKv = registryFor(replayRegistry, this.kv);
+    const existing = perKv.get(this.storeKey);
+    if (existing !== void 0) return existing;
+    const run = this.replayOnce(deps).finally(() => {
+      perKv.delete(this.storeKey);
+    });
+    perKv.set(this.storeKey, run);
+    return run;
+  }
+  async replayOnce(deps) {
+    const stats = { delivered: 0, deferred: 0, failed: 0, poisoned: 0 };
+    for (const entry of await this.list()) {
+      if (entry.undeliverable === true) continue;
+      if (entry.deferredUntil !== void 0 && entry.deferredUntil > deps.now()) {
+        stats.deferred += 1;
+        continue;
+      }
+      await this.replayEntry(entry, deps, stats);
+    }
+    return stats;
+  }
+  async replayEntry(entry, deps, stats) {
+    try {
+      await deps.delivery.deliver(entry.recipientPubkey, hexToBytes(entry.blobHex), {
+        transferId: entry.transferId,
+        ...entry.memo !== void 0 ? { memo: entry.memo } : {}
+      });
+      await this.remove(entry.transferId, entry.opIndex);
+      stats.delivered += 1;
+    } catch (err) {
+      if (isRateLimited(err)) {
+        await this.defer(entry.transferId, entry.opIndex, deps.now() + RATE_LIMIT_DEFER_MS);
+        deps.attention(entry.transferId, ATTENTION_DELIVERY_DEFERRED);
+        stats.deferred += 1;
+      } else if (await this.recordFailure(entry.transferId, entry.opIndex, deps.attention)) {
+        stats.poisoned += 1;
+      } else {
+        stats.failed += 1;
+      }
+    }
+  }
+};
+var MintJournal = class extends ListStore {
+  constructor(kv) {
+    super(kv, STORE_KEYS.mintJournal, (e) => e.mintId);
+  }
+  record(entry) {
+    return this.upsert(entry);
+  }
+  remove(mintId) {
+    return this.removeByKey(mintId);
+  }
+  get(mintId) {
+    return this.getByKey(mintId);
+  }
+};
+var ShortfallStore = class extends ListStore {
+  constructor(kv) {
+    super(kv, STORE_KEYS.shortfalls, (e) => e.transferId);
+  }
+  save(entry) {
+    return this.upsert(entry);
+  }
+  clear(transferId) {
+    return this.removeByKey(transferId);
+  }
+  get(transferId) {
+    return this.getByKey(transferId);
+  }
+};
+function createMachineStores(kv) {
+  return {
+    backstop: new BackstopStore(kv),
+    deliveryJournal: new DeliveryJournal(kv),
+    mintJournal: new MintJournal(kv),
+    shortfalls: new ShortfallStore(kv)
+  };
+}
+
+// token-engine/errors.ts
+var TransferConflictError = class extends SphereError {
+  /**
+   * #625: the source token id (the caller's id, e.g. `v2_<genesis>`) whose state was already spent.
+   * Set by PaymentsModule at the engine call site so the self-healing retry can demote it and re-plan.
+   */
+  conflictedSourceId;
+  constructor(message, cause) {
+    super(message, "TRANSFER_CONFLICT", cause);
+    this.name = "TransferConflictError";
+  }
+};
+var ProofUnconfirmedError = class extends SphereError {
+  mayHaveCertified = true;
+  constructor(message, cause) {
+    super(message, "CERTIFICATION_UNCONFIRMED", cause);
+    this.name = "ProofUnconfirmedError";
+  }
+};
+var CheckpointPersistFailedError = class extends SphereError {
+  mayHaveCertified = true;
+  constructor(message, cause) {
+    super(message, "CHECKPOINT_PERSIST_FAILED", cause);
+    this.name = "CheckpointPersistFailedError";
+  }
+};
+var SplitCheckpointLostError = class extends SphereError {
+  constructor(message, cause) {
+    super(message, "SPLIT_CHECKPOINT_LOST", cause);
+    this.name = "SplitCheckpointLostError";
+  }
+};
+var CheckpointTrustbaseMismatchError = class extends SphereError {
+  constructor(message, cause) {
+    super(message, "CHECKPOINT_TRUSTBASE_MISMATCH", cause);
+    this.name = "CheckpointTrustbaseMismatchError";
+  }
+};
+
+// modules/payments-v2/machine/TransferMachine.ts
+var CERTIFY_WIDTH = 8;
+var KEEP_OPEN_CODES = /* @__PURE__ */ new Set([
+  "CERTIFICATION_UNCONFIRMED",
+  "CHECKPOINT_PERSIST_FAILED",
+  "SPLIT_CHECKPOINT_LOST",
+  "CHECKPOINT_TRUSTBASE_MISMATCH"
+]);
+function buildOps(payload) {
+  const ops = payload.direct.map((sourceTokenId, opIndex) => ({
+    kind: "direct",
+    opIndex,
+    sourceTokenId,
+    deliveredAmount: 0n
+  }));
+  if (payload.split !== void 0) {
+    ops.push({
+      kind: "split",
+      opIndex: payload.direct.length,
+      sourceTokenId: payload.split.tokenId,
+      deliveredAmount: BigInt(payload.split.splitAmount)
+    });
+  }
+  return ops;
+}
+function classifyError(e) {
+  if (e instanceof ProofUnconfirmedError || e instanceof SplitCheckpointLostError || e instanceof CheckpointPersistFailedError || e instanceof CheckpointTrustbaseMismatchError) {
+    return "keep-open";
+  }
+  if (e instanceof TransferConflictError) return "conflict";
+  const coded = e !== null && typeof e === "object" ? e : null;
+  if (coded !== null) {
+    if (coded.mayHaveCertified === true) return "keep-open";
+    if (typeof coded.code === "string" && KEEP_OPEN_CODES.has(coded.code)) return "keep-open";
+    if (coded.code === "TRANSFER_CONFLICT") return "conflict";
+  }
+  return "other";
+}
+function summarize(outcomes) {
+  const committed = outcomes.filter((o) => o.certified);
+  const rank = { "keep-open": 3, conflict: 2, "clean-reject": 1, other: 1 };
+  let cls = null;
+  let firstError;
+  for (const o of outcomes) {
+    if (o.error === void 0) continue;
+    const c = classifyError(o.error);
+    if (cls === null || rank[c] > rank[cls]) {
+      cls = c;
+      firstError = o.error;
+    }
+  }
+  return { committed, cls, firstError };
+}
+var TransferMachine = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.stores = createMachineStores(deps.kv);
+  }
+  stores;
+  // ── send path ─────────────────────────────────────────────────────────────
+  async run(plan) {
+    const engine = this.deps.engine();
+    const envelope = await this.deps.encryptPayload(plan.payload);
+    await this.stores.backstop.save({
+      transferId: plan.transferId,
+      payloadEnvelope: envelope,
+      requiresSeedClose: plan.payload.split !== void 0,
+      disposition: "open",
+      createdAt: this.deps.now()
+    });
+    await this.putIntentGate(plan, envelope);
+    const outcomes = await this.certifyAll(plan, engine);
+    const { committed, cls, firstError } = summarize(outcomes);
+    let deliveryPending = false;
+    if (committed.length > 0) {
+      deliveryPending = await this.deliverSet(plan.transferId, plan.recipientPubkey, plan.memo, committed);
+    }
+    if (cls === null) {
+      await this.applyCommitted(engine, plan.transferId, committed);
+      this.closeTail(plan.transferId, plan.payload);
+      return { committed, deliveryPending };
+    }
+    if (cls === "conflict" && committed.length > 0) {
+      await this.applyBestEffort(engine, plan.transferId, committed);
+    }
+    await this.disposeOnFailure(plan.transferId, committed, cls);
+    throw firstError;
+  }
+  // ── resume path: the SAME machine, rehydrated from an open intent ─────────
+  async resumeIntent(r) {
+    const engine = this.deps.engine();
+    const ctx = {
+      transferId: r.transferId,
+      recipientPubkey: r.payload.recipient,
+      payload: r.payload,
+      ...r.payload.memo !== void 0 ? { memo: r.payload.memo } : {}
+    };
+    const { committed, conflicts } = await this.resumeOps(ctx, engine, r);
+    if (committed.length === 0 && conflicts.length > 0) throw conflicts[0].error;
+    let deliveryPending = false;
+    if (committed.length > 0) {
+      deliveryPending = await this.deliverSet(r.transferId, r.payload.recipient, r.payload.memo, committed);
+    }
+    await this.applyCommitted(engine, r.transferId, committed);
+    if (conflicts.length > 0) {
+      return { deliveryPending, partial: await this.settlePartial(r, committed, conflicts) };
+    }
+    await this.completeIntent(r.transferId, r.payload);
+    await this.finishBookkeeping(r.transferId, r.payload, "resumed");
+    return { deliveryPending, partial: null };
+  }
+  // ── shared transitions ─────────────────────────────────────────────────────
+  async putIntentGate(plan, envelope) {
+    try {
+      await this.deps.intents.put(plan.transferId, envelope, plan.payload.split !== void 0);
+    } catch (err) {
+      if (isValidationReject(err)) await this.stores.backstop.drop(plan.transferId);
+      throw err;
+    }
+  }
+  async certifyAll(plan, engine) {
+    const ctx = {
+      transferId: plan.transferId,
+      recipientPubkey: plan.recipientPubkey,
+      payload: plan.payload,
+      ...plan.memo !== void 0 ? { memo: plan.memo } : {}
+    };
+    const outcomes = [];
+    for (let at = 0; at < plan.ops.length; at += CERTIFY_WIDTH) {
+      const batch = plan.ops.slice(at, at + CERTIFY_WIDTH);
+      const settled = await Promise.all(
+        batch.map((op) => this.certifyOne(ctx, engine, op, plan.sources.get(op.sourceTokenId)))
+      );
+      outcomes.push(...settled);
+      if (settled.some((o) => o.error !== void 0 && !o.certified)) break;
+    }
+    return outcomes;
+  }
+  async certifyOne(ctx, engine, op, source) {
+    if (source === void 0) {
+      return {
+        op,
+        certified: false,
+        error: new SphereError(`source ${op.sourceTokenId} is not materialized`, "VALIDATION_ERROR")
+      };
+    }
+    let produced;
+    try {
+      produced = await this.certifyOnChain(ctx, engine, op, source);
+    } catch (error) {
+      return { op, certified: false, error };
+    }
+    const outcome = { op, certified: true, ...produced };
+    try {
+      await this.stores.deliveryJournal.record({
+        transferId: ctx.transferId,
+        opIndex: op.opIndex,
+        recipientPubkey: ctx.recipientPubkey,
+        blobHex: bytesToHex(produced.recipientBlob),
+        ...ctx.memo !== void 0 ? { memo: ctx.memo } : {},
+        attempts: 0
+      });
+      return outcome;
+    } catch (error) {
+      return { ...outcome, error };
+    }
+  }
+  async certifyOnChain(ctx, engine, op, source) {
+    const recipientPubkey = hexToBytes(ctx.recipientPubkey);
+    const opts = { transferId: ctx.transferId, opIndex: op.opIndex, checkpointStore: this.deps.checkpointStore };
+    if (op.kind === "direct") {
+      const finished = await engine.transfer({ token: source, recipientPubkey }, opts);
+      return { recipientBlob: finished.blob.token };
+    }
+    const split = ctx.payload.split;
+    const { outputs } = await engine.split(
+      {
+        token: source,
+        outputs: [
+          { recipientPubkey, coinId: ctx.payload.coinId, amount: BigInt(split.splitAmount) },
+          { recipientPubkey: this.deps.ownPubkey, coinId: ctx.payload.coinId, amount: BigInt(split.remainderAmount) }
+        ]
+      },
+      opts
+    );
+    return { recipientBlob: outputs[0].blob.token, changeBlob: outputs[1].blob.token };
+  }
+  async resumeOps(ctx, engine, r) {
+    const committed = [];
+    const conflicts = [];
+    for (const op of buildOps(r.payload)) {
+      const journaled = op.kind === "direct" ? r.journaled.get(op.opIndex) : void 0;
+      if (journaled !== void 0) {
+        committed.push({ op, certified: true, recipientBlob: hexToBytes(journaled.blobHex) });
+        continue;
+      }
+      const source = r.sources.get(op.sourceTokenId);
+      const outcome = await this.certifyOne(ctx, engine, op, source);
+      if (outcome.certified) {
+        committed.push(outcome);
+        continue;
+      }
+      if (classifyError(outcome.error) !== "conflict") throw outcome.error;
+      conflicts.push({ op, error: outcome.error, amount: conflictAmount(engine, r.payload, op, source) });
+    }
+    return { committed, conflicts };
+  }
+  async deliverSet(transferId, recipientPubkey, memo, committed) {
+    const journaled = committed.filter((o) => o.error === void 0 && o.recipientBlob !== void 0);
+    let pending = journaled.length < committed.length;
+    if (journaled.length === 0) return pending;
+    const options = { transferId, ...memo !== void 0 ? { memo } : {} };
+    if (await this.tryBatchDeposit(recipientPubkey, journaled, options)) return pending;
+    for (const outcome of journaled) {
+      const stillPending = await this.deliverOne(recipientPubkey, outcome, options);
+      pending = pending || stillPending;
+    }
+    return pending;
+  }
+  async tryBatchDeposit(recipientPubkey, journaled, options) {
+    const batch = this.deps.delivery.deliverBatch?.bind(this.deps.delivery);
+    if (batch === void 0) return false;
+    try {
+      await batch(recipientPubkey, journaled.map((o) => o.recipientBlob), options);
+    } catch {
+      return false;
+    }
+    for (const o of journaled) await this.removeJournaled(options.transferId, o.op.opIndex);
+    return true;
+  }
+  async deliverOne(recipientPubkey, outcome, options) {
+    try {
+      await this.deps.delivery.deliver(recipientPubkey, outcome.recipientBlob, options);
+      await this.removeJournaled(options.transferId, outcome.op.opIndex);
+      return false;
+    } catch (err) {
+      if (isRateLimited(err)) {
+        await this.stores.deliveryJournal.defer(options.transferId, outcome.op.opIndex, this.deps.now() + RATE_LIMIT_DEFER_MS);
+        this.attention()(options.transferId, ATTENTION_DELIVERY_DEFERRED);
+      } else {
+        await this.stores.deliveryJournal.recordFailure(options.transferId, outcome.op.opIndex, this.attention());
+      }
+      return true;
+    }
+  }
+  async removeJournaled(transferId, opIndex) {
+    try {
+      await this.stores.deliveryJournal.remove(transferId, opIndex);
+    } catch {
+    }
+  }
+  async applyCommitted(engine, transferId, committed) {
+    try {
+      const added = await this.uploadChangeBlobs(engine, committed);
+      await this.deps.storage.applyDelta({
+        transferId,
+        spent: committed.map((o) => o.op.sourceTokenId),
+        added
+      });
+    } catch (cause) {
+      const pending = new SphereError(
+        "The spend committed on-chain; the wallet-api mirror is catching up.",
+        "SEND_SYNC_PENDING",
+        cause
+      );
+      pending.transferId = transferId;
+      throw pending;
+    }
+  }
+  async applyBestEffort(engine, transferId, committed) {
+    if (committed.some((o) => o.error !== void 0)) return;
+    try {
+      await this.applyCommitted(engine, transferId, committed);
+    } catch {
+      this.attention()(transferId, ATTENTION_SYNC_PENDING);
+    }
+  }
+  async uploadChangeBlobs(engine, committed) {
+    const added = [];
+    for (const o of committed) {
+      if (o.changeBlob === void 0) continue;
+      const digest = bytesToHex(sha256(o.changeBlob));
+      const keys = await this.deps.storage.uploadBlobs([{ sha256: digest, bytes: o.changeBlob }]);
+      const key = keys.get(digest);
+      if (key === void 0) throw new SphereError(`no upload key returned for ${digest}`, "STORAGE_ERROR");
+      const { tokenId } = await engine.deliveryKeys(o.changeBlob);
+      added.push({ tokenId, key });
+    }
+    return added;
+  }
+  async settlePartial(r, committed, conflicts) {
+    const undelivered = conflicts.reduce((sum, c) => sum + c.amount, 0n);
+    const entry = {
+      transferId: r.transferId,
+      remainingAmount: undelivered.toString(),
+      coinId: r.payload.coinId,
+      recipient: r.payload.recipient,
+      committedTokenIds: committed.map((o) => o.op.sourceTokenId),
+      createdAt: this.deps.now()
+    };
+    await this.stores.shortfalls.save(entry);
+    await this.completeIntent(r.transferId, r.payload);
+    await this.finishBookkeeping(r.transferId, r.payload, "resumed");
+    return entry;
+  }
+  closeTail(transferId, payload) {
+    void (async () => {
+      try {
+        await this.completeIntent(transferId, payload);
+      } catch {
+        return;
+      }
+      await this.finishBookkeeping(transferId, payload, "sent");
+    })();
+  }
+  async completeIntent(transferId, payload) {
+    const signature = payload.split !== void 0 ? await this.deps.signComplete(transferId) : void 0;
+    await this.deps.intents.complete(transferId, signature);
+  }
+  async finishBookkeeping(transferId, payload, phase) {
+    try {
+      await this.deps.recordHistory?.({ transferId, payload, phase });
+    } catch {
+    }
+    try {
+      await this.stores.backstop.drop(transferId);
+    } catch {
+    }
+  }
+  async disposeOnFailure(transferId, committed, cls) {
+    if (committed.length > 0 || cls === "keep-open") return;
+    try {
+      await this.stores.backstop.setDisposition(transferId, "abortPending");
+    } catch {
+    }
+    try {
+      await this.deps.intents.abort(transferId);
+      await this.stores.backstop.drop(transferId);
+    } catch {
+    }
+  }
+  attention() {
+    return (transferId, code, detail) => {
+      this.deps.emit("transfer:attention", detail === void 0 ? { transferId, code } : { transferId, code, detail });
+    };
+  }
+};
+function conflictAmount(engine, payload, op, source) {
+  if (op.kind === "split") return BigInt(payload.split.splitAmount);
+  return source !== void 0 ? engine.balanceOf(source, payload.coinId) : 0n;
+}
+
+// modules/payments-v2/machine/resume.ts
+async function resumeAll(deps) {
+  const report = { resumed: [], conflicted: [], failed: [] };
+  const stores = createMachineStores(deps.kv);
+  const open = await deps.intents.listOpen();
+  let locals;
+  try {
+    locals = new Map((await stores.backstop.list()).map((e) => [e.transferId, e]));
+  } catch {
+    return report;
+  }
+  await dropStaleLocalAborts(stores, locals, new Set(open.map((i) => i.transferId)));
+  const jobs = await gateAndDecode(deps, stores, open, locals, report);
+  const ctx = {
+    deps,
+    stores,
+    machine: new TransferMachine(deps),
+    sources: await fetchSources(deps, jobs)
+  };
+  for (const job of jobs) {
+    await runOne(ctx, job, report);
+  }
+  return report;
+}
+async function dropStaleLocalAborts(stores, locals, openIds) {
+  for (const entry of locals.values()) {
+    if (entry.disposition !== "open" && !openIds.has(entry.transferId)) {
+      await stores.backstop.drop(entry.transferId);
+    }
+  }
+}
+async function gateAndDecode(deps, stores, open, locals, report) {
+  const jobs = [];
+  for (const intent of open) {
+    const local = locals.get(intent.transferId);
+    if (local !== void 0 && local.disposition !== "open") {
+      try {
+        await deps.intents.abort(intent.transferId);
+        await stores.backstop.drop(intent.transferId);
+      } catch {
+      }
+      report.conflicted.push(intent.transferId);
+      continue;
+    }
+    let payload;
+    try {
+      payload = validatePayload(await deps.decryptPayload(intent.payload));
+    } catch {
+      report.failed.push(intent.transferId);
+      continue;
+    }
+    jobs.push({
+      transferId: intent.transferId,
+      payload,
+      journaled: await stores.deliveryJournal.byTransfer(intent.transferId)
+    });
+  }
+  return jobs;
+}
+async function fetchSources(deps, jobs) {
+  const needed = /* @__PURE__ */ new Set();
+  for (const job of jobs) {
+    for (const op of buildOps(job.payload)) {
+      if (op.kind === "direct" && job.journaled.has(op.opIndex)) continue;
+      needed.add(op.sourceTokenId);
+    }
+  }
+  const decoded = /* @__PURE__ */ new Map();
+  if (needed.size === 0) return decoded;
+  let blobs;
+  try {
+    blobs = await deps.storage.getBlobs([...needed]);
+  } catch {
+    return decoded;
+  }
+  const engine = deps.engine();
+  for (const [tokenId, bytes] of blobs) {
+    try {
+      decoded.set(tokenId, await engine.decodeToken({ v: TOKEN_BLOB_VERSION, network: 0, tokenId, token: bytes }));
+    } catch {
+    }
+  }
+  return decoded;
+}
+async function runOne(ctx, job, report) {
+  const mine = /* @__PURE__ */ new Map();
+  for (const op of buildOps(job.payload)) {
+    if (op.kind === "direct" && job.journaled.has(op.opIndex)) continue;
+    const token = ctx.sources.get(op.sourceTokenId);
+    if (token === void 0) {
+      report.failed.push(job.transferId);
+      return;
+    }
+    mine.set(op.sourceTokenId, token);
+  }
+  try {
+    await ctx.machine.resumeIntent({
+      transferId: job.transferId,
+      payload: job.payload,
+      sources: mine,
+      journaled: job.journaled
+    });
+    report.resumed.push(job.transferId);
+  } catch (err) {
+    await classifyResumeFailure(ctx.deps, ctx.stores, job.transferId, err, report);
+  }
+}
+async function classifyResumeFailure(deps, stores, transferId, err, report) {
+  if (classifyError(err) === "conflict") {
+    try {
+      await deps.intents.abort(transferId);
+      await stores.backstop.drop(transferId);
+    } catch {
+    }
+    report.conflicted.push(transferId);
+    return;
+  }
+  const code = err !== null && typeof err === "object" ? err.code : void 0;
+  if (code === "SPLIT_CHECKPOINT_LOST" || code === "CHECKPOINT_TRUSTBASE_MISMATCH") {
+    deps.emit("transfer:attention", { transferId, code: ATTENTION_CHECKPOINT_STUCK, detail: String(code) });
+  }
+  report.failed.push(transferId);
+}
+function validatePayload(raw) {
+  const p = raw !== null && typeof raw === "object" ? raw : null;
+  if (p === null || p.v !== 2 || !Array.isArray(p.direct) || p.direct.some((t) => typeof t !== "string")) {
+    throw new SphereError(
+      `unsupported intent payload shape (v=${String(raw?.v)}) \u2014 not resumable`,
+      "VALIDATION_ERROR"
+    );
+  }
+  if (typeof p.recipient !== "string" || typeof p.coinId !== "string" || typeof p.amount !== "string") {
+    throw new SphereError("intent payload is missing recipient/coinId/amount", "VALIDATION_ERROR");
+  }
+  const s = p.split;
+  if (s !== void 0 && (typeof s.tokenId !== "string" || typeof s.splitAmount !== "string" || typeof s.remainderAmount !== "string")) {
+    throw new SphereError("intent payload split spec is malformed", "VALIDATION_ERROR");
+  }
+  return p;
+}
+
+// node_modules/@noble/ciphers/utils.js
+function isBytes2(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+function abool(b) {
+  if (typeof b !== "boolean")
+    throw new TypeError(`boolean expected, not ${b}`);
+}
+function anumber(n) {
+  if (typeof n !== "number")
+    throw new TypeError("number expected, got " + typeof n);
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new RangeError("positive integer expected, got " + n);
+}
+function abytes2(value, length, title = "") {
+  const bytes = isBytes2(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
+    if (!bytes)
+      throw new TypeError(message);
+    throw new RangeError(message);
+  }
+  return value;
+}
+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, onlyAligned = false) {
+  abytes2(out, void 0, "output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new RangeError("digestInto() expects output buffer of length at least " + min);
+  }
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+}
+function u32(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);
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+var swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n) >>> 0;
+var byteSwap32 = (arr) => {
+  for (let i = 0; i < arr.length; i++)
+    arr[i] = byteSwap(arr[i]);
+  return arr;
+};
+var swap32IfBE = isLE ? (u) => u : byteSwap32;
+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;
+}
+function wrapMacConstructor(keyLen, macCons, fromMsg) {
+  const mac = macCons;
+  const getArgs = fromMsg || (() => []);
+  const macC = (msg, key) => mac(key, ...getArgs(msg)).update(msg).digest();
+  const tmp = mac(new Uint8Array(keyLen), ...getArgs(new Uint8Array(0)));
+  macC.outputLen = tmp.outputLen;
+  macC.blockLen = tmp.blockLen;
+  macC.create = (key, ...args) => mac(key, ...args);
+  return macC;
+}
+var wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, constructor) => {
+  function wrappedCipher(key, ...args) {
+    abytes2(key, void 0, "key");
+    if (params.nonceLength !== void 0) {
+      const nonce = args[0];
+      abytes2(nonce, params.varSizeNonce ? void 0 : params.nonceLength, "nonce");
+    }
+    const tagl = params.tagLength;
+    if (tagl && args[1] !== void 0)
+      abytes2(args[1], void 0, "AAD");
+    const cipher = constructor(key, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== void 0) {
+        if (fnLength !== 2)
+          throw new Error("cipher output not supported");
+        abytes2(output, void 0, "output");
+      }
+    };
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        called = true;
+        abytes2(data);
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes2(data);
+        if (tagl && data.length < tagl)
+          throw new Error('"ciphertext" expected length bigger 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);
+  abytes2(out, void 0, "output");
+  if (out.length !== expectedLength)
+    throw new Error('"output" expected Uint8Array of length ' + expectedLength + ", got: " + out.length);
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
+}
+function u64Lengths(dataLength, aadLength, isLE2) {
+  anumber(dataLength);
+  anumber(aadLength);
+  abool(isLE2);
+  const num = new Uint8Array(16);
+  const view = createView2(num);
+  view.setBigUint64(0, BigInt(aadLength), isLE2);
+  view.setBigUint64(8, BigInt(dataLength), isLE2);
+  return num;
+}
+function isAligned32(bytes) {
+  return bytes.byteOffset % 4 === 0;
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(abytes2(bytes));
+}
+function randomBytes(bytesLength = 32) {
+  anumber(bytesLength);
+  const cr = typeof globalThis === "object" ? globalThis.crypto : null;
+  if (typeof cr?.getRandomValues !== "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return cr.getRandomValues(new Uint8Array(bytesLength));
+}
+
+// node_modules/@noble/ciphers/_arx.js
+var encodeStr = (str) => Uint8Array.from(str.split(""), (c) => c.charCodeAt(0));
+var sigma16_32 = /* @__PURE__ */ (() => swap32IfBE(u32(encodeStr("expand 16-byte k"))))();
+var sigma32_32 = /* @__PURE__ */ (() => swap32IfBE(u32(encodeStr("expand 32-byte k"))))();
+function rotl(a, b) {
+  return a << b | a >>> 32 - b;
+}
+var BLOCK_LEN = 64;
+var BLOCK_LEN32 = 16;
+var MAX_COUNTER = /* @__PURE__ */ (() => 2 ** 32 - 1)();
+var U32_EMPTY = /* @__PURE__ */ Uint32Array.of();
+function runCipher(core, sigma, key, nonce, data, output, counter, rounds) {
+  const len = data.length;
+  const block = new Uint8Array(BLOCK_LEN);
+  const b32 = u32(block);
+  const isAligned = isLE && isAligned32(data) && isAligned32(output);
+  const d32 = isAligned ? u32(data) : U32_EMPTY;
+  const o32 = isAligned ? u32(output) : U32_EMPTY;
+  if (!isLE) {
+    for (let pos = 0; pos < len; counter++) {
+      core(sigma, key, nonce, b32, counter, rounds);
+      swap32IfBE(b32);
+      if (counter >= MAX_COUNTER)
+        throw new Error("arx: counter overflow");
+      const take = Math.min(BLOCK_LEN, len - pos);
+      for (let j = 0, posj; j < take; j++) {
+        posj = pos + j;
+        output[posj] = data[posj] ^ block[j];
+      }
+      pos += take;
+    }
+    return;
+  }
+  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] ^ block[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) => {
+    abytes2(key, void 0, "key");
+    abytes2(nonce, void 0, "nonce");
+    abytes2(data, void 0, "data");
+    const len = data.length;
+    output = getOutput(len, output, false);
+    anumber(counter);
+    if (counter < 0 || counter >= MAX_COUNTER)
+      throw new Error("arx: counter overflow");
+    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 {
+      abytes2(key, 32, "arx key");
+      throw new Error("invalid key size");
+    }
+    if (!isLE || !isAligned32(nonce))
+      toClean.push(nonce = copyBytes(nonce));
+    let k32 = u32(k);
+    if (extendNonceFn) {
+      if (nonce.length !== 24)
+        throw new Error(`arx: extended nonce must be 24 bytes`);
+      const n16 = nonce.subarray(0, 16);
+      if (isLE)
+        extendNonceFn(sigma, k32, u32(n16), k32);
+      else {
+        const sigmaRaw = swap32IfBE(Uint32Array.from(sigma));
+        extendNonceFn(sigmaRaw, k32, u32(n16), k32);
+        clean2(sigmaRaw);
+        swap32IfBE(k32);
+      }
+      nonce = nonce.subarray(16);
+    } else if (!isLE)
+      swap32IfBE(k32);
+    const nonceNcLen = 16 - counterLength;
+    if (nonceNcLen !== nonce.length)
+      throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);
+    if (nonceNcLen !== 12) {
+      const nc = new Uint8Array(12);
+      nc.set(nonce, counterRight ? 0 : 12 - nonce.length);
+      nonce = nc;
+      toClean.push(nonce);
+    }
+    const n32 = swap32IfBE(u32(nonce));
+    try {
+      runCipher(core, sigma, k32, n32, data, output, counter, rounds);
+      return output;
+    } finally {
+      clean2(...toClean);
+    }
+  };
+}
+
+// node_modules/@noble/ciphers/_poly1305.js
+function u8to16(a, i) {
+  return a[i++] & 255 | (a[i++] & 255) << 8;
+}
+var Poly1305 = class {
+  blockLen = 16;
+  outputLen = 16;
+  buffer = new Uint8Array(16);
+  r = new Uint16Array(10);
+  // Allocating 1 array with .subarray() here is slower than 3
+  h = new Uint16Array(10);
+  pad = new Uint16Array(8);
+  pos = 0;
+  finished = false;
+  destroyed = false;
+  // Can be speed-up using BigUint64Array, at the cost of complexity
+  constructor(key) {
+    key = copyBytes(abytes2(key, 32, "key"));
+    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;
+    }
+    clean2(g);
+  }
+  update(data) {
+    aexists2(this);
+    abytes2(data);
+    data = copyBytes(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() {
+    this.destroyed = true;
+    clean2(this.h, this.r, this.buffer, this.pad);
+  }
+  digestInto(out) {
+    aexists2(this);
+    aoutput2(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;
+    }
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+};
+var poly1305 = /* @__PURE__ */ wrapMacConstructor(32, (key) => new Poly1305(key));
+
+// node_modules/@noble/ciphers/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, out) {
+  let x00 = swap8IfBE(s[0]), x01 = swap8IfBE(s[1]), x02 = swap8IfBE(s[2]), x03 = swap8IfBE(s[3]), x04 = swap8IfBE(k[0]), x05 = swap8IfBE(k[1]), x06 = swap8IfBE(k[2]), x07 = swap8IfBE(k[3]), x08 = swap8IfBE(k[4]), x09 = swap8IfBE(k[5]), x10 = swap8IfBE(k[6]), x11 = swap8IfBE(k[7]), x12 = swap8IfBE(i[0]), x13 = swap8IfBE(i[1]), x14 = swap8IfBE(i[2]), x15 = swap8IfBE(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;
+  out[oi++] = x00;
+  out[oi++] = x01;
+  out[oi++] = x02;
+  out[oi++] = x03;
+  out[oi++] = x12;
+  out[oi++] = x13;
+  out[oi++] = x14;
+  out[oi++] = x15;
+  swap32IfBE(out);
+}
+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 leftover = msg.length % 16;
+  if (leftover)
+    h.update(ZEROS16.subarray(leftover));
+};
+var ZEROS32 = /* @__PURE__ */ new Uint8Array(32);
+function computeTag(fn, key, nonce, ciphertext, AAD) {
+  if (AAD !== void 0)
+    abytes2(AAD, void 0, "AAD");
+  const authKey = fn(key, nonce, ZEROS32);
+  const lengths = u64Lengths(ciphertext.length, AAD ? AAD.length : 0, true);
+  const h = poly1305.create(authKey);
+  if (AAD)
+    updatePadded(h, AAD);
+  updatePadded(h, ciphertext);
+  h.update(lengths);
+  const res = h.digest();
+  clean2(authKey, lengths);
+  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);
+      clean2(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)) {
+        clean2(tag);
+        throw new Error("invalid tag");
+      }
+      output.set(ciphertext.subarray(0, -tagLength));
+      xorStream(key, nonce, output, output, 1);
+      clean2(tag);
+      return output;
+    }
+  };
+};
+var xchacha20poly1305 = /* @__PURE__ */ wrapCipher(
+  { blockSize: 64, nonceLength: 24, tagLength: 16 },
+  /* @__PURE__ */ _poly1305_aead(xchacha20)
+);
+
+// core/field-encryption.ts
+var FIELD_ENVELOPE_PREFIX = "enc1.";
+var FIELD_ENVELOPE_NONCE_BYTES = 24;
+var POLY1305_TAG_BYTES = 16;
+var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var B64_LOOKUP = {};
+for (let i = 0; i < B64_ALPHABET.length; i++) B64_LOOKUP[B64_ALPHABET[i]] = i;
+function base64Encode(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    out += B64_ALPHABET[b0 >> 2];
+    out += B64_ALPHABET[(b0 & 3) << 4 | b1 >> 4];
+    out += i + 1 < bytes.length ? B64_ALPHABET[(b1 & 15) << 2 | b2 >> 6] : "=";
+    out += i + 2 < bytes.length ? B64_ALPHABET[b2 & 63] : "=";
+  }
+  return out;
+}
+function base64Decode(s) {
+  if (s.length % 4 !== 0) {
+    throw new SphereError("Invalid field envelope: base64 length not a multiple of 4", "DECRYPTION_ERROR");
+  }
+  let padding = 0;
+  if (s.endsWith("==")) padding = 2;
+  else if (s.endsWith("=")) padding = 1;
+  const body = s.slice(0, s.length - padding);
+  if (body.includes("=")) {
+    throw new SphereError("Invalid field envelope: misplaced base64 padding", "DECRYPTION_ERROR");
+  }
+  const out = new Uint8Array(s.length / 4 * 3 - padding);
+  let o = 0;
+  for (let i = 0; i < body.length; i += 4) {
+    const n0 = B64_LOOKUP[body[i]];
+    const n1 = B64_LOOKUP[body[i + 1]];
+    const n2 = body[i + 2] !== void 0 ? B64_LOOKUP[body[i + 2]] : 0;
+    const n3 = body[i + 3] !== void 0 ? B64_LOOKUP[body[i + 3]] : 0;
+    if (n0 === void 0 || n1 === void 0 || n2 === void 0 || n3 === void 0) {
+      throw new SphereError("Invalid field envelope: non-base64 character", "DECRYPTION_ERROR");
+    }
+    const triple = n0 << 18 | n1 << 12 | n2 << 6 | n3;
+    if (o < out.length) out[o++] = triple >> 16 & 255;
+    if (o < out.length) out[o++] = triple >> 8 & 255;
+    if (o < out.length) out[o++] = triple & 255;
+  }
+  return out;
+}
+function encryptFieldBytes(key, plaintext, aad) {
+  const nonce = randomBytes(FIELD_ENVELOPE_NONCE_BYTES);
+  const ciphertext = xchacha20poly1305(key, nonce, aad).encrypt(plaintext);
+  const packed = new Uint8Array(nonce.length + ciphertext.length);
+  packed.set(nonce, 0);
+  packed.set(ciphertext, nonce.length);
+  return FIELD_ENVELOPE_PREFIX + base64Encode(packed);
+}
+function decryptFieldBytes(key, envelope, aad) {
+  if (typeof envelope !== "string" || !envelope.startsWith(FIELD_ENVELOPE_PREFIX)) {
+    throw new SphereError('Invalid field envelope: missing "enc1." prefix', "DECRYPTION_ERROR");
+  }
+  const packed = base64Decode(envelope.slice(FIELD_ENVELOPE_PREFIX.length));
+  if (packed.length < FIELD_ENVELOPE_NONCE_BYTES + POLY1305_TAG_BYTES) {
+    throw new SphereError("Invalid field envelope: too short for nonce + tag", "DECRYPTION_ERROR");
+  }
+  const nonce = packed.slice(0, FIELD_ENVELOPE_NONCE_BYTES);
+  const ciphertext = packed.slice(FIELD_ENVELOPE_NONCE_BYTES);
+  try {
+    return xchacha20poly1305(key, nonce, aad).decrypt(ciphertext);
+  } catch (err) {
+    throw new SphereError("Field envelope authentication failed (tampered, wrong key, or wrong AAD)", "DECRYPTION_ERROR", err);
+  }
+}
+function encryptField(key, plaintext) {
+  return encryptFieldBytes(key, new TextEncoder().encode(plaintext));
+}
+function decryptField(key, envelope) {
+  return new TextDecoder().decode(decryptFieldBytes(key, envelope));
+}
+
+// modules/payments-v2/history/History.ts
+var WIRE_TOKEN_ID = /^(?:[0-9a-f]{2}){1,64}$/;
+var WIRE_PUBKEY = /^0[23][0-9a-f]{64}$/;
+var History = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  // ── read-through ───────────────────────────────────────────────────────────
+  async page(opts = {}) {
+    const result = await this.deps.client.listHistory({
+      ...opts.before !== void 0 ? { before: opts.before } : {},
+      ...opts.limit !== void 0 ? { limit: opts.limit } : {}
+    });
+    return {
+      entries: result.records.map((record) => this.toEntry(record)),
+      more: result.more,
+      cursor: result.cursor
+    };
+  }
+  // ── client POSTs (best-effort — NEVER throw into the money path) ────────────
+  async recordSent(input) {
+    await this.post(() => ({
+      dedupKey: input.transferId,
+      id: (this.deps.newId ?? randomUUID)(),
+      type: "SENT",
+      assets: [{ coinId: input.coinId, amount: input.amount }],
+      ts: this.ts(input.timestamp),
+      transferId: input.transferId,
+      ...this.wireTokenId(input.tokenId),
+      ...this.wireCounterparty(input.recipientPubkey, input.recipientNametag),
+      ...this.wireMemo(input.memo)
+    }));
+  }
+  async recordReceived(input) {
+    await this.post(() => ({
+      dedupKey: `RECEIVED:${input.tokenId.toLowerCase()}:${input.stateHash.toLowerCase()}`,
+      id: (this.deps.newId ?? randomUUID)(),
+      type: "RECEIVED",
+      assets: [{ coinId: input.coinId, amount: input.amount }],
+      ts: this.ts(input.timestamp),
+      ...input.transferId !== void 0 ? { transferId: input.transferId } : {},
+      ...this.wireTokenId(input.tokenId),
+      ...this.wireCounterparty(input.senderPubkey, input.senderNametag),
+      ...this.wireMemo(input.memo)
+    }));
+  }
+  async recordMint(input) {
+    await this.post(() => ({
+      dedupKey: `MINT:${input.tokenId.toLowerCase()}`,
+      id: (this.deps.newId ?? randomUUID)(),
+      type: "MINT",
+      assets: [{ coinId: input.coinId, amount: input.amount }],
+      ts: this.ts(input.timestamp),
+      ...this.wireTokenId(input.tokenId)
+    }));
+  }
+  // ── internals ────────────────────────────────────────────────────────────────
+  async post(build) {
+    try {
+      await this.deps.client.postHistory([build()]);
+    } catch (err) {
+      this.deps.log?.("history POST failed (dedupKey makes retry safe)", err);
+      return;
+    }
+    this.deps.emit("history:updated");
+  }
+  ts(timestamp) {
+    return new Date(timestamp ?? (this.deps.now ?? Date.now)()).toISOString();
+  }
+  wireTokenId(tokenId) {
+    const lower = tokenId?.toLowerCase();
+    return lower !== void 0 && WIRE_TOKEN_ID.test(lower) ? { tokenId: lower } : {};
+  }
+  // Server zod is strict — a non-pubkey counterparty stays off the wire; the
+  // nametag rides regardless (S6-encrypted, operator-blind).
+  wireCounterparty(pubkey, nametag) {
+    const lower = pubkey?.toLowerCase();
+    return {
+      ...lower !== void 0 && WIRE_PUBKEY.test(lower) ? { counterpartyPubkey: lower } : {},
+      ...nametag !== void 0 ? { counterpartyNametag: encryptField(this.deps.fieldKey, nametag) } : {}
+    };
+  }
+  wireMemo(memo) {
+    return memo !== void 0 ? { memo: encryptField(this.deps.fieldKey, memo) } : {};
+  }
+  // Consumed mapping: wire `ts` (ISO 8601, any offset) → epoch-ms `timestamp`;
+  // coinId/amount from the FIRST asset (multi-asset remainder surfaces via
+  // tokenIds[]); counterparty lands on the role-appropriate side by type.
+  toEntry(wire) {
+    const first = wire.assets[0];
+    const coinId = first?.coinId ?? "";
+    const received = wire.type === "RECEIVED";
+    const memo = this.tryDecrypt(wire.memo);
+    const nametag = this.tryDecrypt(wire.counterpartyNametag);
+    return {
+      id: wire.id,
+      type: wire.type,
+      coinId,
+      amount: first?.amount ?? "0",
+      symbol: this.deps.registry.getSymbol(coinId),
+      timestamp: Date.parse(wire.ts),
+      ...wire.transferId !== void 0 ? { transferId: wire.transferId } : {},
+      ...wire.tokenId !== void 0 ? { tokenId: wire.tokenId } : {},
+      ...wire.assets.length > 1 ? { tokenIds: wire.assets.map((asset) => ({ id: asset.coinId, amount: asset.amount })) } : {},
+      ...wire.counterpartyPubkey !== void 0 ? received ? { senderPubkey: wire.counterpartyPubkey } : { recipientPubkey: wire.counterpartyPubkey } : {},
+      ...nametag !== void 0 ? received ? { senderNametag: nametag } : { recipientNametag: nametag } : {},
+      ...memo !== void 0 ? { memo } : {}
+    };
+  }
+  // Self-scoped decrypt: a foreign/undecryptable/plaintext value is absent,
+  // never ciphertext and never a throw.
+  tryDecrypt(envelope) {
+    if (envelope === void 0) return void 0;
+    try {
+      return decryptField(this.deps.fieldKey, envelope);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// modules/payments-v2/inventory/InventoryView.ts
+var SUSPECTED_KEY = "suspected-spent";
+var KNOWN_SPENDS_KEY = "known-spends";
+function stateKey(tokenId, stateHash) {
+  return `${tokenId}:${stateHash}`;
+}
+var InventoryView = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  mirror = /* @__PURE__ */ new Map();
+  suspected = /* @__PURE__ */ new Set();
+  knownSpends = /* @__PURE__ */ new Set();
+  inFlight = /* @__PURE__ */ new Set();
+  firstPullOk = false;
+  hydrated = null;
+  chain = Promise.resolve();
+  overlayChain = Promise.resolve();
+  sharedPull = null;
+  fullPull() {
+    if (this.sharedPull) return this.sharedPull;
+    const run = this.enqueue(() => this.doFullPull(false)).finally(() => {
+      this.sharedPull = null;
+    });
+    this.sharedPull = run;
+    return run;
+  }
+  delta(since) {
+    return this.enqueue(async () => {
+      await this.hydrate();
+      if (!this.firstPullOk) {
+        await this.doFullPull(false);
+        return;
+      }
+      const flags = { changed: false };
+      try {
+        await this.runDeltaLoop(since, void 0, flags);
+      } finally {
+        if (flags.changed) this.deps.emit("inventory:updated");
+      }
+    });
+  }
+  // Epoch reset (§5.1): full re-pull with per-key replace; entries absent from
+  // the restored server drop only AFTER the new snapshot is fully applied.
+  onEpochReset() {
+    return this.enqueue(() => this.doFullPull(true));
+  }
+  async demote(tokenId, stateHash) {
+    if (tokenId === "" || stateHash === "") {
+      throw new Error("demote requires both tokenId and stateHash");
+    }
+    const key = stateKey(tokenId, stateHash);
+    if (this.suspected.has(key)) return;
+    const added = await this.inOverlayChain(async () => {
+      await this.hydrate();
+      if (this.suspected.has(key)) return false;
+      await this.deps.kv.set(SUSPECTED_KEY, [...this.suspected, key]);
+      this.suspected.add(key);
+      return true;
+    });
+    if (added) this.deps.emit("inventory:updated");
+  }
+  recoverRemoved(getBlobs, isSpent, reAdd) {
+    return this.enqueue(() => this.doRecover(getBlobs, isSpent, reAdd));
+  }
+  markInFlight(tokenId) {
+    if (this.inFlight.has(tokenId)) return;
+    this.inFlight.add(tokenId);
+    this.deps.emit("inventory:updated");
+  }
+  release(tokenId) {
+    if (this.inFlight.delete(tokenId)) this.deps.emit("inventory:updated");
+  }
+  pool(coinId) {
+    const out = [];
+    for (const [tokenId, entry] of this.mirror) {
+      if (entry.status !== "active" || this.inFlight.has(tokenId)) continue;
+      if (this.suspected.has(stateKey(tokenId, entry.stateHash))) continue;
+      const asset = entry.assets.find((a) => a.coinId === coinId);
+      if (asset) out.push({ tokenId, amount: BigInt(asset.amount) });
+    }
+    return out;
+  }
+  tokens(registry, filter) {
+    const out = [];
+    for (const [tokenId, entry] of this.mirror) {
+      if (entry.status !== "active") continue;
+      const asset = entry.assets[0];
+      if (!asset) continue;
+      if (filter?.coinId !== void 0 && asset.coinId !== filter.coinId) continue;
+      out.push(this.toToken(tokenId, entry, asset, registry));
+    }
+    return out;
+  }
+  async assets(registry, price) {
+    const raw = [];
+    for (const [coinId, totals] of this.aggregate()) {
+      raw.push(this.toAsset(coinId, totals, registry));
+    }
+    if (!price || raw.length === 0) return raw;
+    return this.withPrices(raw, registry, price);
+  }
+  enqueue(fn) {
+    const run = this.chain.then(fn, fn);
+    this.chain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  inOverlayChain(fn) {
+    const run = this.overlayChain.then(fn, fn);
+    this.overlayChain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  hydrate() {
+    this.hydrated ??= this.loadDurable().catch((error) => {
+      this.hydrated = null;
+      throw error;
+    });
+    return this.hydrated;
+  }
+  async loadDurable() {
+    const suspected = await this.deps.kv.get(SUSPECTED_KEY);
+    for (const key of suspected ?? []) this.suspected.add(key);
+    const known = await this.deps.kv.get(KNOWN_SPENDS_KEY);
+    for (const key of known ?? []) this.knownSpends.add(key);
+  }
+  now() {
+    return (this.deps.now ?? Date.now)();
+  }
+  async doFullPull(reconcileAbsent) {
+    await this.hydrate();
+    const seen = reconcileAbsent ? /* @__PURE__ */ new Set() : void 0;
+    const flags = { changed: false };
+    try {
+      let page = await this.deps.port.listInventory();
+      const firstCursor = page.cursor;
+      if (this.applyItems(page.items, seen)) flags.changed = true;
+      while (page.more) {
+        page = await this.deps.port.listInventory(page.cursor);
+        if (this.applyItems(page.items, seen)) flags.changed = true;
+      }
+      await this.runDeltaLoop(firstCursor, seen, flags);
+      if (seen && this.dropAbsent(seen)) flags.changed = true;
+      this.firstPullOk = true;
+    } finally {
+      if (flags.changed) this.deps.emit("inventory:updated");
+    }
+  }
+  async runDeltaLoop(since, seen, flags) {
+    let page = await this.deps.port.listInventory(since);
+    if (this.applyItems(page.items, seen)) flags.changed = true;
+    while (page.more) {
+      page = await this.deps.port.listInventory(page.cursor);
+      if (this.applyItems(page.items, seen)) flags.changed = true;
+    }
+  }
+  // Synchronous per-key application; the overlay prune runs in this same
+  // synchronous step (F7) — never against a cleared or half-filled view.
+  applyItems(items, seen) {
+    const now = this.now();
+    let changed = false;
+    for (const item of items) {
+      seen?.add(item.tokenId);
+      if (this.applyOne(item, now)) changed = true;
+    }
+    const pruned = this.pruneOverlaySync(false);
+    return changed || pruned;
+  }
+  applyOne(item, now) {
+    const prev = this.mirror.get(item.tokenId);
+    if (prev && item.seq < prev.seq) return false;
+    if (prev && prev.seq === item.seq && prev.status === item.status && prev.stateHash === item.stateHash) {
+      return false;
+    }
+    this.mirror.set(item.tokenId, {
+      stateHash: item.stateHash,
+      seq: item.seq,
+      status: item.status,
+      assets: item.assets ?? prev?.assets ?? [],
+      createdAt: prev?.createdAt ?? now,
+      updatedAt: now
+    });
+    return true;
+  }
+  // Prunes only on positive evidence (state advance or tombstone). Absence is
+  // evidence only when the caller holds a complete post-reset snapshot.
+  pruneOverlaySync(allowAbsent) {
+    let pruned = false;
+    for (const key of this.suspected) {
+      const cut = key.lastIndexOf(":");
+      const entry = this.mirror.get(key.slice(0, cut));
+      const live = entry !== void 0 ? entry.status === "active" && entry.stateHash === key.slice(cut + 1) : !allowAbsent;
+      if (!live) {
+        this.suspected.delete(key);
+        pruned = true;
+      }
+    }
+    if (pruned) this.schedulePersistSuspected();
+    return pruned;
+  }
+  schedulePersistSuspected() {
+    void this.inOverlayChain(() => this.deps.kv.set(SUSPECTED_KEY, [...this.suspected])).catch(
+      () => void 0
+    );
+  }
+  dropAbsent(seen) {
+    let changed = false;
+    for (const tokenId of [...this.mirror.keys()]) {
+      if (!seen.has(tokenId)) {
+        this.mirror.delete(tokenId);
+        changed = true;
+      }
+    }
+    if (changed) this.pruneOverlaySync(true);
+    return changed;
+  }
+  async doRecover(getBlobs, isSpent, reAdd) {
+    await this.hydrate();
+    const candidates = this.firstPullOk ? this.recoveryCandidates() : [];
+    if (candidates.length === 0) return { recovered: [], confirmedSpent: [] };
+    const blobs = await getBlobs(candidates.map((c) => c.tokenId));
+    const recovered = [];
+    const confirmedSpent = [];
+    try {
+      for (const candidate of candidates) {
+        const blob = blobs.get(candidate.tokenId);
+        if (!blob) continue;
+        const outcome = await this.recoverOne(candidate, blob, isSpent, reAdd);
+        if (outcome === "recovered") recovered.push(candidate.tokenId);
+        if (outcome === "spent") confirmedSpent.push(candidate);
+      }
+    } finally {
+      if (recovered.length > 0) this.deps.emit("inventory:updated");
+    }
+    return { recovered, confirmedSpent };
+  }
+  recoveryCandidates() {
+    const out = [];
+    for (const [tokenId, entry] of this.mirror) {
+      if (entry.status !== "removed") continue;
+      if (this.knownSpends.has(stateKey(tokenId, entry.stateHash))) continue;
+      out.push({ tokenId, stateHash: entry.stateHash });
+    }
+    return out;
+  }
+  async recoverOne(candidate, blob, isSpent, reAdd) {
+    if (await isSpent(candidate.tokenId, blob)) {
+      await this.recordKnownSpend(candidate);
+      return "spent";
+    }
+    if (await reAdd(candidate.tokenId, blob) === "evidenced-tombstone") {
+      await this.recordKnownSpend(candidate);
+      return "spent";
+    }
+    const current = this.mirror.get(candidate.tokenId);
+    if (!current || current.status !== "removed" || current.stateHash !== candidate.stateHash) {
+      return "skipped";
+    }
+    current.status = "active";
+    current.updatedAt = this.now();
+    return "recovered";
+  }
+  async recordKnownSpend(spend) {
+    if (spend.tokenId === "" || spend.stateHash === "") {
+      throw new Error("knownSpend requires both tokenId and stateHash");
+    }
+    this.knownSpends.add(stateKey(spend.tokenId, spend.stateHash));
+    await this.deps.kv.set(KNOWN_SPENDS_KEY, [...this.knownSpends]);
+  }
+  toToken(tokenId, entry, asset, registry) {
+    const iconUrl = registry.getIconUrl(asset.coinId);
+    const suspected = this.suspected.has(stateKey(tokenId, entry.stateHash));
+    return {
+      id: tokenId,
+      coinId: asset.coinId,
+      symbol: registry.getSymbol(asset.coinId),
+      name: registry.getName(asset.coinId),
+      decimals: registry.getDecimals(asset.coinId),
+      ...iconUrl !== null ? { iconUrl } : {},
+      amount: asset.amount,
+      status: this.inFlight.has(tokenId) ? "transferring" : "confirmed",
+      createdAt: entry.createdAt,
+      updatedAt: entry.updatedAt,
+      lazy: true,
+      ...suspected ? { suspectedSpent: true } : {}
+    };
+  }
+  aggregate() {
+    const groups = /* @__PURE__ */ new Map();
+    for (const [tokenId, entry] of this.mirror) {
+      if (entry.status !== "active") continue;
+      const moving = this.inFlight.has(tokenId);
+      for (const asset of entry.assets) {
+        let group = groups.get(asset.coinId);
+        if (!group) {
+          group = { total: 0n, count: 0, transferring: 0n, transferringCount: 0 };
+          groups.set(asset.coinId, group);
+        }
+        if (moving) {
+          group.transferring += BigInt(asset.amount);
+          group.transferringCount += 1;
+        } else {
+          group.total += BigInt(asset.amount);
+          group.count += 1;
+        }
+      }
+    }
+    return groups;
+  }
+  toAsset(coinId, totals, registry) {
+    const iconUrl = registry.getIconUrl(coinId);
+    return {
+      coinId,
+      symbol: registry.getSymbol(coinId),
+      name: registry.getName(coinId),
+      decimals: registry.getDecimals(coinId),
+      ...iconUrl !== null ? { iconUrl } : {},
+      totalAmount: totals.total.toString(),
+      tokenCount: totals.count,
+      confirmedAmount: totals.total.toString(),
+      unconfirmedAmount: "0",
+      confirmedTokenCount: totals.count,
+      unconfirmedTokenCount: 0,
+      transferringTokenCount: totals.transferringCount,
+      transferringAmount: totals.transferring.toString(),
+      priceUsd: null,
+      priceEur: null,
+      change24h: null,
+      fiatValueUsd: null,
+      fiatValueEur: null
+    };
+  }
+  async withPrices(raw, registry, price) {
+    try {
+      const names = [...new Set(raw.map((a) => registry.getName(a.coinId)))];
+      const quotes = await price.getPrices(names);
+      return raw.map((a) => this.priceOne(a, quotes.get(registry.getName(a.coinId))));
+    } catch {
+      return raw;
+    }
+  }
+  // Fiat display conversion is the one sanctioned Number use (display only).
+  priceOne(asset, quote) {
+    if (!quote) return asset;
+    const human = Number(asset.totalAmount) / Math.pow(10, asset.decimals);
+    return {
+      ...asset,
+      priceUsd: quote.priceUsd,
+      priceEur: quote.priceEur ?? null,
+      change24h: quote.change24h ?? null,
+      fiatValueUsd: human * quote.priceUsd,
+      fiatValueEur: quote.priceEur != null ? human * quote.priceEur : null
+    };
+  }
+};
+
+// modules/payments-v2/receive/Receive.ts
+var ACK_BATCH_SIZE = 200;
+var POLL_INTERVAL_MS = 3e4;
+function receivedDedupKey(tokenId, stateHash) {
+  return `RECEIVED:${tokenId}:${stateHash}`;
+}
+var Receive = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  inFlight = null;
+  pollTimer = null;
+  unsubscribeWake = null;
+  drainOnce() {
+    if (this.inFlight) return this.inFlight;
+    const run = this.doDrain().finally(() => {
+      this.inFlight = null;
+    });
+    this.inFlight = run;
+    return run;
+  }
+  start(pollIntervalMs = POLL_INTERVAL_MS) {
+    this.unsubscribeWake ??= this.deps.delivery.onWake?.(() => {
+      void this.drainOnce();
+    }) ?? null;
+    this.pollTimer ??= setInterval(() => {
+      void this.drainOnce();
+    }, pollIntervalMs);
+  }
+  stop() {
+    if (this.pollTimer !== null) clearInterval(this.pollTimer);
+    this.pollTimer = null;
+    this.unsubscribeWake?.();
+    this.unsubscribeWake = null;
+  }
+  async doDrain() {
+    const deps = this.deps;
+    const stored = [];
+    const pending = [];
+    let epoch = "";
+    try {
+      epoch = deps.syncEpoch();
+      const record = await deps.kv.get(STORE_KEYS.streamCursor("mailbox"));
+      const since = record !== null && record.syncEpoch === epoch ? String(record.cursor) : void 0;
+      for await (const entry of deps.delivery.incoming(since)) {
+        await this.processEntry(deps, entry, pending, stored);
+        if (pending.length >= ACK_BATCH_SIZE) await flushAcks(deps, pending, epoch);
+      }
+      await flushAcks(deps, pending, epoch);
+    } catch {
+      await flushAcks(deps, pending, epoch).catch(() => void 0);
+    }
+    return stored;
+  }
+  async processEntry(deps, entry, pending, stored) {
+    const screened = await screen(deps, entry);
+    if (screened.kind === "ack") {
+      pending.push(screened.ack);
+      return;
+    }
+    const outcome = await deps.view.store(screened.record);
+    if (outcome === "rejected") {
+      pending.push(rejectAck(entry, "storage-rejected"));
+      return;
+    }
+    pending.push(claimAck(entry));
+    const transfer = await announce(deps, entry, screened.record);
+    stored.push(transfer);
+    deps.emit("transfer:incoming", transfer);
+  }
+};
+async function screen(deps, entry) {
+  const blobBytes = await entry.fetchBlob();
+  let token;
+  try {
+    token = await deps.engine.decodeToken({
+      v: TOKEN_BLOB_VERSION,
+      network: 0,
+      tokenId: "",
+      token: blobBytes
+    });
+  } catch {
+    return { kind: "ack", ack: rejectAck(entry, "invalid") };
+  }
+  const verdict = await deps.engine.verify(token);
+  if (!verdict.ok) return { kind: "ack", ack: rejectAck(entry, "invalid") };
+  if (!deps.engine.isOwnedBy(token, deps.engine.getIdentity().chainPubkey)) {
+    return { kind: "ack", ack: rejectAck(entry, "not-owned") };
+  }
+  const keys = await deps.engine.deliveryKeys(blobBytes);
+  const held = deps.view.heldState(keys.tokenId);
+  if (held === keys.stateHash) return { kind: "ack", ack: claimAck(entry) };
+  if (held !== null && await deps.engine.isSpent(token)) {
+    return { kind: "ack", ack: rejectAck(entry, "invalid") };
+  }
+  return {
+    kind: "accept",
+    record: { tokenId: keys.tokenId, stateHash: keys.stateHash, assets: toAssetAmounts(token) }
+  };
+}
+async function announce(deps, entry, record) {
+  const receivedAt = (deps.now ?? Date.now)();
+  try {
+    await deps.recordReceived({
+      dedupKey: receivedDedupKey(record.tokenId, record.stateHash),
+      tokenId: record.tokenId,
+      stateHash: record.stateHash,
+      assets: record.assets,
+      ...entry.senderPubkey !== void 0 ? { senderPubkey: entry.senderPubkey } : {},
+      ...entry.senderNametag !== void 0 ? { senderNametag: entry.senderNametag } : {},
+      ...entry.memo !== void 0 ? { memo: entry.memo } : {},
+      receivedAt
+    });
+  } catch {
+  }
+  return {
+    id: record.tokenId,
+    senderPubkey: entry.senderPubkey ?? "",
+    ...entry.senderNametag !== void 0 ? { senderNametag: entry.senderNametag } : {},
+    tokens: record.assets.map((asset) => toUiToken(record.tokenId, asset, deps.registry, receivedAt)),
+    ...entry.memo !== void 0 ? { memo: entry.memo } : {},
+    receivedAt
+  };
+}
+async function flushAcks(deps, pending, epoch) {
+  let lastAcked = null;
+  try {
+    while (pending.length > 0) {
+      const next = pending[0];
+      await deps.delivery.ack(next.deliveryId, next.disposition, next.reason);
+      lastAcked = next.cursor;
+      pending.shift();
+    }
+  } finally {
+    if (lastAcked !== null) {
+      const record = { cursor: lastAcked, syncEpoch: epoch };
+      await deps.kv.set(STORE_KEYS.streamCursor("mailbox"), record);
+    }
+  }
+}
+function claimAck(entry) {
+  return { deliveryId: entry.deliveryId, disposition: "claimed", cursor: entry.cursor };
+}
+function rejectAck(entry, reason) {
+  return { deliveryId: entry.deliveryId, disposition: "rejected", reason, cursor: entry.cursor };
+}
+function toAssetAmounts(token) {
+  return (token.value?.assets ?? []).map((asset) => ({
+    coinId: asset.coinId,
+    amount: asset.amount.toString()
+  }));
+}
+function toUiToken(tokenId, asset, registry, receivedAt) {
+  const iconUrl = registry.getIconUrl(asset.coinId);
+  return {
+    id: tokenId,
+    coinId: asset.coinId,
+    symbol: registry.getSymbol(asset.coinId),
+    name: registry.getName(asset.coinId),
+    decimals: registry.getDecimals(asset.coinId),
+    ...iconUrl !== null ? { iconUrl } : {},
+    amount: asset.amount,
+    status: "confirmed",
+    createdAt: receivedAt,
+    updatedAt: receivedAt,
+    lazy: true
+  };
+}
+
+// core/logger.ts
+var LOGGER_KEY = "__sphere_sdk_logger__";
+function getState() {
+  const g = globalThis;
+  if (!g[LOGGER_KEY]) {
+    g[LOGGER_KEY] = { debug: false, tags: {}, handler: null };
+  }
+  return g[LOGGER_KEY];
+}
+function isEnabled(tag) {
+  const state = getState();
+  if (tag in state.tags) return state.tags[tag];
+  return state.debug;
+}
+var logger = {
+  /**
+   * Configure the logger. Can be called multiple times (last write wins).
+   * Typically called by createBrowserProviders(), createNodeProviders(), or Sphere.init().
+   */
+  configure(config) {
+    const state = getState();
+    if (config.debug !== void 0) state.debug = config.debug;
+    if (config.handler !== void 0) state.handler = config.handler;
+  },
+  /**
+   * Enable/disable debug logging for a specific tag.
+   * Per-tag setting overrides the global debug flag.
+   *
+   * @example
+   * ```ts
+   * logger.setTagDebug('Nostr', true);  // enable only Nostr logs
+   * logger.setTagDebug('Nostr', false); // disable Nostr logs even if global debug=true
+   * ```
+   */
+  setTagDebug(tag, enabled) {
+    getState().tags[tag] = enabled;
+  },
+  /**
+   * Clear per-tag override, falling back to global debug flag.
+   */
+  clearTagDebug(tag) {
+    delete getState().tags[tag];
+  },
+  /** Returns true if debug mode is enabled for the given tag (or globally). */
+  isDebugEnabled(tag) {
+    if (tag) return isEnabled(tag);
+    return getState().debug;
+  },
+  /**
+   * Debug-level log. Only shown when debug is enabled (globally or for this tag).
+   * Use for detailed operational information.
+   */
+  debug(tag, message, ...args) {
+    if (!isEnabled(tag)) return;
+    const state = getState();
+    if (state.handler) {
+      state.handler("debug", tag, message, ...args);
+    } else {
+      console.log(`[${tag}]`, message, ...args);
+    }
+  },
+  /**
+   * Warning-level log. ALWAYS shown regardless of debug flag.
+   * Use for important but non-critical issues (timeouts, retries, degraded state).
+   */
+  warn(tag, message, ...args) {
+    const state = getState();
+    if (state.handler) {
+      state.handler("warn", tag, message, ...args);
+    } else {
+      console.warn(`[${tag}]`, message, ...args);
+    }
+  },
+  /**
+   * Error-level log. ALWAYS shown regardless of debug flag.
+   * Use for critical failures that should never be silenced.
+   */
+  error(tag, message, ...args) {
+    const state = getState();
+    if (state.handler) {
+      state.handler("error", tag, message, ...args);
+    } else {
+      console.error(`[${tag}]`, message, ...args);
+    }
+  },
+  /** Reset all logger state (debug flag, tags, handler). Primarily for tests. */
+  reset() {
+    const g = globalThis;
+    delete g[LOGGER_KEY];
+  }
+};
+
+// modules/payments-v2/requests/Requests.ts
+var WIRE_STATUS = {
+  open: "pending",
+  paid: "paid",
+  declined: "rejected",
+  expired: "expired"
+};
+var TERMINAL = /* @__PURE__ */ new Set(["paid", "rejected", "expired"]);
+var MAX_HYDRATION_PAGES = 100;
+var CHAIN_PUBKEY_RE = /^0[23][0-9a-fA-F]{64}$/;
+var CURSOR_KEY = STORE_KEYS.streamCursor("payment_requests");
+function isConflict409(err) {
+  if (typeof err !== "object" || err === null) return false;
+  const e = err;
+  return e.status === 409 || e.statusCode === 409 || e.code === "CONFLICT";
+}
+var Requests = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  mirror = /* @__PURE__ */ new Map();
+  hydrated = false;
+  drainInFlight = null;
+  journal = null;
+  journalLoad = null;
+  journalTail = Promise.resolve();
+  payInFlight = /* @__PURE__ */ new Map();
+  reconcileInFlight = false;
+  now() {
+    return this.deps.now?.() ?? Date.now();
+  }
+  // ── settling journal (#441; single-flight load, serialized RMW) ──────────
+  ensureJournalLoaded() {
+    return this.journalLoad ??= (async () => {
+      let entries = [];
+      try {
+        const raw = await this.deps.kv.get(STORE_KEYS.settlingLinks);
+        if (raw !== null && typeof raw === "object") entries = Object.entries(raw);
+      } catch (err) {
+        logger.error("PaymentsV2", "Settling journal unreadable \u2014 failing open to empty:", err);
+      }
+      this.journal = new Map(entries);
+    })();
+  }
+  mutateJournal(fn) {
+    this.journalTail = this.journalTail.catch(() => void 0).then(async () => {
+      await this.ensureJournalLoaded();
+      if (fn(this.journal)) {
+        await this.deps.kv.set(STORE_KEYS.settlingLinks, Object.fromEntries(this.journal));
+      }
+    });
+    return this.journalTail;
+  }
+  writeLink(requestId, transferId, committed) {
+    return this.mutateJournal((m) => {
+      m.set(requestId, { requestId, transferId, committed, createdAt: this.now() });
+      return true;
+    });
+  }
+  clearLink(requestId) {
+    return this.mutateJournal((m) => m.delete(requestId));
+  }
+  // ── incoming stream (gap-free ?since= upsert-by-id) ──────────────────────
+  drainIncoming() {
+    return this.drainInFlight ??= this.doDrain().finally(() => {
+      this.drainInFlight = null;
+    });
+  }
+  async doDrain() {
+    await this.ensureJournalLoaded();
+    const persisted = await this.deps.kv.get(CURSOR_KEY);
+    if (!this.hydrated) {
+      let page2 = await this.deps.client.listPaymentRequests({ role: "incoming", since: 0 });
+      for (let i = 0; i < MAX_HYDRATION_PAGES; i++) {
+        for (const wire of page2.requests) this.surface(wire);
+        if (!page2.more || typeof page2.cursor !== "number") break;
+        page2 = await this.deps.client.listPaymentRequests({ role: "incoming", since: page2.cursor });
+      }
+      this.hydrated = true;
+    }
+    let since = typeof persisted?.cursor === "number" ? persisted.cursor : 0;
+    let page = await this.deps.client.listPaymentRequests({ role: "incoming", since });
+    if (persisted !== null && String(page.syncEpoch) !== persisted.syncEpoch) {
+      since = 0;
+      page = await this.deps.client.listPaymentRequests({ role: "incoming", since: 0 });
+    }
+    for (; ; ) {
+      for (const wire of page.requests) this.surface(wire);
+      const record = {
+        cursor: typeof page.cursor === "number" ? page.cursor : since,
+        syncEpoch: String(page.syncEpoch)
+      };
+      await this.deps.kv.set(CURSOR_KEY, record);
+      if (!page.more || typeof page.cursor !== "number") break;
+      since = page.cursor;
+      page = await this.deps.client.listPaymentRequests({ role: "incoming", since });
+    }
+  }
+  surface(wire) {
+    if (wire.toPubkey !== this.deps.ownPubkey) {
+      logger.warn("PaymentsV2", `payment request ${wire.id.slice(0, 12)}\u2026 addressed to a different owner \u2014 dropped`);
+      return;
+    }
+    let status = WIRE_STATUS[wire.status];
+    const link = this.journal?.get(wire.id);
+    if (link !== void 0) {
+      if (wire.status === "open") {
+        status = "settling";
+      } else {
+        void this.clearLink(wire.id).catch(
+          (err) => logger.warn("PaymentsV2", `failed to clear stale settling link for ${wire.id}:`, err)
+        );
+      }
+    }
+    const existing = this.mirror.get(wire.id);
+    if (existing !== void 0) {
+      if (TERMINAL.has(status) && !TERMINAL.has(existing.status)) this.setStatus(wire.id, status);
+      return;
+    }
+    const bundle = this.decryptMemo(wire);
+    const view = {
+      id: wire.id,
+      requestId: wire.id,
+      senderPubkey: wire.fromPubkey,
+      ...bundle.senderNametag !== void 0 ? { senderNametag: bundle.senderNametag } : {},
+      amount: wire.assets[0]?.amount ?? "0",
+      coinId: wire.assets[0]?.coinId ?? "",
+      ...bundle.memo !== void 0 ? { message: bundle.memo } : {},
+      timestamp: Date.parse(wire.createdAt),
+      status
+    };
+    this.mirror.set(wire.id, view);
+    if (status === "pending") this.deps.emit("payment_request:incoming", { ...view });
+  }
+  decryptMemo(wire) {
+    if (wire.memo === void 0) return {};
+    try {
+      return this.deps.memo.decrypt(wire.fromPubkey, wire.memo);
+    } catch {
+      logger.debug("PaymentsV2", `payment request ${wire.id.slice(0, 12)}\u2026 memo not decryptable here`);
+      return {};
+    }
+  }
+  setStatus(id, status) {
+    const entry = this.mirror.get(id);
+    if (entry === void 0 || entry.status === status) return;
+    entry.status = status;
+    this.deps.emit("payment_request:updated", { id, status });
+  }
+  // ── public surface (PaymentsRequestsApi) ─────────────────────────────────
+  list() {
+    const views = [...this.mirror.values()].map((entry) => ({
+      ...entry,
+      // A live settling link is NEVER payable, whatever the mirror says.
+      status: entry.status === "pending" && this.journal?.has(entry.id) ? "settling" : entry.status
+    }));
+    return views.sort((a, b) => b.timestamp - a.timestamp || (a.id < b.id ? -1 : 1));
+  }
+  async create(to, terms) {
+    try {
+      const toPubkey = CHAIN_PUBKEY_RE.test(to) ? to.toLowerCase() : await this.deps.resolvePubkey(to);
+      if (toPubkey === null || toPubkey === void 0) {
+        return { success: false, error: `Recipient ${to} has no published chain pubkey` };
+      }
+      const amount = BigInt(terms.amount);
+      if (amount <= 0n) return { success: false, error: "Amount must be a positive base-unit decimal string" };
+      const senderNametag = this.deps.ownNametag?.();
+      const envelope = this.deps.memo.encrypt(toPubkey, {
+        ...terms.memo !== void 0 ? { memo: terms.memo } : {},
+        ...senderNametag !== void 0 ? { senderNametag } : {}
+      });
+      const wire = await this.deps.client.createPaymentRequest({
+        toPubkey,
+        assets: [{ coinId: terms.coinId, amount: amount.toString() }],
+        ...envelope !== void 0 ? { memo: envelope } : {}
+      });
+      return { success: true, requestId: wire.id };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  pay(id) {
+    const inFlight = this.payInFlight.get(id);
+    if (inFlight !== void 0) return inFlight;
+    const run = this.payInner(id).finally(() => {
+      this.payInFlight.delete(id);
+    });
+    this.payInFlight.set(id, run);
+    return run;
+  }
+  async payInner(id) {
+    await this.ensureJournalLoaded();
+    const entry = this.mirror.get(id);
+    if (entry === void 0) throw new SphereError(`Payment request not found: ${id}`, "VALIDATION_ERROR");
+    if (entry.status !== "pending" || this.journal.has(id)) {
+      throw new SphereError(`Payment request is not payable: ${entry.status}`, "VALIDATION_ERROR");
+    }
+    let result;
+    try {
+      result = await this.deps.send({
+        recipient: entry.senderPubkey,
+        amount: entry.amount,
+        coinId: entry.coinId,
+        ...entry.message !== void 0 ? { memo: entry.message } : {}
+      });
+    } catch (error) {
+      if (isPossiblyCommittedSendOutcome(error)) {
+        const transferId = error instanceof SphereError && error.transferId !== void 0 ? error.transferId : void 0;
+        if (transferId !== void 0) {
+          const committed = error instanceof PartialSendConflictError;
+          await this.writeLink(id, transferId, committed);
+          this.setStatus(id, "settling");
+        } else {
+          logger.error("PaymentsV2", `possibly-committed send for ${id} carried no transferId \u2014 paid (fail-closed)`);
+          this.setStatus(id, "paid");
+        }
+      } else {
+        await this.clearLink(id);
+        this.setStatus(id, "pending");
+      }
+      throw error;
+    }
+    this.setStatus(id, "paid");
+    await this.respondPaid(id, result.id);
+    await this.clearLink(id);
+    return result;
+  }
+  /** 'paid' respond leg: 409 = already resolved = idempotent success; other errors defer. */
+  async respondPaid(id, transferId) {
+    try {
+      await this.deps.client.respondPaymentRequest(id, { action: "paid", transferId });
+      return true;
+    } catch (err) {
+      if (isConflict409(err)) return true;
+      logger.warn("PaymentsV2", `paid respond failed for ${id} (deferred):`, err);
+      return false;
+    }
+  }
+  async decline(id) {
+    const entry = this.mirror.get(id);
+    if (entry === void 0) throw new SphereError(`Payment request not found: ${id}`, "VALIDATION_ERROR");
+    await this.deps.client.respondPaymentRequest(id, { action: "declined" });
+    this.setStatus(id, "rejected");
+  }
+  dismissProcessed() {
+    for (const [id, entry] of this.mirror) {
+      if (TERMINAL.has(entry.status)) this.mirror.delete(id);
+    }
+  }
+  // ── reconcile (#441, fed by resume outcomes) ─────────────────────────────
+  async reconcile(outcomes) {
+    if (this.reconcileInFlight) return;
+    await this.ensureJournalLoaded();
+    if (this.journal.size === 0) return;
+    this.reconcileInFlight = true;
+    try {
+      const resumed = new Set(outcomes.resumed);
+      const conflicted = new Set(outcomes.conflicted);
+      const open = new Set(outcomes.open);
+      let aborted = null;
+      for (const [requestId, link] of [...this.journal]) {
+        if (link.committed || resumed.has(link.transferId)) {
+          await this.resolvePaid(requestId, link.transferId);
+        } else if (conflicted.has(link.transferId)) {
+          await this.revertPayable(requestId);
+        } else if (open.has(link.transferId)) {
+        } else {
+          aborted = await this.reconcileUnaccounted(requestId, link.transferId, aborted);
+        }
+      }
+    } finally {
+      this.reconcileInFlight = false;
+    }
+  }
+  // Unaccounted link: consult the server aborted authority (lazy, memoized);
+  // a probe failure defers the link to the next session.
+  async reconcileUnaccounted(requestId, transferId, aborted) {
+    try {
+      aborted ??= new Set(await this.deps.listAbortedTransferIds());
+      if (aborted.has(transferId)) await this.revertPayable(requestId);
+      else await this.resolvePaid(requestId, transferId);
+    } catch (err) {
+      logger.warn("PaymentsV2", `aborted-intent probe failed \u2014 ${requestId} deferred:`, err);
+    }
+    return aborted;
+  }
+  async resolvePaid(requestId, transferId) {
+    if (!await this.respondPaid(requestId, transferId)) return;
+    await this.clearLink(requestId);
+    this.setStatus(requestId, "paid");
+  }
+  async revertPayable(requestId) {
+    await this.clearLink(requestId);
+    this.setStatus(requestId, "pending");
+  }
+};
+
+// modules/payments-v2/select/ledger.ts
+var ReservationLedger = class {
+  reservations = /* @__PURE__ */ new Map();
+  tokenIndex = /* @__PURE__ */ new Map();
+  // All-or-nothing: every entry is validated before any state mutates.
+  reserve(reservationId, entries) {
+    if (entries.length === 0) throw new Error("EMPTY_RESERVATION");
+    if (this.reservations.has(reservationId)) throw new Error("DUPLICATE_RESERVATION_ID");
+    const amounts = /* @__PURE__ */ new Map();
+    const tokenAmounts = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (entry.amount <= 0n) throw new Error("INVALID_RESERVATION_AMOUNT");
+      amounts.set(entry.tokenId, (amounts.get(entry.tokenId) ?? 0n) + entry.amount);
+      const known = tokenAmounts.get(entry.tokenId);
+      if (known === void 0 || entry.tokenAmount > known) {
+        tokenAmounts.set(entry.tokenId, entry.tokenAmount);
+      }
+    }
+    for (const [tokenId, amount] of amounts) {
+      if (this.getFreeAmount(tokenId, tokenAmounts.get(tokenId)) < amount) {
+        throw new Error("INSUFFICIENT_FREE_AMOUNT");
+      }
+    }
+    this.reservations.set(reservationId, amounts);
+    for (const tokenId of amounts.keys()) {
+      let ids = this.tokenIndex.get(tokenId);
+      if (!ids) {
+        ids = /* @__PURE__ */ new Set();
+        this.tokenIndex.set(tokenId, ids);
+      }
+      ids.add(reservationId);
+    }
+  }
+  commit(reservationId) {
+    this.release(reservationId);
+  }
+  cancel(reservationId) {
+    this.release(reservationId);
+  }
+  cancelForToken(tokenId, excludeReservationId) {
+    const ids = this.tokenIndex.get(tokenId);
+    if (!ids) return [];
+    const cancelled = [];
+    for (const reservationId of [...ids]) {
+      if (reservationId === excludeReservationId) continue;
+      this.release(reservationId);
+      cancelled.push(reservationId);
+    }
+    return cancelled;
+  }
+  getFreeAmount(tokenId, tokenAmount) {
+    let reserved = 0n;
+    const ids = this.tokenIndex.get(tokenId);
+    if (ids) {
+      for (const reservationId of ids) {
+        reserved += this.reservations.get(reservationId)?.get(tokenId) ?? 0n;
+      }
+    }
+    const free = tokenAmount - reserved;
+    return free > 0n ? free : 0n;
+  }
+  clear() {
+    this.reservations.clear();
+    this.tokenIndex.clear();
+  }
+  release(reservationId) {
+    const amounts = this.reservations.get(reservationId);
+    if (!amounts) return;
+    this.reservations.delete(reservationId);
+    for (const tokenId of amounts.keys()) {
+      const ids = this.tokenIndex.get(tokenId);
+      if (!ids) continue;
+      ids.delete(reservationId);
+      if (ids.size === 0) this.tokenIndex.delete(tokenId);
+    }
+  }
+};
+
+// modules/payments-v2/select/selector.ts
+var DEFAULT_WORK_BUDGET = 2e4;
+var MAX_COMBINATION_SIZE = 5;
+function selectCoins(pool, target, options = {}) {
+  if (target <= 0n) return null;
+  const candidates = pool.filter((e) => e.amount > 0n).sort(byAmountAscending);
+  let total = 0n;
+  for (const c of candidates) total += c.amount;
+  if (total < target) return null;
+  const single = candidates.find((c) => c.amount === target);
+  if (single) return { direct: [single.tokenId] };
+  const search = {
+    examined: 0,
+    budget: options.workBudget ?? DEFAULT_WORK_BUDGET
+  };
+  const combo = findExactCombination(candidates, target, search);
+  if (options.stats) options.stats.combinationsExamined = search.examined;
+  if (combo) return { direct: combo.map((c) => c.tokenId) };
+  return greedyWithSplit(candidates, target);
+}
+function byAmountAscending(a, b) {
+  if (a.amount !== b.amount) return a.amount < b.amount ? -1 : 1;
+  return a.tokenId < b.tokenId ? -1 : a.tokenId > b.tokenId ? 1 : 0;
+}
+function greedyWithSplit(sortedAscending, target) {
+  const direct = [];
+  let sum = 0n;
+  for (const candidate of sortedAscending) {
+    const next = sum + candidate.amount;
+    if (next < target) {
+      direct.push(candidate.tokenId);
+      sum = next;
+    } else if (next === target) {
+      direct.push(candidate.tokenId);
+      return { direct };
+    } else {
+      const splitAmount = target - sum;
+      return {
+        direct,
+        split: {
+          tokenId: candidate.tokenId,
+          splitAmount,
+          remainderAmount: candidate.amount - splitAmount
+        }
+      };
+    }
+  }
+  return null;
+}
+function findExactCombination(sortedAscending, target, search) {
+  const maxSize = Math.min(MAX_COMBINATION_SIZE, sortedAscending.length);
+  for (let size = 2; size <= maxSize; size++) {
+    if (search.examined >= search.budget) return null;
+    const window = orderNearestTo(sortedAscending, target / BigInt(size));
+    const found = searchCombinationsOfSize(window, size, target, search);
+    if (found) return found;
+  }
+  return null;
+}
+function orderNearestTo(entries, pivot) {
+  const distance = (e) => e.amount >= pivot ? e.amount - pivot : pivot - e.amount;
+  return [...entries].sort((a, b) => {
+    const da = distance(a);
+    const db = distance(b);
+    if (da !== db) return da < db ? -1 : 1;
+    return byAmountAscending(a, b);
+  });
+}
+function searchCombinationsOfSize(window, size, target, search) {
+  const chosen = [];
+  const recurse = (start, sum) => {
+    if (chosen.length === size) {
+      search.examined += 1;
+      return sum === target ? [...chosen] : null;
+    }
+    for (let i = start; i < window.length; i++) {
+      if (search.examined >= search.budget) return null;
+      chosen.push(window[i]);
+      const found = recurse(i + 1, sum + window[i].amount);
+      chosen.pop();
+      if (found) return found;
+    }
+    return null;
+  };
+  return recurse(0, 0n);
+}
+
+// modules/payments-v2/select/queue.ts
+var QUEUE_TIMEOUT_MS = 3e4;
+var QUEUE_MAX_SIZE = 100;
+var SpendQueue = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  queues = /* @__PURE__ */ new Map();
+  expectedChange = /* @__PURE__ */ new Map();
+  destroyed = false;
+  plan(reservationId, request) {
+    if (this.destroyed) {
+      throw new SphereError("Module has been destroyed", "MODULE_DESTROYED");
+    }
+    const amount = parseAmount(request.amount);
+    const { freeView, freeTotal } = this.freeView(request.coinId);
+    if (freeTotal + this.expectedChangeTotal(request.coinId) < amount) {
+      throw new SphereError(
+        "Insufficient balance for this transaction",
+        "SEND_INSUFFICIENT_BALANCE"
+      );
+    }
+    const plan = selectCoins(freeView, amount, { workBudget: this.deps.workBudget });
+    if (plan !== null) {
+      this.reservePlan(reservationId, plan, freeView);
+      return { kind: "planned", spend: { reservationId, plan } };
+    }
+    return { kind: "queued", settled: this.enqueue(reservationId, request.coinId, amount) };
+  }
+  // Coverage math: free + Σ declared expected change of in-flight sends —
+  // never the full amount of in-flight sources (§5.3).
+  declareExpectedChange(transferId, coinId, amount) {
+    this.expectedChange.set(transferId, { coinId, amount });
+  }
+  clearExpectedChange(transferId) {
+    this.expectedChange.delete(transferId);
+  }
+  notifyChange(coinId) {
+    if (this.destroyed) return;
+    const entries = this.queues.get(coinId);
+    if (!entries) return;
+    let i = 0;
+    while (i < entries.length) {
+      const entry = entries[i];
+      if (this.tryServe(entry) === "blocked") {
+        i += 1;
+        continue;
+      }
+      clearTimeout(entry.timer);
+      entries.splice(i, 1);
+    }
+    if (entries.length === 0) this.queues.delete(coinId);
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    for (const entries of this.queues.values()) {
+      for (const entry of entries) {
+        clearTimeout(entry.timer);
+        entry.reject(new SphereError("Module destroyed", "MODULE_DESTROYED"));
+      }
+    }
+    this.queues.clear();
+    this.expectedChange.clear();
+  }
+  tryServe(entry) {
+    if (Date.now() - entry.enqueuedAt > QUEUE_TIMEOUT_MS) {
+      entry.reject(new SphereError("Send queue timeout", "SEND_QUEUE_TIMEOUT"));
+      return "rejected";
+    }
+    const { freeView, freeTotal } = this.freeView(entry.coinId);
+    if (freeTotal + this.expectedChangeTotal(entry.coinId) < entry.amount) {
+      entry.reject(
+        new SphereError("Insufficient balance for this transaction", "SEND_INSUFFICIENT_BALANCE")
+      );
+      return "rejected";
+    }
+    const plan = selectCoins(freeView, entry.amount, { workBudget: this.deps.workBudget });
+    if (plan === null) return "blocked";
+    try {
+      this.reservePlan(entry.id, plan, freeView);
+    } catch (e) {
+      entry.reject(e instanceof Error ? e : new Error(String(e)));
+      return "rejected";
+    }
+    entry.resolve({ reservationId: entry.id, plan });
+    return "served";
+  }
+  enqueue(id, coinId, amount) {
+    if (this.totalQueued() >= QUEUE_MAX_SIZE) {
+      throw new SphereError("Send queue is full", "SEND_QUEUE_FULL");
+    }
+    let resolve;
+    let reject;
+    const settled = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    settled.catch(() => {
+    });
+    const timer = setTimeout(() => this.expire(id, coinId), QUEUE_TIMEOUT_MS);
+    const entry = { id, coinId, amount, enqueuedAt: Date.now(), resolve, reject, timer };
+    let queue = this.queues.get(coinId);
+    if (!queue) {
+      queue = [];
+      this.queues.set(coinId, queue);
+    }
+    queue.push(entry);
+    return settled;
+  }
+  expire(id, coinId) {
+    const entries = this.queues.get(coinId);
+    if (!entries) return;
+    const index = entries.findIndex((e) => e.id === id);
+    if (index === -1) return;
+    const [entry] = entries.splice(index, 1);
+    entry.reject(new SphereError("Send queue timeout", "SEND_QUEUE_TIMEOUT"));
+    if (entries.length === 0) this.queues.delete(coinId);
+  }
+  // Whole-token semantics: only fully-free tokens enter the selector pool.
+  freeView(coinId) {
+    const freeView = [];
+    let freeTotal = 0n;
+    for (const entry of this.deps.getPool(coinId)) {
+      if (entry.amount <= 0n) continue;
+      if (this.deps.ledger.getFreeAmount(entry.tokenId, entry.amount) === entry.amount) {
+        freeView.push(entry);
+        freeTotal += entry.amount;
+      }
+    }
+    return { freeView, freeTotal };
+  }
+  expectedChangeTotal(coinId) {
+    let total = 0n;
+    for (const change of this.expectedChange.values()) {
+      if (change.coinId === coinId) total += change.amount;
+    }
+    return total;
+  }
+  reservePlan(reservationId, plan, freeView) {
+    const amounts = new Map(freeView.map((e) => [e.tokenId, e.amount]));
+    const requests = plan.direct.map((tokenId) => wholeToken(tokenId, amounts));
+    if (plan.split) requests.push(wholeToken(plan.split.tokenId, amounts));
+    this.deps.ledger.reserve(reservationId, requests);
+  }
+  totalQueued() {
+    let total = 0;
+    for (const entries of this.queues.values()) total += entries.length;
+    return total;
+  }
+};
+function wholeToken(tokenId, amounts) {
+  const amount = amounts.get(tokenId);
+  if (amount === void 0) {
+    throw new SphereError("Planned token missing from pool", "VALIDATION_ERROR");
+  }
+  return { tokenId, amount, tokenAmount: amount };
+}
+function parseAmount(raw) {
+  if (!/^\d+$/.test(raw)) {
+    throw new SphereError("Invalid send amount", "VALIDATION_ERROR");
+  }
+  const amount = BigInt(raw);
+  if (amount <= 0n) {
+    throw new SphereError("Send amount must be positive", "VALIDATION_ERROR");
+  }
+  return amount;
+}
+
+// modules/payments-v2/compose.ts
+function supportsDeterministicMint(engine) {
+  const candidate = engine;
+  return candidate.deterministicMint === true && typeof candidate.deriveMintTokenId === "function";
+}
+var HeldStateCache = class {
+  held = /* @__PURE__ */ new Map();
+  get(tokenId) {
+    return this.held.get(tokenId) ?? null;
+  }
+  set(tokenId, stateHash) {
+    this.held.set(tokenId, stateHash);
+  }
+};
+function composeFacadeParts(deps, hooks) {
+  const ownPubkeyBytes = hexToBytes(deps.ownPubkey);
+  const view = new InventoryView({
+    port: deps.storagePort,
+    kv: deps.kv,
+    emit: (event) => deps.emit(event, {}),
+    ...deps.now !== void 0 ? { now: deps.now } : {}
+  });
+  const ledger = new ReservationLedger();
+  const queue = new SpendQueue({
+    ledger,
+    getPool: (coinId) => view.pool(coinId),
+    ...deps.workBudget !== void 0 ? { workBudget: deps.workBudget } : {}
+  });
+  const historyStore = new History({
+    client: deps.client,
+    fieldKey: deps.fieldKey,
+    registry: deps.registry,
+    emit: (event) => deps.emit(event, {}),
+    ...deps.now !== void 0 ? { now: deps.now } : {},
+    ...deps.newId !== void 0 ? { newId: deps.newId } : {}
+  });
+  const machineDeps = buildMachineDeps(deps, hooks, historyStore);
+  const heldStates = new HeldStateCache();
+  return {
+    ownPubkeyBytes,
+    view,
+    ledger,
+    queue,
+    historyStore,
+    machineStores: createMachineStores(deps.kv),
+    machineDeps,
+    machine: new TransferMachine(machineDeps),
+    heldStates,
+    receiveLoop: buildReceive(deps, hooks, historyStore, heldStates),
+    requests: buildRequests(deps, hooks)
+  };
+}
+function buildMachineDeps(deps, hooks, historyStore) {
+  return {
+    engine: () => hooks.engine(),
+    storage: deps.storagePort,
+    delivery: deps.deliveryPort,
+    intents: intentApi(deps.client),
+    checkpointStore: deps.checkpointStore,
+    kv: deps.kv,
+    encryptPayload: async (payload) => encryptField(deps.fieldKey, JSON.stringify(payload)),
+    decryptPayload: async (envelope) => JSON.parse(decryptField(deps.fieldKey, envelope)),
+    signComplete: deps.signComplete,
+    ownPubkey: hexToBytes(deps.ownPubkey),
+    emit: deps.emit,
+    now: deps.now ?? Date.now,
+    recordHistory: async ({ transferId, payload }) => {
+      await historyStore.recordSent({
+        transferId,
+        coinId: payload.coinId,
+        amount: payload.amount,
+        recipientPubkey: payload.recipient,
+        ...payload.memo !== void 0 ? { memo: payload.memo } : {}
+      });
+    }
+  };
+}
+function intentApi(client) {
+  return {
+    put: (transferId, envelope, requiresSeedClose) => client.putIntent(transferId, envelope, requiresSeedClose),
+    listOpen: async () => (await client.listIntents("open")).map((intent) => ({
+      transferId: intent.transferId,
+      payload: intent.payload,
+      createdAt: intent.createdAt
+    })),
+    abort: (transferId) => client.abortIntent(transferId),
+    complete: (transferId, signature) => client.completeIntent(transferId, signature)
+  };
+}
+function buildReceive(deps, hooks, historyStore, heldStates) {
+  return new Receive({
+    delivery: deps.deliveryPort,
+    engine: receiveEngine(hooks),
+    view: {
+      heldState: (tokenId) => heldStates.get(tokenId),
+      store: async (entry) => {
+        heldStates.set(entry.tokenId, entry.stateHash);
+        return "stored";
+      }
+    },
+    kv: deps.kv,
+    registry: deps.registry,
+    recordReceived: (record) => recordReceived(historyStore, record),
+    emit: (event, transfer) => deps.emit(event, transfer),
+    syncEpoch: deps.syncEpoch ?? (() => ""),
+    ...deps.now !== void 0 ? { now: deps.now } : {}
+  });
+}
+function receiveEngine(hooks) {
+  return {
+    getIdentity: () => hooks.engine().getIdentity(),
+    decodeToken: (blob) => hooks.engine().decodeToken(blob),
+    verify: (token, options) => hooks.engine().verify(token, options),
+    isOwnedBy: (token, pubkey) => hooks.engine().isOwnedBy(token, pubkey),
+    isSpent: (token, options) => hooks.engine().isSpent(token, options),
+    tokenId: (token) => hooks.engine().tokenId(token),
+    deliveryKeys: (blobBytes) => hooks.engine().deliveryKeys(blobBytes)
+  };
+}
+async function recordReceived(historyStore, record) {
+  const first = record.assets[0];
+  await historyStore.recordReceived({
+    tokenId: record.tokenId,
+    stateHash: record.stateHash,
+    coinId: first?.coinId ?? "",
+    amount: first?.amount ?? "0",
+    ...record.senderPubkey !== void 0 ? { senderPubkey: record.senderPubkey } : {},
+    ...record.senderNametag !== void 0 ? { senderNametag: record.senderNametag } : {},
+    ...record.memo !== void 0 ? { memo: record.memo } : {},
+    timestamp: record.receivedAt
+  });
+}
+function buildRequests(deps, hooks) {
+  return new Requests({
+    client: deps.client,
+    kv: deps.kv,
+    ownPubkey: deps.ownPubkey,
+    send: (request) => hooks.send(request),
+    resolvePubkey: async (identifier) => (await deps.resolveRecipient(identifier))?.chainPubkey ?? null,
+    listAbortedTransferIds: async () => (await deps.client.listIntents("aborted")).map((intent) => intent.transferId),
+    emit: deps.emit,
+    memo: deps.requestMemo,
+    ...deps.ownNametag !== void 0 ? { ownNametag: deps.ownNametag } : {},
+    ...deps.now !== void 0 ? { now: deps.now } : {}
+  });
+}
+
+// modules/payments-v2/PaymentsFacade.ts
+var MAX_RESELECT = 8;
+var ATTENTION_MINT_UNRESOLVED = "mint:unresolved";
+var INVENTORY_SCAN_PAGE_LIMIT = 50;
+var PaymentsFacade = class {
+  constructor(deps) {
+    this.deps = deps;
+    const parts = composeFacadeParts(deps, {
+      engine: () => this.engine(),
+      send: (request) => this.send(request)
+    });
+    this.view = parts.view;
+    this.ledger = parts.ledger;
+    this.queue = parts.queue;
+    this.machine = parts.machine;
+    this.machineDeps = parts.machineDeps;
+    this.machineStores = parts.machineStores;
+    this.historyStore = parts.historyStore;
+    this.receiveLoop = parts.receiveLoop;
+    this.heldStates = parts.heldStates;
+    this.ownPubkeyBytes = parts.ownPubkeyBytes;
+    this.requests = parts.requests;
+    deps.deliveryPort.bindDeliveryKeys((blob) => this.engine().deliveryKeys(blob));
+  }
+  view;
+  ledger;
+  queue;
+  machine;
+  machineDeps;
+  machineStores;
+  historyStore;
+  receiveLoop;
+  heldStates;
+  ownPubkeyBytes;
+  requests;
+  currentEngine = null;
+  pendingOps = /* @__PURE__ */ new Set();
+  unsubscribers = [];
+  started = false;
+  // ── lifecycle ──────────────────────────────────────────────────────────────
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    await this.deps.session.start();
+    this.unsubscribers.push(
+      this.deps.session.subscribeStream("mailbox", () => {
+        this.trackTail(this.receiveLoop.drainOnce());
+      }),
+      this.deps.session.subscribeStream("inventory", () => {
+        this.trackTail(this.view.delta(0));
+      }),
+      this.deps.session.subscribeStream("payment_requests", () => {
+        this.trackTail(this.requests.drainIncoming());
+      })
+    );
+    this.trackTail(this.runResume());
+    this.trackTail(
+      this.machineStores.deliveryJournal.replay({
+        delivery: this.deps.deliveryPort,
+        now: this.deps.now ?? Date.now,
+        attention: (transferId, code, detail) => {
+          this.deps.emit(
+            "transfer:attention",
+            detail === void 0 ? { transferId, code } : { transferId, code, detail }
+          );
+        }
+      })
+    );
+    this.trackTail(this.replayMints());
+    this.trackTail(this.seedHeldStates());
+    await this.view.fullPull().catch(() => void 0);
+    this.receiveLoop.start(this.deps.receivePollMs);
+  }
+  /** §7 same-address restart gate: resolves only after in-flight ops settle. */
+  async stop() {
+    this.started = false;
+    this.receiveLoop.stop();
+    for (const unsubscribe of this.unsubscribers) unsubscribe();
+    this.unsubscribers = [];
+    await this.deps.session.stop();
+    while (this.pendingOps.size > 0) {
+      await Promise.allSettled([...this.pendingOps]);
+    }
+  }
+  /** Swaps what FUTURE operations snapshot; in-flight ops finish on the old engine. */
+  setEngine(next) {
+    const previous = this.currentEngine ?? this.deps.engineRef();
+    this.currentEngine = next;
+    if (previous !== next) previous.dispose?.();
+  }
+  // ── reads ──────────────────────────────────────────────────────────────────
+  async assets(coinId) {
+    const all = await this.view.assets(this.deps.registry, this.deps.price);
+    return coinId === void 0 ? all : all.filter((asset) => asset.coinId === coinId);
+  }
+  tokens(filter) {
+    return this.view.tokens(this.deps.registry, filter);
+  }
+  history(page) {
+    return this.historyStore.page(page ?? {});
+  }
+  // ── money movement ─────────────────────────────────────────────────────────
+  send(request) {
+    return this.track(this.sendWithPolicy(request));
+  }
+  async receive() {
+    const transfers = await this.track(this.receiveLoop.drainOnce());
+    if (transfers.length > 0) this.trackTail(this.view.delta(0));
+    return { transfers };
+  }
+  mint(coinId, amount) {
+    return this.track(this.mintInner(coinId, amount));
+  }
+  // ── send policy (§5.5 + old-loop parity; the machine stays policy-free) ────
+  async sendWithPolicy(request) {
+    const recipient = await this.requireSameNetworkRecipient(request.recipient);
+    const run = {
+      amount: request.amount,
+      delivered: [],
+      sentTokens: [],
+      tokenTransfers: [],
+      settledShortfalls: [],
+      firstPartialId: void 0,
+      pendingAny: false
+    };
+    for (let attempt = 0; ; attempt++) {
+      let ctx;
+      try {
+        ctx = await this.planAndMaterialize(recipient.chainPubkey, { ...request, amount: run.amount });
+      } catch (err) {
+        throw this.partialize(err, run);
+      }
+      const disposition = await this.runAttempt(ctx);
+      if (disposition.kind === "rethrow") throw this.partialize(disposition.error, run);
+      if (disposition.kind === "retry-full") {
+        if (attempt >= MAX_RESELECT) throw this.partialize(disposition.error, run);
+        continue;
+      }
+      if (disposition.kind === "success") {
+        run.pendingAny = run.pendingAny || disposition.deliveryPending;
+        this.accumulate(ctx, ctx.sourceIds, run);
+        return await this.finishSend(ctx.transferId, run);
+      }
+      const surfaced = await this.consumePartial(ctx, disposition, run, attempt);
+      if (surfaced !== null) return surfaced;
+    }
+  }
+  /** §5.6 cross-network deposit trap: refused BEFORE any reserve/certification. */
+  async requireSameNetworkRecipient(identifier) {
+    const recipient = await this.deps.resolveRecipient(identifier);
+    if (recipient === null || recipient.chainPubkey === "") {
+      throw new SphereError(`Recipient ${identifier} has no published chain pubkey`, "INVALID_RECIPIENT");
+    }
+    if (recipient.network !== this.deps.network) {
+      throw new SphereError(
+        `Recipient ${identifier} is on network "${recipient.network}" but this session is on "${this.deps.network}" \u2014 a cross-network deposit is unrecoverable`,
+        "INVALID_RECIPIENT"
+      );
+    }
+    return recipient;
+  }
+  async runAttempt(ctx) {
+    try {
+      const { deliveryPending } = await this.machine.run(ctx.plan);
+      this.settleSuccess(ctx, ctx.sourceIds);
+      return { kind: "success", deliveryPending };
+    } catch (err) {
+      return this.disposeFailedAttempt(ctx, err);
+    }
+  }
+  /**
+   * Partial outcome (#677/#690): the shortfall is already durable (written by
+   * the machine BEFORE complete). Accumulate the settled set, then re-plan ONLY
+   * the remainder under a NEW transferId — never the full amount.
+   */
+  async consumePartial(ctx, disposition, run, attempt) {
+    run.pendingAny = run.pendingAny || disposition.deliveryPending;
+    const partial = disposition.entry;
+    run.delivered.push(...partial.committedTokenIds);
+    run.firstPartialId ??= partial.transferId;
+    run.settledShortfalls.push(partial.transferId);
+    this.accumulate(ctx, partial.committedTokenIds, run);
+    this.settlePartial(ctx, partial);
+    if (BigInt(partial.remainingAmount) <= 0n) {
+      return this.finishSend(ctx.transferId, run);
+    }
+    if (attempt >= MAX_RESELECT) {
+      throw new PartialSendConflictError(
+        "Part of your payment was sent, but the remainder could not be completed within the re-plan budget. The delivered portion is final \u2014 re-plan only the shortfall, never the full amount.",
+        run.firstPartialId,
+        run.delivered,
+        partial.remainingAmount
+      );
+    }
+    run.amount = partial.remainingAmount;
+    return null;
+  }
+  /**
+   * One attempt's failure disposition: possibly-committed → rethrow UNWRAPPED;
+   * backstop still 'open' (committed>0) → converge via the same machine's
+   * resumeIntent; clean conflict with a demoted source → bounded full re-plan.
+   */
+  async disposeFailedAttempt(ctx, err) {
+    if (isPossiblyCommittedSendOutcome(err)) {
+      this.settleKeepOpen(ctx);
+      this.stampTransferId(err, ctx.transferId);
+      return { kind: "rethrow", error: err };
+    }
+    const backstop = await this.machineStores.backstop.get(ctx.transferId);
+    if (backstop !== void 0 && backstop.disposition === "open") {
+      return this.convergePartial(ctx);
+    }
+    this.settleFailure(ctx.transferId, ctx.coinId, ctx.sourceIds);
+    if (classifyError(err) !== "conflict") return { kind: "rethrow", error: err };
+    const demoted = await this.demoteSpentSources(ctx);
+    return demoted > 0 ? { kind: "retry-full", error: err } : { kind: "rethrow", error: err };
+  }
+  /** #677/#690: ≥1 leg committed — the SAME machine, resumed in-process, converges it. */
+  async convergePartial(ctx) {
+    let outcome;
+    try {
+      outcome = await this.machine.resumeIntent({
+        transferId: ctx.transferId,
+        payload: ctx.plan.payload,
+        sources: ctx.plan.sources,
+        journaled: await this.machineStores.deliveryJournal.byTransfer(ctx.transferId)
+      });
+    } catch (err) {
+      return this.disposeConvergeFailure(ctx, err);
+    }
+    if (outcome.partial === null) {
+      this.settleSuccess(ctx, ctx.sourceIds);
+      return { kind: "success", deliveryPending: outcome.deliveryPending };
+    }
+    return { kind: "partial", entry: outcome.partial, deliveryPending: outcome.deliveryPending };
+  }
+  async disposeConvergeFailure(ctx, err) {
+    if (isPossiblyCommittedSendOutcome(err)) {
+      this.settleKeepOpen(ctx);
+      this.stampTransferId(err, ctx.transferId);
+      return { kind: "rethrow", error: err };
+    }
+    if (classifyError(err) === "conflict") {
+      await this.softAbort(ctx.transferId);
+      this.settleFailure(ctx.transferId, ctx.coinId, ctx.sourceIds);
+      const demoted = await this.demoteSpentSources(ctx);
+      return demoted > 0 ? { kind: "retry-full", error: err } : { kind: "rethrow", error: err };
+    }
+    return { kind: "rethrow", error: err };
+  }
+  async planAndMaterialize(recipientPubkey, request) {
+    const transferId = this.newId();
+    const planned = this.queue.plan(transferId, { coinId: request.coinId, amount: request.amount });
+    const spend = planned.kind === "planned" ? planned.spend : await planned.settled;
+    const sourceIds = this.markPlanned(transferId, request.coinId, spend);
+    try {
+      return await this.materialize(transferId, recipientPubkey, request, spend, sourceIds);
+    } catch (err) {
+      this.settleFailure(transferId, request.coinId, sourceIds);
+      throw err;
+    }
+  }
+  /** Reserve happened synchronously inside queue.plan; mark + declare with no await between. */
+  markPlanned(transferId, coinId, spend) {
+    const sourceIds = [
+      ...spend.plan.direct,
+      ...spend.plan.split !== void 0 ? [spend.plan.split.tokenId] : []
+    ];
+    for (const tokenId of sourceIds) this.view.markInFlight(tokenId);
+    if (spend.plan.split !== void 0) {
+      this.queue.declareExpectedChange(transferId, coinId, spend.plan.split.remainderAmount);
+    }
+    return sourceIds;
+  }
+  async materialize(transferId, recipientPubkey, request, spend, sourceIds) {
+    const engine = this.engine();
+    const blobs = await this.deps.storagePort.getBlobs([...sourceIds]);
+    const sources = /* @__PURE__ */ new Map();
+    const sourceTokens = [];
+    const spentStates = {};
+    for (const tokenId of sourceIds) {
+      const bytes = blobs.get(tokenId);
+      if (bytes === void 0) {
+        throw new SphereError(`Selected source ${tokenId} has no blob in storage`, "STORAGE_ERROR");
+      }
+      const token = await engine.decodeToken({ v: TOKEN_BLOB_VERSION, network: 0, tokenId, token: bytes });
+      const keys = await engine.deliveryKeys(bytes);
+      spentStates[tokenId] = { local: keys.stateHash, protocol: keys.stateHash };
+      sources.set(tokenId, token);
+      sourceTokens.push(this.toUiToken(tokenId, request.coinId, engine.balanceOf(token, request.coinId)));
+    }
+    const payload = buildPayload(recipientPubkey, request, spend, spentStates);
+    const plan = {
+      transferId,
+      recipientPubkey,
+      payload,
+      ops: buildOps(payload),
+      sources,
+      ...request.memo !== void 0 ? { memo: request.memo } : {}
+    };
+    return { transferId, coinId: request.coinId, plan, sourceIds, sourceTokens };
+  }
+  /** isSpent sweep over the attempt's sources; demote proven-spent states (durable). */
+  async demoteSpentSources(ctx) {
+    const engine = this.engine();
+    let demoted = 0;
+    for (const [tokenId, token] of ctx.plan.sources) {
+      const state = ctx.plan.payload.spentStates?.[tokenId];
+      if (state === void 0) continue;
+      try {
+        if (await engine.isSpent(token)) {
+          await this.view.demote(tokenId, state.protocol);
+          demoted += 1;
+        }
+      } catch {
+      }
+    }
+    return demoted;
+  }
+  // ── attempt settlement (reservation / in-flight / expected-change hygiene) ─
+  settleSuccess(ctx, spentIds) {
+    this.ledger.commit(ctx.transferId);
+    this.queue.clearExpectedChange(ctx.transferId);
+    this.trackTail(this.refreshThenRelease(ctx.coinId, spentIds));
+  }
+  settleFailure(transferId, coinId, releaseIds) {
+    this.ledger.cancel(transferId);
+    this.queue.clearExpectedChange(transferId);
+    for (const tokenId of releaseIds) this.view.release(tokenId);
+    this.queue.notifyChange(coinId);
+  }
+  /** Open intent: sources stay reserved + in-flight (§5.2) until resume adopts them. */
+  settleKeepOpen(ctx) {
+    this.queue.clearExpectedChange(ctx.transferId);
+  }
+  settlePartial(ctx, partial) {
+    this.ledger.cancel(ctx.transferId);
+    this.queue.clearExpectedChange(ctx.transferId);
+    const committed = new Set(partial.committedTokenIds);
+    for (const tokenId of ctx.sourceIds) {
+      if (committed.has(tokenId)) continue;
+      const state = ctx.plan.payload.spentStates?.[tokenId];
+      if (state !== void 0) this.trackTail(this.view.demote(tokenId, state.protocol));
+      this.view.release(tokenId);
+    }
+    this.trackTail(this.refreshThenRelease(ctx.coinId, [...committed]));
+  }
+  /** Release spent sources only AFTER the mirror refresh tombstoned them. */
+  async refreshThenRelease(coinId, spentIds) {
+    try {
+      await this.view.delta(0);
+      for (const tokenId of spentIds) this.view.release(tokenId);
+    } finally {
+      this.queue.notifyChange(coinId);
+    }
+  }
+  accumulate(ctx, committedIds, run) {
+    const committed = new Set(committedIds);
+    for (const op of ctx.plan.ops) {
+      if (!committed.has(op.sourceTokenId)) continue;
+      run.tokenTransfers.push({ sourceTokenId: op.sourceTokenId, method: op.kind });
+    }
+    for (const token of ctx.sourceTokens) {
+      if (committed.has(token.id)) run.sentTokens.push(token);
+    }
+  }
+  async finishSend(transferId, run) {
+    for (const id of run.settledShortfalls.splice(0)) {
+      await this.machineStores.shortfalls.clear(id).catch(() => void 0);
+    }
+    const result = {
+      id: transferId,
+      status: run.pendingAny ? "confirmed" : "delivered",
+      tokens: [...run.sentTokens],
+      tokenTransfers: [...run.tokenTransfers],
+      deliveryPending: run.pendingAny,
+      deliveryState: run.pendingAny ? "pending-delivery" : "landed"
+    };
+    this.deps.emit("transfer:updated", result);
+    return result;
+  }
+  /**
+   * With nothing delivered the error passes UNWRAPPED (identity + cause kept);
+   * after ≥1 delivered leg EVERY failure surfaces as PartialSendConflictError
+   * over the accumulated settled set — never bare, never a full-amount retry.
+   */
+  partialize(err, run) {
+    if (run.delivered.length === 0) return err;
+    return new PartialSendConflictError(
+      "Part of your payment was sent; the remaining amount could not be completed (see cause). The delivered portion is final \u2014 re-plan only the shortfall, never the full amount.",
+      run.firstPartialId ?? "",
+      run.delivered,
+      run.amount,
+      err
+    );
+  }
+  /** #441: possibly-committed errors must carry the transferId for the settling journal. */
+  stampTransferId(err, transferId) {
+    if (err instanceof SphereError && isPossiblyCommittedSendOutcome(err) && err.transferId === void 0) {
+      err.transferId = transferId;
+    }
+  }
+  async softAbort(transferId) {
+    try {
+      await this.deps.client.abortIntent(transferId);
+      await this.machineStores.backstop.drop(transferId);
+    } catch {
+    }
+  }
+  // ── mint (§5.9: journal-first, replayed at start, never blind re-mint) ─────
+  async mintInner(coinId, amount) {
+    if (!/^(?:[0-9a-f]{2})+$/.test(coinId) || amount <= 0n) {
+      return { success: false, error: "coinId must be even-length lowercase hex and amount positive" };
+    }
+    const engine = this.engine();
+    const mintId = this.newId();
+    const params = this.mintParams(coinId, amount);
+    const preDerived = supportsDeterministicMint(engine) ? await engine.deriveMintTokenId(params, mintId) : "";
+    const entry = {
+      mintId,
+      coinId,
+      amount: amount.toString(),
+      tokenId: preDerived,
+      createdAt: (this.deps.now ?? Date.now)()
+    };
+    await this.machineStores.mintJournal.record(entry);
+    let token;
+    try {
+      token = await engine.mint(params, { transferId: mintId });
+    } catch (err) {
+      return { success: false, error: messageOf(err) };
+    }
+    if (token.blob.tokenId !== entry.tokenId) {
+      await this.machineStores.mintJournal.record({ ...entry, tokenId: token.blob.tokenId });
+    }
+    try {
+      await this.finalizeMint(engine, mintId, token, coinId, amount.toString());
+    } catch (err) {
+      return { success: false, tokenId: token.blob.tokenId, error: messageOf(err) };
+    }
+    return { success: true, tokenId: token.blob.tokenId };
+  }
+  async finalizeMint(engine, mintId, token, coinId, amount) {
+    const bytes = token.blob.token;
+    const digest = bytesToHex(sha256(bytes));
+    const keys = await this.deps.storagePort.uploadBlobs([{ sha256: digest, bytes }]);
+    const key = keys.get(digest);
+    if (key === void 0) {
+      throw new SphereError(`no upload key returned for mint blob ${digest}`, "STORAGE_ERROR");
+    }
+    await this.deps.storagePort.applyDelta({
+      transferId: mintId,
+      spent: [],
+      added: [{ tokenId: token.blob.tokenId, key }]
+    });
+    await this.historyStore.recordMint({ tokenId: token.blob.tokenId, coinId, amount });
+    await this.machineStores.mintJournal.remove(mintId);
+    this.heldStates.set(token.blob.tokenId, (await engine.deliveryKeys(bytes)).stateHash);
+    this.trackTail(this.view.delta(0));
+  }
+  async replayMints() {
+    for (const entry of await this.machineStores.mintJournal.list()) {
+      try {
+        await this.replayMint(entry);
+      } catch {
+      }
+    }
+  }
+  async replayMint(entry) {
+    if (entry.tokenId !== "" && await this.tokenInServerInventory(entry.tokenId)) {
+      await this.machineStores.mintJournal.remove(entry.mintId);
+      return;
+    }
+    const engine = this.engine();
+    if (!supportsDeterministicMint(engine)) {
+      this.deps.emit("transfer:attention", {
+        transferId: entry.mintId,
+        code: ATTENTION_MINT_UNRESOLVED
+      });
+      return;
+    }
+    const token = await engine.mint(this.mintParams(entry.coinId, BigInt(entry.amount)), {
+      transferId: entry.mintId
+    });
+    if (token.blob.tokenId !== entry.tokenId) {
+      await this.machineStores.mintJournal.record({ ...entry, tokenId: token.blob.tokenId });
+    }
+    await this.finalizeMint(engine, entry.mintId, token, entry.coinId, entry.amount);
+  }
+  mintParams(coinId, amount) {
+    return {
+      recipientPubkey: this.ownPubkeyBytes,
+      value: { assets: [{ coinId, amount }] }
+    };
+  }
+  async tokenInServerInventory(tokenId) {
+    let page = await this.deps.storagePort.listInventory();
+    for (let i = 0; i < INVENTORY_SCAN_PAGE_LIMIT; i++) {
+      if (page.items.some((item) => item.tokenId === tokenId && item.status === "active")) {
+        return true;
+      }
+      if (!page.more) return false;
+      page = await this.deps.storagePort.listInventory(page.cursor);
+    }
+    return false;
+  }
+  // ── wiring internals ───────────────────────────────────────────────────────
+  engine() {
+    return this.currentEngine ?? this.deps.engineRef();
+  }
+  newId() {
+    return (this.deps.newId ?? randomUUID)();
+  }
+  async runResume() {
+    const report = await resumeAll(this.machineDeps);
+    await this.requests.reconcile({
+      resumed: report.resumed,
+      conflicted: report.conflicted,
+      open: report.failed
+    });
+    if (report.resumed.length > 0 || report.conflicted.length > 0) {
+      await this.view.delta(0).catch(() => void 0);
+    }
+  }
+  async seedHeldStates() {
+    let page = await this.deps.storagePort.listInventory();
+    for (let i = 0; i < INVENTORY_SCAN_PAGE_LIMIT; i++) {
+      for (const item of page.items) {
+        if (item.status === "active") this.heldStates.set(item.tokenId, item.stateHash);
+      }
+      if (!page.more) return;
+      page = await this.deps.storagePort.listInventory(page.cursor);
+    }
+  }
+  toUiToken(tokenId, coinId, amount) {
+    const registry = this.deps.registry;
+    const iconUrl = registry.getIconUrl(coinId);
+    const now = (this.deps.now ?? Date.now)();
+    return {
+      id: tokenId,
+      coinId,
+      symbol: registry.getSymbol(coinId),
+      name: registry.getName(coinId),
+      decimals: registry.getDecimals(coinId),
+      ...iconUrl !== null ? { iconUrl } : {},
+      amount: amount.toString(),
+      status: "transferring",
+      createdAt: now,
+      updatedAt: now,
+      lazy: true
+    };
+  }
+  track(op) {
+    const settled = op.then(
+      () => void 0,
+      () => void 0
+    );
+    this.pendingOps.add(settled);
+    void settled.finally(() => this.pendingOps.delete(settled));
+    return op;
+  }
+  trackTail(op) {
+    this.track(op).catch(() => void 0);
+  }
+};
+function buildPayload(recipientPubkey, request, spend, spentStates) {
+  return {
+    v: 2,
+    recipient: recipientPubkey,
+    coinId: request.coinId,
+    amount: request.amount,
+    ...request.memo !== void 0 ? { memo: request.memo } : {},
+    direct: [...spend.plan.direct],
+    ...spend.plan.split !== void 0 ? {
+      split: {
+        tokenId: spend.plan.split.tokenId,
+        splitAmount: spend.plan.split.splitAmount.toString(),
+        remainderAmount: spend.plan.split.remainderAmount.toString()
+      }
+    } : {},
+    spentStates
+  };
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+export {
+  ATTENTION_MINT_UNRESOLVED,
+  MAX_RESELECT,
+  PaymentsFacade,
+  STORE_KEYS,
+  createScopedKV,
+  supportsDeterministicMint
+};
+/*! Bundled license information:
+
+@noble/ciphers/utils.js:
+  (*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=index.js.map