@babylonlabs-io/ts-sdk 0.33.7 → 0.34.0

package/dist/vault-registry-reader-CqhD3Iyd.js

@@ -0,0 +1,1292 @@
+var fe = Object.defineProperty;
+var me = (t, e, n) => e in t ? fe(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var p = (t, e, n) => me(t, typeof e != "symbol" ? e + "" : e, n);
+import { D as be, J as re, e as _e } from "./types-TiIjyo2b.js";
+import { X as R, C as L, s as C, S as ye, h as Pe } from "./bitcoin-B0S8SHCX.js";
+import { H as T } from "./validation-CxqROCno.js";
+import * as j from "@bitcoin-js/tiny-secp256k1-asmjs";
+import { payments as we, Transaction as K } from "bitcoinjs-lib";
+import { Buffer as A } from "buffer";
+import { s as q } from "./sha2-6wN58S6R.js";
+import { B as V } from "./BTCVaultRegistry.abi-DbJ5lsFJ.js";
+import { P as _, A as F } from "./ProtocolParams.abi-DXu8L0Fn.js";
+const W = new Set(Object.values(be)), ve = 200;
+function l(t) {
+  var e;
+  return ((e = JSON.stringify(t)) == null ? void 0 : e.slice(0, ve)) ?? "undefined";
+}
+const xe = "The vault provider returned an unexpected response. Please try again or contact support.";
+class s extends Error {
+  constructor(n) {
+    super(xe);
+    p(this, "detail");
+    this.name = "VpResponseValidationError", this.detail = n;
+  }
+}
+const $ = 64;
+function w(t) {
+  return typeof t == "string" && t.length > 0 && T.test(t);
+}
+function ie(t) {
+  return typeof t == "string" && t.length > 0;
+}
+function se(t, e) {
+  if (!w(t))
+    throw new s(
+      `VP response validation failed: "${e}" must be a non-empty hex string, got ${l(t)}`
+    );
+}
+function m(t, e) {
+  if (!ie(t))
+    throw new s(
+      `VP response validation failed: "${e}" must be a non-empty string, got ${l(t)}`
+    );
+}
+function oe(t, e) {
+  if (!w(t) || t.length !== R && t.length !== L)
+    throw new s(
+      `VP response validation failed: "${e}" must be a ${R} or ${L}-char hex string (BTC pubkey), got ${l(t)}`
+    );
+}
+function Ae(t) {
+  const e = t.presigning;
+  if (e == null) return;
+  if (typeof e != "object" || Array.isArray(e))
+    throw new s(
+      'VP response validation failed: "progress.presigning" must be an object if present'
+    );
+  const n = e;
+  if (n.depositor_graph_created !== void 0 && typeof n.depositor_graph_created != "boolean")
+    throw new s(
+      `VP response validation failed: "progress.presigning.depositor_graph_created" must be a boolean if present, got ${l(n.depositor_graph_created)}`
+    );
+  if (n.vk_challenger_presigning_completed !== void 0 && typeof n.vk_challenger_presigning_completed != "number")
+    throw new s(
+      `VP response validation failed: "progress.presigning.vk_challenger_presigning_completed" must be a number if present, got ${l(n.vk_challenger_presigning_completed)}`
+    );
+  if (n.vk_challenger_presigning_total !== void 0 && typeof n.vk_challenger_presigning_total != "number")
+    throw new s(
+      `VP response validation failed: "progress.presigning.vk_challenger_presigning_total" must be a number if present, got ${l(n.vk_challenger_presigning_total)}`
+    );
+}
+function ae(t) {
+  if (t === null || typeof t != "object")
+    throw new s(
+      "VP response validation failed: getPeginStatus response is not an object"
+    );
+  const e = t;
+  if (!w(e.pegin_txid) || e.pegin_txid.length !== $)
+    throw new s(
+      `VP response validation failed: "pegin_txid" must be a ${$}-char hex string (txid), got ${l(e.pegin_txid)}`
+    );
+  if (typeof e.status != "string")
+    throw new s(
+      'VP response validation failed: "status" must be a string'
+    );
+  if (!W.has(e.status))
+    throw new s(
+      `VP response validation failed: unrecognized status "${e.status}". Expected one of: ${[...W].join(", ")}`
+    );
+  if (e.progress === null || typeof e.progress != "object" || Array.isArray(e.progress))
+    throw new s(
+      'VP response validation failed: "progress" must be an object'
+    );
+  if (Ae(e.progress), typeof e.health_info != "string")
+    throw new s(
+      'VP response validation failed: "health_info" must be a string'
+    );
+  if (e.last_error !== void 0 && typeof e.last_error != "string")
+    throw new s(
+      `VP response validation failed: "last_error" must be a string if present, got ${l(e.last_error)}`
+    );
+}
+function Ve(t) {
+  if (t === null || typeof t != "object")
+    throw new s(
+      "VP response validation failed: requestDepositorPresignTransactions response is not an object"
+    );
+  const e = t;
+  if (!Array.isArray(e.txs))
+    throw new s(
+      'VP response validation failed: "txs" must be an array'
+    );
+  for (let n = 0; n < e.txs.length; n++)
+    $e(e.txs[n], `txs[${n}]`);
+  if (e.depositor_graph === null || typeof e.depositor_graph != "object")
+    throw new s(
+      'VP response validation failed: "depositor_graph" must be an object'
+    );
+  Re(
+    e.depositor_graph
+  );
+}
+function y(t, e) {
+  if (t === null || typeof t != "object")
+    throw new s(
+      `VP response validation failed: "${e}" must be an object`
+    );
+  se(t.tx_hex, `${e}.tx_hex`);
+}
+function $e(t, e) {
+  if (t === null || typeof t != "object")
+    throw new s(
+      `VP response validation failed: "${e}" must be an object`
+    );
+  const n = t;
+  oe(n.claimer_pubkey, `${e}.claimer_pubkey`), y(n.claim_tx, `${e}.claim_tx`), y(n.assert_tx, `${e}.assert_tx`), y(n.payout_tx, `${e}.payout_tx`), m(n.payout_psbt, `${e}.payout_psbt`);
+}
+function Te(t, e) {
+  if (t === null || typeof t != "object")
+    throw new s(
+      `VP response validation failed: "${e}" must be an object`
+    );
+  const n = t;
+  m(n.wots_pks_json, `${e}.wots_pks_json`), m(n.gc_wots_keys_json, `${e}.gc_wots_keys_json`);
+}
+function ke(t, e) {
+  if (t === null || typeof t != "object")
+    throw new s(
+      `VP response validation failed: "${e}" must be an object`
+    );
+  const n = t;
+  if (oe(n.challenger_pubkey, `${e}.challenger_pubkey`), y(
+    n.challenge_assert_x_tx,
+    `${e}.challenge_assert_x_tx`
+  ), y(
+    n.challenge_assert_y_tx,
+    `${e}.challenge_assert_y_tx`
+  ), y(n.nopayout_tx, `${e}.nopayout_tx`), m(n.nopayout_psbt, `${e}.nopayout_psbt`), !Array.isArray(n.challenge_assert_connectors))
+    throw new s(
+      `VP response validation failed: "${e}.challenge_assert_connectors" must be an array`
+    );
+  for (let r = 0; r < n.challenge_assert_connectors.length; r++)
+    Te(
+      n.challenge_assert_connectors[r],
+      `${e}.challenge_assert_connectors[${r}]`
+    );
+  if (!Array.isArray(n.output_label_hashes))
+    throw new s(
+      `VP response validation failed: "${e}.output_label_hashes" must be an array`
+    );
+  for (let r = 0; r < n.output_label_hashes.length; r++)
+    se(
+      n.output_label_hashes[r],
+      `${e}.output_label_hashes[${r}]`
+    );
+}
+function Se(t) {
+  if (t === null || typeof t != "object")
+    throw new s(
+      "VP response validation failed: requestDepositorClaimerArtifacts response is not an object"
+    );
+  const e = t;
+  if (!ie(e.tx_graph_json))
+    throw new s(
+      `VP response validation failed: "tx_graph_json" must be a non-empty string, got ${l(e.tx_graph_json)}`
+    );
+  if (!w(e.verifying_key_hex))
+    throw new s(
+      `VP response validation failed: "verifying_key_hex" must be a non-empty hex string, got ${l(e.verifying_key_hex)}`
+    );
+  if (e.babe_sessions === null || typeof e.babe_sessions != "object")
+    throw new s(
+      'VP response validation failed: "babe_sessions" must be an object'
+    );
+  for (const [n, r] of Object.entries(
+    e.babe_sessions
+  )) {
+    if (r === null || typeof r != "object")
+      throw new s(
+        `VP response validation failed: "babe_sessions.${n}" must be an object`
+      );
+    const i = r;
+    if (!w(i.decryptor_artifacts_hex))
+      throw new s(
+        `VP response validation failed: "babe_sessions.${n}.decryptor_artifacts_hex" must be a non-empty hex string, got ${l(i.decryptor_artifacts_hex)}`
+      );
+  }
+}
+function Ce(t) {
+  if (t === null || typeof t != "object")
+    throw new s(
+      "VP response validation failed: pegout status payload is not an object"
+    );
+  const e = t;
+  if (!w(e.pegin_txid) || e.pegin_txid.length !== $)
+    throw new s(
+      `VP response validation failed: "pegin_txid" must be a ${$}-char hex string (txid), got ${l(e.pegin_txid)}`
+    );
+  if (typeof e.found != "boolean")
+    throw new s(
+      `VP response validation failed: "found" must be a boolean, got ${l(e.found)}`
+    );
+  if (e.claimer !== null) {
+    if (typeof e.claimer != "object")
+      throw new s(
+        `VP response validation failed: "claimer" must be an object or null, got ${l(e.claimer)}`
+      );
+    Ie(e.claimer);
+  }
+  if (!Array.isArray(e.challengers))
+    throw new s(
+      `VP response validation failed: "challengers" must be an array, got ${l(e.challengers)}`
+    );
+  for (let n = 0; n < e.challengers.length; n++)
+    Ee(e.challengers[n], n);
+}
+function Ie(t) {
+  if (m(t.status, "claimer.status"), typeof t.failed != "boolean")
+    throw new s(
+      `VP response validation failed: "claimer.failed" must be a boolean, got ${l(t.failed)}`
+    );
+  if (m(t.claim_txid, "claimer.claim_txid"), m(t.claimer_pubkey, "claimer.claimer_pubkey"), m(t.assert_txid, "claimer.assert_txid"), t.challenger_pubkey !== null && typeof t.challenger_pubkey != "string")
+    throw new s(
+      `VP response validation failed: "claimer.challenger_pubkey" must be a string or null, got ${l(t.challenger_pubkey)}`
+    );
+  if (typeof t.created_at != "number")
+    throw new s(
+      `VP response validation failed: "claimer.created_at" must be a number, got ${l(t.created_at)}`
+    );
+  if (typeof t.updated_at != "number")
+    throw new s(
+      `VP response validation failed: "claimer.updated_at" must be a number, got ${l(t.updated_at)}`
+    );
+}
+function Ee(t, e) {
+  if (t === null || typeof t != "object")
+    throw new s(
+      `VP response validation failed: "challengers[${e}]" must be an object, got ${l(t)}`
+    );
+  const n = t;
+  if (m(n.status, `challengers[${e}].status`), m(n.claim_txid, `challengers[${e}].claim_txid`), m(n.claimer_pubkey, `challengers[${e}].claimer_pubkey`), I(n.assert_txid, `challengers[${e}].assert_txid`), I(
+    n.challenge_assert_x_txid,
+    `challengers[${e}].challenge_assert_x_txid`
+  ), I(
+    n.challenge_assert_y_txid,
+    `challengers[${e}].challenge_assert_y_txid`
+  ), I(n.nopayout_txid, `challengers[${e}].nopayout_txid`), typeof n.created_at != "number")
+    throw new s(
+      `VP response validation failed: "challengers[${e}].created_at" must be a number, got ${l(n.created_at)}`
+    );
+  if (typeof n.updated_at != "number")
+    throw new s(
+      `VP response validation failed: "challengers[${e}].updated_at" must be a number, got ${l(n.updated_at)}`
+    );
+}
+function I(t, e) {
+  if (t !== null && typeof t != "string")
+    throw new s(
+      `VP response validation failed: "${e}" must be a string or null, got ${l(t)}`
+    );
+}
+function Be(t) {
+  ce(t, "batchGetPeginStatus", (e) => {
+    e.result !== null && ae(e.result);
+  });
+}
+function Ne(t) {
+  ce(t, "batchGetPegoutStatus", (e) => {
+    e.result !== null && Ce(e.result);
+  });
+}
+function ce(t, e, n) {
+  if (t === null || typeof t != "object")
+    throw new s(
+      `VP response validation failed: ${e} response is not an object`
+    );
+  const r = t;
+  if (!Array.isArray(r.results))
+    throw new s(
+      `VP response validation failed: "${e}.results" must be an array, got ${l(r.results)}`
+    );
+  for (let i = 0; i < r.results.length; i++) {
+    const o = r.results[i];
+    if (o === null || typeof o != "object")
+      throw new s(
+        `VP response validation failed: "${e}.results[${i}]" must be an object, got ${l(o)}`
+      );
+    const a = o;
+    if (!w(a.pegin_txid) || a.pegin_txid.length !== $)
+      throw new s(
+        `VP response validation failed: "${e}.results[${i}].pegin_txid" must be a ${$}-char hex string, got ${l(a.pegin_txid)}`
+      );
+    if (a.error !== null && typeof a.error != "string")
+      throw new s(
+        `VP response validation failed: "${e}.results[${i}].error" must be a string or null, got ${l(a.error)}`
+      );
+    if (a.result === null && a.error === null)
+      throw new s(
+        `VP response validation failed: "${e}.results[${i}]" has neither "result" nor "error" populated`
+      );
+    if (a.result !== null && a.error !== null)
+      throw new s(
+        `VP response validation failed: "${e}.results[${i}]" has both "result" and "error" populated`
+      );
+    n(a, i);
+  }
+}
+function Re(t) {
+  if (y(t.claim_tx, "depositor_graph.claim_tx"), y(t.assert_tx, "depositor_graph.assert_tx"), y(t.payout_tx, "depositor_graph.payout_tx"), m(t.payout_psbt, "depositor_graph.payout_psbt"), !Array.isArray(t.challenger_presign_data))
+    throw new s(
+      'VP response validation failed: "depositor_graph.challenger_presign_data" must be an array'
+    );
+  for (let e = 0; e < t.challenger_presign_data.length; e++)
+    ke(
+      t.challenger_presign_data[e],
+      `depositor_graph.challenger_presign_data[${e}]`
+    );
+  if (typeof t.offchain_params_version != "number")
+    throw new s(
+      'VP response validation failed: "depositor_graph.offchain_params_version" must be a number'
+    );
+}
+const Oe = 6e4;
+class He {
+  constructor(e, n) {
+    p(this, "client");
+    const r = {
+      baseUrl: e,
+      timeout: (n == null ? void 0 : n.timeout) ?? Oe,
+      retries: n == null ? void 0 : n.retries,
+      retryDelay: n == null ? void 0 : n.retryDelay,
+      retryableFor: n == null ? void 0 : n.retryableFor,
+      headers: n == null ? void 0 : n.headers,
+      tokenProvider: n == null ? void 0 : n.tokenProvider,
+      maxResponseBytes: n == null ? void 0 : n.maxResponseBytes
+    };
+    this.client = new re(r);
+  }
+  /**
+   * Request the payout/claim/assert transactions that the depositor
+   * needs to pre-sign before the vault can be activated on Bitcoin.
+   */
+  async requestDepositorPresignTransactions(e, n) {
+    const r = await this.client.call("vaultProvider_requestDepositorPresignTransactions", e, n);
+    return Ve(r), r;
+  }
+  /**
+   * Submit the depositor's pre-signatures for the payout transactions
+   * and the depositor-as-claimer graph.
+   */
+  async submitDepositorPresignatures(e, n) {
+    return this.client.call(
+      "vaultProvider_submitDepositorPresignatures",
+      e,
+      n
+    );
+  }
+  /**
+   * Submit the depositor's WOTS public key to the vault provider.
+   * Called after the pegin is finalized on Ethereum, when the VP is in
+   * `PendingDepositorWotsPK` status.
+   */
+  async submitDepositorWotsKey(e, n) {
+    return this.client.call(
+      "vaultProvider_submitDepositorWotsKey",
+      e,
+      n
+    );
+  }
+  /**
+   * Request the BaBe DecryptorArtifacts needed for the depositor to
+   * independently evaluate garbled circuits during a challenge.
+   */
+  async requestDepositorClaimerArtifacts(e, n) {
+    const r = await this.client.call("vaultProvider_requestDepositorClaimerArtifacts", e, n);
+    return Se(r), r;
+  }
+  /** Get the current pegin status from the vault provider daemon. */
+  async getPeginStatus(e, n) {
+    const r = await this.client.call(
+      "vaultProvider_getPeginStatus",
+      e,
+      n
+    );
+    return ae(r), r;
+  }
+  /**
+   * Get pegin status for many txids in one round trip. Per-result envelope
+   * isolates per-pegin failures from the overall RPC. Caller must chunk
+   * inputs at `VP_BATCH_MAX_SIZE`.
+   */
+  async batchGetPeginStatus(e, n) {
+    const r = await this.client.call("vaultProvider_batchGetPeginStatus", e, n);
+    return Be(r), r;
+  }
+  /**
+   * Get pegout status for many txids in one round trip. Same per-result
+   * envelope semantics as `batchGetPeginStatus`.
+   */
+  async batchGetPegoutStatus(e, n) {
+    const r = await this.client.call("vaultProvider_batchGetPegoutStatus", e, n);
+    return Ne(r), r;
+  }
+}
+function De(t, e) {
+  const n = /* @__PURE__ */ new Set();
+  for (const u of t)
+    n.add(u.toLowerCase());
+  const r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set(), o = [], a = [];
+  for (const u of e) {
+    const h = u.pegin_txid.toLowerCase();
+    if (!n.has(h)) {
+      a.push(h);
+      continue;
+    }
+    if (i.has(h)) {
+      o.push(h);
+      continue;
+    }
+    i.add(h), r.set(h, { result: u.result, error: u.error });
+  }
+  const c = [];
+  for (const u of n)
+    i.has(u) || c.push(u);
+  return { byTxid: r, missing: c, unexpected: a, duplicate: o };
+}
+async function lt(t) {
+  const {
+    items: e,
+    getTxid: n,
+    batchCall: r,
+    onItem: i,
+    onMissing: o,
+    onDuplicate: a,
+    onDuplicateBatch: c,
+    onWholeBatchError: u,
+    onUnexpected: h,
+    batchSize: f = _e
+  } = t;
+  if (!Number.isInteger(f) || f <= 0)
+    throw new Error(
+      `batchPollByProvider: batchSize must be a positive integer, got ${f}`
+    );
+  for (let P = 0; P < e.length; P += f) {
+    const v = e.slice(P, P + f), k = /* @__PURE__ */ new Map(), U = [];
+    for (const d of v) {
+      const b = n(d).toLowerCase();
+      k.set(b, d), U.push(b);
+    }
+    let x;
+    try {
+      const d = await r(U);
+      x = De(U, d.results);
+    } catch (d) {
+      u(v, d);
+      continue;
+    }
+    h && x.unexpected.length > 0 && h(x.unexpected);
+    const S = new Set(x.duplicate);
+    for (const d of S) {
+      const b = k.get(d);
+      b && a(b);
+    }
+    c && S.size > 0 && c(S.size);
+    for (const d of x.missing) {
+      const b = k.get(d);
+      b && o(b);
+    }
+    for (const [d, b] of x.byTxid) {
+      if (S.has(d)) continue;
+      const z = k.get(d);
+      z && i(z, {
+        pegin_txid: d,
+        result: b.result,
+        error: b.error
+      });
+    }
+  }
+}
+const je = "BIP0322-signed-message", Ue = "TapTweak", le = 32, Ke = 64;
+function ue(t, e) {
+  const n = new TextEncoder().encode(t), r = q(n), i = new Uint8Array(r.length * 2 + e.length);
+  return i.set(r, 0), i.set(r, r.length), i.set(e, r.length * 2), q(i);
+}
+function Fe(t) {
+  if (t.length !== le) return null;
+  const e = ue(Ue, t), n = j.xOnlyPointAddTweak(t, e);
+  return n ? n.xOnlyPubkey : null;
+}
+function Me(t, e, n) {
+  if (e.length !== le || n.length !== Ke) return !1;
+  try {
+    const r = ue(je, t), i = we.p2tr({
+      internalPubkey: A.from(e)
+    });
+    if (!i.output) return !1;
+    const o = i.output, a = 0, c = new K();
+    c.version = 0, c.locktime = 0;
+    const u = A.concat([
+      A.from([0, 32]),
+      A.from(r)
+    ]);
+    c.addInput(
+      A.alloc(32, 0),
+      // prev_txid = 0x0000...0000
+      4294967295,
+      // prev_vout = 0xFFFFFFFF
+      0,
+      // sequence = 0
+      u
+    ), c.addOutput(o, a);
+    const h = new K();
+    h.version = 0, h.locktime = 0;
+    const f = c.getHash();
+    h.addInput(f, 0, 0), h.addOutput(A.from([106]), a);
+    const P = h.hashForWitnessV1(
+      0,
+      [o],
+      [a],
+      K.SIGHASH_DEFAULT
+    ), v = Fe(e);
+    return v ? j.verifySchnorr(P, v, n) : !1;
+  } catch {
+    return !1;
+  }
+}
+function O(t, e) {
+  const n = (t & 7) << 5, r = typeof e == "bigint" ? e : BigInt(e);
+  if (r < 0n) throw new Error("cborHead: negative argument");
+  if (r < 24n) return new Uint8Array([n | Number(r)]);
+  if (r < 0x100n) return new Uint8Array([n | 24, Number(r)]);
+  if (r < 0x10000n) {
+    const o = Number(r);
+    return new Uint8Array([n | 25, o >>> 8 & 255, o & 255]);
+  }
+  if (r < 0x100000000n) {
+    const o = Number(r);
+    return new Uint8Array([
+      n | 26,
+      o >>> 24 & 255,
+      o >>> 16 & 255,
+      o >>> 8 & 255,
+      o & 255
+    ]);
+  }
+  const i = new Uint8Array(9);
+  i[0] = n | 27;
+  for (let o = 7; o >= 0; o--)
+    i[1 + o] = Number(r >> BigInt((7 - o) * 8)) & 255;
+  return i;
+}
+function he(...t) {
+  const e = t.reduce((i, o) => i + o.length, 0), n = new Uint8Array(e);
+  let r = 0;
+  for (const i of t)
+    n.set(i, r), r += i.length;
+  return n;
+}
+function Q(t) {
+  const n = [O(4, t.length)];
+  for (const r of t)
+    n.push(O(0, r));
+  return he(...n);
+}
+function Le(t, e, n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error(
+      `encodeServerIdentityPayload: expires_at must be a non-negative safe integer, got ${n}`
+    );
+  const r = O(4, 3), i = Q(t), o = Q(e), a = O(0, n);
+  return he(r, i, o, a);
+}
+const Ge = new TextEncoder().encode(
+  "btc-auth.server-identity.v1"
+), Xe = 2 * 3600;
+class g extends Error {
+  constructor(e, n) {
+    super(e), this.reason = n, this.name = "ServerIdentityError";
+  }
+}
+function E(t) {
+  const e = new Uint8Array(t.length / 2);
+  for (let n = 0; n < e.length; n++)
+    e[n] = parseInt(t.slice(n * 2, n * 2 + 2), 16);
+  return e;
+}
+function ze(t) {
+  const { proof: e, pinnedServerPubkey: n, now: r } = t, i = t.maxLifetimeSecs ?? Xe, o = C(n).toLowerCase();
+  if (o.length !== R || !T.test(o))
+    throw new g(
+      `pinnedServerPubkey must be 32-byte hex; got ${o.length} chars`,
+      "invalid_pubkey_encoding"
+    );
+  const a = C(e.server_pubkey).toLowerCase();
+  if (a.length !== R || !T.test(a))
+    throw new g(
+      `server_pubkey must be 32-byte hex; got ${a.length} chars`,
+      "invalid_pubkey_encoding"
+    );
+  if (a !== o)
+    throw new g(
+      `server_pubkey does not match pinned value: expected ${o}, got ${a}`,
+      "pinned_pubkey_mismatch"
+    );
+  if (!Number.isSafeInteger(e.expires_at))
+    throw new g(
+      `expires_at must be a finite integer; got ${JSON.stringify(e.expires_at)}`,
+      "invalid_expires_at"
+    );
+  if (!Number.isSafeInteger(r))
+    throw new g(
+      `now must be a finite integer; got ${JSON.stringify(r)}`,
+      "invalid_expires_at"
+    );
+  if (e.expires_at <= r)
+    throw new g(
+      `server identity proof expired at ${e.expires_at}, now ${r}`,
+      "expired"
+    );
+  if (!Number.isSafeInteger(i) || i <= 0)
+    throw new g(
+      `maxLifetimeSecs must be a positive safe integer; got ${JSON.stringify(i)}`,
+      "invalid_max_lifetime"
+    );
+  if (e.expires_at - r > i)
+    throw new g(
+      `server identity proof expires too far in the future: expires_at=${e.expires_at}, now=${r}, max lifetime=${i}s`,
+      "expires_too_far"
+    );
+  const c = C(e.ephemeral_pubkey).toLowerCase();
+  if (c.length !== L || !T.test(c))
+    throw new g(
+      `ephemeral_pubkey must be 33-byte compressed hex; got ${c.length} chars`,
+      "invalid_ephemeral_pubkey"
+    );
+  const u = c.slice(0, 2);
+  if (u !== "02" && u !== "03")
+    throw new g(
+      `ephemeral_pubkey must be compressed (prefix 02/03); got ${u}`,
+      "invalid_ephemeral_pubkey"
+    );
+  const h = E(c);
+  if (!j.isPoint(h))
+    throw new g(
+      "ephemeral_pubkey is not a valid secp256k1 point",
+      "invalid_ephemeral_pubkey"
+    );
+  const f = C(e.signature).toLowerCase();
+  if (f.length !== ye || !T.test(f))
+    throw new g(
+      `signature must be 64-byte Schnorr hex; got ${f.length} chars`,
+      "invalid_signature_encoding"
+    );
+  const P = Le(
+    Ge,
+    E(c),
+    e.expires_at
+  );
+  if (!Me(P, E(a), E(f)))
+    throw new g(
+      "BIP-322 signature verification failed — ephemeral key is not attested by pinned server pubkey",
+      "signature_verification_failed"
+    );
+}
+const qe = /* @__PURE__ */ new Set([
+  "vaultProvider_submitDepositorWotsKey",
+  "vaultProvider_submitDepositorPresignatures",
+  "vaultProvider_requestDepositorPresignTransactions"
+]), We = 6e4, G = "auth_createDepositorToken";
+function de(t, e) {
+  return new re({
+    baseUrl: t,
+    timeout: We,
+    headers: e,
+    retryableFor: (n) => n === G
+  });
+}
+const J = 4102444800, Qe = 30;
+class Je {
+  constructor(e) {
+    // `client` is the only mutable field — see `setClient`. The
+    // identity-bearing fields (peginTxid/authAnchorHex/pinnedServerPubkey)
+    // remain readonly and are checked against re-registration in the
+    // registry's `getOrCreate`.
+    p(this, "client");
+    p(this, "peginTxid");
+    p(this, "authAnchorHex");
+    p(this, "pinnedServerPubkey");
+    p(this, "authGatedMethods");
+    p(this, "refreshSkewSecs");
+    p(this, "now");
+    p(this, "cached", null);
+    p(this, "inFlight", null);
+    this.client = e.client, this.peginTxid = e.peginTxid, this.authAnchorHex = e.authAnchorHex, this.pinnedServerPubkey = e.pinnedServerPubkey, this.authGatedMethods = e.authGatedMethods, this.refreshSkewSecs = e.refreshSkewSecs ?? Qe, this.now = e.now ?? (() => Math.floor(Date.now() / 1e3));
+  }
+  /**
+   * Return a bearer token for `method`, or `null` if `method` is not
+   * auth-gated. Triggers a token acquisition if no token is cached or
+   * the cached token is within {@link refreshSkewSecs} of expiry.
+   *
+   * The token-issuing method itself is hard-exempted from the gate —
+   * if `auth_createDepositorToken` were ever included in
+   * `authGatedMethods` (caller misconfiguration) the provider would
+   * recurse into `acquireSingleFlight` from inside the JSON-RPC header
+   * builder before `inFlight` is assigned, defeating the single-flight
+   * guard. Returning `null` here breaks that recursion deterministically.
+   */
+  async getToken(e) {
+    if (e === G || !this.authGatedMethods.has(e)) return null;
+    const n = this.cached;
+    return n && this.now() + this.refreshSkewSecs < n.expiresAt ? n.token : (await this.acquireSingleFlight()).token;
+  }
+  /**
+   * Drop the cached token. Next `getToken` call re-acquires.
+   * Called by `JsonRpcClient` on wire `auth_expired` responses.
+   */
+  invalidate() {
+    this.cached = null;
+  }
+  /**
+   * Swap in a different transport for subsequent token-issuing calls.
+   * Used by the registry when a later caller registers the same
+   * `peginTxid` against a different `baseUrl` — the cached token
+   * (bound to identity, not transport) stays valid, but future
+   * refreshes hit the new URL. An in-flight acquire keeps using the
+   * old client (it captured the reference); next call uses the new.
+   */
+  setClient(e) {
+    this.client = e;
+  }
+  acquireSingleFlight() {
+    const e = this.inFlight;
+    if (e) return e;
+    const n = (async () => {
+      try {
+        const r = await this.client.call(G, {
+          pegin_txid: this.peginTxid,
+          auth_anchor: this.authAnchorHex
+        });
+        if (ze({
+          proof: r.server_identity,
+          pinnedServerPubkey: this.pinnedServerPubkey,
+          now: this.now()
+        }), typeof r.token != "string" || r.token.length === 0)
+          throw new Error(
+            `VpTokenProvider: invalid token in acquire response (expected non-empty string, got ${typeof r.token})`
+          );
+        const i = this.now();
+        if (!Number.isSafeInteger(r.expires_at) || r.expires_at <= i || r.expires_at > J)
+          throw new Error(
+            `VpTokenProvider: invalid expires_at in acquire response (got ${JSON.stringify(r.expires_at)}; must be a safe integer in (${i}, ${J}])`
+          );
+        const o = {
+          token: r.token,
+          expiresAt: r.expires_at
+        };
+        return this.cached = o, o;
+      } finally {
+        this.inFlight = null;
+      }
+    })();
+    return this.inFlight = n, n;
+  }
+}
+class Ye {
+  constructor() {
+    p(this, "entries", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Return the cached `VpTokenProvider` for `peginTxid` if one exists
+   * with matching `authAnchorHex` and `pinnedServerPubkey`, otherwise
+   * construct and cache a fresh provider. A mismatch on either field
+   * throws — silent overwrite would mask derivation drift or VP
+   * pubkey rotation.
+   */
+  getOrCreate(e) {
+    const n = this.entries.get(e.peginTxid);
+    if (n) {
+      if (n.authAnchorHex !== e.authAnchorHex)
+        throw new Error(
+          `VpTokenRegistry: peginTxid ${e.peginTxid} already bound to authAnchorHex ${n.authAnchorHex.slice(0, 8)}…; got ${e.authAnchorHex.slice(0, 8)}…`
+        );
+      if (n.pinnedServerPubkey !== e.pinnedServerPubkey)
+        throw new Error(
+          `VpTokenRegistry: peginTxid ${e.peginTxid} already bound to pinnedServerPubkey ${n.pinnedServerPubkey.slice(0, 8)}…; got ${e.pinnedServerPubkey.slice(0, 8)}…`
+        );
+      return n.provider.setClient(e.client), n.provider;
+    }
+    const r = new Je({
+      client: e.client,
+      peginTxid: e.peginTxid,
+      authAnchorHex: e.authAnchorHex,
+      pinnedServerPubkey: e.pinnedServerPubkey,
+      authGatedMethods: qe
+    });
+    return this.entries.set(e.peginTxid, {
+      provider: r,
+      authAnchorHex: e.authAnchorHex,
+      pinnedServerPubkey: e.pinnedServerPubkey
+    }), r;
+  }
+  /** Return the cached provider, or `undefined` if none. */
+  peek(e) {
+    var n;
+    return (n = this.entries.get(e)) == null ? void 0 : n.provider;
+  }
+  /**
+   * Evict the entry for `peginTxid`. Idempotent. Called on terminal
+   * paths — activation success, user-cancel, or component unmount —
+   * so `authAnchorHex` doesn't outlive the deposit session.
+   */
+  release(e) {
+    this.entries.delete(e);
+  }
+  /**
+   * Wipe every cached entry. Test-only escape hatch — not exposed on
+   * the public {@link VpTokenRegistryPublic} singleton type.
+   *
+   * @internal
+   */
+  clear() {
+    this.entries.clear();
+  }
+  get size() {
+    return this.entries.size;
+  }
+}
+const pe = new Ye();
+function ut(t) {
+  var r;
+  const e = de(
+    t.baseUrl,
+    (r = t.options) == null ? void 0 : r.headers
+  ), n = pe.getOrCreate({
+    client: e,
+    peginTxid: t.peginTxid,
+    authAnchorHex: t.authAnchorHex,
+    pinnedServerPubkey: t.pinnedServerPubkey
+  });
+  return new He(t.baseUrl, {
+    ...t.options,
+    tokenProvider: n
+  });
+}
+function ht(t) {
+  pe.getOrCreate({
+    client: de(t.baseUrl, t.headers),
+    peginTxid: t.peginTxid,
+    authAnchorHex: t.authAnchorHex,
+    pinnedServerPubkey: t.pinnedServerPubkey
+  });
+}
+async function dt(t, e) {
+  const [n, r] = await t.multicall({
+    contracts: [
+      {
+        address: e,
+        abi: V,
+        functionName: "protocolParams"
+      },
+      {
+        address: e,
+        abi: V,
+        functionName: "applicationRegistry"
+      }
+    ],
+    allowFailure: !1
+  });
+  return {
+    protocolParams: n,
+    applicationRegistry: r
+  };
+}
+const M = 65535, Y = 1e4, H = 4294967295, Z = 255;
+function X(t) {
+  if (!Number.isInteger(t) || t < 0 || t > H)
+    throw new Error(
+      `Invalid offchainParamsVersion from contract: must be a uint32, got ${t}`
+    );
+}
+function N(t) {
+  const e = [];
+  if (t.timelockAssert <= 0n && e.push(
+    `timelockAssert must be positive, got ${t.timelockAssert}`
+  ), t.timelockAssert > BigInt(M) && e.push(
+    `timelockAssert ${t.timelockAssert} exceeds uint16 max (${M})`
+  ), t.timelockChallengeAssert <= 0n && e.push(
+    `timelockChallengeAssert must be positive, got ${t.timelockChallengeAssert}`
+  ), t.tRefund <= 0 && e.push(`tRefund must be positive, got ${t.tRefund}`), t.tStale <= 0 && e.push(`tStale must be positive, got ${t.tStale}`), t.securityCouncilKeys.length === 0 && e.push("securityCouncilKeys must not be empty"), t.councilQuorum <= 0 && e.push(`councilQuorum must be positive, got ${t.councilQuorum}`), t.councilQuorum > t.securityCouncilKeys.length && e.push(
+    `councilQuorum (${t.councilQuorum}) exceeds securityCouncilKeys count (${t.securityCouncilKeys.length})`
+  ), t.feeRate <= 0n && e.push(`feeRate must be positive, got ${t.feeRate}`), t.minPeginFeeRate <= 0n && e.push(
+    `minPeginFeeRate must be positive, got ${t.minPeginFeeRate}`
+  ), (!Number.isInteger(t.proverProgramVersion) || t.proverProgramVersion < 0 || t.proverProgramVersion > M) && e.push(
+    `proverProgramVersion must be a uint16, got ${t.proverProgramVersion}`
+  ), (!Number.isInteger(t.minPrepeginDepth) || t.minPrepeginDepth <= 0 || t.minPrepeginDepth > H) && e.push(
+    `minPrepeginDepth must be a uint32 in [1, ${H}], got ${t.minPrepeginDepth}`
+  ), t.babeTotalInstances <= 0 && e.push(
+    `babeTotalInstances must be positive, got ${t.babeTotalInstances}`
+  ), t.babeInstancesToFinalize <= 0 && e.push(
+    `babeInstancesToFinalize must be positive, got ${t.babeInstancesToFinalize}`
+  ), t.babeInstancesToFinalize > t.babeTotalInstances && e.push(
+    `babeInstancesToFinalize (${t.babeInstancesToFinalize}) exceeds babeTotalInstances (${t.babeTotalInstances})`
+  ), (t.minVpCommissionBps < 0 || t.minVpCommissionBps > Y) && e.push(
+    `minVpCommissionBps must be in [0, ${Y}], got ${t.minVpCommissionBps}`
+  ), e.length > 0)
+    throw new Error(
+      `Invalid offchain protocol parameters: ${e.join("; ")}`
+    );
+}
+function ge(t) {
+  const e = [];
+  if (t.minimumPegInAmount <= 0n && e.push(
+    `minimumPegInAmount must be positive, got ${t.minimumPegInAmount}`
+  ), t.maxPegInAmount < t.minimumPegInAmount && e.push(
+    `maxPegInAmount (${t.maxPegInAmount}) must be >= minimumPegInAmount (${t.minimumPegInAmount})`
+  ), t.pegInAckTimeout <= 0n && e.push(
+    `pegInAckTimeout must be positive, got ${t.pegInAckTimeout}`
+  ), t.pegInActivationTimeout <= 0n && e.push(
+    `pegInActivationTimeout must be positive, got ${t.pegInActivationTimeout}`
+  ), (!Number.isInteger(t.maxHtlcOutputCount) || t.maxHtlcOutputCount <= 0 || t.maxHtlcOutputCount > Z) && e.push(
+    `maxHtlcOutputCount must be an integer in [1, ${Z}], got ${t.maxHtlcOutputCount}`
+  ), e.length > 0)
+    throw new Error(`Invalid TBV protocol parameters: ${e.join("; ")}`);
+}
+function Ze(t) {
+  if (ge(t), N(t.offchainParams), !Number.isInteger(t.offchainParamsVersion) || t.offchainParamsVersion < 0 || t.offchainParamsVersion > H)
+    throw new Error(
+      `Invalid peg-in configuration: offchainParamsVersion must be a uint32, got ${t.offchainParamsVersion}`
+    );
+}
+const ee = 65535;
+function B(t) {
+  return {
+    timelockAssert: t.timelockAssert,
+    timelockChallengeAssert: t.timelockChallengeAssert,
+    securityCouncilKeys: [...t.securityCouncilKeys],
+    councilQuorum: t.councilQuorum,
+    feeRate: t.feeRate,
+    babeTotalInstances: t.babeTotalInstances,
+    babeInstancesToFinalize: t.babeInstancesToFinalize,
+    minVpCommissionBps: t.minVpCommissionBps,
+    tRefund: t.tRefund,
+    tStale: t.tStale,
+    minPeginFeeRate: t.minPeginFeeRate,
+    proverProgramVersion: t.proverProgramVersion,
+    minPrepeginDepth: t.minPrepeginDepth
+  };
+}
+function te(t) {
+  return {
+    minimumPegInAmount: t.minimumPegInAmount,
+    maxPegInAmount: t.maxPegInAmount,
+    pegInAckTimeout: t.pegInAckTimeout,
+    pegInActivationTimeout: t.pegInActivationTimeout,
+    maxHtlcOutputCount: t.maxHtlcOutputCount
+  };
+}
+function ne(t) {
+  if (t > BigInt(ee))
+    throw new Error(
+      `timelockAssert value ${t} exceeds uint16 max (${ee})`
+    );
+  return Number(t);
+}
+class pt {
+  constructor(e, n) {
+    this.publicClient = e, this.contractAddress = n;
+  }
+  async getTBVProtocolParams() {
+    const e = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: _,
+      functionName: "getTBVProtocolParams"
+    }), n = te(e);
+    return ge(n), n;
+  }
+  async getLatestOffchainParams() {
+    const e = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: _,
+      functionName: "getLatestOffchainParams"
+    }), n = B(e);
+    return N(n), n;
+  }
+  async getOffchainParamsByVersion(e) {
+    const n = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: _,
+      functionName: "getOffchainParamsByVersion",
+      args: [e]
+    }), r = B(n);
+    return N(r), r;
+  }
+  async getLatestOffchainParamsVersion() {
+    const e = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: _,
+      functionName: "latestOffchainParamsVersion"
+    }), n = Number(e);
+    return X(n), n;
+  }
+  async getTimelockPeginByVersion(e) {
+    const n = await this.getOffchainParamsByVersion(e);
+    return ne(n.timelockAssert);
+  }
+  /**
+   * Read TBV protocol params, latest offchain params, and the latest version
+   * label atomically via multicall. The version is paired with the params so
+   * that a governance update between separate reads cannot let JS build BTC
+   * scripts with version N params while the contract registers the vault
+   * under version N+1.
+   */
+  async getPegInConfiguration() {
+    const e = await this.publicClient.multicall({
+      contracts: [
+        {
+          address: this.contractAddress,
+          abi: _,
+          functionName: "getTBVProtocolParams"
+        },
+        {
+          address: this.contractAddress,
+          abi: _,
+          functionName: "getLatestOffchainParams"
+        },
+        {
+          address: this.contractAddress,
+          abi: _,
+          functionName: "latestOffchainParamsVersion"
+        }
+      ],
+      allowFailure: !1
+    }), n = te(e[0]), r = B(e[1]), i = Number(e[2]), o = {
+      minimumPegInAmount: n.minimumPegInAmount,
+      maxPegInAmount: n.maxPegInAmount,
+      pegInAckTimeout: n.pegInAckTimeout,
+      pegInActivationTimeout: n.pegInActivationTimeout,
+      maxHtlcOutputCount: n.maxHtlcOutputCount,
+      timelockPegin: ne(r.timelockAssert),
+      timelockRefund: r.tRefund,
+      minVpCommissionBps: r.minVpCommissionBps,
+      offchainParams: r,
+      offchainParamsVersion: i
+    };
+    return Ze(o), o;
+  }
+  /**
+   * Fetch every historical offchain params version in a single multicall.
+   * Iterates 1..latestVersion and calls `getOffchainParamsByVersion` for each.
+   * Versions whose payload fails validation are skipped (not included in the
+   * returned map) so a single bad historical version doesn't block the
+   * lookup of the rest.
+   *
+   * @param onSkippedVersion - optional observer invoked once per skipped
+   *   version. Use to log/telemeter without coupling the SDK to a logger.
+   */
+  async fetchAllOffchainParams(e) {
+    const n = await this.getLatestOffchainParamsVersion();
+    if (n === 0)
+      return { byVersion: /* @__PURE__ */ new Map(), latestVersion: 0 };
+    const r = Array.from({ length: n }, (c, u) => u + 1), i = r.map((c) => ({
+      address: this.contractAddress,
+      abi: _,
+      functionName: "getOffchainParamsByVersion",
+      args: [c]
+    })), o = await this.publicClient.multicall({
+      contracts: i,
+      allowFailure: !1
+    }), a = /* @__PURE__ */ new Map();
+    for (let c = 0; c < r.length; c++) {
+      const u = B(o[c]);
+      try {
+        N(u), a.set(r[c], u);
+      } catch (h) {
+        e == null || e(
+          r[c],
+          h instanceof Error ? h : new Error(String(h))
+        );
+      }
+    }
+    return { byVersion: a, latestVersion: n };
+  }
+}
+function D(t) {
+  return t.map((e) => ({
+    ethAddress: e.ethAddress,
+    btcPubKey: e.btcPubKey
+  }));
+}
+class gt {
+  constructor(e, n) {
+    this.publicClient = e, this.contractAddress = n;
+  }
+  async getVaultKeepersByVersion(e, n) {
+    const r = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: F,
+      functionName: "getVaultKeepersByVersion",
+      args: [e, n]
+    });
+    return D(r);
+  }
+  async getCurrentVaultKeepers(e) {
+    const n = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: F,
+      functionName: "getCurrentVaultKeepers",
+      args: [e]
+    });
+    return D(n);
+  }
+  async getCurrentVaultKeepersVersion(e) {
+    return await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: F,
+      functionName: "getCurrentVaultKeepersVersion",
+      args: [e]
+    });
+  }
+}
+class ft {
+  constructor(e, n) {
+    this.publicClient = e, this.contractAddress = n;
+  }
+  async getUniversalChallengersByVersion(e) {
+    const n = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: _,
+      functionName: "getUniversalChallengersByVersion",
+      args: [e]
+    });
+    return D(n);
+  }
+  async getCurrentUniversalChallengers() {
+    const e = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: _,
+      functionName: "getCurrentUniversalChallengers"
+    });
+    return D(e);
+  }
+  async getLatestUniversalChallengersVersion() {
+    return await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: _,
+      functionName: "latestUniversalChallengersVersion"
+    });
+  }
+}
+class mt {
+  constructor(e, n) {
+    this.publicClient = e, this.contractAddress = n;
+  }
+  /**
+   * Read the VP's persistent x-only BTC pubkey from the on-chain
+   * registry. Validates length, hex form, and secp256k1 curve
+   * membership before minting the brand. Returns 64-char lowercase
+   * hex without the `0x` prefix.
+   */
+  async getVaultProviderBtcPubKey(e) {
+    const r = (await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: V,
+      functionName: "getVaultProviderBTCKey",
+      args: [e]
+    })).toLowerCase();
+    if (!/^0x[0-9a-f]{64}$/.test(r))
+      throw new Error(
+        `getVaultProviderBTCKey returned an unexpected value (vp=${e}, length ${r.length}, prefix "${r.slice(0, 2)}")`
+      );
+    const i = r.slice(2);
+    if (!j.isXOnlyPoint(Pe(i)))
+      throw new Error(
+        `getVaultProviderBTCKey returned a value that is not on the secp256k1 curve (vp=${e})`
+      );
+    return i;
+  }
+  async getVaultBasicInfo(e) {
+    const n = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: V,
+      functionName: "getBtcVaultBasicInfo",
+      args: [e]
+    });
+    return {
+      depositor: n.depositor,
+      depositorBtcPubKey: n.depositorBtcPubKey,
+      amount: n.amount,
+      vaultProvider: n.vaultProvider,
+      status: n.status,
+      applicationEntryPoint: n.applicationEntryPoint,
+      createdAt: n.createdAt
+    };
+  }
+  async getVaultProtocolInfo(e) {
+    const n = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: V,
+      functionName: "getBtcVaultProtocolInfo",
+      args: [e]
+    }), r = Number(n.offchainParamsVersion);
+    return X(r), {
+      depositorSignedPeginTx: n.depositorSignedPeginTx,
+      universalChallengersVersion: n.universalChallengersVersion,
+      appVaultKeepersVersion: n.appVaultKeepersVersion,
+      offchainParamsVersion: r,
+      verifiedAt: n.verifiedAt,
+      depositorWotsPkHash: n.depositorWotsPkHash,
+      hashlock: n.hashlock,
+      htlcVout: n.htlcVout,
+      depositorPopSignature: n.depositorPopSignature,
+      prePeginTxHash: n.prePeginTxHash,
+      vaultProviderCommissionBps: n.vaultProviderCommissionBps
+    };
+  }
+  async getVaultData(e) {
+    const [n, r] = await Promise.all([
+      this.getVaultBasicInfo(e),
+      this.getVaultProtocolInfo(e)
+    ]);
+    if (!r.depositorSignedPeginTx || r.depositorSignedPeginTx === "0x")
+      throw new Error(
+        `Vault ${e} not found on-chain or has no pegin transaction`
+      );
+    return { basic: n, protocol: r };
+  }
+  /**
+   * Read `offchainParamsVersion` for many vaults in a single multicall.
+   * Reads only `getBtcVaultProtocolInfo` (one read per vault), so an N-vault
+   * batch costs one RPC round-trip instead of 2N parallel `eth_call`s.
+   */
+  async getOffchainParamsVersionsByVaultIds(e) {
+    return e.length === 0 ? [] : (await this.publicClient.multicall({
+      contracts: e.map((r) => ({
+        address: this.contractAddress,
+        abi: V,
+        functionName: "getBtcVaultProtocolInfo",
+        args: [r]
+      })),
+      allowFailure: !1
+    })).map((r) => {
+      const i = r;
+      if (!i.depositorSignedPeginTx || i.depositorSignedPeginTx === "0x")
+        throw new Error(
+          "Vault not found on-chain or has no pegin transaction while reading offchain params version"
+        );
+      const o = Number(i.offchainParamsVersion);
+      return X(o), o;
+    });
+  }
+}
+export {
+  g as S,
+  He as V,
+  s as a,
+  lt as b,
+  ze as c,
+  Ye as d,
+  pe as e,
+  ut as f,
+  N as g,
+  Ze as h,
+  ge as i,
+  pt as j,
+  ft as k,
+  gt as l,
+  mt as m,
+  ht as p,
+  dt as r,
+  Se as v
+};
+//# sourceMappingURL=vault-registry-reader-CqhD3Iyd.js.map