@babylonlabs-io/ts-sdk 0.68.0 → 0.69.0

package/dist/PeginManager-DSFecw-w.js

@@ -0,0 +1,1503 @@
+var Ge = Object.defineProperty;
+var qe = (s, e, t) => e in s ? Ge(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var x = (s, e, t) => qe(s, typeof e != "symbol" ? e + "" : e, t);
+import { c as _e, H as Ye, r as W, a as K, b as ae, u as ze, d as ce, e as le, f as ue, g as je, s as Se } from "./sha2-BYVxyZzX.js";
+import * as Ce from "bitcoinjs-lib";
+import { Transaction as Ae, Psbt as he } from "bitcoinjs-lib";
+import { Buffer as O } from "buffer";
+import { isAddressEqual as de, encodeFunctionData as ee, zeroAddress as Qe } from "viem";
+import { B as H } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
+import { h as R } from "./errors-Blc-JWnI.js";
+import { expandWotsSeed as Ze, expandHashlockSecret as Je, expandAuthAnchor as et, deriveVaultId as pe } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import { a as fe, b as tt, f as ge, g as st } from "./verifyScriptPathSchnorrSignature-Dy9gF5RF.js";
+import { d as ot, b as nt, e as rt, f as it, c as at } from "./verifyKeyPathSchnorrSignature-C6Cmk0R1.js";
+import { p as ct, h as te, u as se, e as A, i as me, s as k, k as Pe, X as lt } from "./bitcoin-Ch_jxnDa.js";
+import { c as ut } from "./signing-DaLvGwQe.js";
+import { M as be } from "./validation-Dj3dqYtl.js";
+import { p as ht, d as Ie } from "./parseFundingOutpoints-CO-f6IHK.js";
+import { c as dt, s as F, r as pt, b as ft, d as gt } from "./signPsbtsWithFallback-DCZO2h6i.js";
+import { s as mt, f as q, i as Pt, w as we } from "./waitForTransactionReceiptSmartAware-lobLm0q0.js";
+import { p as bt, f as wt } from "./fundPeginTransaction-B2wyjqp0.js";
+import { M as X, B as yt } from "./constants-GjWXdaqV.js";
+import { l as xt, P as kt, m as Et, n as Tt, p as vt, V as Bt, i as _t } from "./mempoolApi-71R_CNZa.js";
+import * as St from "@bitcoin-js/tiny-secp256k1-asmjs";
+const D = /* @__PURE__ */ BigInt(2 ** 32 - 1), ye = /* @__PURE__ */ BigInt(32);
+function Ct(s, e = !1) {
+  return e ? { h: Number(s & D), l: Number(s >> ye & D) } : { h: Number(s >> ye & D) | 0, l: Number(s & D) | 0 };
+}
+function At(s, e = !1) {
+  const t = s.length;
+  let o = new Uint32Array(t), i = new Uint32Array(t);
+  for (let n = 0; n < t; n++) {
+    const { h: r, l: a } = Ct(s[n], e);
+    [o[n], i[n]] = [r, a];
+  }
+  return [o, i];
+}
+const It = (s, e, t) => s << t | e >>> 32 - t, Ht = (s, e, t) => e << t | s >>> 32 - t, Rt = (s, e, t) => e << t - 32 | s >>> 64 - t, $t = (s, e, t) => s << t - 32 | e >>> 64 - t, Ot = 64;
+function Vt(s) {
+  const e = s.prepeginTxid.toLowerCase();
+  if (!/^[0-9a-f]+$/.test(e) || e.length !== Ot)
+    throw new Error(
+      `buildDepositTerms: prepeginTxid must be 64 hex chars, got "${s.prepeginTxid}"`
+    );
+  if (s.peginAmounts.length === 0)
+    throw new Error("buildDepositTerms: at least one pegin amount is required");
+  if (s.timelockPegin <= 0 || s.timelockAssert <= 0 || s.timelockRefund <= 0)
+    throw new Error("buildDepositTerms: timelocks must be positive");
+  if (!Number.isInteger(s.maxAcceptableCommissionBps) || s.maxAcceptableCommissionBps < 0 || s.maxAcceptableCommissionBps >= X)
+    throw new Error(
+      `buildDepositTerms: maxAcceptableCommissionBps must be an integer in [0, ${X}), got ${s.maxAcceptableCommissionBps}`
+    );
+  const t = BigInt(yt), o = s.peginAmounts.map(
+    (i, n) => ({
+      htlcVout: n,
+      vaultProviderBtcPubkey: s.vaultProviderBtcPubkey,
+      peginAmount: i,
+      // Ceiling, not quote: floor(peginAmount * maxAcceptableBps / 10_000) —
+      // the same bound the registration calldata enforces on-chain, so any
+      // stamped commission the contract admits stays under it (firmware
+      // >= c8db53e checks the payout commission output <= this value).
+      commissionFee: i * BigInt(s.maxAcceptableCommissionBps) / t,
+      depositorClaimValue: s.depositorClaimValue,
+      peginMaxFee: s.peginMaxFee
+    })
+  );
+  return {
+    vaultCoreVersion: s.vaultCoreVersion,
+    protocolFeeRate: s.protocolFeeRate,
+    timelockPegin: s.timelockPegin,
+    timelockAssert: s.timelockAssert,
+    timelockRefund: s.timelockRefund,
+    prepeginTxid: e,
+    prepeginMaxFee: s.prepeginMaxFee,
+    vaultKeeperBtcPubkeys: [...s.vaultKeeperBtcPubkeys],
+    universalChallengerBtcPubkeys: [...s.universalChallengerBtcPubkeys],
+    vaults: o
+  };
+}
+const oe = 25, He = 9999;
+function Y(s) {
+  if (!Number.isInteger(s) || s < 0 || s >= X)
+    throw new Error(
+      `Quoted commissionBps must be an integer in [0, ${X}), got ${s}`
+    );
+  return Math.min(
+    s + oe,
+    He
+  );
+}
+const Ft = /^0x[0-9a-f]+$/i, Mt = /^[0-9a-f]+$/i, Wt = /^[A-Za-z0-9+/]+={0,2}$/;
+function $(s) {
+  if (typeof s != "string" || s.length === 0)
+    throw new Error("BTC wallet returned empty public key");
+  return ct(s).toLowerCase();
+}
+function Dt(s) {
+  if (typeof s != "string" || s.length === 0)
+    throw new Error("BTC wallet returned empty BIP-322 signature");
+  if (s.startsWith("0x") || s.startsWith("0X")) {
+    if (!Ft.test(s) || s.length < 4 || s.length % 2 !== 0)
+      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
+    return s.toLowerCase();
+  }
+  if (Mt.test(s)) {
+    if (s.length % 2 !== 0)
+      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
+    return `0x${s.toLowerCase()}`;
+  }
+  if (!Wt.test(s) || s.length % 4 !== 0)
+    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
+  const e = O.from(s, "base64");
+  if (e.length === 0 || e.toString("base64") !== s)
+    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
+  return `0x${e.toString("hex")}`;
+}
+async function Nt(s) {
+  const { wallet: e, depositTerms: t, fundedPrePeginTxHex: o, depositorBtcPubkey: i } = s, n = typeof e.approveDepositTerms == "function" ? e.approveDepositTerms : void 0;
+  if (!n && !t)
+    return;
+  const r = o.startsWith("0x") ? o.slice(2) : o, c = Ae.fromHex(r).getId();
+  if (t && t.prepeginTxid.replace(/^0x/, "").toLowerCase() !== c)
+    throw new Error(
+      `Deposit terms do not match the transaction being broadcast: terms are for prepeginTxid ${t.prepeginTxid}, but this transaction is ${c}.`
+    );
+  if (!n)
+    return;
+  if (!t)
+    throw new Error(
+      "This wallet requires approved deposit terms before signing the Pre-PegIn transaction, but none were provided. Pass PreparePeginResult.depositTerms (fresh flows) or a resume rebuild."
+    );
+  if (typeof e.deriveContextHash != "function")
+    throw new Error(
+      "A deposit-approval wallet must also implement deriveContextHash, but this one does not."
+    );
+  if (typeof e.holdsApprovedDepositTerms == "function") {
+    let g = !1;
+    try {
+      g = await e.holdsApprovedDepositTerms(t);
+    } catch {
+    }
+    if (g)
+      return;
+  }
+  typeof e.validateDepositTerms == "function" && await e.validateDepositTerms(t);
+  const h = ht(o);
+  (await Ie(
+    { deriveContextHash: e.deriveContextHash.bind(e) },
+    {
+      depositorBtcPubkey: te(
+        $(i)
+      ),
+      fundingOutpoints: h
+    }
+  )).fill(0), await n.call(e, t);
+}
+const Ut = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), Re = Uint8Array.from(new Array(16).fill(0).map((s, e) => e)), Lt = Re.map((s) => (9 * s + 5) % 16), $e = /* @__PURE__ */ (() => {
+  const t = [[Re], [Lt]];
+  for (let o = 0; o < 4; o++)
+    for (let i of t)
+      i.push(i[o].map((n) => Ut[n]));
+  return t;
+})(), Oe = $e[0], Ve = $e[1], Fe = /* @__PURE__ */ [
+  [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
+  [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
+  [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
+  [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
+  [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
+].map((s) => Uint8Array.from(s)), Kt = /* @__PURE__ */ Oe.map((s, e) => s.map((t) => Fe[e][t])), Xt = /* @__PURE__ */ Ve.map((s, e) => s.map((t) => Fe[e][t])), Gt = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), qt = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function xe(s, e, t, o) {
+  return s === 0 ? e ^ t ^ o : s === 1 ? e & t | ~e & o : s === 2 ? (e | ~t) ^ o : s === 3 ? e & o | t & ~o : e ^ (t | ~o);
+}
+const N = /* @__PURE__ */ new Uint32Array(16);
+class Yt extends Ye {
+  constructor() {
+    super(64, 20, 8, !0);
+    x(this, "h0", 1732584193);
+    x(this, "h1", -271733879);
+    x(this, "h2", -1732584194);
+    x(this, "h3", 271733878);
+    x(this, "h4", -1009589776);
+  }
+  get() {
+    const { h0: t, h1: o, h2: i, h3: n, h4: r } = this;
+    return [t, o, i, n, r];
+  }
+  set(t, o, i, n, r) {
+    this.h0 = t | 0, this.h1 = o | 0, this.h2 = i | 0, this.h3 = n | 0, this.h4 = r | 0;
+  }
+  process(t, o) {
+    for (let l = 0; l < 16; l++, o += 4)
+      N[l] = t.getUint32(o, !0);
+    let i = this.h0 | 0, n = i, r = this.h1 | 0, a = r, c = this.h2 | 0, h = c, d = this.h3 | 0, g = d, P = this.h4 | 0, b = P;
+    for (let l = 0; l < 5; l++) {
+      const T = 4 - l, E = Gt[l], p = qt[l], B = Oe[l], S = Ve[l], f = Kt[l], w = Xt[l];
+      for (let u = 0; u < 16; u++) {
+        const y = W(i + xe(l, r, c, d) + N[B[u]] + E, f[u]) + P | 0;
+        i = P, P = d, d = W(c, 10) | 0, c = r, r = y;
+      }
+      for (let u = 0; u < 16; u++) {
+        const y = W(n + xe(T, a, h, g) + N[S[u]] + p, w[u]) + b | 0;
+        n = b, b = g, g = W(h, 10) | 0, h = a, a = y;
+      }
+    }
+    this.set(this.h1 + c + g | 0, this.h2 + d + b | 0, this.h3 + P + n | 0, this.h4 + i + a | 0, this.h0 + r + h | 0);
+  }
+  roundClean() {
+    K(N);
+  }
+  destroy() {
+    this.destroyed = !0, K(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const zt = /* @__PURE__ */ _e(() => new Yt()), jt = BigInt(0), M = BigInt(1), Qt = BigInt(2), Zt = BigInt(7), Jt = BigInt(256), es = BigInt(113), Me = [], We = [], De = [];
+for (let s = 0, e = M, t = 1, o = 0; s < 24; s++) {
+  [t, o] = [o, (2 * t + 3 * o) % 5], Me.push(2 * (5 * o + t)), We.push((s + 1) * (s + 2) / 2 % 64);
+  let i = jt;
+  for (let n = 0; n < 7; n++)
+    e = (e << M ^ (e >> Zt) * es) % Jt, e & Qt && (i ^= M << (M << BigInt(n)) - M);
+  De.push(i);
+}
+const Ne = At(De, !0), ts = Ne[0], ss = Ne[1], ke = (s, e, t) => t > 32 ? Rt(s, e, t) : It(s, e, t), Ee = (s, e, t) => t > 32 ? $t(s, e, t) : Ht(s, e, t);
+function os(s, e = 24) {
+  const t = new Uint32Array(10);
+  for (let o = 24 - e; o < 24; o++) {
+    for (let r = 0; r < 10; r++)
+      t[r] = s[r] ^ s[r + 10] ^ s[r + 20] ^ s[r + 30] ^ s[r + 40];
+    for (let r = 0; r < 10; r += 2) {
+      const a = (r + 8) % 10, c = (r + 2) % 10, h = t[c], d = t[c + 1], g = ke(h, d, 1) ^ t[a], P = Ee(h, d, 1) ^ t[a + 1];
+      for (let b = 0; b < 50; b += 10)
+        s[r + b] ^= g, s[r + b + 1] ^= P;
+    }
+    let i = s[2], n = s[3];
+    for (let r = 0; r < 24; r++) {
+      const a = We[r], c = ke(i, n, a), h = Ee(i, n, a), d = Me[r];
+      i = s[d], n = s[d + 1], s[d] = c, s[d + 1] = h;
+    }
+    for (let r = 0; r < 50; r += 10) {
+      for (let a = 0; a < 10; a++)
+        t[a] = s[r + a];
+      for (let a = 0; a < 10; a++)
+        s[r + a] ^= ~t[(a + 2) % 10] & t[(a + 4) % 10];
+    }
+    s[0] ^= ts[o], s[1] ^= ss[o];
+  }
+  K(t);
+}
+class re {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(e, t, o, i = !1, n = 24) {
+    x(this, "state");
+    x(this, "pos", 0);
+    x(this, "posOut", 0);
+    x(this, "finished", !1);
+    x(this, "state32");
+    x(this, "destroyed", !1);
+    x(this, "blockLen");
+    x(this, "suffix");
+    x(this, "outputLen");
+    x(this, "enableXOF", !1);
+    x(this, "rounds");
+    if (this.blockLen = e, this.suffix = t, this.outputLen = o, this.enableXOF = i, this.rounds = n, ae(o, "outputLen"), !(0 < e && e < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200), this.state32 = ze(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    ce(this.state32), os(this.state32, this.rounds), ce(this.state32), this.posOut = 0, this.pos = 0;
+  }
+  update(e) {
+    le(this), ue(e);
+    const { blockLen: t, state: o } = this, i = e.length;
+    for (let n = 0; n < i; ) {
+      const r = Math.min(t - this.pos, i - n);
+      for (let a = 0; a < r; a++)
+        o[this.pos++] ^= e[n++];
+      this.pos === t && this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = !0;
+    const { state: e, suffix: t, pos: o, blockLen: i } = this;
+    e[o] ^= t, (t & 128) !== 0 && o === i - 1 && this.keccak(), e[i - 1] ^= 128, this.keccak();
+  }
+  writeInto(e) {
+    le(this, !1), ue(e), this.finish();
+    const t = this.state, { blockLen: o } = this;
+    for (let i = 0, n = e.length; i < n; ) {
+      this.posOut >= o && this.keccak();
+      const r = Math.min(o - this.posOut, n - i);
+      e.set(t.subarray(this.posOut, this.posOut + r), i), this.posOut += r, i += r;
+    }
+    return e;
+  }
+  xofInto(e) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(e);
+  }
+  xof(e) {
+    return ae(e), this.xofInto(new Uint8Array(e));
+  }
+  digestInto(e) {
+    if (je(e, this), this.finished)
+      throw new Error("digest() was already called");
+    return this.writeInto(e), this.destroy(), e;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = !0, K(this.state);
+  }
+  _cloneInto(e) {
+    const { blockLen: t, suffix: o, outputLen: i, rounds: n, enableXOF: r } = this;
+    return e || (e = new re(t, o, i, r, n)), e.state32.set(this.state32), e.pos = this.pos, e.posOut = this.posOut, e.finished = this.finished, e.rounds = n, e.suffix = o, e.outputLen = i, e.enableXOF = r, e.destroyed = this.destroyed, e;
+  }
+}
+const ns = (s, e, t, o = {}) => _e(() => new re(e, s, t), o), rs = /* @__PURE__ */ ns(1, 136, 32), Te = 64, _ = 20, ne = 4, Ue = 2, is = 0, as = 1, U = [64, 64], cs = (s) => Array.from(s).map((e) => e.toString(16).padStart(2, "0")).join("");
+function ie(s) {
+  return zt(Se(s));
+}
+function Le(s) {
+  return (1 << s) - 1;
+}
+function ls(s) {
+  let e = 1;
+  for (; e * e < s + 1; ) e++;
+  return Math.max(e, 2);
+}
+function us(s) {
+  const e = ne, t = s * Le(e);
+  return { d: e, n: s, checksum_radix: ls(t) };
+}
+function z(s, e) {
+  const t = [];
+  let o = e;
+  for (; o > 0; )
+    t.push(o & 255), o >>>= 8;
+  const i = new Uint8Array(s.length + t.length);
+  i.set(s);
+  for (let n = 0; n < t.length; n++)
+    i[s.length + n] = t[n];
+  return ie(i);
+}
+function j(s, e) {
+  let t = s;
+  for (let o = 0; o < e; o++)
+    t = ie(t);
+  return t;
+}
+function hs(s, e) {
+  const t = Le(e.d), o = e.checksum_radix - 1, i = Math.floor(e.n * t / e.checksum_radix), n = [];
+  for (let d = 0; d < e.n; d++) {
+    const g = z(s, d + Ue), P = j(g, t);
+    n.push(Array.from(P));
+  }
+  const r = z(
+    s,
+    is
+  ), a = j(
+    r,
+    o
+  ), c = z(
+    s,
+    as
+  ), h = j(
+    c,
+    i
+  );
+  return {
+    config: e,
+    message_terminals: n,
+    checksum_major_terminal: Array.from(h),
+    checksum_minor_terminal: Array.from(a)
+  };
+}
+async function ds(s) {
+  try {
+    if (s.length !== Te)
+      throw new Error(
+        `WOTS seed must be exactly ${Te} bytes, got ${s.length}`
+      );
+    const e = [];
+    for (let t = 0; t < U.length; t++) {
+      const o = U[t], i = us(o), n = new Uint8Array(s.length + 1);
+      n.set(s), n[s.length] = t;
+      const r = ie(n);
+      try {
+        const a = hs(r, i);
+        if (a.config.d !== ne)
+          throw new Error(
+            `Block ${t}: expected d=${ne}, got d=${a.config.d}`
+          );
+        if (a.config.n !== o)
+          throw new Error(
+            `Block ${t}: expected n=${o}, got n=${a.config.n}`
+          );
+        if (a.message_terminals.length !== o)
+          throw new Error(
+            `Block ${t}: expected ${o} message terminals, got ${a.message_terminals.length}`
+          );
+        for (let c = 0; c < a.message_terminals.length; c++)
+          if (a.message_terminals[c].length !== _)
+            throw new Error(
+              `Block ${t} terminal ${c}: expected ${_} bytes, got ${a.message_terminals[c].length}`
+            );
+        if (a.checksum_minor_terminal.length !== _)
+          throw new Error(
+            `Block ${t} checksum_minor: expected ${_} bytes`
+          );
+        if (a.checksum_major_terminal.length !== _)
+          throw new Error(
+            `Block ${t} checksum_major: expected ${_} bytes`
+          );
+        e.push(a);
+      } finally {
+        n.fill(0), r.fill(0);
+      }
+    }
+    if (e.length !== U.length)
+      throw new Error(
+        `Expected ${U.length} blocks, got ${e.length}`
+      );
+    return e;
+  } finally {
+    s.fill(0);
+  }
+}
+function Q(s, e, t) {
+  if (s.length !== _)
+    throw new Error(
+      `Block ${e} ${t}: expected ${_} bytes, got ${s.length}`
+    );
+  for (let o = 0; o < s.length; o++) {
+    const i = s[o];
+    if (!Number.isInteger(i) || i < 0 || i > 255)
+      throw new Error(
+        `Block ${e} ${t}[${o}]: invalid byte value ${i}`
+      );
+  }
+}
+function ps(s) {
+  if (s.length === 0)
+    throw new Error("Public keys array must not be empty");
+  for (let n = 0; n < s.length; n++) {
+    const r = s[n];
+    Q(r.checksum_minor_terminal, n, "checksum_minor_terminal"), Q(r.checksum_major_terminal, n, "checksum_major_terminal");
+    for (let a = 0; a < r.message_terminals.length; a++)
+      Q(r.message_terminals[a], n, `message_terminal[${a}]`);
+  }
+  let e = 0;
+  for (const n of s)
+    e += Ue + n.message_terminals.length;
+  const t = new Uint8Array(e * _);
+  let o = 0;
+  for (const n of s) {
+    t.set(n.checksum_minor_terminal, o), o += _, t.set(n.checksum_major_terminal, o), o += _;
+    for (const r of n.message_terminals)
+      t.set(r, o), o += _;
+  }
+  const i = rs(t);
+  return `0x${cs(i)}`;
+}
+async function fs(s, e) {
+  const t = [], o = [], i = [], n = [];
+  try {
+    for (let r = 0; r < e; r++) {
+      const a = await Ze(s, r);
+      try {
+        const h = await ds(a);
+        t.push(h), o.push(ps(h));
+      } finally {
+        a.fill(0);
+      }
+      const c = await Je(s, r);
+      try {
+        const h = se(c);
+        i.push(h), n.push(dt(A(h)).slice(2));
+      } finally {
+        c.fill(0);
+      }
+    }
+  } finally {
+    s.fill(0);
+  }
+  return { perVaultWotsKeys: t, wotsPkHashes: o, htlcSecretHexes: i, hashlocks: n };
+}
+const gs = 1, ms = 2, Ps = 33, bs = 2, ws = 3, ys = 1, L = 64, xs = 0, Z = 1, ve = /^[0-9a-f]{64}$/i, ks = /^(?:[0-9a-f]{2})+$/;
+function Es(s) {
+  const e = s.slice(2);
+  if (!ks.test(e))
+    throw new Error(
+      "proof of possession witness is not even-length lowercase hex"
+    );
+  return ot(
+    Uint8Array.from(O.from(e, "hex")),
+    "proof of possession witness"
+  );
+}
+function Ts(s, e, t) {
+  var i;
+  const o = Es(t);
+  if (o.length === gs) {
+    const [n] = o;
+    let r, a;
+    if (n.length === L)
+      r = n, a = xs;
+    else if (n.length === L + 1 && n[L] === Z)
+      r = n.subarray(0, L), a = Z;
+    else
+      throw new Error(
+        "proof of possession witness item must be a 64-byte Schnorr signature (or 65 bytes ending in 0x01)"
+      );
+    if (!ve.test(e))
+      throw new Error(
+        `depositor public key must be bare 64-char x-only hex, got "${e}"`
+      );
+    const c = Uint8Array.from(O.from(e, "hex"));
+    if (!xt(s, c, r, a))
+      throw new Error(
+        "proof of possession signature does not verify against the depositor key"
+      );
+    return { kind: "p2tr-verified" };
+  }
+  if (o.length === ms) {
+    if (!ve.test(e))
+      throw new Error(
+        `depositor public key must be bare 64-char x-only hex, got "${e}"`
+      );
+    const [n, r] = o;
+    if (r.length !== Ps || r[0] !== bs && r[0] !== ws)
+      throw new Error(
+        `proof of possession P2WPKH witness item 1 is not a compressed public key (${r.length} bytes, prefix 0x${((i = r[0]) == null ? void 0 : i.toString(16)) ?? "none"})`
+      );
+    if (!St.isPointCompressed(r))
+      throw new Error(
+        "proof of possession P2WPKH witness pubkey is not a valid secp256k1 point"
+      );
+    const a = O.from(
+      r.subarray(ys)
+    ).toString("hex");
+    if (a !== e.toLowerCase())
+      throw new Error(
+        `proof of possession witness pubkey does not match the depositor key: witness carries ${a}, expected ${e}`
+      );
+    if (n.length < kt || n.length > Et)
+      throw new Error(
+        `proof of possession signature is ${n.length} bytes; vault ingestion accepts only 71/72-byte DER signatures with a sighash byte — try a different account or a Taproot address`
+      );
+    if (n[n.length - 1] !== Z)
+      throw new Error(
+        `proof of possession P2WPKH signature must end in a SIGHASH_ALL (0x01) byte, got 0x${n[n.length - 1].toString(16)}`
+      );
+    if (!Tt(s, r, n))
+      throw new Error(
+        "proof of possession signature does not verify against the depositor key"
+      );
+    return { kind: "p2wpkh-verified" };
+  }
+  throw new Error(
+    `proof of possession witness has ${o.length} items; expected 1 (P2TR) or 2 (P2WPKH)`
+  );
+}
+const Ke = 0, J = "00".repeat(32), vs = "00".repeat(32);
+function Bs(s, e) {
+  const t = {
+    bitcoin: "bc",
+    testnet: "tb",
+    signet: "tb",
+    regtest: "bcrt"
+  };
+  try {
+    const o = Ce.address.fromBech32(s);
+    return o.prefix === t[e] && o.version === 0 && o.data.length === 20;
+  } catch {
+    return !1;
+  }
+}
+function _s(s, e, t, o) {
+  const i = t == null ? void 0 : t[`${s}:${e}`];
+  return i ? Promise.resolve({
+    txid: s,
+    vout: e,
+    value: i.value,
+    scriptPubKey: i.scriptPubKey
+  }) : _t(s, e, o);
+}
+const Be = 12e4;
+class Js {
+  /**
+   * Creates a new PeginManager instance.
+   *
+   * @param config - Manager configuration including wallets and contract addresses
+   */
+  constructor(e) {
+    x(this, "config");
+    this.config = e;
+  }
+  /**
+   * Prepare a peg-in: sizing pass → vault-root derivation (one wallet
+   * popup) → per-vault WOTS / hashlock derivation → commit pass with
+   * PSBT signing (signPsbt for a single vault, one batch popup for a
+   * split). Returns broadcast-ready txs, the pubkey snapshot, and the
+   * sensitive derived material.
+   *
+   * @throws If the wallet rejects, insufficient funds, or an internal
+   *         invariant violation.
+   */
+  async preparePegin(e) {
+    if (e.amounts.length === 0)
+      throw new Error("amounts must contain at least one entry");
+    const t = await this.config.btcWallet.getPublicKeyHex(), o = $(t);
+    if (F(this.config.btcWallet)) {
+      const p = (await pt(this.config.btcWallet)).trim();
+      if (e.changeAddress.trim() !== p)
+        throw new Error(
+          `Pre-PegIn changeAddress "${e.changeAddress}" is not the approval wallet's change address ("${p}"). Refusing to build a tx the signing device would reject.`
+        );
+    } else if (!me(
+      e.changeAddress,
+      t,
+      this.config.btcNetwork
+    ))
+      throw new Error(
+        `Pre-PegIn changeAddress "${e.changeAddress}" is not derived from the connected wallet's public key. Refusing to build a tx that would send change to an address the signing key doesn't control.`
+      );
+    const i = await this.prepareSizing(o, e);
+    if (F(this.config.btcWallet)) {
+      const { validateDepositTerms: p } = this.config.btcWallet;
+      typeof p == "function" && await p.call(
+        this.config.btcWallet,
+        this.buildPeginDepositTerms({
+          params: e,
+          prepeginTxid: vs,
+          prepeginMaxFee: i.fee,
+          depositorClaimValue: i.depositorClaimValue,
+          peginMaxFee: i.minPeginFee
+        })
+      );
+    }
+    const n = i.selectedUTXOs.map(
+      (p) => ({
+        txid: te(p.txid),
+        vout: p.vout
+      })
+    ), r = await Ie(this.config.btcWallet, {
+      depositorBtcPubkey: te(o),
+      fundingOutpoints: n
+    });
+    let a, c;
+    try {
+      const p = await et(r);
+      try {
+        a = se(p), c = se(Se(p));
+      } finally {
+        p.fill(0);
+      }
+    } catch (p) {
+      throw r.fill(0), p;
+    }
+    const h = await fs(r, e.amounts.length), { perVaultWotsKeys: d, wotsPkHashes: g, htlcSecretHexes: P, hashlocks: b } = h, l = await this.preparePeginCommit({
+      depositorBtcPubkeyRaw: t,
+      depositorBtcPubkey: o,
+      hashlocks: b,
+      authAnchorHash: c,
+      sizing: i,
+      params: e
+    });
+    for (let p = 0; p < l.perVault.length; p++)
+      if (l.perVault[p].htlcVout !== p)
+        throw new Error(
+          `Internal invariant violation: htlcVout/index mismatch at vault ${p} (expected ${p}, got ${l.perVault[p].htlcVout})`
+        );
+    ft(
+      l.fundedPrePeginTxHex,
+      e.amounts.length,
+      c
+    );
+    const { depositTerms: T, ...E } = l;
+    return {
+      transaction: {
+        ...E,
+        selectedUTXOs: i.selectedUTXOs,
+        fee: i.fee,
+        changeAmount: i.changeAmount
+      },
+      depositorBtcPubkey: o,
+      derivedSecrets: {
+        perVaultWotsKeys: d,
+        wotsPkHashes: g,
+        htlcSecretHexes: P,
+        authAnchorHex: a
+      },
+      depositTerms: T
+    };
+  }
+  /**
+   * Build unfunded Pre-PegIn + select UTXOs. No PSBT signing.
+   *
+   * Returns the full selection result (UTXOs, fee, changeAmount) so the
+   * commit pass funds the broadcast tx with the exact same set used to
+   * build the vault-context funding-outpoints commitment. Re-running
+   * `selectUtxosForPegin` in the commit pass would be deterministic given
+   * the same inputs, but threading the result through guarantees the
+   * domain separator structurally matches the funded tx inputs.
+   *
+   * Sizing runs before the wallet popup, so neither the real per-vault
+   * hashlocks nor the real `authAnchorHash` are known yet. Both slots
+   * are filled with a 32-byte placeholder; the commit pass swaps in the
+   * real values. Output budget is identical (32-byte push regardless of
+   * content), so UTXO selection is invariant under substitution.
+   */
+  async prepareSizing(e, t) {
+    const o = t.amounts.map(
+      () => J
+    ), i = t.vaultKeeperBtcPubkeys.length, n = await fe({
+      vaultCoreVersion: t.vaultCoreVersion,
+      depositorPubkey: e,
+      vaultProviderPubkey: k(t.vaultProviderBtcPubkey),
+      vaultKeeperPubkeys: t.vaultKeeperBtcPubkeys.map(k),
+      universalChallengerPubkeys: t.universalChallengerBtcPubkeys.map(k),
+      hashlocks: o,
+      timelockRefund: t.timelockRefund,
+      pegInAmounts: t.amounts,
+      feeRate: t.protocolFeeRate,
+      minPeginFeeRate: t.minPeginFeeRate,
+      numLocalChallengers: i,
+      councilQuorum: t.councilQuorum,
+      councilSize: t.councilSize,
+      network: this.config.btcNetwork,
+      authAnchorHash: J
+    }), r = mt(
+      [...t.availableUTXOs],
+      n.totalOutputValue,
+      t.mempoolFeeRate,
+      bt(n.htlcValues.length, !0)
+    );
+    return {
+      selectedUTXOs: r.selectedUTXOs,
+      fee: r.fee,
+      changeAmount: r.changeAmount,
+      depositorClaimValue: n.depositorClaimValue,
+      minPeginFee: n.minPeginFee
+    };
+  }
+  /**
+   * One projection for both the provisional (pre-derive, placeholder-txid)
+   * terms and the final approved terms, so the fields the pre-check validated
+   * cannot drift from the fields the device later displays (#2110 T4).
+   */
+  buildPeginDepositTerms(e) {
+    const { params: t } = e;
+    return Vt({
+      vaultCoreVersion: t.vaultCoreVersion,
+      protocolFeeRate: t.protocolFeeRate,
+      timelockPegin: t.timelockPegin,
+      timelockAssert: t.timelockAssert,
+      timelockRefund: t.timelockRefund,
+      prepeginTxid: e.prepeginTxid,
+      prepeginMaxFee: e.prepeginMaxFee,
+      vaultProviderBtcPubkey: k(t.vaultProviderBtcPubkey),
+      vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys.map(k),
+      universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys.map(k),
+      maxAcceptableCommissionBps: Y(
+        t.commissionBps
+      ),
+      peginAmounts: t.amounts,
+      depositorClaimValue: e.depositorClaimValue,
+      peginMaxFee: e.peginMaxFee
+    });
+  }
+  /** Build PegIn txs and batch-sign their inputs with real hashlocks. */
+  async preparePeginCommit(e) {
+    const {
+      depositorBtcPubkeyRaw: t,
+      depositorBtcPubkey: o,
+      hashlocks: i,
+      authAnchorHash: n,
+      sizing: r,
+      params: a
+    } = e, c = J.toLowerCase();
+    for (let m = 0; m < i.length; m++)
+      if (i[m].toLowerCase() === c)
+        throw new Error(
+          `preparePeginCommit refusing to build with sizing-pass placeholder hashlock at vault ${m} — internal substitution bug`
+        );
+    if (n.toLowerCase() === c)
+      throw new Error(
+        "preparePeginCommit refusing to build with sizing-pass placeholder auth-anchor hash — internal substitution bug"
+      );
+    const h = k(
+      a.vaultProviderBtcPubkey
+    ), d = a.vaultKeeperBtcPubkeys.map(k), g = a.universalChallengerBtcPubkeys.map(k), P = d.length, b = {
+      vaultCoreVersion: a.vaultCoreVersion,
+      depositorPubkey: o,
+      vaultProviderPubkey: h,
+      vaultKeeperPubkeys: d,
+      universalChallengerPubkeys: g,
+      hashlocks: i,
+      timelockRefund: a.timelockRefund,
+      pegInAmounts: a.amounts,
+      feeRate: a.protocolFeeRate,
+      minPeginFeeRate: a.minPeginFeeRate,
+      numLocalChallengers: P,
+      councilQuorum: a.councilQuorum,
+      councilSize: a.councilSize,
+      network: this.config.btcNetwork,
+      authAnchorHash: n
+    }, l = await fe(b);
+    if (l.depositorClaimValue !== r.depositorClaimValue || l.minPeginFee !== r.minPeginFee)
+      throw new Error(
+        `Pre-PegIn sizing/commit divergence: depositorClaimValue ${r.depositorClaimValue} -> ${l.depositorClaimValue}, minPeginFee ${r.minPeginFee} -> ${l.minPeginFee}. The provisional deposit terms validated before derivation would not match the terms sent for approval; refusing to continue.`
+      );
+    const T = Pe(this.config.btcNetwork), E = wt({
+      unfundedTxHex: l.psbtHex,
+      selectedUTXOs: r.selectedUTXOs,
+      changeAddress: a.changeAddress,
+      changeAmount: r.changeAmount,
+      network: T
+    }), p = r.selectedUTXOs.reduce((m, v) => m + BigInt(v.value), 0n) - l.totalOutputValue - r.changeAmount;
+    if (p !== r.fee)
+      throw new Error(
+        `Pre-PegIn funded fee ${p} does not match the sizing-pass fee ${r.fee}; refusing to publish a deposit-terms fee bound the funded transaction does not pay.`
+      );
+    const B = k(
+      q(E)
+    ), S = [], f = [], w = [];
+    for (let m = 0; m < i.length; m++) {
+      const v = await tt({
+        prePeginParams: b,
+        timelockPegin: a.timelockPegin,
+        fundedPrePeginTxHex: E,
+        htlcVout: m
+      }), I = await nt({
+        vaultCoreVersion: a.vaultCoreVersion,
+        peginTxHex: v.txHex,
+        fundedPrePeginTxHex: E,
+        depositorPubkey: o,
+        vaultProviderPubkey: h,
+        vaultKeeperPubkeys: d,
+        universalChallengerPubkeys: g,
+        hashlock: i[m],
+        timelockRefund: a.timelockRefund,
+        network: this.config.btcNetwork
+      });
+      S.push(v), f.push(I.psbtHex), w.push(
+        ut(t, 1)
+      );
+    }
+    const u = this.buildPeginDepositTerms({
+      params: a,
+      prepeginTxid: B,
+      prepeginMaxFee: r.fee,
+      depositorClaimValue: l.depositorClaimValue,
+      peginMaxFee: l.minPeginFee
+    });
+    F(this.config.btcWallet) && await this.config.btcWallet.approveDepositTerms(u);
+    const y = await gt(
+      this.config.btcWallet,
+      f,
+      w
+    ), C = [];
+    for (let m = 0; m < y.length; m++) {
+      ge({
+        requestedPsbtHex: f[m],
+        returnedPsbtHex: y[m]
+      });
+      const v = rt(
+        y[m],
+        o
+      );
+      st({
+        requestedPsbtHex: f[m],
+        signatureHex: v,
+        signerXOnlyPubkeyHex: o,
+        inputIndex: 0
+      });
+      const I = it(y[m]);
+      C.push({
+        htlcVout: m,
+        htlcValue: l.htlcValues[m],
+        peginTxHex: I,
+        peginTxid: S[m].txid,
+        peginInputSignature: v,
+        vaultScriptPubKey: S[m].vaultScriptPubKey
+      });
+    }
+    return {
+      fundedPrePeginTxHex: E,
+      prePeginTxid: B,
+      perVault: C,
+      depositTerms: u
+    };
+  }
+  /**
+   * Signs and broadcasts a funded peg-in transaction to the Bitcoin network.
+   *
+   * This method:
+   * 1. Parses the funded transaction hex
+   * 2. Fetches UTXO data from mempool for each input
+   * 3. Creates a PSBT with proper witnessUtxo/tapInternalKey
+   * 4. Signs via btcWallet.signPsbt()
+   * 5. Finalizes and extracts the transaction
+   * 6. Broadcasts via mempool API
+   *
+   * IMPORTANT — this method does NOT gate on Ethereum finality. Committing
+   * BTC to the HTLC while the peg-in registration is still reorg-exposed can
+   * strand the deposit: the vault record disappears from the chain while the
+   * BTC stays locked until the HTLC refund timelock. Callers must await
+   * `waitForPeginRegistrationDepth` for the registered vault(s) before calling
+   * this. The gate is not applied here because the params carry no vault ID —
+   * adding one would be a breaking signature change.
+   *
+   * @param params - Transaction hex and depositor public key
+   * @returns The broadcasted Bitcoin transaction ID
+   * @throws Error if signing or broadcasting fails
+   */
+  async signAndBroadcast(e) {
+    const { fundedPrePeginTxHex: t, depositorBtcPubkey: o } = e, i = t.startsWith("0x") ? t.slice(2) : t, n = Ae.fromHex(i);
+    if (n.ins.length === 0)
+      throw new Error("Transaction has no inputs");
+    const r = new he();
+    r.setVersion(n.version), r.setLocktime(n.locktime);
+    const a = O.from(
+      $(o),
+      "hex"
+    ), c = this.config.mempoolApiUrl, h = n.ins.map((f) => {
+      const w = O.from(f.hash).reverse().toString("hex"), u = f.index;
+      return _s(w, u, e.localPrevouts, c).then(
+        (y) => ({ input: f, utxoData: y, txid: w, vout: u })
+      );
+    }), d = await Promise.all(h), g = d.reduce(
+      (f, w) => f + BigInt(w.utxoData.value),
+      0n
+    ), P = n.outs.reduce(
+      (f, w) => f + BigInt(w.value),
+      0n
+    );
+    if (g < P)
+      throw new Error(
+        `UTXO value mismatch: total input value (${g} sat) is less than total output value (${P} sat). This may indicate the mempool API returned manipulated UTXO data.`
+      );
+    const b = g - P;
+    if (b > be)
+      throw new Error(
+        `Implied transaction fee (${b} sat) exceeds maximum reasonable fee (${be} sat). This may indicate manipulated UTXO data.`
+      );
+    for (const { input: f, utxoData: w, txid: u, vout: y } of d) {
+      const C = Pt(
+        {
+          value: w.value,
+          scriptPubKey: w.scriptPubKey
+        },
+        a
+      );
+      r.addInput({
+        hash: f.hash,
+        index: f.index,
+        sequence: f.sequence,
+        ...C
+      });
+    }
+    for (const f of n.outs)
+      r.addOutput({
+        script: f.script,
+        value: f.value
+      });
+    await Nt({
+      wallet: this.config.btcWallet,
+      depositTerms: e.depositTerms,
+      fundedPrePeginTxHex: t,
+      depositorBtcPubkey: o
+    });
+    const l = r.toHex(), T = await this.config.btcWallet.signPsbt(l);
+    ge({
+      requestedPsbtHex: l,
+      returnedPsbtHex: T
+    });
+    const E = at({
+      requestedPsbtHex: l,
+      returnedPsbtHex: T
+    });
+    if (F(this.config.btcWallet) && E !== r.data.inputs.length)
+      throw new Error(
+        `Key-path verification covered ${E} of ${r.data.inputs.length} Pre-PegIn inputs; an approval wallet signs every input key-path, so the unverified ones must not be broadcast.`
+      );
+    const p = he.fromHex(T);
+    try {
+      p.finalizeAllInputs();
+    } catch (f) {
+      if (!p.data.inputs.every(
+        (u) => u.finalScriptWitness || u.finalScriptSig
+      ))
+        throw new Error(
+          `PSBT finalization failed and wallet did not auto-finalize: ${f}`
+        );
+    }
+    const B = p.extractTransaction().toHex();
+    return await vt(B, c);
+  }
+  /**
+   * Registers a peg-in on Ethereum by calling the BTCVaultRegistry contract.
+   *
+   * This method:
+   * 1. Re-verifies the PopSignature against the currently connected ETH
+   *    and BTC wallets — refuses to proceed if either has changed
+   * 2. Derives vault ID and checks if it already exists (pre-flight)
+   * 3. Encodes the contract call using viem
+   * 4. Estimates gas (catches contract errors early with proper revert
+   *    reasons)
+   * 5. Sends transaction with pre-estimated gas via
+   *    ethWallet.sendTransaction()
+   *
+   * The PopSignature must be obtained via
+   * {@link signProofOfPossession} before this call.
+   *
+   * @param params - Registration parameters including the PopSignature
+   *                 and the prepared Pre-PegIn / PegIn transactions
+   * @returns Result containing Ethereum transaction hash and vault ID
+   * @throws Error if the PopSignature does not match the connected wallets
+   * @throws Error if the vault already exists
+   * @throws Error if contract simulation fails (e.g., invalid signature,
+   *         unauthorized)
+   */
+  async registerPeginOnChain(e) {
+    const {
+      unsignedPrePeginTx: t,
+      depositorSignedPeginTx: o,
+      vaultProvider: i,
+      hashlock: n,
+      htlcVout: r,
+      depositorPayoutBtcAddress: a,
+      depositorWotsPkHash: c,
+      popSignature: h
+    } = e;
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const d = this.config.ethWallet.account.address;
+    if (!de(h.depositorEthAddress, d))
+      throw new Error(
+        `Proof of possession was signed for ${h.depositorEthAddress} but the Ethereum wallet is currently connected to ${d}. Reconnect the original account or call signProofOfPossession() again.`
+      );
+    const g = await this.assertPopMatchesBtcWallet(h), P = h.btcPopSignature, b = A(
+      h.depositorBtcPubkey
+    ), l = A(t), T = A(o), E = a ?? await this.config.btcWallet.getAddress(), p = this.resolvePayoutScriptPubKey(
+      g,
+      E
+    ), B = q(T), S = await pe(
+      k(B),
+      k(d)
+    ), f = A(S);
+    if (await this.checkVaultExists(f))
+      throw new Error(
+        `Vault already exists (ID: ${f}, peginTxHash: ${B}). Vault IDs are derived from the pegin transaction hash and depositor address. To create a new vault, use different UTXOs or a different amount to generate a unique transaction.`
+      );
+    const u = this.config.publicClient;
+    let y;
+    try {
+      y = await u.readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: H,
+        functionName: "getPegInFee",
+        args: [i]
+      });
+    } catch (V) {
+      throw new Error(
+        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct.",
+        { cause: V }
+      );
+    }
+    const C = await this.resolveMaxAcceptableCommissionBps(
+      i,
+      e.quotedCommissionBps
+    ), m = ee({
+      abi: H,
+      functionName: "submitPeginRequest",
+      args: [
+        d,
+        b,
+        P,
+        l,
+        T,
+        i,
+        C,
+        n,
+        r,
+        p,
+        c
+      ]
+    });
+    let v;
+    try {
+      v = await u.estimateGas({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: m,
+        value: y,
+        account: this.config.ethWallet.account.address
+      });
+    } catch (V) {
+      R(V);
+    }
+    let I;
+    try {
+      I = await this.config.ethWallet.sendTransaction({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: m,
+        value: y,
+        account: this.config.ethWallet.account,
+        chain: this.config.ethChain,
+        gas: v
+      });
+    } catch (V) {
+      R(V);
+    }
+    const G = await we({
+      publicClient: u,
+      walletAddress: this.config.ethWallet.account.address,
+      hash: I,
+      timeout: Be
+    });
+    return G.status === "reverted" && R(
+      new Error(
+        `Transaction reverted. Hash: ${G.transactionHash}. Check the transaction on block explorer for details.`
+      )
+    ), {
+      ethTxHash: G.transactionHash,
+      vaultId: f,
+      peginTxHash: B
+    };
+  }
+  /**
+   * Register multiple pegins on Ethereum in a single transaction.
+   *
+   * Uses the contract's submitPeginRequestBatch() to submit all vault
+   * registrations atomically. All vaults must share the same vault provider.
+   * The PoP signature is signed once and included in each request.
+   *
+   * @param params - Batch registration parameters
+   * @returns Batch result with per-vault IDs and single ETH tx hash
+   */
+  async registerPeginBatchOnChain(e) {
+    const { vaultProvider: t, unsignedPrePeginTx: o, requests: i, popSignature: n } = e;
+    if (i.length === 0)
+      throw new Error("Batch pegin requires at least one request");
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const r = this.config.ethWallet.account.address;
+    if (!de(n.depositorEthAddress, r))
+      throw new Error(
+        `Proof of possession was signed for ${n.depositorEthAddress} but the Ethereum wallet is currently connected to ${r}. Reconnect the original account or call signProofOfPossession() again.`
+      );
+    const a = await this.assertPopMatchesBtcWallet(n), c = n.btcPopSignature, h = i.map(
+      (u) => this.resolvePayoutScriptPubKey(
+        a,
+        u.depositorPayoutBtcAddress
+      )
+    ), d = [];
+    for (const u of i) {
+      const y = A(
+        u.depositorSignedPeginTx
+      ), C = q(y), m = await pe(
+        k(C),
+        k(r)
+      ), v = A(m);
+      if (await this.checkVaultExists(v))
+        throw new Error(
+          `Vault already exists (ID: ${v}, peginTxHash: ${C}). To create a new vault, use different UTXOs or a different amount.`
+        );
+      d.push({ vaultId: v, peginTxHash: C });
+    }
+    const g = this.config.publicClient;
+    let P;
+    try {
+      P = await g.readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: H,
+        functionName: "getPegInFee",
+        args: [t]
+      });
+    } catch (u) {
+      throw new Error(
+        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct.",
+        { cause: u }
+      );
+    }
+    const b = P * BigInt(i.length), l = await this.resolveMaxAcceptableCommissionBps(
+      t,
+      e.quotedCommissionBps
+    ), T = A(
+      n.depositorBtcPubkey
+    ), E = A(o), p = i.map((u, y) => ({
+      depositorBtcPubKey: T,
+      btcPopSignature: c,
+      unsignedPrePeginTx: E,
+      depositorSignedPeginTx: A(
+        u.depositorSignedPeginTx
+      ),
+      hashlock: u.hashlock,
+      htlcVout: u.htlcVout,
+      referralCode: Ke,
+      depositorPayoutBtcAddress: h[y],
+      depositorWotsPkHash: u.depositorWotsPkHash
+    })), B = ee({
+      abi: H,
+      functionName: "submitPeginRequestBatch",
+      args: [
+        r,
+        t,
+        l,
+        p
+      ]
+    });
+    let S;
+    try {
+      S = await g.estimateGas({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: B,
+        value: b,
+        account: this.config.ethWallet.account.address
+      });
+    } catch (u) {
+      R(u);
+    }
+    let f;
+    try {
+      f = await this.config.ethWallet.sendTransaction({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: B,
+        value: b,
+        account: this.config.ethWallet.account,
+        chain: this.config.ethChain,
+        gas: S
+      });
+    } catch (u) {
+      R(u);
+    }
+    const w = await we({
+      publicClient: g,
+      walletAddress: this.config.ethWallet.account.address,
+      hash: f,
+      timeout: Be
+    });
+    return w.status === "reverted" && R(
+      new Error(
+        `Batch transaction reverted. Hash: ${w.transactionHash}. Check the transaction on block explorer for details.`
+      )
+    ), {
+      ethTxHash: w.transactionHash,
+      vaults: d
+    };
+  }
+  // Anchor to quoted+headroom when supplied (refuse if chain drifted past it);
+  // otherwise fall back to chain-current+headroom — see #1691.
+  async resolveMaxAcceptableCommissionBps(e, t) {
+    if (t === void 0 && F(this.config.btcWallet))
+      throw new Error(
+        "quotedCommissionBps is required when the wallet approved deposit terms: the registration ceiling must anchor to the approved quote."
+      );
+    let o;
+    try {
+      o = await new Bt(
+        this.config.publicClient,
+        this.config.vaultContracts.btcVaultRegistry
+      ).getVaultProviderCommission(e);
+    } catch (i) {
+      throw new Error(
+        "Failed to query vault provider commission from the contract. Please check your network connection and that the contract address is correct.",
+        { cause: i }
+      );
+    }
+    if (t !== void 0) {
+      if (o > t + oe)
+        throw new Error(
+          `Vault provider commission changed since quote: quoted ${t} bps, chain currently reports ${o} bps (allowed drift ${oe} bps). Please refresh to see the new commission and try again.`
+        );
+      return Y(t);
+    }
+    return Y(o);
+  }
+  /**
+   * Check if a vault already exists for a given vault ID.
+   *
+   * The contract returns a default struct (with `depositor === zeroAddress`)
+   * when no vault is registered, so existence is signalled in the response,
+   * not via a thrown error. RPC/network failures are propagated rather than
+   * silently treated as "vault doesn't exist", which would otherwise let
+   * downstream calls run with stale assumptions.
+   *
+   * @param vaultId - The Bitcoin transaction hash (vault ID)
+   * @returns True if vault exists, false otherwise
+   * @throws If the underlying RPC read fails
+   */
+  async checkVaultExists(e) {
+    return (await this.config.publicClient.readContract({
+      address: this.config.vaultContracts.btcVaultRegistry,
+      abi: H,
+      functionName: "getBtcVaultBasicInfo",
+      args: [e]
+    })).depositor !== Qe;
+  }
+  /**
+   * Resolve the BTC scriptPubKey to register as the depositor's payout sink.
+   *
+   * `address` is validated against the verified depositor pubkey, sourced
+   * from `assertPopMatchesBtcWallet`'s return value rather than
+   * `popSignature.depositorBtcPubkey` (which is x-only, parity stripped).
+   * For wallets that expose a compressed key this preserves y-parity end to
+   * end. For Taproot wallets that only expose an x-only key, the helper
+   * itself fails closed for P2WPKH — the parity is unknowable, so the
+   * payout sink must be a P2TR address derived from that same x.
+   *
+   * The helper does not call into the wallet so the batch path can resolve
+   * many requests without any extra adapter reads. Threat closed: a
+   * state-race or stale FE state that lets a non-wallet address reach the
+   * on-chain payout-script registration.
+   */
+  resolvePayoutScriptPubKey(e, t) {
+    if (!me(
+      t,
+      e,
+      this.config.btcNetwork
+    ))
+      throw k(e).length === lt && Bs(t, this.config.btcNetwork) ? new Error(
+        `BTC payout address "${t}" is a P2WPKH (Native SegWit) address, but the connected wallet only exposes an x-only public key. P2WPKH validation requires a compressed key with known y-parity. Use a P2TR (Taproot) payout address instead.`
+      ) : new Error(
+        `BTC payout address "${t}" is not derived from the connected wallet's public key. The payout sink must be controlled by the same key that signs the pegin; refusing to register a mismatched address.`
+      );
+    const o = Pe(this.config.btcNetwork);
+    try {
+      return `0x${Ce.address.toOutputScript(t, o).toString("hex")}`;
+    } catch {
+      throw new Error(
+        `Invalid BTC payout address: "${t}". Please provide a valid Bitcoin address for the ${this.config.btcNetwork} network.`
+      );
+    }
+  }
+  /**
+   * Sign a BIP-322 BTC Proof-of-Possession binding the connected BTC
+   * wallet to the connected ETH account for this chain and vault
+   * registry. The returned {@link PopSignature} can be reused across
+   * every register call in the same session.
+   *
+   * The witness is verified against the depositor key before it is
+   * returned — Schnorr for one-item (P2TR), ECDSA over the BIP-322
+   * P2WPKH virtual transaction for two-item — see {@link verifyPopWitness}.
+   *
+   * @throws If the wallet returns a malformed witness or a signature that
+   *         does not verify.
+   */
+  async signProofOfPossession() {
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const e = this.config.ethWallet.account.address, t = $(
+      await this.config.btcWallet.getPublicKeyHex()
+    ), o = this.config.vaultContracts.btcVaultRegistry, i = `${e.toLowerCase()}:${this.config.ethChain.id}:pegin:${o.toLowerCase()}`, n = await this.config.btcWallet.signMessage(
+      i,
+      "bip322-simple"
+    ), r = Dt(n);
+    return Ts(
+      new TextEncoder().encode(i),
+      t,
+      r
+    ), { btcPopSignature: r, depositorEthAddress: e, depositorBtcPubkey: t };
+  }
+  /**
+   * Confirm the connected BTC wallet still matches the PoP it produced, and
+   * return the wallet's *raw* pubkey hex (parity-preserving form, as the
+   * wallet adapter returns it). The raw form is required by callers that
+   * validate Native SegWit / P2WPKH addresses, since P2WPKH is derived from
+   * a parity-bearing compressed key — an x-only form would let an attacker
+   * substitute the opposite-parity P2WPKH address.
+   */
+  async assertPopMatchesBtcWallet(e) {
+    const t = await this.config.btcWallet.getPublicKeyHex(), o = $(t), i = $(e.depositorBtcPubkey);
+    if (o !== i)
+      throw new Error(
+        `Proof of possession was signed with BTC pubkey ${i} but the BTC wallet is currently connected to ${o}. Reconnect the original wallet or call signProofOfPossession() again.`
+      );
+    return t;
+  }
+  /**
+   * Gets the configured Bitcoin network.
+   *
+   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
+   */
+  getNetwork() {
+    return this.config.btcNetwork;
+  }
+  /**
+   * Gets the configured BTCVaultRegistry contract address.
+   *
+   * @returns The Ethereum address of the BTCVaultRegistry contract
+   */
+  getVaultContractAddress() {
+    return this.config.vaultContracts.btcVaultRegistry;
+  }
+}
+const Ss = 80, Cs = 250, As = 300, Is = 22, Xe = "ab";
+function Hs(s, e) {
+  const t = Xe.repeat(As), o = k(s).toLowerCase(), i = e.toString(16).padStart(8, "0"), n = `${o}${i}`, r = t.slice(n.length);
+  return `0x${n}${r}`;
+}
+function Rs(s, e) {
+  const t = (o) => `0x${Xe.repeat(o)}`;
+  return {
+    depositorBtcPubKey: t(32),
+    btcPopSignature: t(Ss),
+    unsignedPrePeginTx: t(Cs),
+    depositorSignedPeginTx: Hs(
+      s,
+      e
+    ),
+    hashlock: t(32),
+    htlcVout: e,
+    referralCode: Ke,
+    depositorPayoutBtcAddress: t(Is),
+    depositorWotsPkHash: t(32)
+  };
+}
+async function eo(s) {
+  const {
+    publicClient: e,
+    btcVaultRegistry: t,
+    depositorEthAddress: o,
+    vaultProvider: i,
+    batchSize: n
+  } = s;
+  if (n <= 0)
+    throw new Error(
+      `estimateSubmitPeginRequestBatchGas requires batchSize >= 1 (received ${n})`
+    );
+  const a = await e.readContract({
+    address: t,
+    abi: H,
+    functionName: "getPegInFee",
+    args: [i]
+  }) * BigInt(n), c = Array.from(
+    { length: n },
+    (d, g) => Rs(o, g)
+  ), h = ee({
+    abi: H,
+    functionName: "submitPeginRequestBatch",
+    args: [
+      o,
+      i,
+      He,
+      c
+    ]
+  });
+  return e.estimateGas({
+    to: t,
+    data: h,
+    value: a,
+    account: o
+  });
+}
+export {
+  oe as C,
+  He as M,
+  Js as P,
+  Y as a,
+  Vt as b,
+  ps as c,
+  ds as d,
+  eo as e,
+  Nt as f,
+  fs as g
+};
+//# sourceMappingURL=PeginManager-DSFecw-w.js.map