@babylonlabs-io/ts-sdk 0.67.0 → 0.68.0

package/dist/PeginManager-BBl4xkWz.js

@@ -1,1359 +0,0 @@
-var Lt = Object.defineProperty;
-var Xt = (s, e, t) => e in s ? Lt(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
-var y = (s, e, t) => Xt(s, typeof e != "symbol" ? e + "" : e, t);
-import { c as vt, H as Kt, r as M, a as W, b as nt, u as qt, d as rt, e as it, f as at, g as Gt, s as Bt } from "./sha2-BYVxyZzX.js";
-import * as Et from "bitcoinjs-lib";
-import { Transaction as At, Psbt as ct } from "bitcoinjs-lib";
-import { Buffer as j } from "buffer";
-import { isAddressEqual as lt, encodeFunctionData as Q, zeroAddress as zt } from "viem";
-import { B as H } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
-import { h as R } from "./errors-Blc-JWnI.js";
-import { expandWotsSeed as Yt, expandHashlockSecret as jt, expandAuthAnchor as Qt, deriveVaultId as ut } from "@babylonlabs-io/babylon-tbv-rust-wasm";
-import { a as ht, b as Zt, d as dt, f as Jt } from "./verifyScriptPathSchnorrSignature-i-koT139.js";
-import { b as te, e as ee, f as se } from "./peginInput-HQPWZfly.js";
-import { p as oe, h as Z, u as J, e as _, i as gt, s as E, k as ft, X as ne } from "./bitcoin-d9eaaZB_.js";
-import { c as re } from "./signing-DaLvGwQe.js";
-import { M as pt } from "./validation-Dj3dqYtl.js";
-import { p as ie, d as Ct } from "./parseFundingOutpoints-pBRE11Hr.js";
-import { c as ae, b as ce, s as mt, d as le } from "./signPsbtsWithFallback-Bb66DfY5.js";
-import { s as ue, f as X, i as he, w as bt } from "./waitForTransactionReceiptSmartAware-lobLm0q0.js";
-import { p as de, f as ge } from "./fundPeginTransaction-B2wyjqp0.js";
-import { M as D, B as fe } from "./constants-GjWXdaqV.js";
-import { p as pe, V as me, i as be } from "./mempoolApi-BxSINXIB.js";
-const U = /* @__PURE__ */ BigInt(2 ** 32 - 1), Pt = /* @__PURE__ */ BigInt(32);
-function Pe(s, e = !1) {
-  return e ? { h: Number(s & U), l: Number(s >> Pt & U) } : { h: Number(s >> Pt & U) | 0, l: Number(s & U) | 0 };
-}
-function we(s, e = !1) {
-  const t = s.length;
-  let o = new Uint32Array(t), n = new Uint32Array(t);
-  for (let r = 0; r < t; r++) {
-    const { h: i, l: a } = Pe(s[r], e);
-    [o[r], n[r]] = [i, a];
-  }
-  return [o, n];
-}
-const xe = (s, e, t) => s << t | e >>> 32 - t, ye = (s, e, t) => e << t | s >>> 32 - t, ke = (s, e, t) => e << t - 32 | s >>> 64 - t, Te = (s, e, t) => s << t - 32 | e >>> 64 - t, ve = 64;
-function Be(s) {
-  const e = s.prepeginTxid.toLowerCase();
-  if (!/^[0-9a-f]+$/.test(e) || e.length !== ve)
-    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 >= D)
-    throw new Error(
-      `buildDepositTerms: maxAcceptableCommissionBps must be an integer in [0, ${D}), got ${s.maxAcceptableCommissionBps}`
-    );
-  const t = BigInt(fe), o = s.peginAmounts.map(
-    (n, r) => ({
-      htlcVout: r,
-      vaultProviderBtcPubkey: s.vaultProviderBtcPubkey,
-      peginAmount: n,
-      // 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: n * 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 tt = 25, _t = 9999;
-function K(s) {
-  if (!Number.isInteger(s) || s < 0 || s >= D)
-    throw new Error(
-      `Quoted commissionBps must be an integer in [0, ${D}), got ${s}`
-    );
-  return Math.min(
-    s + tt,
-    _t
-  );
-}
-const Ee = /^0x[0-9a-f]+$/i, Ae = /^[0-9a-f]+$/i, Ce = /^[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 oe(s).toLowerCase();
-}
-function _e(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 (!Ee.test(s) || s.length < 4 || s.length % 2 !== 0)
-      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
-    return s.toLowerCase();
-  }
-  if (Ae.test(s)) {
-    if (s.length % 2 !== 0)
-      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
-    return `0x${s.toLowerCase()}`;
-  }
-  if (!Ce.test(s) || s.length % 4 !== 0)
-    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
-  const e = j.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 Se(s) {
-  const { wallet: e, depositTerms: t, fundedPrePeginTxHex: o, depositorBtcPubkey: n } = s, r = typeof e.approveDepositTerms == "function" ? e.approveDepositTerms : void 0;
-  if (!r && !t)
-    return;
-  const i = o.startsWith("0x") ? o.slice(2) : o, c = At.fromHex(i).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 (!r)
-    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."
-    );
-  const l = ie(o);
-  (await Ct(
-    { deriveContextHash: e.deriveContextHash.bind(e) },
-    {
-      depositorBtcPubkey: Z(
-        $(n)
-      ),
-      fundingOutpoints: l
-    }
-  )).fill(0), await r(t);
-}
-const Ie = /* @__PURE__ */ Uint8Array.from([
-  7,
-  4,
-  13,
-  1,
-  10,
-  6,
-  15,
-  3,
-  12,
-  0,
-  9,
-  5,
-  2,
-  14,
-  11,
-  8
-]), St = Uint8Array.from(new Array(16).fill(0).map((s, e) => e)), He = St.map((s) => (9 * s + 5) % 16), It = /* @__PURE__ */ (() => {
-  const t = [[St], [He]];
-  for (let o = 0; o < 4; o++)
-    for (let n of t)
-      n.push(n[o].map((r) => Ie[r]));
-  return t;
-})(), Ht = It[0], Rt = It[1], $t = /* @__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)), Re = /* @__PURE__ */ Ht.map((s, e) => s.map((t) => $t[e][t])), $e = /* @__PURE__ */ Rt.map((s, e) => s.map((t) => $t[e][t])), Oe = /* @__PURE__ */ Uint32Array.from([
-  0,
-  1518500249,
-  1859775393,
-  2400959708,
-  2840853838
-]), Ve = /* @__PURE__ */ Uint32Array.from([
-  1352829926,
-  1548603684,
-  1836072691,
-  2053994217,
-  0
-]);
-function wt(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 F = /* @__PURE__ */ new Uint32Array(16);
-class Me extends Kt {
-  constructor() {
-    super(64, 20, 8, !0);
-    y(this, "h0", 1732584193);
-    y(this, "h1", -271733879);
-    y(this, "h2", -1732584194);
-    y(this, "h3", 271733878);
-    y(this, "h4", -1009589776);
-  }
-  get() {
-    const { h0: t, h1: o, h2: n, h3: r, h4: i } = this;
-    return [t, o, n, r, i];
-  }
-  set(t, o, n, r, i) {
-    this.h0 = t | 0, this.h1 = o | 0, this.h2 = n | 0, this.h3 = r | 0, this.h4 = i | 0;
-  }
-  process(t, o) {
-    for (let d = 0; d < 16; d++, o += 4)
-      F[d] = t.getUint32(o, !0);
-    let n = this.h0 | 0, r = n, i = this.h1 | 0, a = i, c = this.h2 | 0, l = c, u = this.h3 | 0, m = u, P = this.h4 | 0, w = P;
-    for (let d = 0; d < 5; d++) {
-      const B = 4 - d, k = Oe[d], f = Ve[d], A = Ht[d], p = Rt[d], b = Re[d], T = $e[d];
-      for (let h = 0; h < 16; h++) {
-        const x = M(n + wt(d, i, c, u) + F[A[h]] + k, b[h]) + P | 0;
-        n = P, P = u, u = M(c, 10) | 0, c = i, i = x;
-      }
-      for (let h = 0; h < 16; h++) {
-        const x = M(r + wt(B, a, l, m) + F[p[h]] + f, T[h]) + w | 0;
-        r = w, w = m, m = M(l, 10) | 0, l = a, a = x;
-      }
-    }
-    this.set(this.h1 + c + m | 0, this.h2 + u + w | 0, this.h3 + P + r | 0, this.h4 + n + a | 0, this.h0 + i + l | 0);
-  }
-  roundClean() {
-    W(F);
-  }
-  destroy() {
-    this.destroyed = !0, W(this.buffer), this.set(0, 0, 0, 0, 0);
-  }
-}
-const Ue = /* @__PURE__ */ vt(() => new Me()), Fe = BigInt(0), V = BigInt(1), Ne = BigInt(2), We = BigInt(7), De = BigInt(256), Le = BigInt(113), Ot = [], Vt = [], Mt = [];
-for (let s = 0, e = V, t = 1, o = 0; s < 24; s++) {
-  [t, o] = [o, (2 * t + 3 * o) % 5], Ot.push(2 * (5 * o + t)), Vt.push((s + 1) * (s + 2) / 2 % 64);
-  let n = Fe;
-  for (let r = 0; r < 7; r++)
-    e = (e << V ^ (e >> We) * Le) % De, e & Ne && (n ^= V << (V << BigInt(r)) - V);
-  Mt.push(n);
-}
-const Ut = we(Mt, !0), Xe = Ut[0], Ke = Ut[1], xt = (s, e, t) => t > 32 ? ke(s, e, t) : xe(s, e, t), yt = (s, e, t) => t > 32 ? Te(s, e, t) : ye(s, e, t);
-function qe(s, e = 24) {
-  const t = new Uint32Array(10);
-  for (let o = 24 - e; o < 24; o++) {
-    for (let i = 0; i < 10; i++)
-      t[i] = s[i] ^ s[i + 10] ^ s[i + 20] ^ s[i + 30] ^ s[i + 40];
-    for (let i = 0; i < 10; i += 2) {
-      const a = (i + 8) % 10, c = (i + 2) % 10, l = t[c], u = t[c + 1], m = xt(l, u, 1) ^ t[a], P = yt(l, u, 1) ^ t[a + 1];
-      for (let w = 0; w < 50; w += 10)
-        s[i + w] ^= m, s[i + w + 1] ^= P;
-    }
-    let n = s[2], r = s[3];
-    for (let i = 0; i < 24; i++) {
-      const a = Vt[i], c = xt(n, r, a), l = yt(n, r, a), u = Ot[i];
-      n = s[u], r = s[u + 1], s[u] = c, s[u + 1] = l;
-    }
-    for (let i = 0; i < 50; i += 10) {
-      for (let a = 0; a < 10; a++)
-        t[a] = s[i + a];
-      for (let a = 0; a < 10; a++)
-        s[i + a] ^= ~t[(a + 2) % 10] & t[(a + 4) % 10];
-    }
-    s[0] ^= Xe[o], s[1] ^= Ke[o];
-  }
-  W(t);
-}
-class st {
-  // NOTE: we accept arguments in bytes instead of bits here.
-  constructor(e, t, o, n = !1, r = 24) {
-    y(this, "state");
-    y(this, "pos", 0);
-    y(this, "posOut", 0);
-    y(this, "finished", !1);
-    y(this, "state32");
-    y(this, "destroyed", !1);
-    y(this, "blockLen");
-    y(this, "suffix");
-    y(this, "outputLen");
-    y(this, "enableXOF", !1);
-    y(this, "rounds");
-    if (this.blockLen = e, this.suffix = t, this.outputLen = o, this.enableXOF = n, this.rounds = r, nt(o, "outputLen"), !(0 < e && e < 200))
-      throw new Error("only keccak-f1600 function is supported");
-    this.state = new Uint8Array(200), this.state32 = qt(this.state);
-  }
-  clone() {
-    return this._cloneInto();
-  }
-  keccak() {
-    rt(this.state32), qe(this.state32, this.rounds), rt(this.state32), this.posOut = 0, this.pos = 0;
-  }
-  update(e) {
-    it(this), at(e);
-    const { blockLen: t, state: o } = this, n = e.length;
-    for (let r = 0; r < n; ) {
-      const i = Math.min(t - this.pos, n - r);
-      for (let a = 0; a < i; a++)
-        o[this.pos++] ^= e[r++];
-      this.pos === t && this.keccak();
-    }
-    return this;
-  }
-  finish() {
-    if (this.finished)
-      return;
-    this.finished = !0;
-    const { state: e, suffix: t, pos: o, blockLen: n } = this;
-    e[o] ^= t, (t & 128) !== 0 && o === n - 1 && this.keccak(), e[n - 1] ^= 128, this.keccak();
-  }
-  writeInto(e) {
-    it(this, !1), at(e), this.finish();
-    const t = this.state, { blockLen: o } = this;
-    for (let n = 0, r = e.length; n < r; ) {
-      this.posOut >= o && this.keccak();
-      const i = Math.min(o - this.posOut, r - n);
-      e.set(t.subarray(this.posOut, this.posOut + i), n), this.posOut += i, n += i;
-    }
-    return e;
-  }
-  xofInto(e) {
-    if (!this.enableXOF)
-      throw new Error("XOF is not possible for this instance");
-    return this.writeInto(e);
-  }
-  xof(e) {
-    return nt(e), this.xofInto(new Uint8Array(e));
-  }
-  digestInto(e) {
-    if (Gt(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, W(this.state);
-  }
-  _cloneInto(e) {
-    const { blockLen: t, suffix: o, outputLen: n, rounds: r, enableXOF: i } = this;
-    return e || (e = new st(t, o, n, i, r)), e.state32.set(this.state32), e.pos = this.pos, e.posOut = this.posOut, e.finished = this.finished, e.rounds = r, e.suffix = o, e.outputLen = n, e.enableXOF = i, e.destroyed = this.destroyed, e;
-  }
-}
-const Ge = (s, e, t, o = {}) => vt(() => new st(e, s, t), o), ze = /* @__PURE__ */ Ge(1, 136, 32), kt = 64, C = 20, et = 4, Ft = 2, Ye = 0, je = 1, N = [64, 64], Qe = (s) => Array.from(s).map((e) => e.toString(16).padStart(2, "0")).join("");
-function ot(s) {
-  return Ue(Bt(s));
-}
-function Nt(s) {
-  return (1 << s) - 1;
-}
-function Ze(s) {
-  let e = 1;
-  for (; e * e < s + 1; ) e++;
-  return Math.max(e, 2);
-}
-function Je(s) {
-  const e = et, t = s * Nt(e);
-  return { d: e, n: s, checksum_radix: Ze(t) };
-}
-function q(s, e) {
-  const t = [];
-  let o = e;
-  for (; o > 0; )
-    t.push(o & 255), o >>>= 8;
-  const n = new Uint8Array(s.length + t.length);
-  n.set(s);
-  for (let r = 0; r < t.length; r++)
-    n[s.length + r] = t[r];
-  return ot(n);
-}
-function G(s, e) {
-  let t = s;
-  for (let o = 0; o < e; o++)
-    t = ot(t);
-  return t;
-}
-function ts(s, e) {
-  const t = Nt(e.d), o = e.checksum_radix - 1, n = Math.floor(e.n * t / e.checksum_radix), r = [];
-  for (let u = 0; u < e.n; u++) {
-    const m = q(s, u + Ft), P = G(m, t);
-    r.push(Array.from(P));
-  }
-  const i = q(
-    s,
-    Ye
-  ), a = G(
-    i,
-    o
-  ), c = q(
-    s,
-    je
-  ), l = G(
-    c,
-    n
-  );
-  return {
-    config: e,
-    message_terminals: r,
-    checksum_major_terminal: Array.from(l),
-    checksum_minor_terminal: Array.from(a)
-  };
-}
-async function es(s) {
-  try {
-    if (s.length !== kt)
-      throw new Error(
-        `WOTS seed must be exactly ${kt} bytes, got ${s.length}`
-      );
-    const e = [];
-    for (let t = 0; t < N.length; t++) {
-      const o = N[t], n = Je(o), r = new Uint8Array(s.length + 1);
-      r.set(s), r[s.length] = t;
-      const i = ot(r);
-      try {
-        const a = ts(i, n);
-        if (a.config.d !== et)
-          throw new Error(
-            `Block ${t}: expected d=${et}, 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 !== C)
-            throw new Error(
-              `Block ${t} terminal ${c}: expected ${C} bytes, got ${a.message_terminals[c].length}`
-            );
-        if (a.checksum_minor_terminal.length !== C)
-          throw new Error(
-            `Block ${t} checksum_minor: expected ${C} bytes`
-          );
-        if (a.checksum_major_terminal.length !== C)
-          throw new Error(
-            `Block ${t} checksum_major: expected ${C} bytes`
-          );
-        e.push(a);
-      } finally {
-        r.fill(0), i.fill(0);
-      }
-    }
-    if (e.length !== N.length)
-      throw new Error(
-        `Expected ${N.length} blocks, got ${e.length}`
-      );
-    return e;
-  } finally {
-    s.fill(0);
-  }
-}
-function z(s, e, t) {
-  if (s.length !== C)
-    throw new Error(
-      `Block ${e} ${t}: expected ${C} bytes, got ${s.length}`
-    );
-  for (let o = 0; o < s.length; o++) {
-    const n = s[o];
-    if (!Number.isInteger(n) || n < 0 || n > 255)
-      throw new Error(
-        `Block ${e} ${t}[${o}]: invalid byte value ${n}`
-      );
-  }
-}
-function ss(s) {
-  if (s.length === 0)
-    throw new Error("Public keys array must not be empty");
-  for (let r = 0; r < s.length; r++) {
-    const i = s[r];
-    z(i.checksum_minor_terminal, r, "checksum_minor_terminal"), z(i.checksum_major_terminal, r, "checksum_major_terminal");
-    for (let a = 0; a < i.message_terminals.length; a++)
-      z(i.message_terminals[a], r, `message_terminal[${a}]`);
-  }
-  let e = 0;
-  for (const r of s)
-    e += Ft + r.message_terminals.length;
-  const t = new Uint8Array(e * C);
-  let o = 0;
-  for (const r of s) {
-    t.set(r.checksum_minor_terminal, o), o += C, t.set(r.checksum_major_terminal, o), o += C;
-    for (const i of r.message_terminals)
-      t.set(i, o), o += C;
-  }
-  const n = ze(t);
-  return `0x${Qe(n)}`;
-}
-async function os(s, e) {
-  const t = [], o = [], n = [], r = [];
-  try {
-    for (let i = 0; i < e; i++) {
-      const a = await Yt(s, i);
-      try {
-        const l = await es(a);
-        t.push(l), o.push(ss(l));
-      } finally {
-        a.fill(0);
-      }
-      const c = await jt(s, i);
-      try {
-        const l = J(c);
-        n.push(l), r.push(ae(_(l)).slice(2));
-      } finally {
-        c.fill(0);
-      }
-    }
-  } finally {
-    s.fill(0);
-  }
-  return { perVaultWotsKeys: t, wotsPkHashes: o, htlcSecretHexes: n, hashlocks: r };
-}
-const Wt = 0, Y = "00".repeat(32);
-function ns(s, e) {
-  const t = {
-    bitcoin: "bc",
-    testnet: "tb",
-    signet: "tb",
-    regtest: "bcrt"
-  };
-  try {
-    const o = Et.address.fromBech32(s);
-    return o.prefix === t[e] && o.version === 0 && o.data.length === 20;
-  } catch {
-    return !1;
-  }
-}
-function rs(s, e, t, o) {
-  const n = t == null ? void 0 : t[`${s}:${e}`];
-  return n ? Promise.resolve({
-    txid: s,
-    vout: e,
-    value: n.value,
-    scriptPubKey: n.scriptPubKey
-  }) : be(s, e, o);
-}
-const Tt = 12e4;
-class Is {
-  /**
-   * Creates a new PeginManager instance.
-   *
-   * @param config - Manager configuration including wallets and contract addresses
-   */
-  constructor(e) {
-    y(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 (!gt(
-      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 n = await this.prepareSizing(o, e), r = n.selectedUTXOs.map(
-      (f) => ({
-        txid: Z(f.txid),
-        vout: f.vout
-      })
-    ), i = await Ct(this.config.btcWallet, {
-      depositorBtcPubkey: Z(o),
-      fundingOutpoints: r
-    });
-    let a, c;
-    try {
-      const f = await Qt(i);
-      try {
-        a = J(f), c = J(Bt(f));
-      } finally {
-        f.fill(0);
-      }
-    } catch (f) {
-      throw i.fill(0), f;
-    }
-    const l = await os(i, e.amounts.length), { perVaultWotsKeys: u, wotsPkHashes: m, htlcSecretHexes: P, hashlocks: w } = l, d = await this.preparePeginCommit({
-      depositorBtcPubkeyRaw: t,
-      depositorBtcPubkey: o,
-      hashlocks: w,
-      authAnchorHash: c,
-      sizing: n,
-      params: e
-    });
-    for (let f = 0; f < d.perVault.length; f++)
-      if (d.perVault[f].htlcVout !== f)
-        throw new Error(
-          `Internal invariant violation: htlcVout/index mismatch at vault ${f} (expected ${f}, got ${d.perVault[f].htlcVout})`
-        );
-    ce(
-      d.fundedPrePeginTxHex,
-      e.amounts.length,
-      c
-    );
-    const { depositTerms: B, ...k } = d;
-    return {
-      transaction: {
-        ...k,
-        selectedUTXOs: n.selectedUTXOs,
-        fee: n.fee,
-        changeAmount: n.changeAmount
-      },
-      depositorBtcPubkey: o,
-      derivedSecrets: {
-        perVaultWotsKeys: u,
-        wotsPkHashes: m,
-        htlcSecretHexes: P,
-        authAnchorHex: a
-      },
-      depositTerms: B
-    };
-  }
-  /**
-   * 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(
-      () => Y
-    ), n = t.vaultKeeperBtcPubkeys.length, r = await ht({
-      vaultCoreVersion: t.vaultCoreVersion,
-      depositorPubkey: e,
-      vaultProviderPubkey: E(t.vaultProviderBtcPubkey),
-      vaultKeeperPubkeys: t.vaultKeeperBtcPubkeys.map(E),
-      universalChallengerPubkeys: t.universalChallengerBtcPubkeys.map(E),
-      hashlocks: o,
-      timelockRefund: t.timelockRefund,
-      pegInAmounts: t.amounts,
-      feeRate: t.protocolFeeRate,
-      minPeginFeeRate: t.minPeginFeeRate,
-      numLocalChallengers: n,
-      councilQuorum: t.councilQuorum,
-      councilSize: t.councilSize,
-      network: this.config.btcNetwork,
-      authAnchorHash: Y
-    }), i = ue(
-      [...t.availableUTXOs],
-      r.totalOutputValue,
-      t.mempoolFeeRate,
-      de(r.htlcValues.length, !0)
-    );
-    return {
-      selectedUTXOs: i.selectedUTXOs,
-      fee: i.fee,
-      changeAmount: i.changeAmount
-    };
-  }
-  /** Build PegIn txs and batch-sign their inputs with real hashlocks. */
-  async preparePeginCommit(e) {
-    const {
-      depositorBtcPubkeyRaw: t,
-      depositorBtcPubkey: o,
-      hashlocks: n,
-      authAnchorHash: r,
-      sizing: i,
-      params: a
-    } = e, c = Y.toLowerCase();
-    for (let g = 0; g < n.length; g++)
-      if (n[g].toLowerCase() === c)
-        throw new Error(
-          `preparePeginCommit refusing to build with sizing-pass placeholder hashlock at vault ${g} — internal substitution bug`
-        );
-    if (r.toLowerCase() === c)
-      throw new Error(
-        "preparePeginCommit refusing to build with sizing-pass placeholder auth-anchor hash — internal substitution bug"
-      );
-    const l = E(
-      a.vaultProviderBtcPubkey
-    ), u = a.vaultKeeperBtcPubkeys.map(E), m = a.universalChallengerBtcPubkeys.map(E), P = u.length, w = {
-      vaultCoreVersion: a.vaultCoreVersion,
-      depositorPubkey: o,
-      vaultProviderPubkey: l,
-      vaultKeeperPubkeys: u,
-      universalChallengerPubkeys: m,
-      hashlocks: n,
-      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: r
-    }, d = await ht(w), B = ft(this.config.btcNetwork), k = ge({
-      unfundedTxHex: d.psbtHex,
-      selectedUTXOs: i.selectedUTXOs,
-      changeAddress: a.changeAddress,
-      changeAmount: i.changeAmount,
-      network: B
-    }), f = i.selectedUTXOs.reduce((g, v) => g + BigInt(v.value), 0n) - d.totalOutputValue - i.changeAmount;
-    if (f !== i.fee)
-      throw new Error(
-        `Pre-PegIn funded fee ${f} does not match the sizing-pass fee ${i.fee}; refusing to publish a deposit-terms fee bound the funded transaction does not pay.`
-      );
-    const A = E(
-      X(k)
-    ), p = [], b = [], T = [];
-    for (let g = 0; g < n.length; g++) {
-      const v = await Zt({
-        prePeginParams: w,
-        timelockPegin: a.timelockPegin,
-        fundedPrePeginTxHex: k,
-        htlcVout: g
-      }), I = await te({
-        vaultCoreVersion: a.vaultCoreVersion,
-        peginTxHex: v.txHex,
-        fundedPrePeginTxHex: k,
-        depositorPubkey: o,
-        vaultProviderPubkey: l,
-        vaultKeeperPubkeys: u,
-        universalChallengerPubkeys: m,
-        hashlock: n[g],
-        timelockRefund: a.timelockRefund,
-        network: this.config.btcNetwork
-      });
-      p.push(v), b.push(I.psbtHex), T.push(
-        re(t, 1)
-      );
-    }
-    const h = Be({
-      vaultCoreVersion: a.vaultCoreVersion,
-      protocolFeeRate: a.protocolFeeRate,
-      timelockPegin: a.timelockPegin,
-      timelockAssert: a.timelockAssert,
-      timelockRefund: a.timelockRefund,
-      prepeginTxid: A,
-      prepeginMaxFee: i.fee,
-      vaultProviderBtcPubkey: l,
-      vaultKeeperBtcPubkeys: u,
-      universalChallengerBtcPubkeys: m,
-      maxAcceptableCommissionBps: K(
-        a.commissionBps
-      ),
-      peginAmounts: a.amounts,
-      depositorClaimValue: d.depositorClaimValue,
-      peginMaxFee: d.minPeginFee
-    });
-    mt(this.config.btcWallet) && await this.config.btcWallet.approveDepositTerms(h);
-    const x = await le(
-      this.config.btcWallet,
-      b,
-      T
-    ), S = [];
-    for (let g = 0; g < x.length; g++) {
-      dt({
-        requestedPsbtHex: b[g],
-        returnedPsbtHex: x[g]
-      });
-      const v = ee(
-        x[g],
-        o
-      );
-      Jt({
-        requestedPsbtHex: b[g],
-        signatureHex: v,
-        signerXOnlyPubkeyHex: o,
-        inputIndex: 0
-      });
-      const I = se(x[g]);
-      S.push({
-        htlcVout: g,
-        htlcValue: d.htlcValues[g],
-        peginTxHex: I,
-        peginTxid: p[g].txid,
-        peginInputSignature: v,
-        vaultScriptPubKey: p[g].vaultScriptPubKey
-      });
-    }
-    return {
-      fundedPrePeginTxHex: k,
-      prePeginTxid: A,
-      perVault: S,
-      depositTerms: h
-    };
-  }
-  /**
-   * 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, n = t.startsWith("0x") ? t.slice(2) : t, r = At.fromHex(n);
-    if (r.ins.length === 0)
-      throw new Error("Transaction has no inputs");
-    const i = new ct();
-    i.setVersion(r.version), i.setLocktime(r.locktime);
-    const a = j.from(
-      $(o),
-      "hex"
-    ), c = this.config.mempoolApiUrl, l = r.ins.map((p) => {
-      const b = j.from(p.hash).reverse().toString("hex"), T = p.index;
-      return rs(b, T, e.localPrevouts, c).then(
-        (h) => ({ input: p, utxoData: h, txid: b, vout: T })
-      );
-    }), u = await Promise.all(l), m = u.reduce(
-      (p, b) => p + BigInt(b.utxoData.value),
-      0n
-    ), P = r.outs.reduce(
-      (p, b) => p + BigInt(b.value),
-      0n
-    );
-    if (m < P)
-      throw new Error(
-        `UTXO value mismatch: total input value (${m} sat) is less than total output value (${P} sat). This may indicate the mempool API returned manipulated UTXO data.`
-      );
-    const w = m - P;
-    if (w > pt)
-      throw new Error(
-        `Implied transaction fee (${w} sat) exceeds maximum reasonable fee (${pt} sat). This may indicate manipulated UTXO data.`
-      );
-    for (const { input: p, utxoData: b, txid: T, vout: h } of u) {
-      const x = he(
-        {
-          value: b.value,
-          scriptPubKey: b.scriptPubKey
-        },
-        a
-      );
-      i.addInput({
-        hash: p.hash,
-        index: p.index,
-        sequence: p.sequence,
-        ...x
-      });
-    }
-    for (const p of r.outs)
-      i.addOutput({
-        script: p.script,
-        value: p.value
-      });
-    await Se({
-      wallet: this.config.btcWallet,
-      depositTerms: e.depositTerms,
-      fundedPrePeginTxHex: t,
-      depositorBtcPubkey: o
-    });
-    const d = i.toHex(), B = await this.config.btcWallet.signPsbt(d);
-    dt({
-      requestedPsbtHex: d,
-      returnedPsbtHex: B
-    });
-    const k = ct.fromHex(B);
-    try {
-      k.finalizeAllInputs();
-    } catch (p) {
-      if (!k.data.inputs.every(
-        (T) => T.finalScriptWitness || T.finalScriptSig
-      ))
-        throw new Error(
-          `PSBT finalization failed and wallet did not auto-finalize: ${p}`
-        );
-    }
-    const f = k.extractTransaction().toHex();
-    return await pe(f, 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: n,
-      hashlock: r,
-      htlcVout: i,
-      depositorPayoutBtcAddress: a,
-      depositorWotsPkHash: c,
-      popSignature: l
-    } = e;
-    if (!this.config.ethWallet.account)
-      throw new Error("Ethereum wallet account not found");
-    const u = this.config.ethWallet.account.address;
-    if (!lt(l.depositorEthAddress, u))
-      throw new Error(
-        `Proof of possession was signed for ${l.depositorEthAddress} but the Ethereum wallet is currently connected to ${u}. Reconnect the original account or call signProofOfPossession() again.`
-      );
-    const m = await this.assertPopMatchesBtcWallet(l), P = l.btcPopSignature, w = _(
-      l.depositorBtcPubkey
-    ), d = _(t), B = _(o), k = a ?? await this.config.btcWallet.getAddress(), f = this.resolvePayoutScriptPubKey(
-      m,
-      k
-    ), A = X(B), p = await ut(
-      E(A),
-      E(u)
-    ), b = _(p);
-    if (await this.checkVaultExists(b))
-      throw new Error(
-        `Vault already exists (ID: ${b}, peginTxHash: ${A}). 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 h = this.config.publicClient;
-    let x;
-    try {
-      x = await h.readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: H,
-        functionName: "getPegInFee",
-        args: [n]
-      });
-    } catch (O) {
-      throw new Error(
-        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct.",
-        { cause: O }
-      );
-    }
-    const S = await this.resolveMaxAcceptableCommissionBps(
-      n,
-      e.quotedCommissionBps
-    ), g = Q({
-      abi: H,
-      functionName: "submitPeginRequest",
-      args: [
-        u,
-        w,
-        P,
-        d,
-        B,
-        n,
-        S,
-        r,
-        i,
-        f,
-        c
-      ]
-    });
-    let v;
-    try {
-      v = await h.estimateGas({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: g,
-        value: x,
-        account: this.config.ethWallet.account.address
-      });
-    } catch (O) {
-      R(O);
-    }
-    let I;
-    try {
-      I = await this.config.ethWallet.sendTransaction({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: g,
-        value: x,
-        account: this.config.ethWallet.account,
-        chain: this.config.ethChain,
-        gas: v
-      });
-    } catch (O) {
-      R(O);
-    }
-    const L = await bt({
-      publicClient: h,
-      walletAddress: this.config.ethWallet.account.address,
-      hash: I,
-      timeout: Tt
-    });
-    return L.status === "reverted" && R(
-      new Error(
-        `Transaction reverted. Hash: ${L.transactionHash}. Check the transaction on block explorer for details.`
-      )
-    ), {
-      ethTxHash: L.transactionHash,
-      vaultId: b,
-      peginTxHash: A
-    };
-  }
-  /**
-   * 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: n, popSignature: r } = e;
-    if (n.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 i = this.config.ethWallet.account.address;
-    if (!lt(r.depositorEthAddress, i))
-      throw new Error(
-        `Proof of possession was signed for ${r.depositorEthAddress} but the Ethereum wallet is currently connected to ${i}. Reconnect the original account or call signProofOfPossession() again.`
-      );
-    const a = await this.assertPopMatchesBtcWallet(r), c = r.btcPopSignature, l = n.map(
-      (h) => this.resolvePayoutScriptPubKey(
-        a,
-        h.depositorPayoutBtcAddress
-      )
-    ), u = [];
-    for (const h of n) {
-      const x = _(
-        h.depositorSignedPeginTx
-      ), S = X(x), g = await ut(
-        E(S),
-        E(i)
-      ), v = _(g);
-      if (await this.checkVaultExists(v))
-        throw new Error(
-          `Vault already exists (ID: ${v}, peginTxHash: ${S}). To create a new vault, use different UTXOs or a different amount.`
-        );
-      u.push({ vaultId: v, peginTxHash: S });
-    }
-    const m = this.config.publicClient;
-    let P;
-    try {
-      P = await m.readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: H,
-        functionName: "getPegInFee",
-        args: [t]
-      });
-    } catch (h) {
-      throw new Error(
-        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct.",
-        { cause: h }
-      );
-    }
-    const w = P * BigInt(n.length), d = await this.resolveMaxAcceptableCommissionBps(
-      t,
-      e.quotedCommissionBps
-    ), B = _(
-      r.depositorBtcPubkey
-    ), k = _(o), f = n.map((h, x) => ({
-      depositorBtcPubKey: B,
-      btcPopSignature: c,
-      unsignedPrePeginTx: k,
-      depositorSignedPeginTx: _(
-        h.depositorSignedPeginTx
-      ),
-      hashlock: h.hashlock,
-      htlcVout: h.htlcVout,
-      referralCode: Wt,
-      depositorPayoutBtcAddress: l[x],
-      depositorWotsPkHash: h.depositorWotsPkHash
-    })), A = Q({
-      abi: H,
-      functionName: "submitPeginRequestBatch",
-      args: [
-        i,
-        t,
-        d,
-        f
-      ]
-    });
-    let p;
-    try {
-      p = await m.estimateGas({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: A,
-        value: w,
-        account: this.config.ethWallet.account.address
-      });
-    } catch (h) {
-      R(h);
-    }
-    let b;
-    try {
-      b = await this.config.ethWallet.sendTransaction({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: A,
-        value: w,
-        account: this.config.ethWallet.account,
-        chain: this.config.ethChain,
-        gas: p
-      });
-    } catch (h) {
-      R(h);
-    }
-    const T = await bt({
-      publicClient: m,
-      walletAddress: this.config.ethWallet.account.address,
-      hash: b,
-      timeout: Tt
-    });
-    return T.status === "reverted" && R(
-      new Error(
-        `Batch transaction reverted. Hash: ${T.transactionHash}. Check the transaction on block explorer for details.`
-      )
-    ), {
-      ethTxHash: T.transactionHash,
-      vaults: u
-    };
-  }
-  // 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 && mt(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 me(
-        this.config.publicClient,
-        this.config.vaultContracts.btcVaultRegistry
-      ).getVaultProviderCommission(e);
-    } catch (n) {
-      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: n }
-      );
-    }
-    if (t !== void 0) {
-      if (o > t + tt)
-        throw new Error(
-          `Vault provider commission changed since quote: quoted ${t} bps, chain currently reports ${o} bps (allowed drift ${tt} bps). Please refresh to see the new commission and try again.`
-        );
-      return K(t);
-    }
-    return K(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 !== zt;
-  }
-  /**
-   * 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 (!gt(
-      t,
-      e,
-      this.config.btcNetwork
-    ))
-      throw E(e).length === ne && ns(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 = ft(this.config.btcNetwork);
-    try {
-      return `0x${Et.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.
-   */
-  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, n = `${e.toLowerCase()}:${this.config.ethChain.id}:pegin:${o.toLowerCase()}`, r = await this.config.btcWallet.signMessage(
-      n,
-      "bip322-simple"
-    );
-    return {
-      btcPopSignature: _e(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), n = $(e.depositorBtcPubkey);
-    if (o !== n)
-      throw new Error(
-        `Proof of possession was signed with BTC pubkey ${n} 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 is = 80, as = 250, cs = 300, ls = 22, Dt = "ab";
-function us(s, e) {
-  const t = Dt.repeat(cs), o = E(s).toLowerCase(), n = e.toString(16).padStart(8, "0"), r = `${o}${n}`, i = t.slice(r.length);
-  return `0x${r}${i}`;
-}
-function hs(s, e) {
-  const t = (o) => `0x${Dt.repeat(o)}`;
-  return {
-    depositorBtcPubKey: t(32),
-    btcPopSignature: t(is),
-    unsignedPrePeginTx: t(as),
-    depositorSignedPeginTx: us(
-      s,
-      e
-    ),
-    hashlock: t(32),
-    htlcVout: e,
-    referralCode: Wt,
-    depositorPayoutBtcAddress: t(ls),
-    depositorWotsPkHash: t(32)
-  };
-}
-async function Hs(s) {
-  const {
-    publicClient: e,
-    btcVaultRegistry: t,
-    depositorEthAddress: o,
-    vaultProvider: n,
-    batchSize: r
-  } = s;
-  if (r <= 0)
-    throw new Error(
-      `estimateSubmitPeginRequestBatchGas requires batchSize >= 1 (received ${r})`
-    );
-  const a = await e.readContract({
-    address: t,
-    abi: H,
-    functionName: "getPegInFee",
-    args: [n]
-  }) * BigInt(r), c = Array.from(
-    { length: r },
-    (u, m) => hs(o, m)
-  ), l = Q({
-    abi: H,
-    functionName: "submitPeginRequestBatch",
-    args: [
-      o,
-      n,
-      _t,
-      c
-    ]
-  });
-  return e.estimateGas({
-    to: t,
-    data: l,
-    value: a,
-    account: o
-  });
-}
-export {
-  tt as C,
-  _t as M,
-  Is as P,
-  K as a,
-  Be as b,
-  ss as c,
-  es as d,
-  Hs as e,
-  Se as f,
-  os as g
-};
-//# sourceMappingURL=PeginManager-BBl4xkWz.js.map