@babylonlabs-io/ts-sdk 0.28.0 → 0.28.1

package/dist/{deriveVaultRoot-DAMZDqg-.js → PeginManager-DzMSIQ0I.js}

@@ -1,21 +1,22 @@
-var zt = Object.defineProperty;
-var Yt = (e, t, n) => t in e ? zt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
-var p = (e, t, n) => Yt(e, typeof t != "symbol" ? t + "" : t, n);
-import * as Jt from "bitcoinjs-lib";
-import { Transaction as Qt, Psbt as dt } from "bitcoinjs-lib";
+var Jt = Object.defineProperty;
+var te = (e, t, n) => t in e ? Jt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var b = (e, t, n) => te(e, typeof t != "symbol" ? t + "" : t, n);
+import * as ee from "bitcoinjs-lib";
+import { Transaction as ne, Psbt as ft } from "bitcoinjs-lib";
 import { Buffer as et } from "buffer";
-import { isAddressEqual as ft, createPublicClient as j, http as q, encodeFunctionData as gt, zeroAddress as te } from "viem";
-import { c as ee } from "./signing-BZigafm0.js";
-import { deriveVaultId as pt } from "@babylonlabs-io/babylon-tbv-rust-wasm";
-import { b as ne, a as se, d as oe, e as re, f as ie } from "./challengeAssert-j2Vwqo0-.js";
-import { s as v, g as mt, e as _, i as ae, p as ce, u as le, h as he } from "./bitcoin-B-Y0DlqR.js";
-import { M as bt } from "./validation-CxqROCno.js";
-import { b as ue, f as G, i as de } from "./psbtInputFields-DeTFSJOq.js";
-import { p as fe, f as ge } from "./fundPeginTransaction-oV-dNJOU.js";
-import { p as pe, f as me } from "./vault-registry-reader-CshEgmS0.js";
-import { B as S } from "./types-CQ86O7NX.js";
-import { c as St, H as be, r as W, a as H, b as nt, u as we, d as wt, e as F, f as U, g as ye, s as L, h as Ot } from "./sha2-CPdTLk1u.js";
-const C = {
+import { isAddressEqual as gt, createPublicClient as j, http as z, encodeFunctionData as pt, zeroAddress as se } from "viem";
+import { deriveVaultId as mt } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import { b as bt, a as oe, d as re, e as ie, f as ae } from "./challengeAssert-j2Vwqo0-.js";
+import { u as $t, h as nt, e as I, s as _, g as wt, i as ce, p as le } from "./bitcoin-B-Y0DlqR.js";
+import { h as ue } from "./buildAndBroadcastRefund-xWS8frc6.js";
+import { c as he } from "./signing-BZigafm0.js";
+import { M as yt } from "./validation-CxqROCno.js";
+import { a as Rt, b as U, c as A, d as F, e as st, s as L, f as Ut, H as de, r as V, u as fe, g as xt, h as ge } from "./sha2-6wN58S6R.js";
+import { b as pe, f as q, i as me } from "./psbtInputFields-DeTFSJOq.js";
+import { p as be, f as we } from "./fundPeginTransaction-oV-dNJOU.js";
+import { p as ye, f as xe } from "./vault-registry-reader-BywZhqJL.js";
+import { B as C } from "./types-CnG3JsRs.js";
+const S = {
   // VaultAlreadyExists()
   "0x04aabf33": "Vault already exists: This Bitcoin transaction has already been registered. Please select different UTXOs or use a different amount to create a unique transaction.",
   // ScriptPubKeyMismatch() - taproot output doesn't match expected script
@@ -49,7 +50,7 @@ const C = {
   // PeginTransactionAlreadyUsed()
   "0x7ed061c9": "This pegin transaction has already been used to activate another vault."
 };
-function it(e) {
+function at(e) {
   if (!e || typeof e != "object") return;
   const t = e;
   if (typeof t.data == "string" && t.data.startsWith("0x"))
@@ -68,24 +69,24 @@ function it(e) {
   if (i)
     return i[1];
 }
-function An(e) {
-  const t = it(e);
+function Ln(e) {
+  const t = at(e);
   if (t) {
     const n = t.substring(0, 10);
-    return C[t] ?? C[n];
+    return S[t] ?? S[n];
   }
 }
-function Hn(e) {
-  const t = it(e);
+function Vn(e) {
+  const t = at(e);
   if (t === void 0) return !1;
   const n = t.substring(0, 10);
-  return t in C || n in C;
+  return t in S || n in S;
 }
-function A(e) {
+function H(e) {
   console.error("[Contract Error] Raw error:", e);
-  const t = it(e);
+  const t = at(e);
   if (console.error("[Contract Error] Extracted error data:", t), t) {
-    const s = t.substring(0, 10), o = C[t] ?? C[s];
+    const s = t.substring(0, 10), o = S[t] ?? S[s];
     if (o)
       throw console.error("[Contract Error] Known error:", o), new Error(o);
   }
@@ -103,281 +104,899 @@ function A(e) {
   }
   throw e instanceof Error ? (console.error("[Contract Error] Unhandled error:", e.message), e) : new Error(`Contract call failed: ${String(e)}`);
 }
-const xe = 0, Pe = /^0x[0-9a-f]+$/i, Ee = /^[0-9a-f]+$/i, Te = /^[A-Za-z0-9+/]+={0,2}$/;
-function O(e) {
-  if (typeof e != "string" || e.length === 0)
-    throw new Error("BTC wallet returned empty public key");
-  return ce(e).toLowerCase();
+const W = /* @__PURE__ */ BigInt(2 ** 32 - 1), Pt = /* @__PURE__ */ BigInt(32);
+function Pe(e, t = !1) {
+  return t ? { h: Number(e & W), l: Number(e >> Pt & W) } : { h: Number(e >> Pt & W) | 0, l: Number(e & W) | 0 };
 }
-function ke(e) {
-  if (typeof e != "string" || e.length === 0)
-    throw new Error("BTC wallet returned empty BIP-322 signature");
-  if (e.startsWith("0x") || e.startsWith("0X")) {
-    if (!Pe.test(e) || e.length < 4 || e.length % 2 !== 0)
-      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
-    return e.toLowerCase();
+function Ee(e, t = !1) {
+  const n = e.length;
+  let s = new Uint32Array(n), o = new Uint32Array(n);
+  for (let r = 0; r < n; r++) {
+    const { h: i, l: a } = Pe(e[r], t);
+    [s[r], o[r]] = [i, a];
   }
-  if (Ee.test(e)) {
-    if (e.length % 2 !== 0)
-      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
-    return `0x${e.toLowerCase()}`;
+  return [s, o];
+}
+const ke = (e, t, n) => e << n | t >>> 32 - n, Te = (e, t, n) => t << n | e >>> 32 - n, _e = (e, t, n) => t << n - 32 | e >>> 64 - n, ve = (e, t, n) => e << n - 32 | t >>> 64 - n;
+class Lt {
+  constructor(t, n) {
+    b(this, "oHash");
+    b(this, "iHash");
+    b(this, "blockLen");
+    b(this, "outputLen");
+    b(this, "finished", !1);
+    b(this, "destroyed", !1);
+    if (Rt(t), U(n, void 0, "key"), this.iHash = t.create(), typeof this.iHash.update != "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
+    const s = this.blockLen, o = new Uint8Array(s);
+    o.set(n.length > s ? t.create().update(n).digest() : n);
+    for (let r = 0; r < o.length; r++)
+      o[r] ^= 54;
+    this.iHash.update(o), this.oHash = t.create();
+    for (let r = 0; r < o.length; r++)
+      o[r] ^= 106;
+    this.oHash.update(o), A(o);
+  }
+  update(t) {
+    return F(this), this.iHash.update(t), this;
+  }
+  digestInto(t) {
+    F(this), U(t, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
+  }
+  digest() {
+    const t = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(t), t;
+  }
+  _cloneInto(t) {
+    t || (t = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: n, iHash: s, finished: o, destroyed: r, blockLen: i, outputLen: a } = this;
+    return t = t, t.finished = o, t.destroyed = r, t.blockLen = i, t.outputLen = a, t.oHash = n._cloneInto(t.oHash), t.iHash = s._cloneInto(t.iHash), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
   }
-  if (!Te.test(e) || e.length % 4 !== 0)
-    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
-  const t = et.from(e, "base64");
-  if (t.length === 0 || t.toString("base64") !== e)
-    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
-  return `0x${t.toString("hex")}`;
 }
-function _e(e, t, n, s) {
-  const o = n == null ? void 0 : n[`${e}:${t}`];
-  return o ? Promise.resolve({
-    txid: e,
-    vout: t,
-    value: o.value,
-    scriptPubKey: o.scriptPubKey
-  }) : me(e, t, s);
+const Vt = (e, t, n) => new Lt(e, t).update(n).digest();
+Vt.create = (e, t) => new Lt(e, t);
+const G = /* @__PURE__ */ Uint8Array.of(0), Et = /* @__PURE__ */ Uint8Array.of();
+function ct(e, t, n, s = 32) {
+  Rt(e), st(s, "length");
+  const o = e.outputLen;
+  if (s > 255 * o)
+    throw new Error("Length must be <= 255*HashLen");
+  const r = Math.ceil(s / o);
+  n === void 0 ? n = Et : U(n, void 0, "info");
+  const i = new Uint8Array(r * o), a = Vt.create(e, t), l = a._cloneInto(), u = new Uint8Array(a.outputLen);
+  for (let c = 0; c < r; c++)
+    G[0] = c + 1, l.update(c === 0 ? Et : u).update(n).update(G).digestInto(u), i.set(u, o * c), a._cloneInto(l);
+  return a.destroy(), l.destroy(), A(u, G), i.slice(0, s);
 }
-const yt = 12e4;
-class Cn {
-  /**
-   * Creates a new PeginManager instance.
-   *
-   * @param config - Manager configuration including wallets and contract addresses
-   */
-  constructor(t) {
-    p(this, "config");
-    this.config = t;
-  }
-  /**
-   * Prepares a peg-in by building the Pre-PegIn HTLC transaction,
-   * funding it, constructing the PegIn transaction, and signing the PegIn input.
-   *
-   * This method orchestrates the following steps:
-   * 1. Get depositor BTC public key from wallet
-   * 2. Build unfunded Pre-PegIn transaction (HTLC output) using primitives
-   * 3. Select UTXOs to cover the HTLC value
-   * 4. Fund the Pre-PegIn transaction
-   * 5. Derive the PegIn transaction from the funded Pre-PegIn tx
-   * 6. Build PSBT for signing the PegIn input (HTLC leaf 0)
-   * 7. Sign via BTC wallet and extract depositor signature
-   *
-   * The returned `fundedPrePeginTxHex` is funded but unsigned (inputs unsigned).
-   * Use `signAndBroadcast()` AFTER registering on Ethereum to broadcast it.
-   *
-   * @param params - Pegin parameters including amount, HTLC params, UTXOs
-   * @returns Pegin result with funded Pre-PegIn tx, signed PegIn input, and signatures
-   * @throws Error if wallet operations fail or insufficient funds
-   */
-  async preparePegin(t) {
-    const n = await this.config.btcWallet.getPublicKeyHex(), s = O(n), o = v(t.vaultProviderBtcPubkey), r = t.vaultKeeperBtcPubkeys.map(v), i = t.universalChallengerBtcPubkeys.map(v);
-    if (t.hashlocks.length !== t.amounts.length)
+const Z = new TextEncoder().encode("babylonvault"), kt = 255, Tt = 65535, _t = 2, Ie = "hashlock", Be = "auth-anchor", He = "wots-seed";
+function Wt(e) {
+  if (!Number.isInteger(e) || e < 0 || e > 4294967295)
+    throw new Error(`i2osp4: value must be a u32, got ${e}`);
+  const t = new Uint8Array(4);
+  return t[0] = e >>> 24 & 255, t[1] = e >>> 16 & 255, t[2] = e >>> 8 & 255, t[3] = e & 255, t;
+}
+function lt(e, t = new Uint8Array(0)) {
+  const n = new TextEncoder().encode(e);
+  if (n.length === 0 || n.length > kt)
+    throw new Error(
+      `info: label length must be in [1, ${kt}], got ${n.length}`
+    );
+  if (t.length > Tt)
+    throw new Error(
+      `info: ctx length must be in [0, ${Tt}], got ${t.length}`
+    );
+  const s = Z.length + 1 + n.length + _t + t.length, o = new Uint8Array(s);
+  let r = 0;
+  return o.set(Z, r), r += Z.length, o[r] = n.length, r += 1, o.set(n, r), r += n.length, o[r] = t.length >>> 8 & 255, o[r + 1] = t.length & 255, r += _t, o.set(t, r), o;
+}
+const vt = 32, Ae = 32, Se = 32, Ce = 64;
+function ut(e) {
+  if (e.length !== vt)
+    throw new Error(
+      `vault-secrets: root must be exactly ${vt} bytes, got ${e.length}`
+    );
+}
+function Wn(e) {
+  return ut(e), ct(
+    L,
+    e,
+    lt(Be),
+    Ae
+  );
+}
+function Oe(e, t) {
+  return ut(e), ct(
+    L,
+    e,
+    lt(Ie, Wt(t)),
+    Se
+  );
+}
+function $e(e, t) {
+  return ut(e), ct(
+    L,
+    e,
+    lt(He, Wt(t)),
+    Ce
+  );
+}
+const R = 32, Y = 32, ot = 36, Nt = 32, X = 4, Re = X + R + X + Nt;
+function rt(e, t, n) {
+  e[t] = n >>> 24 & 255, e[t + 1] = n >>> 16 & 255, e[t + 2] = n >>> 8 & 255, e[t + 3] = n & 255;
+}
+function Ue(e) {
+  if (e.txid.length !== Y)
+    throw new Error(
+      `outpoint.txid must be exactly ${Y} bytes, got ${e.txid.length}`
+    );
+  if (!Number.isInteger(e.vout) || e.vout < 0 || e.vout > 4294967295)
+    throw new Error(`outpoint.vout must be a u32, got ${e.vout}`);
+  const t = new Uint8Array(ot);
+  return t.set(e.txid, 0), rt(t, Y, e.vout), t;
+}
+function It(e, t) {
+  const n = Math.min(e.length, t.length);
+  for (let s = 0; s < n; s++)
+    if (e[s] !== t[s]) return e[s] - t[s];
+  return e.length - t.length;
+}
+function Le(e) {
+  if (e.length === 0)
+    throw new Error(
+      "buildFundingOutpointsCommitment: outpoints must be non-empty"
+    );
+  const t = e.map(Ue);
+  t.sort(It);
+  for (let s = 1; s < t.length; s++)
+    if (It(t[s - 1], t[s]) === 0)
       throw new Error(
-        `hashlocks.length (${t.hashlocks.length}) must equal amounts.length (${t.amounts.length})`
-      );
-    if (t.hashlocks.length === 0)
-      throw new Error("hashlocks must contain at least one entry");
-    const a = r.length, l = {
-      depositorPubkey: s,
-      vaultProviderPubkey: o,
-      vaultKeeperPubkeys: r,
-      universalChallengerPubkeys: i,
-      hashlocks: t.hashlocks,
-      timelockRefund: t.timelockRefund,
-      pegInAmounts: t.amounts,
-      feeRate: t.protocolFeeRate,
-      numLocalChallengers: a,
-      councilQuorum: t.councilQuorum,
-      councilSize: t.councilSize,
-      network: this.config.btcNetwork
-    }, h = await ne(l), c = ue(
-      [...t.availableUTXOs],
-      h.totalOutputValue,
-      t.mempoolFeeRate,
-      fe(
-        h.htlcValues.length,
-        l.authAnchorHash
-      )
-    ), b = mt(this.config.btcNetwork), m = ge({
-      unfundedTxHex: h.psbtHex,
-      selectedUTXOs: c.selectedUTXOs,
-      changeAddress: t.changeAddress,
-      changeAmount: c.changeAmount,
-      network: b
-    }), w = v(G(m)), g = [], E = [], P = [];
-    for (let u = 0; u < t.hashlocks.length; u++) {
-      const d = await se({
-        prePeginParams: l,
-        timelockPegin: t.timelockPegin,
-        fundedPrePeginTxHex: m,
-        htlcVout: u
-      }), x = await oe({
-        peginTxHex: d.txHex,
-        fundedPrePeginTxHex: m,
-        depositorPubkey: s,
-        vaultProviderPubkey: o,
-        vaultKeeperPubkeys: r,
-        universalChallengerPubkeys: i,
-        hashlock: t.hashlocks[u],
-        timelockRefund: t.timelockRefund,
-        network: this.config.btcNetwork
-      });
-      g.push(d), E.push(x.psbtHex), P.push(
-        ee(n, 1)
+        "buildFundingOutpointsCommitment: duplicate outpoint detected"
       );
+  const n = new Uint8Array(t.length * ot);
+  for (let s = 0; s < t.length; s++)
+    n.set(t[s], s * ot);
+  return L(n);
+}
+function Ve(e) {
+  if (e.depositorBtcPubkey.length !== R)
+    throw new Error(
+      `vaultContext: depositorBtcPubkey must be exactly ${R} bytes, got ${e.depositorBtcPubkey.length}`
+    );
+  const t = Le(e.fundingOutpoints), n = new Uint8Array(Re);
+  let s = 0;
+  return rt(n, s, R), s += X, n.set(e.depositorBtcPubkey, s), s += R, rt(n, s, Nt), s += X, n.set(t, s), n;
+}
+const We = "babylon-vault", Mt = 32, Bt = Mt * 2, Ne = /^[0-9a-f]+$/;
+async function Me(e, t) {
+  const n = Ve(t), s = $t(n), o = await e.deriveContextHash(We, s);
+  if (typeof o != "string")
+    throw new Error(
+      `deriveVaultRoot: wallet must return a string, got ${typeof o}`
+    );
+  if (o.length !== Bt)
+    throw new Error(
+      `deriveVaultRoot: wallet must return a ${Bt}-character hex string (${Mt} bytes), got length ${o.length}`
+    );
+  if (!Ne.test(o))
+    throw new Error(
+      "deriveVaultRoot: wallet must return lowercase hex per derive-context-hash.md §2.1; got value with non-lowercase or non-hex characters"
+    );
+  return nt(o);
+}
+const Fe = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), Ft = Uint8Array.from(new Array(16).fill(0).map((e, t) => t)), Xe = Ft.map((e) => (9 * e + 5) % 16), Xt = /* @__PURE__ */ (() => {
+  const n = [[Ft], [Xe]];
+  for (let s = 0; s < 4; s++)
+    for (let o of n)
+      o.push(o[s].map((r) => Fe[r]));
+  return n;
+})(), Kt = Xt[0], Dt = Xt[1], jt = /* @__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((e) => Uint8Array.from(e)), Ke = /* @__PURE__ */ Kt.map((e, t) => e.map((n) => jt[t][n])), De = /* @__PURE__ */ Dt.map((e, t) => e.map((n) => jt[t][n])), je = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), ze = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function Ht(e, t, n, s) {
+  return e === 0 ? t ^ n ^ s : e === 1 ? t & n | ~t & s : e === 2 ? (t | ~n) ^ s : e === 3 ? t & s | n & ~s : t ^ (n | ~s);
+}
+const N = /* @__PURE__ */ new Uint32Array(16);
+class qe extends de {
+  constructor() {
+    super(64, 20, 8, !0);
+    b(this, "h0", 1732584193);
+    b(this, "h1", -271733879);
+    b(this, "h2", -1732584194);
+    b(this, "h3", 271733878);
+    b(this, "h4", -1009589776);
+  }
+  get() {
+    const { h0: n, h1: s, h2: o, h3: r, h4: i } = this;
+    return [n, s, o, r, i];
+  }
+  set(n, s, o, r, i) {
+    this.h0 = n | 0, this.h1 = s | 0, this.h2 = o | 0, this.h3 = r | 0, this.h4 = i | 0;
+  }
+  process(n, s) {
+    for (let p = 0; p < 16; p++, s += 4)
+      N[p] = n.getUint32(s, !0);
+    let o = this.h0 | 0, r = o, i = this.h1 | 0, a = i, l = this.h2 | 0, u = l, c = this.h3 | 0, y = c, g = this.h4 | 0, h = g;
+    for (let p = 0; p < 5; p++) {
+      const T = 4 - p, P = je[p], v = ze[p], d = Kt[p], x = Dt[p], f = Ke[p], m = De[p];
+      for (let w = 0; w < 16; w++) {
+        const E = V(o + Ht(p, i, l, c) + N[d[w]] + P, f[w]) + g | 0;
+        o = g, g = c, c = V(l, 10) | 0, l = i, i = E;
+      }
+      for (let w = 0; w < 16; w++) {
+        const E = V(r + Ht(T, a, u, y) + N[x[w]] + v, m[w]) + h | 0;
+        r = h, h = y, y = V(u, 10) | 0, u = a, a = E;
+      }
     }
-    const k = await this.signPsbtsWithFallback(
-      E,
-      P
-    ), f = [];
-    for (let u = 0; u < k.length; u++) {
-      const d = re(
-        k[u],
-        s
-      ), x = ie(k[u]);
-      f.push({
-        htlcVout: u,
-        htlcValue: h.htlcValues[u],
-        peginTxHex: x,
-        peginTxid: g[u].txid,
-        peginInputSignature: d,
-        vaultScriptPubKey: g[u].vaultScriptPubKey
-      });
-    }
-    return {
-      fundedPrePeginTxHex: m,
-      prePeginTxid: w,
-      perVault: f,
-      selectedUTXOs: c.selectedUTXOs,
-      fee: c.fee,
-      changeAmount: c.changeAmount
-    };
+    this.set(this.h1 + l + y | 0, this.h2 + c + h | 0, this.h3 + g + r | 0, this.h4 + o + a | 0, this.h0 + i + u | 0);
   }
-  /**
-   * Signs multiple PSBTs using batch signing if available, falling back to sequential signing.
-   *
-   * Wallets that support native batch signing (e.g. UniSat) will sign all PSBTs
-   * in a single interaction. Others (e.g. Ledger, AppKit) implement signPsbts
-   * by looping signPsbt internally, so the UX depends on the wallet adapter.
-   */
-  async signPsbtsWithFallback(t, n) {
-    if (typeof this.config.btcWallet.signPsbts == "function") {
-      const o = await this.config.btcWallet.signPsbts(
-        t,
-        n
-      );
-      if (o.length !== t.length)
-        throw new Error(
-          `Expected ${t.length} signed PSBTs but received ${o.length}`
-        );
-      return o;
+  roundClean() {
+    A(N);
+  }
+  destroy() {
+    this.destroyed = !0, A(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const Ge = /* @__PURE__ */ Ut(() => new qe()), Ze = BigInt(0), O = BigInt(1), Ye = BigInt(2), Qe = BigInt(7), Je = BigInt(256), tn = BigInt(113), zt = [], qt = [], Gt = [];
+for (let e = 0, t = O, n = 1, s = 0; e < 24; e++) {
+  [n, s] = [s, (2 * n + 3 * s) % 5], zt.push(2 * (5 * s + n)), qt.push((e + 1) * (e + 2) / 2 % 64);
+  let o = Ze;
+  for (let r = 0; r < 7; r++)
+    t = (t << O ^ (t >> Qe) * tn) % Je, t & Ye && (o ^= O << (O << BigInt(r)) - O);
+  Gt.push(o);
+}
+const Zt = Ee(Gt, !0), en = Zt[0], nn = Zt[1], At = (e, t, n) => n > 32 ? _e(e, t, n) : ke(e, t, n), St = (e, t, n) => n > 32 ? ve(e, t, n) : Te(e, t, n);
+function sn(e, t = 24) {
+  const n = new Uint32Array(10);
+  for (let s = 24 - t; s < 24; s++) {
+    for (let i = 0; i < 10; i++)
+      n[i] = e[i] ^ e[i + 10] ^ e[i + 20] ^ e[i + 30] ^ e[i + 40];
+    for (let i = 0; i < 10; i += 2) {
+      const a = (i + 8) % 10, l = (i + 2) % 10, u = n[l], c = n[l + 1], y = At(u, c, 1) ^ n[a], g = St(u, c, 1) ^ n[a + 1];
+      for (let h = 0; h < 50; h += 10)
+        e[i + h] ^= y, e[i + h + 1] ^= g;
     }
-    const s = [];
-    for (let o = 0; o < t.length; o++) {
-      const r = await this.config.btcWallet.signPsbt(
-        t[o],
-        n[o]
-      );
-      s.push(r);
+    let o = e[2], r = e[3];
+    for (let i = 0; i < 24; i++) {
+      const a = qt[i], l = At(o, r, a), u = St(o, r, a), c = zt[i];
+      o = e[c], r = e[c + 1], e[c] = l, e[c + 1] = u;
     }
-    return s;
-  }
-  /**
-   * 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
-   *
-   * @param params - Transaction hex and depositor public key
-   * @returns The broadcasted Bitcoin transaction ID
-   * @throws Error if signing or broadcasting fails
-   */
-  async signAndBroadcast(t) {
-    const { fundedPrePeginTxHex: n, depositorBtcPubkey: s } = t, o = n.startsWith("0x") ? n.slice(2) : n, r = Qt.fromHex(o);
-    if (r.ins.length === 0)
-      throw new Error("Transaction has no inputs");
-    const i = new dt();
-    i.setVersion(r.version), i.setLocktime(r.locktime);
-    const a = et.from(
-      O(s),
-      "hex"
-    ), l = this.config.mempoolApiUrl, h = r.ins.map((f) => {
-      const u = et.from(f.hash).reverse().toString("hex"), d = f.index;
-      return _e(u, d, t.localPrevouts, l).then(
-        (x) => ({ input: f, utxoData: x, txid: u, vout: d })
-      );
-    }), c = await Promise.all(h), b = c.reduce(
-      (f, u) => f + BigInt(u.utxoData.value),
-      0n
-    ), m = r.outs.reduce(
-      (f, u) => f + BigInt(u.value),
-      0n
-    );
-    if (b < m)
+    for (let i = 0; i < 50; i += 10) {
+      for (let a = 0; a < 10; a++)
+        n[a] = e[i + a];
+      for (let a = 0; a < 10; a++)
+        e[i + a] ^= ~n[(a + 2) % 10] & n[(a + 4) % 10];
+    }
+    e[0] ^= en[s], e[1] ^= nn[s];
+  }
+  A(n);
+}
+class ht {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(t, n, s, o = !1, r = 24) {
+    b(this, "state");
+    b(this, "pos", 0);
+    b(this, "posOut", 0);
+    b(this, "finished", !1);
+    b(this, "state32");
+    b(this, "destroyed", !1);
+    b(this, "blockLen");
+    b(this, "suffix");
+    b(this, "outputLen");
+    b(this, "enableXOF", !1);
+    b(this, "rounds");
+    if (this.blockLen = t, this.suffix = n, this.outputLen = s, this.enableXOF = o, this.rounds = r, st(s, "outputLen"), !(0 < t && t < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200), this.state32 = fe(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    xt(this.state32), sn(this.state32, this.rounds), xt(this.state32), this.posOut = 0, this.pos = 0;
+  }
+  update(t) {
+    F(this), U(t);
+    const { blockLen: n, state: s } = this, o = t.length;
+    for (let r = 0; r < o; ) {
+      const i = Math.min(n - this.pos, o - r);
+      for (let a = 0; a < i; a++)
+        s[this.pos++] ^= t[r++];
+      this.pos === n && this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = !0;
+    const { state: t, suffix: n, pos: s, blockLen: o } = this;
+    t[s] ^= n, (n & 128) !== 0 && s === o - 1 && this.keccak(), t[o - 1] ^= 128, this.keccak();
+  }
+  writeInto(t) {
+    F(this, !1), U(t), this.finish();
+    const n = this.state, { blockLen: s } = this;
+    for (let o = 0, r = t.length; o < r; ) {
+      this.posOut >= s && this.keccak();
+      const i = Math.min(s - this.posOut, r - o);
+      t.set(n.subarray(this.posOut, this.posOut + i), o), this.posOut += i, o += i;
+    }
+    return t;
+  }
+  xofInto(t) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(t);
+  }
+  xof(t) {
+    return st(t), this.xofInto(new Uint8Array(t));
+  }
+  digestInto(t) {
+    if (ge(t, this), this.finished)
+      throw new Error("digest() was already called");
+    return this.writeInto(t), this.destroy(), t;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = !0, A(this.state);
+  }
+  _cloneInto(t) {
+    const { blockLen: n, suffix: s, outputLen: o, rounds: r, enableXOF: i } = this;
+    return t || (t = new ht(n, s, o, i, r)), t.state32.set(this.state32), t.pos = this.pos, t.posOut = this.posOut, t.finished = this.finished, t.rounds = r, t.suffix = s, t.outputLen = o, t.enableXOF = i, t.destroyed = this.destroyed, t;
+  }
+}
+const on = (e, t, n, s = {}) => Ut(() => new ht(t, e, n), s), rn = /* @__PURE__ */ on(1, 136, 32), Ct = 64, k = 20, it = 4, Yt = 2, an = 0, cn = 1, M = [64, 64], ln = (e) => Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("");
+function dt(e) {
+  return Ge(L(e));
+}
+function Qt(e) {
+  return (1 << e) - 1;
+}
+function un(e) {
+  let t = 1;
+  for (; t * t < e + 1; ) t++;
+  return Math.max(t, 2);
+}
+function hn(e) {
+  const t = it, n = e * Qt(t);
+  return { d: t, n: e, checksum_radix: un(n) };
+}
+function Q(e, t) {
+  const n = [];
+  let s = t;
+  for (; s > 0; )
+    n.push(s & 255), s >>>= 8;
+  const o = new Uint8Array(e.length + n.length);
+  o.set(e);
+  for (let r = 0; r < n.length; r++)
+    o[e.length + r] = n[r];
+  return dt(o);
+}
+function J(e, t) {
+  let n = e;
+  for (let s = 0; s < t; s++)
+    n = dt(n);
+  return n;
+}
+function dn(e, t) {
+  const n = Qt(t.d), s = t.checksum_radix - 1, o = Math.floor(t.n * n / t.checksum_radix), r = [];
+  for (let c = 0; c < t.n; c++) {
+    const y = Q(e, c + Yt), g = J(y, n);
+    r.push(Array.from(g));
+  }
+  const i = Q(
+    e,
+    an
+  ), a = J(
+    i,
+    s
+  ), l = Q(
+    e,
+    cn
+  ), u = J(
+    l,
+    o
+  );
+  return {
+    config: t,
+    message_terminals: r,
+    checksum_major_terminal: Array.from(u),
+    checksum_minor_terminal: Array.from(a)
+  };
+}
+async function fn(e) {
+  try {
+    if (e.length !== Ct)
       throw new Error(
-        `UTXO value mismatch: total input value (${b} sat) is less than total output value (${m} sat). This may indicate the mempool API returned manipulated UTXO data.`
+        `WOTS seed must be exactly ${Ct} bytes, got ${e.length}`
       );
-    const w = b - m;
-    if (w > bt)
+    const t = [];
+    for (let n = 0; n < M.length; n++) {
+      const s = M[n], o = hn(s), r = new Uint8Array(e.length + 1);
+      r.set(e), r[e.length] = n;
+      const i = dt(r);
+      try {
+        const a = dn(i, o);
+        if (a.config.d !== it)
+          throw new Error(
+            `Block ${n}: expected d=${it}, got d=${a.config.d}`
+          );
+        if (a.config.n !== s)
+          throw new Error(
+            `Block ${n}: expected n=${s}, got n=${a.config.n}`
+          );
+        if (a.message_terminals.length !== s)
+          throw new Error(
+            `Block ${n}: expected ${s} message terminals, got ${a.message_terminals.length}`
+          );
+        for (let l = 0; l < a.message_terminals.length; l++)
+          if (a.message_terminals[l].length !== k)
+            throw new Error(
+              `Block ${n} terminal ${l}: expected ${k} bytes, got ${a.message_terminals[l].length}`
+            );
+        if (a.checksum_minor_terminal.length !== k)
+          throw new Error(
+            `Block ${n} checksum_minor: expected ${k} bytes`
+          );
+        if (a.checksum_major_terminal.length !== k)
+          throw new Error(
+            `Block ${n} checksum_major: expected ${k} bytes`
+          );
+        t.push(a);
+      } finally {
+        r.fill(0), i.fill(0);
+      }
+    }
+    if (t.length !== M.length)
       throw new Error(
-        `Implied transaction fee (${w} sat) exceeds maximum reasonable fee (${bt} sat). This may indicate manipulated UTXO data.`
+        `Expected ${M.length} blocks, got ${t.length}`
       );
-    for (const { input: f, utxoData: u, txid: d, vout: x } of c) {
-      const y = de(
-        {
-          value: u.value,
-          scriptPubKey: u.scriptPubKey
-        },
-        a
+    return t;
+  } finally {
+    e.fill(0);
+  }
+}
+function tt(e, t, n) {
+  if (e.length !== k)
+    throw new Error(
+      `Block ${t} ${n}: expected ${k} bytes, got ${e.length}`
+    );
+  for (let s = 0; s < e.length; s++) {
+    const o = e[s];
+    if (!Number.isInteger(o) || o < 0 || o > 255)
+      throw new Error(
+        `Block ${t} ${n}[${s}]: invalid byte value ${o}`
       );
-      i.addInput({
-        hash: f.hash,
-        index: f.index,
-        sequence: f.sequence,
-        ...y
-      });
-    }
-    for (const f of r.outs)
-      i.addOutput({
-        script: f.script,
-        value: f.value
-      });
-    const g = await this.config.btcWallet.signPsbt(i.toHex()), E = dt.fromHex(g);
-    try {
-      E.finalizeAllInputs();
-    } catch (f) {
-      if (!E.data.inputs.every(
-        (d) => d.finalScriptWitness || d.finalScriptSig
-      ))
+  }
+}
+function gn(e) {
+  if (e.length === 0)
+    throw new Error("Public keys array must not be empty");
+  for (let r = 0; r < e.length; r++) {
+    const i = e[r];
+    tt(i.checksum_minor_terminal, r, "checksum_minor_terminal"), tt(i.checksum_major_terminal, r, "checksum_major_terminal");
+    for (let a = 0; a < i.message_terminals.length; a++)
+      tt(i.message_terminals[a], r, `message_terminal[${a}]`);
+  }
+  let t = 0;
+  for (const r of e)
+    t += Yt + r.message_terminals.length;
+  const n = new Uint8Array(t * k);
+  let s = 0;
+  for (const r of e) {
+    n.set(r.checksum_minor_terminal, s), s += k, n.set(r.checksum_major_terminal, s), s += k;
+    for (const i of r.message_terminals)
+      n.set(i, s), s += k;
+  }
+  const o = rn(n);
+  return `0x${ln(o)}`;
+}
+function Nn(e) {
+  const t = (e instanceof Error ? e.message : typeof e == "string" ? e : "").toLowerCase();
+  return t.includes("wots") && t.includes("hash") && t.includes("does not match");
+}
+const pn = 0, mn = /^0x[0-9a-f]+$/i, bn = /^[0-9a-f]+$/i, wn = /^[A-Za-z0-9+/]+={0,2}$/, yn = "00".repeat(32);
+function $(e) {
+  if (typeof e != "string" || e.length === 0)
+    throw new Error("BTC wallet returned empty public key");
+  return le(e).toLowerCase();
+}
+function xn(e) {
+  if (typeof e != "string" || e.length === 0)
+    throw new Error("BTC wallet returned empty BIP-322 signature");
+  if (e.startsWith("0x") || e.startsWith("0X")) {
+    if (!mn.test(e) || e.length < 4 || e.length % 2 !== 0)
+      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
+    return e.toLowerCase();
+  }
+  if (bn.test(e)) {
+    if (e.length % 2 !== 0)
+      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
+    return `0x${e.toLowerCase()}`;
+  }
+  if (!wn.test(e) || e.length % 4 !== 0)
+    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
+  const t = et.from(e, "base64");
+  if (t.length === 0 || t.toString("base64") !== e)
+    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
+  return `0x${t.toString("hex")}`;
+}
+function Pn(e, t, n, s) {
+  const o = n == null ? void 0 : n[`${e}:${t}`];
+  return o ? Promise.resolve({
+    txid: e,
+    vout: t,
+    value: o.value,
+    scriptPubKey: o.scriptPubKey
+  }) : xe(e, t, s);
+}
+const Ot = 12e4;
+class Mn {
+  /**
+   * Creates a new PeginManager instance.
+   *
+   * @param config - Manager configuration including wallets and contract addresses
+   */
+  constructor(t) {
+    b(this, "config");
+    this.config = t;
+  }
+  /**
+   * Prepare a peg-in: sizing pass → vault-root derivation (one wallet
+   * popup) → per-vault WOTS / hashlock derivation → commit pass with
+   * batch PSBT signing (one popup). 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(t) {
+    if (t.amounts.length === 0)
+      throw new Error("amounts must contain at least one entry");
+    const n = await this.config.btcWallet.getPublicKeyHex(), s = $(n), o = await this.prepareSizing(s, t), r = o.selectedUTXOs.map(
+      (h) => ({
+        txid: nt(h.txid),
+        vout: h.vout
+      })
+    ), i = await Me(this.config.btcWallet, {
+      depositorBtcPubkey: nt(s),
+      fundingOutpoints: r
+    }), a = await this.expandPerVaultSecrets(i, t.amounts.length), { perVaultWotsKeys: l, wotsPkHashes: u, htlcSecretHexes: c, hashlocks: y } = a, g = await this.preparePeginCommit({
+      depositorBtcPubkeyRaw: n,
+      depositorBtcPubkey: s,
+      hashlocks: y,
+      sizing: o,
+      params: t
+    });
+    for (let h = 0; h < g.perVault.length; h++)
+      if (g.perVault[h].htlcVout !== h)
         throw new Error(
-          `PSBT finalization failed and wallet did not auto-finalize: ${f}`
+          `Internal invariant violation: htlcVout/index mismatch at vault ${h} (expected ${h}, got ${g.perVault[h].htlcVout})`
         );
+    return {
+      transaction: {
+        ...g,
+        selectedUTXOs: o.selectedUTXOs,
+        fee: o.fee,
+        changeAmount: o.changeAmount
+      },
+      depositorBtcPubkey: s,
+      derivedSecrets: {
+        perVaultWotsKeys: l,
+        wotsPkHashes: u,
+        htlcSecretHexes: c
+      }
+    };
+  }
+  /**
+   * Derive per-vault WOTS keys + HTLC preimages from the wallet root.
+   * Takes ownership of `root`: zeros the buffer (and per-vault secret
+   * buffers) before returning, regardless of how the caller exits.
+   */
+  async expandPerVaultSecrets(t, n) {
+    const s = [], o = [], r = [], i = [];
+    try {
+      for (let a = 0; a < n; a++) {
+        const l = $e(t, a);
+        try {
+          const c = await fn(l);
+          s.push(c), o.push(gn(c));
+        } finally {
+          l.fill(0);
+        }
+        const u = Oe(t, a);
+        try {
+          const c = $t(u);
+          r.push(c), i.push(
+            ue(I(c)).slice(2)
+          );
+        } finally {
+          u.fill(0);
+        }
+      }
+    } finally {
+      t.fill(0);
     }
-    const P = E.extractTransaction().toHex();
-    return await pe(P, l);
+    return { perVaultWotsKeys: s, wotsPkHashes: o, htlcSecretHexes: r, hashlocks: i };
   }
   /**
-   * 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()
+   * Build unfunded Pre-PegIn + select UTXOs. No PSBT signing.
    *
-   * The PopSignature must be obtained via
-   * {@link signProofOfPossession} before this call.
-   *
-   * @param params - Registration parameters including the PopSignature
+   * 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.
+   */
+  async prepareSizing(t, n) {
+    const s = n.amounts.map(
+      () => yn
+    ), o = n.vaultKeeperBtcPubkeys.length, r = await bt({
+      depositorPubkey: t,
+      vaultProviderPubkey: _(n.vaultProviderBtcPubkey),
+      vaultKeeperPubkeys: n.vaultKeeperBtcPubkeys.map(_),
+      universalChallengerPubkeys: n.universalChallengerBtcPubkeys.map(_),
+      hashlocks: s,
+      timelockRefund: n.timelockRefund,
+      pegInAmounts: n.amounts,
+      feeRate: n.protocolFeeRate,
+      numLocalChallengers: o,
+      councilQuorum: n.councilQuorum,
+      councilSize: n.councilSize,
+      network: this.config.btcNetwork
+    }), i = pe(
+      [...n.availableUTXOs],
+      r.totalOutputValue,
+      n.mempoolFeeRate,
+      // No auth-anchor OP_RETURN in this PR (deferred to PR5).
+      be(r.htlcValues.length)
+    );
+    return {
+      selectedUTXOs: i.selectedUTXOs,
+      fee: i.fee,
+      changeAmount: i.changeAmount
+    };
+  }
+  /** Build PegIn txs and batch-sign their inputs with real hashlocks. */
+  async preparePeginCommit(t) {
+    const {
+      depositorBtcPubkeyRaw: n,
+      depositorBtcPubkey: s,
+      hashlocks: o,
+      sizing: r,
+      params: i
+    } = t, a = _(i.vaultProviderBtcPubkey), l = i.vaultKeeperBtcPubkeys.map(_), u = i.universalChallengerBtcPubkeys.map(_), c = l.length, y = {
+      depositorPubkey: s,
+      vaultProviderPubkey: a,
+      vaultKeeperPubkeys: l,
+      universalChallengerPubkeys: u,
+      hashlocks: o,
+      timelockRefund: i.timelockRefund,
+      pegInAmounts: i.amounts,
+      feeRate: i.protocolFeeRate,
+      numLocalChallengers: c,
+      councilQuorum: i.councilQuorum,
+      councilSize: i.councilSize,
+      network: this.config.btcNetwork
+    }, g = await bt(y), h = wt(this.config.btcNetwork), p = we({
+      unfundedTxHex: g.psbtHex,
+      selectedUTXOs: r.selectedUTXOs,
+      changeAddress: i.changeAddress,
+      changeAmount: r.changeAmount,
+      network: h
+    }), T = _(q(p)), P = [], v = [], d = [];
+    for (let m = 0; m < o.length; m++) {
+      const w = await oe({
+        prePeginParams: y,
+        timelockPegin: i.timelockPegin,
+        fundedPrePeginTxHex: p,
+        htlcVout: m
+      }), E = await re({
+        peginTxHex: w.txHex,
+        fundedPrePeginTxHex: p,
+        depositorPubkey: s,
+        vaultProviderPubkey: a,
+        vaultKeeperPubkeys: l,
+        universalChallengerPubkeys: u,
+        hashlock: o[m],
+        timelockRefund: i.timelockRefund,
+        network: this.config.btcNetwork
+      });
+      P.push(w), v.push(E.psbtHex), d.push(
+        he(n, 1)
+      );
+    }
+    const x = await this.signPsbtsWithFallback(
+      v,
+      d
+    ), f = [];
+    for (let m = 0; m < x.length; m++) {
+      const w = ie(
+        x[m],
+        s
+      ), E = ae(x[m]);
+      f.push({
+        htlcVout: m,
+        htlcValue: g.htlcValues[m],
+        peginTxHex: E,
+        peginTxid: P[m].txid,
+        peginInputSignature: w,
+        vaultScriptPubKey: P[m].vaultScriptPubKey
+      });
+    }
+    return {
+      fundedPrePeginTxHex: p,
+      prePeginTxid: T,
+      perVault: f
+    };
+  }
+  /**
+   * Signs multiple PSBTs using batch signing if available, falling back to sequential signing.
+   *
+   * Wallets that support native batch signing (e.g. UniSat) will sign all PSBTs
+   * in a single interaction. Others (e.g. Ledger, AppKit) implement signPsbts
+   * by looping signPsbt internally, so the UX depends on the wallet adapter.
+   */
+  async signPsbtsWithFallback(t, n) {
+    if (typeof this.config.btcWallet.signPsbts == "function") {
+      const o = await this.config.btcWallet.signPsbts(
+        t,
+        n
+      );
+      if (o.length !== t.length)
+        throw new Error(
+          `Expected ${t.length} signed PSBTs but received ${o.length}`
+        );
+      return o;
+    }
+    const s = [];
+    for (let o = 0; o < t.length; o++) {
+      const r = await this.config.btcWallet.signPsbt(
+        t[o],
+        n[o]
+      );
+      s.push(r);
+    }
+    return s;
+  }
+  /**
+   * 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
+   *
+   * @param params - Transaction hex and depositor public key
+   * @returns The broadcasted Bitcoin transaction ID
+   * @throws Error if signing or broadcasting fails
+   */
+  async signAndBroadcast(t) {
+    const { fundedPrePeginTxHex: n, depositorBtcPubkey: s } = t, o = n.startsWith("0x") ? n.slice(2) : n, r = ne.fromHex(o);
+    if (r.ins.length === 0)
+      throw new Error("Transaction has no inputs");
+    const i = new ft();
+    i.setVersion(r.version), i.setLocktime(r.locktime);
+    const a = et.from(
+      $(s),
+      "hex"
+    ), l = this.config.mempoolApiUrl, u = r.ins.map((d) => {
+      const x = et.from(d.hash).reverse().toString("hex"), f = d.index;
+      return Pn(x, f, t.localPrevouts, l).then(
+        (m) => ({ input: d, utxoData: m, txid: x, vout: f })
+      );
+    }), c = await Promise.all(u), y = c.reduce(
+      (d, x) => d + BigInt(x.utxoData.value),
+      0n
+    ), g = r.outs.reduce(
+      (d, x) => d + BigInt(x.value),
+      0n
+    );
+    if (y < g)
+      throw new Error(
+        `UTXO value mismatch: total input value (${y} sat) is less than total output value (${g} sat). This may indicate the mempool API returned manipulated UTXO data.`
+      );
+    const h = y - g;
+    if (h > yt)
+      throw new Error(
+        `Implied transaction fee (${h} sat) exceeds maximum reasonable fee (${yt} sat). This may indicate manipulated UTXO data.`
+      );
+    for (const { input: d, utxoData: x, txid: f, vout: m } of c) {
+      const w = me(
+        {
+          value: x.value,
+          scriptPubKey: x.scriptPubKey
+        },
+        a
+      );
+      i.addInput({
+        hash: d.hash,
+        index: d.index,
+        sequence: d.sequence,
+        ...w
+      });
+    }
+    for (const d of r.outs)
+      i.addOutput({
+        script: d.script,
+        value: d.value
+      });
+    const p = await this.config.btcWallet.signPsbt(i.toHex()), T = ft.fromHex(p);
+    try {
+      T.finalizeAllInputs();
+    } catch (d) {
+      if (!T.data.inputs.every(
+        (f) => f.finalScriptWitness || f.finalScriptSig
+      ))
+        throw new Error(
+          `PSBT finalization failed and wallet did not auto-finalize: ${d}`
+        );
+    }
+    const P = T.extractTransaction().toHex();
+    return await ye(P, l);
+  }
+  /**
+   * 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
@@ -394,35 +1013,35 @@ class Cn {
       htlcVout: i,
       depositorPayoutBtcAddress: a,
       depositorWotsPkHash: l,
-      popSignature: h
+      popSignature: u
     } = t;
     if (!this.config.ethWallet.account)
       throw new Error("Ethereum wallet account not found");
     const c = this.config.ethWallet.account.address;
-    if (!ft(h.depositorEthAddress, c))
+    if (!gt(u.depositorEthAddress, c))
       throw new Error(
-        `Proof of possession was signed for ${h.depositorEthAddress} but the Ethereum wallet is currently connected to ${c}. Reconnect the original account or call signProofOfPossession() again.`
+        `Proof of possession was signed for ${u.depositorEthAddress} but the Ethereum wallet is currently connected to ${c}. Reconnect the original account or call signProofOfPossession() again.`
       );
-    await this.assertPopMatchesBtcWallet(h);
-    const b = h.btcPopSignature, m = _(h.depositorBtcPubkey), w = _(n), g = _(s), E = await this.resolvePayoutScriptPubKey(
+    await this.assertPopMatchesBtcWallet(u);
+    const y = u.btcPopSignature, g = I(u.depositorBtcPubkey), h = I(n), p = I(s), T = await this.resolvePayoutScriptPubKey(
       a
-    ), P = G(g), k = await pt(
-      v(P),
-      v(c)
-    ), f = _(k);
-    if (await this.checkVaultExists(f))
+    ), P = q(p), v = await mt(
+      _(P),
+      _(c)
+    ), d = I(v);
+    if (await this.checkVaultExists(d))
       throw new Error(
-        `Vault already exists (ID: ${f}, peginTxHash: ${P}). 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.`
+        `Vault already exists (ID: ${d}, peginTxHash: ${P}). 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 d = j({
+    const f = j({
       chain: this.config.ethChain,
-      transport: q()
+      transport: z()
     });
-    let x;
+    let m;
     try {
-      x = await d.readContract({
+      m = await f.readContract({
         address: this.config.vaultContracts.btcVaultRegistry,
-        abi: S,
+        abi: C,
         functionName: "getPegInFee",
         args: [o]
       });
@@ -431,57 +1050,57 @@ class Cn {
         "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct."
       );
     }
-    const y = gt({
-      abi: S,
+    const w = pt({
+      abi: C,
       functionName: "submitPeginRequest",
       args: [
         c,
-        m,
-        b,
-        w,
         g,
+        y,
+        h,
+        p,
         o,
         r,
         i,
-        E,
+        T,
         l
       ]
     });
-    let I;
+    let E;
     try {
-      I = await d.estimateGas({
+      E = await f.estimateGas({
         to: this.config.vaultContracts.btcVaultRegistry,
-        data: y,
-        value: x,
+        data: w,
+        value: m,
         account: this.config.ethWallet.account.address
       });
-    } catch (K) {
-      A(K);
+    } catch (D) {
+      H(D);
     }
     let B;
     try {
       B = await this.config.ethWallet.sendTransaction({
         to: this.config.vaultContracts.btcVaultRegistry,
-        data: y,
-        value: x,
+        data: w,
+        value: m,
         account: this.config.ethWallet.account,
         chain: this.config.ethChain,
-        gas: I
+        gas: E
       });
-    } catch (K) {
-      A(K);
+    } catch (D) {
+      H(D);
     }
-    const D = await d.waitForTransactionReceipt({
+    const K = await f.waitForTransactionReceipt({
       hash: B,
-      timeout: yt
+      timeout: Ot
     });
-    return D.status === "reverted" && A(
+    return K.status === "reverted" && H(
       new Error(
         `Transaction reverted. Hash: ${B}. Check the transaction on block explorer for details.`
       )
     ), {
-      ethTxHash: D.transactionHash,
-      vaultId: f,
+      ethTxHash: K.transactionHash,
+      vaultId: d,
       peginTxHash: P
     };
   }
@@ -502,750 +1121,219 @@ class Cn {
     if (!this.config.ethWallet.account)
       throw new Error("Ethereum wallet account not found");
     const i = this.config.ethWallet.account.address;
-    if (!ft(r.depositorEthAddress, i))
+    if (!gt(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.`
       );
     await this.assertPopMatchesBtcWallet(r);
     const a = r.btcPopSignature, l = [];
-    for (const d of o)
+    for (const f of o)
       l.push(
-        await this.resolvePayoutScriptPubKey(d.depositorPayoutBtcAddress)
+        await this.resolvePayoutScriptPubKey(f.depositorPayoutBtcAddress)
       );
-    const h = [];
-    for (const d of o) {
-      const x = _(
-        d.depositorSignedPeginTx
-      ), y = G(x), I = await pt(
-        v(y),
-        v(i)
-      ), B = _(I);
+    const u = [];
+    for (const f of o) {
+      const m = I(
+        f.depositorSignedPeginTx
+      ), w = q(m), E = await mt(
+        _(w),
+        _(i)
+      ), B = I(E);
       if (await this.checkVaultExists(B))
-        throw new Error(
-          `Vault already exists (ID: ${B}, peginTxHash: ${y}). To create a new vault, use different UTXOs or a different amount.`
-        );
-      h.push({ vaultId: B, peginTxHash: y });
-    }
-    const c = j({
-      chain: this.config.ethChain,
-      transport: q()
-    });
-    let b;
-    try {
-      b = await c.readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: S,
-        functionName: "getPegInFee",
-        args: [n]
-      });
-    } catch {
-      throw new Error(
-        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct."
-      );
-    }
-    const m = b * BigInt(o.length), w = _(
-      r.depositorBtcPubkey
-    ), g = _(s), E = o.map((d, x) => ({
-      depositorBtcPubKey: w,
-      btcPopSignature: a,
-      unsignedPrePeginTx: g,
-      depositorSignedPeginTx: _(
-        d.depositorSignedPeginTx
-      ),
-      hashlock: d.hashlock,
-      htlcVout: d.htlcVout,
-      referralCode: xe,
-      depositorPayoutBtcAddress: l[x],
-      depositorWotsPkHash: d.depositorWotsPkHash
-    })), P = gt({
-      abi: S,
-      functionName: "submitPeginRequestBatch",
-      args: [i, n, E]
-    });
-    let k;
-    try {
-      k = await c.estimateGas({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: P,
-        value: m,
-        account: this.config.ethWallet.account.address
-      });
-    } catch (d) {
-      A(d);
-    }
-    let f;
-    try {
-      f = await this.config.ethWallet.sendTransaction({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: P,
-        value: m,
-        account: this.config.ethWallet.account,
-        chain: this.config.ethChain,
-        gas: k
-      });
-    } catch (d) {
-      A(d);
-    }
-    const u = await c.waitForTransactionReceipt({
-      hash: f,
-      timeout: yt
-    });
-    return u.status === "reverted" && A(
-      new Error(
-        `Batch transaction reverted. Hash: ${f}. Check the transaction on block explorer for details.`
-      )
-    ), {
-      ethTxHash: u.transactionHash,
-      vaults: h
-    };
-  }
-  /**
-   * Check if a vault already exists for a given vault ID.
-   *
-   * @param vaultId - The Bitcoin transaction hash (vault ID)
-   * @returns True if vault exists, false otherwise
-   */
-  async checkVaultExists(t) {
-    try {
-      return (await j({
-        chain: this.config.ethChain,
-        transport: q()
-      }).readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: S,
-        functionName: "getBtcVaultBasicInfo",
-        args: [t]
-      }))[0] !== te;
-    } catch {
-      return !1;
-    }
-  }
-  /**
-   * Resolve the BTC payout address to a scriptPubKey hex for the contract.
-   *
-   * If a payout address is provided, converts it directly.
-   * If omitted, uses the wallet's address and validates it against the
-   * wallet's public key to guard against a compromised wallet provider.
-   */
-  async resolvePayoutScriptPubKey(t) {
-    let n;
-    if (t)
-      n = t;
-    else {
-      n = await this.config.btcWallet.getAddress();
-      const o = await this.config.btcWallet.getPublicKeyHex();
-      if (!ae(
-        n,
-        o,
-        this.config.btcNetwork
-      ))
-        throw new Error(
-          "The BTC address from your wallet does not match the wallet's public key. Please ensure your wallet is using a supported address type (Taproot or Native SegWit)."
-        );
-    }
-    const s = mt(this.config.btcNetwork);
-    try {
-      return `0x${Jt.address.toOutputScript(n, s).toString("hex")}`;
-    } catch {
-      throw new Error(
-        `Invalid BTC payout address: "${n}". 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 t = this.config.ethWallet.account.address, n = O(
-      await this.config.btcWallet.getPublicKeyHex()
-    ), s = this.config.vaultContracts.btcVaultRegistry, o = `${t.toLowerCase()}:${this.config.ethChain.id}:pegin:${s.toLowerCase()}`, r = await this.config.btcWallet.signMessage(
-      o,
-      "bip322-simple"
-    );
-    return {
-      btcPopSignature: ke(r),
-      depositorEthAddress: t,
-      depositorBtcPubkey: n
-    };
-  }
-  async assertPopMatchesBtcWallet(t) {
-    const n = O(
-      await this.config.btcWallet.getPublicKeyHex()
-    ), s = O(t.depositorBtcPubkey);
-    if (n !== s)
-      throw new Error(
-        `Proof of possession was signed with BTC pubkey ${s} but the BTC wallet is currently connected to ${n}. Reconnect the original wallet or call signProofOfPossession() again.`
-      );
-  }
-  /**
-   * 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 M = /* @__PURE__ */ BigInt(2 ** 32 - 1), xt = /* @__PURE__ */ BigInt(32);
-function Ie(e, t = !1) {
-  return t ? { h: Number(e & M), l: Number(e >> xt & M) } : { h: Number(e >> xt & M) | 0, l: Number(e & M) | 0 };
-}
-function ve(e, t = !1) {
-  const n = e.length;
-  let s = new Uint32Array(n), o = new Uint32Array(n);
-  for (let r = 0; r < n; r++) {
-    const { h: i, l: a } = Ie(e[r], t);
-    [s[r], o[r]] = [i, a];
-  }
-  return [s, o];
-}
-const Be = (e, t, n) => e << n | t >>> 32 - n, Ae = (e, t, n) => t << n | e >>> 32 - n, He = (e, t, n) => t << n - 32 | e >>> 64 - n, Ce = (e, t, n) => e << n - 32 | t >>> 64 - n, Se = /* @__PURE__ */ Uint8Array.from([
-  7,
-  4,
-  13,
-  1,
-  10,
-  6,
-  15,
-  3,
-  12,
-  0,
-  9,
-  5,
-  2,
-  14,
-  11,
-  8
-]), $t = Uint8Array.from(new Array(16).fill(0).map((e, t) => t)), Oe = $t.map((e) => (9 * e + 5) % 16), Rt = /* @__PURE__ */ (() => {
-  const n = [[$t], [Oe]];
-  for (let s = 0; s < 4; s++)
-    for (let o of n)
-      o.push(o[s].map((r) => Se[r]));
-  return n;
-})(), Ut = Rt[0], Lt = Rt[1], Wt = /* @__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((e) => Uint8Array.from(e)), $e = /* @__PURE__ */ Ut.map((e, t) => e.map((n) => Wt[t][n])), Re = /* @__PURE__ */ Lt.map((e, t) => e.map((n) => Wt[t][n])), Ue = /* @__PURE__ */ Uint32Array.from([
-  0,
-  1518500249,
-  1859775393,
-  2400959708,
-  2840853838
-]), Le = /* @__PURE__ */ Uint32Array.from([
-  1352829926,
-  1548603684,
-  1836072691,
-  2053994217,
-  0
-]);
-function Pt(e, t, n, s) {
-  return e === 0 ? t ^ n ^ s : e === 1 ? t & n | ~t & s : e === 2 ? (t | ~n) ^ s : e === 3 ? t & s | n & ~s : t ^ (n | ~s);
-}
-const N = /* @__PURE__ */ new Uint32Array(16);
-class We extends be {
-  constructor() {
-    super(64, 20, 8, !0);
-    p(this, "h0", 1732584193);
-    p(this, "h1", -271733879);
-    p(this, "h2", -1732584194);
-    p(this, "h3", 271733878);
-    p(this, "h4", -1009589776);
-  }
-  get() {
-    const { h0: n, h1: s, h2: o, h3: r, h4: i } = this;
-    return [n, s, o, r, i];
-  }
-  set(n, s, o, r, i) {
-    this.h0 = n | 0, this.h1 = s | 0, this.h2 = o | 0, this.h3 = r | 0, this.h4 = i | 0;
-  }
-  process(n, s) {
-    for (let g = 0; g < 16; g++, s += 4)
-      N[g] = n.getUint32(s, !0);
-    let o = this.h0 | 0, r = o, i = this.h1 | 0, a = i, l = this.h2 | 0, h = l, c = this.h3 | 0, b = c, m = this.h4 | 0, w = m;
-    for (let g = 0; g < 5; g++) {
-      const E = 4 - g, P = Ue[g], k = Le[g], f = Ut[g], u = Lt[g], d = $e[g], x = Re[g];
-      for (let y = 0; y < 16; y++) {
-        const I = W(o + Pt(g, i, l, c) + N[f[y]] + P, d[y]) + m | 0;
-        o = m, m = c, c = W(l, 10) | 0, l = i, i = I;
-      }
-      for (let y = 0; y < 16; y++) {
-        const I = W(r + Pt(E, a, h, b) + N[u[y]] + k, x[y]) + w | 0;
-        r = w, w = b, b = W(h, 10) | 0, h = a, a = I;
-      }
-    }
-    this.set(this.h1 + l + b | 0, this.h2 + c + w | 0, this.h3 + m + r | 0, this.h4 + o + a | 0, this.h0 + i + h | 0);
-  }
-  roundClean() {
-    H(N);
-  }
-  destroy() {
-    this.destroyed = !0, H(this.buffer), this.set(0, 0, 0, 0, 0);
-  }
-}
-const Me = /* @__PURE__ */ St(() => new We()), Ne = BigInt(0), $ = BigInt(1), Ve = BigInt(2), Fe = BigInt(7), Xe = BigInt(256), De = BigInt(113), Mt = [], Nt = [], Vt = [];
-for (let e = 0, t = $, n = 1, s = 0; e < 24; e++) {
-  [n, s] = [s, (2 * n + 3 * s) % 5], Mt.push(2 * (5 * s + n)), Nt.push((e + 1) * (e + 2) / 2 % 64);
-  let o = Ne;
-  for (let r = 0; r < 7; r++)
-    t = (t << $ ^ (t >> Fe) * De) % Xe, t & Ve && (o ^= $ << ($ << BigInt(r)) - $);
-  Vt.push(o);
-}
-const Ft = ve(Vt, !0), Ke = Ft[0], je = Ft[1], Et = (e, t, n) => n > 32 ? He(e, t, n) : Be(e, t, n), Tt = (e, t, n) => n > 32 ? Ce(e, t, n) : Ae(e, t, n);
-function qe(e, t = 24) {
-  const n = new Uint32Array(10);
-  for (let s = 24 - t; s < 24; s++) {
-    for (let i = 0; i < 10; i++)
-      n[i] = e[i] ^ e[i + 10] ^ e[i + 20] ^ e[i + 30] ^ e[i + 40];
-    for (let i = 0; i < 10; i += 2) {
-      const a = (i + 8) % 10, l = (i + 2) % 10, h = n[l], c = n[l + 1], b = Et(h, c, 1) ^ n[a], m = Tt(h, c, 1) ^ n[a + 1];
-      for (let w = 0; w < 50; w += 10)
-        e[i + w] ^= b, e[i + w + 1] ^= m;
-    }
-    let o = e[2], r = e[3];
-    for (let i = 0; i < 24; i++) {
-      const a = Nt[i], l = Et(o, r, a), h = Tt(o, r, a), c = Mt[i];
-      o = e[c], r = e[c + 1], e[c] = l, e[c + 1] = h;
-    }
-    for (let i = 0; i < 50; i += 10) {
-      for (let a = 0; a < 10; a++)
-        n[a] = e[i + a];
-      for (let a = 0; a < 10; a++)
-        e[i + a] ^= ~n[(a + 2) % 10] & n[(a + 4) % 10];
-    }
-    e[0] ^= Ke[s], e[1] ^= je[s];
-  }
-  H(n);
-}
-class at {
-  // NOTE: we accept arguments in bytes instead of bits here.
-  constructor(t, n, s, o = !1, r = 24) {
-    p(this, "state");
-    p(this, "pos", 0);
-    p(this, "posOut", 0);
-    p(this, "finished", !1);
-    p(this, "state32");
-    p(this, "destroyed", !1);
-    p(this, "blockLen");
-    p(this, "suffix");
-    p(this, "outputLen");
-    p(this, "enableXOF", !1);
-    p(this, "rounds");
-    if (this.blockLen = t, this.suffix = n, this.outputLen = s, this.enableXOF = o, this.rounds = r, nt(s, "outputLen"), !(0 < t && t < 200))
-      throw new Error("only keccak-f1600 function is supported");
-    this.state = new Uint8Array(200), this.state32 = we(this.state);
-  }
-  clone() {
-    return this._cloneInto();
-  }
-  keccak() {
-    wt(this.state32), qe(this.state32, this.rounds), wt(this.state32), this.posOut = 0, this.pos = 0;
-  }
-  update(t) {
-    F(this), U(t);
-    const { blockLen: n, state: s } = this, o = t.length;
-    for (let r = 0; r < o; ) {
-      const i = Math.min(n - this.pos, o - r);
-      for (let a = 0; a < i; a++)
-        s[this.pos++] ^= t[r++];
-      this.pos === n && this.keccak();
-    }
-    return this;
-  }
-  finish() {
-    if (this.finished)
-      return;
-    this.finished = !0;
-    const { state: t, suffix: n, pos: s, blockLen: o } = this;
-    t[s] ^= n, (n & 128) !== 0 && s === o - 1 && this.keccak(), t[o - 1] ^= 128, this.keccak();
-  }
-  writeInto(t) {
-    F(this, !1), U(t), this.finish();
-    const n = this.state, { blockLen: s } = this;
-    for (let o = 0, r = t.length; o < r; ) {
-      this.posOut >= s && this.keccak();
-      const i = Math.min(s - this.posOut, r - o);
-      t.set(n.subarray(this.posOut, this.posOut + i), o), this.posOut += i, o += i;
-    }
-    return t;
-  }
-  xofInto(t) {
-    if (!this.enableXOF)
-      throw new Error("XOF is not possible for this instance");
-    return this.writeInto(t);
-  }
-  xof(t) {
-    return nt(t), this.xofInto(new Uint8Array(t));
-  }
-  digestInto(t) {
-    if (ye(t, this), this.finished)
-      throw new Error("digest() was already called");
-    return this.writeInto(t), this.destroy(), t;
-  }
-  digest() {
-    return this.digestInto(new Uint8Array(this.outputLen));
-  }
-  destroy() {
-    this.destroyed = !0, H(this.state);
-  }
-  _cloneInto(t) {
-    const { blockLen: n, suffix: s, outputLen: o, rounds: r, enableXOF: i } = this;
-    return t || (t = new at(n, s, o, i, r)), t.state32.set(this.state32), t.pos = this.pos, t.posOut = this.posOut, t.finished = this.finished, t.rounds = r, t.suffix = s, t.outputLen = o, t.enableXOF = i, t.destroyed = this.destroyed, t;
-  }
-}
-const Ge = (e, t, n, s = {}) => St(() => new at(t, e, n), s), Ze = /* @__PURE__ */ Ge(1, 136, 32), kt = 64, T = 20, st = 4, Xt = 2, ze = 0, Ye = 1, V = [64, 64], Je = (e) => Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("");
-function ct(e) {
-  return Me(L(e));
-}
-function Dt(e) {
-  return (1 << e) - 1;
-}
-function Qe(e) {
-  let t = 1;
-  for (; t * t < e + 1; ) t++;
-  return Math.max(t, 2);
-}
-function tn(e) {
-  const t = st, n = e * Dt(t);
-  return { d: t, n: e, checksum_radix: Qe(n) };
-}
-function Z(e, t) {
-  const n = [];
-  let s = t;
-  for (; s > 0; )
-    n.push(s & 255), s >>>= 8;
-  const o = new Uint8Array(e.length + n.length);
-  o.set(e);
-  for (let r = 0; r < n.length; r++)
-    o[e.length + r] = n[r];
-  return ct(o);
-}
-function z(e, t) {
-  let n = e;
-  for (let s = 0; s < t; s++)
-    n = ct(n);
-  return n;
-}
-function en(e, t) {
-  const n = Dt(t.d), s = t.checksum_radix - 1, o = Math.floor(t.n * n / t.checksum_radix), r = [];
-  for (let c = 0; c < t.n; c++) {
-    const b = Z(e, c + Xt), m = z(b, n);
-    r.push(Array.from(m));
-  }
-  const i = Z(
-    e,
-    ze
-  ), a = z(
-    i,
-    s
-  ), l = Z(
-    e,
-    Ye
-  ), h = z(
-    l,
-    o
-  );
-  return {
-    config: t,
-    message_terminals: r,
-    checksum_major_terminal: Array.from(h),
-    checksum_minor_terminal: Array.from(a)
-  };
-}
-async function Sn(e) {
-  try {
-    if (e.length !== kt)
-      throw new Error(
-        `WOTS seed must be exactly ${kt} bytes, got ${e.length}`
-      );
-    const t = [];
-    for (let n = 0; n < V.length; n++) {
-      const s = V[n], o = tn(s), r = new Uint8Array(e.length + 1);
-      r.set(e), r[e.length] = n;
-      const i = ct(r);
-      try {
-        const a = en(i, o);
-        if (a.config.d !== st)
-          throw new Error(
-            `Block ${n}: expected d=${st}, got d=${a.config.d}`
-          );
-        if (a.config.n !== s)
-          throw new Error(
-            `Block ${n}: expected n=${s}, got n=${a.config.n}`
-          );
-        if (a.message_terminals.length !== s)
-          throw new Error(
-            `Block ${n}: expected ${s} message terminals, got ${a.message_terminals.length}`
-          );
-        for (let l = 0; l < a.message_terminals.length; l++)
-          if (a.message_terminals[l].length !== T)
-            throw new Error(
-              `Block ${n} terminal ${l}: expected ${T} bytes, got ${a.message_terminals[l].length}`
-            );
-        if (a.checksum_minor_terminal.length !== T)
-          throw new Error(
-            `Block ${n} checksum_minor: expected ${T} bytes`
-          );
-        if (a.checksum_major_terminal.length !== T)
-          throw new Error(
-            `Block ${n} checksum_major: expected ${T} bytes`
-          );
-        t.push(a);
-      } finally {
-        r.fill(0), i.fill(0);
-      }
+        throw new Error(
+          `Vault already exists (ID: ${B}, peginTxHash: ${w}). To create a new vault, use different UTXOs or a different amount.`
+        );
+      u.push({ vaultId: B, peginTxHash: w });
     }
-    if (t.length !== V.length)
+    const c = j({
+      chain: this.config.ethChain,
+      transport: z()
+    });
+    let y;
+    try {
+      y = await c.readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: C,
+        functionName: "getPegInFee",
+        args: [n]
+      });
+    } catch {
       throw new Error(
-        `Expected ${V.length} blocks, got ${t.length}`
+        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct."
       );
-    return t;
-  } finally {
-    e.fill(0);
+    }
+    const g = y * BigInt(o.length), h = I(
+      r.depositorBtcPubkey
+    ), p = I(s), T = o.map((f, m) => ({
+      depositorBtcPubKey: h,
+      btcPopSignature: a,
+      unsignedPrePeginTx: p,
+      depositorSignedPeginTx: I(
+        f.depositorSignedPeginTx
+      ),
+      hashlock: f.hashlock,
+      htlcVout: f.htlcVout,
+      referralCode: pn,
+      depositorPayoutBtcAddress: l[m],
+      depositorWotsPkHash: f.depositorWotsPkHash
+    })), P = pt({
+      abi: C,
+      functionName: "submitPeginRequestBatch",
+      args: [i, n, T]
+    });
+    let v;
+    try {
+      v = await c.estimateGas({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: P,
+        value: g,
+        account: this.config.ethWallet.account.address
+      });
+    } catch (f) {
+      H(f);
+    }
+    let d;
+    try {
+      d = await this.config.ethWallet.sendTransaction({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: P,
+        value: g,
+        account: this.config.ethWallet.account,
+        chain: this.config.ethChain,
+        gas: v
+      });
+    } catch (f) {
+      H(f);
+    }
+    const x = await c.waitForTransactionReceipt({
+      hash: d,
+      timeout: Ot
+    });
+    return x.status === "reverted" && H(
+      new Error(
+        `Batch transaction reverted. Hash: ${d}. Check the transaction on block explorer for details.`
+      )
+    ), {
+      ethTxHash: x.transactionHash,
+      vaults: u
+    };
   }
-}
-function Y(e, t, n) {
-  if (e.length !== T)
-    throw new Error(
-      `Block ${t} ${n}: expected ${T} bytes, got ${e.length}`
-    );
-  for (let s = 0; s < e.length; s++) {
-    const o = e[s];
-    if (!Number.isInteger(o) || o < 0 || o > 255)
+  /**
+   * Check if a vault already exists for a given vault ID.
+   *
+   * @param vaultId - The Bitcoin transaction hash (vault ID)
+   * @returns True if vault exists, false otherwise
+   */
+  async checkVaultExists(t) {
+    try {
+      return (await j({
+        chain: this.config.ethChain,
+        transport: z()
+      }).readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: C,
+        functionName: "getBtcVaultBasicInfo",
+        args: [t]
+      })).depositor !== se;
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Resolve the BTC payout address to a scriptPubKey hex for the contract.
+   *
+   * If a payout address is provided, converts it directly.
+   * If omitted, uses the wallet's address and validates it against the
+   * wallet's public key to guard against a compromised wallet provider.
+   */
+  async resolvePayoutScriptPubKey(t) {
+    let n;
+    if (t)
+      n = t;
+    else {
+      n = await this.config.btcWallet.getAddress();
+      const o = await this.config.btcWallet.getPublicKeyHex();
+      if (!ce(
+        n,
+        o,
+        this.config.btcNetwork
+      ))
+        throw new Error(
+          "The BTC address from your wallet does not match the wallet's public key. Please ensure your wallet is using a supported address type (Taproot or Native SegWit)."
+        );
+    }
+    const s = wt(this.config.btcNetwork);
+    try {
+      return `0x${ee.address.toOutputScript(n, s).toString("hex")}`;
+    } catch {
       throw new Error(
-        `Block ${t} ${n}[${s}]: invalid byte value ${o}`
+        `Invalid BTC payout address: "${n}". Please provide a valid Bitcoin address for the ${this.config.btcNetwork} network.`
       );
+    }
   }
-}
-function On(e) {
-  if (e.length === 0)
-    throw new Error("Public keys array must not be empty");
-  for (let r = 0; r < e.length; r++) {
-    const i = e[r];
-    Y(i.checksum_minor_terminal, r, "checksum_minor_terminal"), Y(i.checksum_major_terminal, r, "checksum_major_terminal");
-    for (let a = 0; a < i.message_terminals.length; a++)
-      Y(i.message_terminals[a], r, `message_terminal[${a}]`);
-  }
-  let t = 0;
-  for (const r of e)
-    t += Xt + r.message_terminals.length;
-  const n = new Uint8Array(t * T);
-  let s = 0;
-  for (const r of e) {
-    n.set(r.checksum_minor_terminal, s), s += T, n.set(r.checksum_major_terminal, s), s += T;
-    for (const i of r.message_terminals)
-      n.set(i, s), s += T;
-  }
-  const o = Ze(n);
-  return `0x${Je(o)}`;
-}
-function $n(e) {
-  const t = (e instanceof Error ? e.message : typeof e == "string" ? e : "").toLowerCase();
-  return t.includes("wots") && t.includes("hash") && t.includes("does not match");
-}
-class Kt {
-  constructor(t, n) {
-    p(this, "oHash");
-    p(this, "iHash");
-    p(this, "blockLen");
-    p(this, "outputLen");
-    p(this, "finished", !1);
-    p(this, "destroyed", !1);
-    if (Ot(t), U(n, void 0, "key"), this.iHash = t.create(), typeof this.iHash.update != "function")
-      throw new Error("Expected instance of class which extends utils.Hash");
-    this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
-    const s = this.blockLen, o = new Uint8Array(s);
-    o.set(n.length > s ? t.create().update(n).digest() : n);
-    for (let r = 0; r < o.length; r++)
-      o[r] ^= 54;
-    this.iHash.update(o), this.oHash = t.create();
-    for (let r = 0; r < o.length; r++)
-      o[r] ^= 106;
-    this.oHash.update(o), H(o);
-  }
-  update(t) {
-    return F(this), this.iHash.update(t), this;
-  }
-  digestInto(t) {
-    F(this), U(t, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
-  }
-  digest() {
-    const t = new Uint8Array(this.oHash.outputLen);
-    return this.digestInto(t), t;
+  /**
+   * 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 t = this.config.ethWallet.account.address, n = $(
+      await this.config.btcWallet.getPublicKeyHex()
+    ), s = this.config.vaultContracts.btcVaultRegistry, o = `${t.toLowerCase()}:${this.config.ethChain.id}:pegin:${s.toLowerCase()}`, r = await this.config.btcWallet.signMessage(
+      o,
+      "bip322-simple"
+    );
+    return {
+      btcPopSignature: xn(r),
+      depositorEthAddress: t,
+      depositorBtcPubkey: n
+    };
   }
-  _cloneInto(t) {
-    t || (t = Object.create(Object.getPrototypeOf(this), {}));
-    const { oHash: n, iHash: s, finished: o, destroyed: r, blockLen: i, outputLen: a } = this;
-    return t = t, t.finished = o, t.destroyed = r, t.blockLen = i, t.outputLen = a, t.oHash = n._cloneInto(t.oHash), t.iHash = s._cloneInto(t.iHash), t;
+  async assertPopMatchesBtcWallet(t) {
+    const n = $(
+      await this.config.btcWallet.getPublicKeyHex()
+    ), s = $(t.depositorBtcPubkey);
+    if (n !== s)
+      throw new Error(
+        `Proof of possession was signed with BTC pubkey ${s} but the BTC wallet is currently connected to ${n}. Reconnect the original wallet or call signProofOfPossession() again.`
+      );
   }
-  clone() {
-    return this._cloneInto();
+  /**
+   * Gets the configured Bitcoin network.
+   *
+   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
+   */
+  getNetwork() {
+    return this.config.btcNetwork;
   }
-  destroy() {
-    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  /**
+   * Gets the configured BTCVaultRegistry contract address.
+   *
+   * @returns The Ethereum address of the BTCVaultRegistry contract
+   */
+  getVaultContractAddress() {
+    return this.config.vaultContracts.btcVaultRegistry;
   }
 }
-const jt = (e, t, n) => new Kt(e, t).update(n).digest();
-jt.create = (e, t) => new Kt(e, t);
-const J = /* @__PURE__ */ Uint8Array.of(0), _t = /* @__PURE__ */ Uint8Array.of();
-function lt(e, t, n, s = 32) {
-  Ot(e), nt(s, "length");
-  const o = e.outputLen;
-  if (s > 255 * o)
-    throw new Error("Length must be <= 255*HashLen");
-  const r = Math.ceil(s / o);
-  n === void 0 ? n = _t : U(n, void 0, "info");
-  const i = new Uint8Array(r * o), a = jt.create(e, t), l = a._cloneInto(), h = new Uint8Array(a.outputLen);
-  for (let c = 0; c < r; c++)
-    J[0] = c + 1, l.update(c === 0 ? _t : h).update(n).update(J).digestInto(h), i.set(h, o * c), a._cloneInto(l);
-  return a.destroy(), l.destroy(), H(h, J), i.slice(0, s);
-}
-const Q = new TextEncoder().encode("babylonvault"), It = 255, vt = 65535, Bt = 2, nn = "hashlock", sn = "auth-anchor", on = "wots-seed";
-function qt(e) {
-  if (!Number.isInteger(e) || e < 0 || e > 4294967295)
-    throw new Error(`i2osp4: value must be a u32, got ${e}`);
-  const t = new Uint8Array(4);
-  return t[0] = e >>> 24 & 255, t[1] = e >>> 16 & 255, t[2] = e >>> 8 & 255, t[3] = e & 255, t;
-}
-function ht(e, t = new Uint8Array(0)) {
-  const n = new TextEncoder().encode(e);
-  if (n.length === 0 || n.length > It)
-    throw new Error(
-      `info: label length must be in [1, ${It}], got ${n.length}`
-    );
-  if (t.length > vt)
-    throw new Error(
-      `info: ctx length must be in [0, ${vt}], got ${t.length}`
-    );
-  const s = Q.length + 1 + n.length + Bt + t.length, o = new Uint8Array(s);
-  let r = 0;
-  return o.set(Q, r), r += Q.length, o[r] = n.length, r += 1, o.set(n, r), r += n.length, o[r] = t.length >>> 8 & 255, o[r + 1] = t.length & 255, r += Bt, o.set(t, r), o;
-}
-const At = 32, rn = 32, an = 32, cn = 64;
-function ut(e) {
-  if (e.length !== At)
-    throw new Error(
-      `vault-secrets: root must be exactly ${At} bytes, got ${e.length}`
-    );
-}
-function Rn(e) {
-  return ut(e), lt(
-    L,
-    e,
-    ht(sn),
-    rn
-  );
-}
-function Un(e, t) {
-  return ut(e), lt(
-    L,
-    e,
-    ht(nn, qt(t)),
-    an
-  );
-}
-function Ln(e, t) {
-  return ut(e), lt(
-    L,
-    e,
-    ht(on, qt(t)),
-    cn
-  );
-}
-const R = 32, tt = 32, ot = 36, Gt = 32, X = 4, ln = X + R + X + Gt;
-function rt(e, t, n) {
-  e[t] = n >>> 24 & 255, e[t + 1] = n >>> 16 & 255, e[t + 2] = n >>> 8 & 255, e[t + 3] = n & 255;
-}
-function hn(e) {
-  if (e.txid.length !== tt)
-    throw new Error(
-      `outpoint.txid must be exactly ${tt} bytes, got ${e.txid.length}`
-    );
-  if (!Number.isInteger(e.vout) || e.vout < 0 || e.vout > 4294967295)
-    throw new Error(`outpoint.vout must be a u32, got ${e.vout}`);
-  const t = new Uint8Array(ot);
-  return t.set(e.txid, 0), rt(t, tt, e.vout), t;
-}
-function Ht(e, t) {
-  const n = Math.min(e.length, t.length);
-  for (let s = 0; s < n; s++)
-    if (e[s] !== t[s]) return e[s] - t[s];
-  return e.length - t.length;
-}
-function un(e) {
-  if (e.length === 0)
-    throw new Error(
-      "buildFundingOutpointsCommitment: outpoints must be non-empty"
-    );
-  const t = e.map(hn);
-  t.sort(Ht);
-  for (let s = 1; s < t.length; s++)
-    if (Ht(t[s - 1], t[s]) === 0)
-      throw new Error(
-        "buildFundingOutpointsCommitment: duplicate outpoint detected"
-      );
-  const n = new Uint8Array(t.length * ot);
-  for (let s = 0; s < t.length; s++)
-    n.set(t[s], s * ot);
-  return L(n);
-}
-function dn(e) {
-  if (e.depositorBtcPubkey.length !== R)
-    throw new Error(
-      `vaultContext: depositorBtcPubkey must be exactly ${R} bytes, got ${e.depositorBtcPubkey.length}`
-    );
-  const t = un(e.fundingOutpoints), n = new Uint8Array(ln);
-  let s = 0;
-  return rt(n, s, R), s += X, n.set(e.depositorBtcPubkey, s), s += R, rt(n, s, Gt), s += X, n.set(t, s), n;
-}
-const fn = "babylon-vault", Zt = 32, Ct = Zt * 2, gn = /^[0-9a-f]+$/;
-async function Wn(e, t) {
-  const n = dn(t), s = le(n), o = await e.deriveContextHash(fn, s);
-  if (typeof o != "string")
-    throw new Error(
-      `deriveVaultRoot: wallet must return a string, got ${typeof o}`
-    );
-  if (o.length !== Ct)
-    throw new Error(
-      `deriveVaultRoot: wallet must return a ${Ct}-character hex string (${Zt} bytes), got length ${o.length}`
-    );
-  if (!gn.test(o))
-    throw new Error(
-      "deriveVaultRoot: wallet must return lowercase hex per derive-context-hash.md §2.1; got value with non-lowercase or non-hex characters"
-    );
-  return he(o);
-}
 export {
-  C,
-  Cn as P,
-  fn as V,
-  $n as a,
-  Rn as b,
-  On as c,
-  Sn as d,
-  it as e,
-  Un as f,
-  An as g,
-  A as h,
-  Hn as i,
-  Ln as j,
-  un as k,
-  dn as l,
-  Wn as m
+  S as C,
+  Mn as P,
+  We as V,
+  Nn as a,
+  Wn as b,
+  gn as c,
+  fn as d,
+  at as e,
+  Oe as f,
+  Ln as g,
+  H as h,
+  Vn as i,
+  $e as j,
+  Le as k,
+  Ve as l,
+  Me as m
 };
-//# sourceMappingURL=deriveVaultRoot-DAMZDqg-.js.map
+//# sourceMappingURL=PeginManager-DzMSIQ0I.js.map