@babylonlabs-io/ts-sdk 0.68.1 → 0.69.1

package/dist/{PeginManager-Bsv6caG3.js → PeginManager-BI3pacy0.js}

@@ -1,43 +1,43 @@
-var Gt = Object.defineProperty;
-var qt = (s, t, e) => t in s ? Gt(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
-var x = (s, t, e) => qt(s, typeof t != "symbol" ? t + "" : t, e);
-import { c as _t, H as Yt, r as W, a as K, b as at, u as zt, d as ct, e as lt, f as ut, g as jt, s as Bt } from "./sha2-BYVxyZzX.js";
-import * as At from "bitcoinjs-lib";
-import { Transaction as Ct, Psbt as ht } from "bitcoinjs-lib";
+var Ge = Object.defineProperty;
+var qe = (s, e, t) => e in s ? Ge(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var x = (s, e, t) => qe(s, typeof e != "symbol" ? e + "" : e, t);
+import { c as _e, H as Ye, r as W, a as K, b as ae, u as ze, d as ce, e as le, f as ue, g as je, s as Se } from "./sha2-BYVxyZzX.js";
+import * as Ce from "bitcoinjs-lib";
+import { Transaction as Ae, Psbt as he } from "bitcoinjs-lib";
 import { Buffer as O } from "buffer";
-import { isAddressEqual as dt, encodeFunctionData as tt, zeroAddress as Qt } from "viem";
+import { isAddressEqual as de, encodeFunctionData as ee, zeroAddress as Qe } from "viem";
 import { B as H } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
 import { h as R } from "./errors-Blc-JWnI.js";
-import { expandWotsSeed as Zt, expandHashlockSecret as Jt, expandAuthAnchor as te, deriveVaultId as ft } from "@babylonlabs-io/babylon-tbv-rust-wasm";
-import { a as pt, b as ee, f as gt, g as se } from "./verifyScriptPathSchnorrSignature-Dy9gF5RF.js";
-import { d as oe, b as ne, e as re, f as ie, c as ae } from "./verifyKeyPathSchnorrSignature-C6Cmk0R1.js";
-import { p as ce, h as et, u as st, e as C, i as mt, s as S, k as wt, X as le } from "./bitcoin-Ch_jxnDa.js";
-import { c as ue } from "./signing-DaLvGwQe.js";
-import { M as bt } from "./validation-Dj3dqYtl.js";
-import { p as he, d as It } from "./parseFundingOutpoints-CO-f6IHK.js";
-import { c as de, s as U, r as fe, b as pe, d as ge } from "./signPsbtsWithFallback-Bv79gLFe.js";
-import { s as me, f as q, i as we, w as Pt } from "./waitForTransactionReceiptSmartAware-lobLm0q0.js";
-import { p as be, f as Pe } from "./fundPeginTransaction-B2wyjqp0.js";
-import { M as X, B as ye } from "./constants-GjWXdaqV.js";
-import { l as xe, P as ke, m as Ee, n as Te, p as ve, V as Se, i as _e } from "./mempoolApi-71R_CNZa.js";
-import * as Be from "@bitcoin-js/tiny-secp256k1-asmjs";
-const N = /* @__PURE__ */ BigInt(2 ** 32 - 1), yt = /* @__PURE__ */ BigInt(32);
-function Ae(s, t = !1) {
-  return t ? { h: Number(s & N), l: Number(s >> yt & N) } : { h: Number(s >> yt & N) | 0, l: Number(s & N) | 0 };
+import { expandWotsSeed as Ze, expandHashlockSecret as Je, expandAuthAnchor as et, deriveVaultId as pe } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import { a as fe, b as tt, f as ge, g as st } from "./verifyScriptPathSchnorrSignature-Dy9gF5RF.js";
+import { d as ot, b as nt, e as rt, f as it, c as at } from "./verifyKeyPathSchnorrSignature-C6Cmk0R1.js";
+import { p as ct, h as te, u as se, e as A, i as me, s as k, k as Pe, X as lt } from "./bitcoin-Ch_jxnDa.js";
+import { c as ut } from "./signing-DaLvGwQe.js";
+import { M as be } from "./validation-Dj3dqYtl.js";
+import { p as ht, d as Ie } from "./parseFundingOutpoints-CO-f6IHK.js";
+import { c as dt, s as F, r as pt, b as ft, d as gt } from "./signPsbtsWithFallback-DCZO2h6i.js";
+import { s as mt, f as q, i as Pt, w as we } from "./waitForTransactionReceiptSmartAware-B6oYRdFO.js";
+import { p as bt, f as wt } from "./fundPeginTransaction-B2wyjqp0.js";
+import { M as X, B as yt } from "./constants-GjWXdaqV.js";
+import { l as xt, P as kt, m as Et, n as Tt, p as vt, V as Bt, i as _t } from "./mempoolApi-71R_CNZa.js";
+import * as St from "@bitcoin-js/tiny-secp256k1-asmjs";
+const D = /* @__PURE__ */ BigInt(2 ** 32 - 1), ye = /* @__PURE__ */ BigInt(32);
+function Ct(s, e = !1) {
+  return e ? { h: Number(s & D), l: Number(s >> ye & D) } : { h: Number(s >> ye & D) | 0, l: Number(s & D) | 0 };
 }
-function Ce(s, t = !1) {
-  const e = s.length;
-  let o = new Uint32Array(e), i = new Uint32Array(e);
-  for (let n = 0; n < e; n++) {
-    const { h: r, l: a } = Ae(s[n], t);
+function At(s, e = !1) {
+  const t = s.length;
+  let o = new Uint32Array(t), i = new Uint32Array(t);
+  for (let n = 0; n < t; n++) {
+    const { h: r, l: a } = Ct(s[n], e);
     [o[n], i[n]] = [r, a];
   }
   return [o, i];
 }
-const Ie = (s, t, e) => s << e | t >>> 32 - e, He = (s, t, e) => t << e | s >>> 32 - e, Re = (s, t, e) => t << e - 32 | s >>> 64 - e, $e = (s, t, e) => s << e - 32 | t >>> 64 - e, Oe = 64;
-function Ve(s) {
-  const t = s.prepeginTxid.toLowerCase();
-  if (!/^[0-9a-f]+$/.test(t) || t.length !== Oe)
+const It = (s, e, t) => s << t | e >>> 32 - t, Ht = (s, e, t) => e << t | s >>> 32 - t, Rt = (s, e, t) => e << t - 32 | s >>> 64 - t, $t = (s, e, t) => s << t - 32 | e >>> 64 - t, Ot = 64;
+function Vt(s) {
+  const e = s.prepeginTxid.toLowerCase();
+  if (!/^[0-9a-f]+$/.test(e) || e.length !== Ot)
     throw new Error(
       `buildDepositTerms: prepeginTxid must be 64 hex chars, got "${s.prepeginTxid}"`
     );
@@ -49,7 +49,7 @@ function Ve(s) {
     throw new Error(
       `buildDepositTerms: maxAcceptableCommissionBps must be an integer in [0, ${X}), got ${s.maxAcceptableCommissionBps}`
     );
-  const e = BigInt(ye), o = s.peginAmounts.map(
+  const t = BigInt(yt), o = s.peginAmounts.map(
     (i, n) => ({
       htlcVout: n,
       vaultProviderBtcPubkey: s.vaultProviderBtcPubkey,
@@ -58,7 +58,7 @@ function Ve(s) {
       // the same bound the registration calldata enforces on-chain, so any
       // stamped commission the contract admits stays under it (firmware
       // >= c8db53e checks the payout commission output <= this value).
-      commissionFee: i * BigInt(s.maxAcceptableCommissionBps) / e,
+      commissionFee: i * BigInt(s.maxAcceptableCommissionBps) / t,
       depositorClaimValue: s.depositorClaimValue,
       peginMaxFee: s.peginMaxFee
     })
@@ -69,90 +69,91 @@ function Ve(s) {
     timelockPegin: s.timelockPegin,
     timelockAssert: s.timelockAssert,
     timelockRefund: s.timelockRefund,
-    prepeginTxid: t,
+    prepeginTxid: e,
     prepeginMaxFee: s.prepeginMaxFee,
     vaultKeeperBtcPubkeys: [...s.vaultKeeperBtcPubkeys],
     universalChallengerBtcPubkeys: [...s.universalChallengerBtcPubkeys],
     vaults: o
   };
 }
-const ot = 25, Ht = 9999;
+const oe = 25, He = 9999;
 function Y(s) {
   if (!Number.isInteger(s) || s < 0 || s >= X)
     throw new Error(
       `Quoted commissionBps must be an integer in [0, ${X}), got ${s}`
     );
   return Math.min(
-    s + ot,
-    Ht
+    s + oe,
+    He
   );
 }
-const Me = /^0x[0-9a-f]+$/i, We = /^[0-9a-f]+$/i, Ue = /^[A-Za-z0-9+/]+={0,2}$/;
+const Ft = /^0x[0-9a-f]+$/i, Mt = /^[0-9a-f]+$/i, Wt = /^[A-Za-z0-9+/]+={0,2}$/;
 function $(s) {
   if (typeof s != "string" || s.length === 0)
     throw new Error("BTC wallet returned empty public key");
-  return ce(s).toLowerCase();
+  return ct(s).toLowerCase();
 }
-function Ne(s) {
+function Dt(s) {
   if (typeof s != "string" || s.length === 0)
     throw new Error("BTC wallet returned empty BIP-322 signature");
   if (s.startsWith("0x") || s.startsWith("0X")) {
-    if (!Me.test(s) || s.length < 4 || s.length % 2 !== 0)
+    if (!Ft.test(s) || s.length < 4 || s.length % 2 !== 0)
       throw new Error("BTC wallet returned malformed hex BIP-322 signature");
     return s.toLowerCase();
   }
-  if (We.test(s)) {
+  if (Mt.test(s)) {
     if (s.length % 2 !== 0)
       throw new Error("BTC wallet returned malformed hex BIP-322 signature");
     return `0x${s.toLowerCase()}`;
   }
-  if (!Ue.test(s) || s.length % 4 !== 0)
+  if (!Wt.test(s) || s.length % 4 !== 0)
     throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
-  const t = O.from(s, "base64");
-  if (t.length === 0 || t.toString("base64") !== s)
+  const e = O.from(s, "base64");
+  if (e.length === 0 || e.toString("base64") !== s)
     throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
-  return `0x${t.toString("hex")}`;
+  return `0x${e.toString("hex")}`;
 }
-async function Fe(s) {
-  const { wallet: t, depositTerms: e, fundedPrePeginTxHex: o, depositorBtcPubkey: i } = s, n = typeof t.approveDepositTerms == "function" ? t.approveDepositTerms : void 0;
-  if (!n && !e)
+async function Nt(s) {
+  const { wallet: e, depositTerms: t, fundedPrePeginTxHex: o, depositorBtcPubkey: i } = s, n = typeof e.approveDepositTerms == "function" ? e.approveDepositTerms : void 0;
+  if (!n && !t)
     return;
-  const r = o.startsWith("0x") ? o.slice(2) : o, c = Ct.fromHex(r).getId();
-  if (e && e.prepeginTxid.replace(/^0x/, "").toLowerCase() !== c)
+  const r = o.startsWith("0x") ? o.slice(2) : o, c = Ae.fromHex(r).getId();
+  if (t && t.prepeginTxid.replace(/^0x/, "").toLowerCase() !== c)
     throw new Error(
-      `Deposit terms do not match the transaction being broadcast: terms are for prepeginTxid ${e.prepeginTxid}, but this transaction is ${c}.`
+      `Deposit terms do not match the transaction being broadcast: terms are for prepeginTxid ${t.prepeginTxid}, but this transaction is ${c}.`
     );
   if (!n)
     return;
-  if (!e)
+  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 t.deriveContextHash != "function")
+  if (typeof e.deriveContextHash != "function")
     throw new Error(
       "A deposit-approval wallet must also implement deriveContextHash, but this one does not."
     );
-  if (typeof t.holdsApprovedDepositTerms == "function") {
+  if (typeof e.holdsApprovedDepositTerms == "function") {
     let g = !1;
     try {
-      g = await t.holdsApprovedDepositTerms(e);
+      g = await e.holdsApprovedDepositTerms(t);
     } catch {
     }
     if (g)
       return;
   }
-  const u = he(o);
-  (await It(
-    { deriveContextHash: t.deriveContextHash.bind(t) },
+  typeof e.validateDepositTerms == "function" && await e.validateDepositTerms(t);
+  const h = ht(o);
+  (await Ie(
+    { deriveContextHash: e.deriveContextHash.bind(e) },
     {
-      depositorBtcPubkey: et(
+      depositorBtcPubkey: te(
         $(i)
       ),
-      fundingOutpoints: u
+      fundingOutpoints: h
     }
-  )).fill(0), await n.call(t, e);
+  )).fill(0), await n.call(e, t);
 }
-const De = /* @__PURE__ */ Uint8Array.from([
+const Ut = /* @__PURE__ */ Uint8Array.from([
   7,
   4,
   13,
@@ -169,36 +170,36 @@ const De = /* @__PURE__ */ Uint8Array.from([
   14,
   11,
   8
-]), Rt = Uint8Array.from(new Array(16).fill(0).map((s, t) => t)), Le = Rt.map((s) => (9 * s + 5) % 16), $t = /* @__PURE__ */ (() => {
-  const e = [[Rt], [Le]];
+]), Re = Uint8Array.from(new Array(16).fill(0).map((s, e) => e)), Lt = Re.map((s) => (9 * s + 5) % 16), $e = /* @__PURE__ */ (() => {
+  const t = [[Re], [Lt]];
   for (let o = 0; o < 4; o++)
-    for (let i of e)
-      i.push(i[o].map((n) => De[n]));
-  return e;
-})(), Ot = $t[0], Vt = $t[1], Mt = /* @__PURE__ */ [
+    for (let i of t)
+      i.push(i[o].map((n) => Ut[n]));
+  return t;
+})(), Oe = $e[0], Ve = $e[1], Fe = /* @__PURE__ */ [
   [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
   [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
   [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
   [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
   [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
-].map((s) => Uint8Array.from(s)), Ke = /* @__PURE__ */ Ot.map((s, t) => s.map((e) => Mt[t][e])), Xe = /* @__PURE__ */ Vt.map((s, t) => s.map((e) => Mt[t][e])), Ge = /* @__PURE__ */ Uint32Array.from([
+].map((s) => Uint8Array.from(s)), Kt = /* @__PURE__ */ Oe.map((s, e) => s.map((t) => Fe[e][t])), Xt = /* @__PURE__ */ Ve.map((s, e) => s.map((t) => Fe[e][t])), Gt = /* @__PURE__ */ Uint32Array.from([
   0,
   1518500249,
   1859775393,
   2400959708,
   2840853838
-]), qe = /* @__PURE__ */ Uint32Array.from([
+]), qt = /* @__PURE__ */ Uint32Array.from([
   1352829926,
   1548603684,
   1836072691,
   2053994217,
   0
 ]);
-function xt(s, t, e, o) {
-  return s === 0 ? t ^ e ^ o : s === 1 ? t & e | ~t & o : s === 2 ? (t | ~e) ^ o : s === 3 ? t & o | e & ~o : t ^ (e | ~o);
+function xe(s, e, t, o) {
+  return s === 0 ? e ^ t ^ o : s === 1 ? e & t | ~e & o : s === 2 ? (e | ~t) ^ o : s === 3 ? e & o | t & ~o : e ^ (t | ~o);
 }
-const F = /* @__PURE__ */ new Uint32Array(16);
-class Ye extends Yt {
+const N = /* @__PURE__ */ new Uint32Array(16);
+class Yt extends Ye {
   constructor() {
     super(64, 20, 8, !0);
     x(this, "h0", 1732584193);
@@ -208,73 +209,73 @@ class Ye extends Yt {
     x(this, "h4", -1009589776);
   }
   get() {
-    const { h0: e, h1: o, h2: i, h3: n, h4: r } = this;
-    return [e, o, i, n, r];
+    const { h0: t, h1: o, h2: i, h3: n, h4: r } = this;
+    return [t, o, i, n, r];
   }
-  set(e, o, i, n, r) {
-    this.h0 = e | 0, this.h1 = o | 0, this.h2 = i | 0, this.h3 = n | 0, this.h4 = r | 0;
+  set(t, o, i, n, r) {
+    this.h0 = t | 0, this.h1 = o | 0, this.h2 = i | 0, this.h3 = n | 0, this.h4 = r | 0;
   }
-  process(e, o) {
-    for (let d = 0; d < 16; d++, o += 4)
-      F[d] = e.getUint32(o, !0);
-    let i = this.h0 | 0, n = i, r = this.h1 | 0, a = r, c = this.h2 | 0, u = c, h = this.h3 | 0, g = h, w = this.h4 | 0, b = w;
-    for (let d = 0; d < 5; d++) {
-      const E = 4 - d, k = Ge[d], f = qe[d], v = Ot[d], B = Vt[d], p = Ke[d], P = Xe[d];
-      for (let l = 0; l < 16; l++) {
-        const y = W(i + xt(d, r, c, h) + F[v[l]] + k, p[l]) + w | 0;
-        i = w, w = h, h = W(c, 10) | 0, c = r, r = y;
+  process(t, o) {
+    for (let l = 0; l < 16; l++, o += 4)
+      N[l] = t.getUint32(o, !0);
+    let i = this.h0 | 0, n = i, r = this.h1 | 0, a = r, c = this.h2 | 0, h = c, d = this.h3 | 0, g = d, P = this.h4 | 0, b = P;
+    for (let l = 0; l < 5; l++) {
+      const T = 4 - l, E = Gt[l], p = qt[l], B = Oe[l], S = Ve[l], f = Kt[l], w = Xt[l];
+      for (let u = 0; u < 16; u++) {
+        const y = W(i + xe(l, r, c, d) + N[B[u]] + E, f[u]) + P | 0;
+        i = P, P = d, d = W(c, 10) | 0, c = r, r = y;
       }
-      for (let l = 0; l < 16; l++) {
-        const y = W(n + xt(E, a, u, g) + F[B[l]] + f, P[l]) + b | 0;
-        n = b, b = g, g = W(u, 10) | 0, u = a, a = y;
+      for (let u = 0; u < 16; u++) {
+        const y = W(n + xe(T, a, h, g) + N[S[u]] + p, w[u]) + b | 0;
+        n = b, b = g, g = W(h, 10) | 0, h = a, a = y;
       }
     }
-    this.set(this.h1 + c + g | 0, this.h2 + h + b | 0, this.h3 + w + n | 0, this.h4 + i + a | 0, this.h0 + r + u | 0);
+    this.set(this.h1 + c + g | 0, this.h2 + d + b | 0, this.h3 + P + n | 0, this.h4 + i + a | 0, this.h0 + r + h | 0);
   }
   roundClean() {
-    K(F);
+    K(N);
   }
   destroy() {
     this.destroyed = !0, K(this.buffer), this.set(0, 0, 0, 0, 0);
   }
 }
-const ze = /* @__PURE__ */ _t(() => new Ye()), je = BigInt(0), M = BigInt(1), Qe = BigInt(2), Ze = BigInt(7), Je = BigInt(256), ts = BigInt(113), Wt = [], Ut = [], Nt = [];
-for (let s = 0, t = M, e = 1, o = 0; s < 24; s++) {
-  [e, o] = [o, (2 * e + 3 * o) % 5], Wt.push(2 * (5 * o + e)), Ut.push((s + 1) * (s + 2) / 2 % 64);
-  let i = je;
+const zt = /* @__PURE__ */ _e(() => new Yt()), jt = BigInt(0), M = BigInt(1), Qt = BigInt(2), Zt = BigInt(7), Jt = BigInt(256), es = BigInt(113), Me = [], We = [], De = [];
+for (let s = 0, e = M, t = 1, o = 0; s < 24; s++) {
+  [t, o] = [o, (2 * t + 3 * o) % 5], Me.push(2 * (5 * o + t)), We.push((s + 1) * (s + 2) / 2 % 64);
+  let i = jt;
   for (let n = 0; n < 7; n++)
-    t = (t << M ^ (t >> Ze) * ts) % Je, t & Qe && (i ^= M << (M << BigInt(n)) - M);
-  Nt.push(i);
+    e = (e << M ^ (e >> Zt) * es) % Jt, e & Qt && (i ^= M << (M << BigInt(n)) - M);
+  De.push(i);
 }
-const Ft = Ce(Nt, !0), es = Ft[0], ss = Ft[1], kt = (s, t, e) => e > 32 ? Re(s, t, e) : Ie(s, t, e), Et = (s, t, e) => e > 32 ? $e(s, t, e) : He(s, t, e);
-function os(s, t = 24) {
-  const e = new Uint32Array(10);
-  for (let o = 24 - t; o < 24; o++) {
+const Ne = At(De, !0), ts = Ne[0], ss = Ne[1], ke = (s, e, t) => t > 32 ? Rt(s, e, t) : It(s, e, t), Ee = (s, e, t) => t > 32 ? $t(s, e, t) : Ht(s, e, t);
+function os(s, e = 24) {
+  const t = new Uint32Array(10);
+  for (let o = 24 - e; o < 24; o++) {
     for (let r = 0; r < 10; r++)
-      e[r] = s[r] ^ s[r + 10] ^ s[r + 20] ^ s[r + 30] ^ s[r + 40];
+      t[r] = s[r] ^ s[r + 10] ^ s[r + 20] ^ s[r + 30] ^ s[r + 40];
     for (let r = 0; r < 10; r += 2) {
-      const a = (r + 8) % 10, c = (r + 2) % 10, u = e[c], h = e[c + 1], g = kt(u, h, 1) ^ e[a], w = Et(u, h, 1) ^ e[a + 1];
+      const a = (r + 8) % 10, c = (r + 2) % 10, h = t[c], d = t[c + 1], g = ke(h, d, 1) ^ t[a], P = Ee(h, d, 1) ^ t[a + 1];
       for (let b = 0; b < 50; b += 10)
-        s[r + b] ^= g, s[r + b + 1] ^= w;
+        s[r + b] ^= g, s[r + b + 1] ^= P;
     }
     let i = s[2], n = s[3];
     for (let r = 0; r < 24; r++) {
-      const a = Ut[r], c = kt(i, n, a), u = Et(i, n, a), h = Wt[r];
-      i = s[h], n = s[h + 1], s[h] = c, s[h + 1] = u;
+      const a = We[r], c = ke(i, n, a), h = Ee(i, n, a), d = Me[r];
+      i = s[d], n = s[d + 1], s[d] = c, s[d + 1] = h;
     }
     for (let r = 0; r < 50; r += 10) {
       for (let a = 0; a < 10; a++)
-        e[a] = s[r + a];
+        t[a] = s[r + a];
       for (let a = 0; a < 10; a++)
-        s[r + a] ^= ~e[(a + 2) % 10] & e[(a + 4) % 10];
+        s[r + a] ^= ~t[(a + 2) % 10] & t[(a + 4) % 10];
     }
-    s[0] ^= es[o], s[1] ^= ss[o];
+    s[0] ^= ts[o], s[1] ^= ss[o];
   }
-  K(e);
+  K(t);
 }
-class rt {
+class re {
   // NOTE: we accept arguments in bytes instead of bits here.
-  constructor(t, e, o, i = !1, n = 24) {
+  constructor(e, t, o, i = !1, n = 24) {
     x(this, "state");
     x(this, "pos", 0);
     x(this, "posOut", 0);
@@ -286,24 +287,24 @@ class rt {
     x(this, "outputLen");
     x(this, "enableXOF", !1);
     x(this, "rounds");
-    if (this.blockLen = t, this.suffix = e, this.outputLen = o, this.enableXOF = i, this.rounds = n, at(o, "outputLen"), !(0 < t && t < 200))
+    if (this.blockLen = e, this.suffix = t, this.outputLen = o, this.enableXOF = i, this.rounds = n, ae(o, "outputLen"), !(0 < e && e < 200))
       throw new Error("only keccak-f1600 function is supported");
-    this.state = new Uint8Array(200), this.state32 = zt(this.state);
+    this.state = new Uint8Array(200), this.state32 = ze(this.state);
   }
   clone() {
     return this._cloneInto();
   }
   keccak() {
-    ct(this.state32), os(this.state32, this.rounds), ct(this.state32), this.posOut = 0, this.pos = 0;
+    ce(this.state32), os(this.state32, this.rounds), ce(this.state32), this.posOut = 0, this.pos = 0;
   }
-  update(t) {
-    lt(this), ut(t);
-    const { blockLen: e, state: o } = this, i = t.length;
+  update(e) {
+    le(this), ue(e);
+    const { blockLen: t, state: o } = this, i = e.length;
     for (let n = 0; n < i; ) {
-      const r = Math.min(e - this.pos, i - n);
+      const r = Math.min(t - this.pos, i - n);
       for (let a = 0; a < r; a++)
-        o[this.pos++] ^= t[n++];
-      this.pos === e && this.keccak();
+        o[this.pos++] ^= e[n++];
+      this.pos === t && this.keccak();
     }
     return this;
   }
@@ -311,31 +312,31 @@ class rt {
     if (this.finished)
       return;
     this.finished = !0;
-    const { state: t, suffix: e, pos: o, blockLen: i } = this;
-    t[o] ^= e, (e & 128) !== 0 && o === i - 1 && this.keccak(), t[i - 1] ^= 128, this.keccak();
+    const { state: e, suffix: t, pos: o, blockLen: i } = this;
+    e[o] ^= t, (t & 128) !== 0 && o === i - 1 && this.keccak(), e[i - 1] ^= 128, this.keccak();
   }
-  writeInto(t) {
-    lt(this, !1), ut(t), this.finish();
-    const e = this.state, { blockLen: o } = this;
-    for (let i = 0, n = t.length; i < n; ) {
+  writeInto(e) {
+    le(this, !1), ue(e), this.finish();
+    const t = this.state, { blockLen: o } = this;
+    for (let i = 0, n = e.length; i < n; ) {
       this.posOut >= o && this.keccak();
       const r = Math.min(o - this.posOut, n - i);
-      t.set(e.subarray(this.posOut, this.posOut + r), i), this.posOut += r, i += r;
+      e.set(t.subarray(this.posOut, this.posOut + r), i), this.posOut += r, i += r;
     }
-    return t;
+    return e;
   }
-  xofInto(t) {
+  xofInto(e) {
     if (!this.enableXOF)
       throw new Error("XOF is not possible for this instance");
-    return this.writeInto(t);
+    return this.writeInto(e);
   }
-  xof(t) {
-    return at(t), this.xofInto(new Uint8Array(t));
+  xof(e) {
+    return ae(e), this.xofInto(new Uint8Array(e));
   }
-  digestInto(t) {
-    if (jt(t, this), this.finished)
+  digestInto(e) {
+    if (je(e, this), this.finished)
       throw new Error("digest() was already called");
-    return this.writeInto(t), this.destroy(), t;
+    return this.writeInto(e), this.destroy(), e;
   }
   digest() {
     return this.digestInto(new Uint8Array(this.outputLen));
@@ -343,49 +344,49 @@ class rt {
   destroy() {
     this.destroyed = !0, K(this.state);
   }
-  _cloneInto(t) {
-    const { blockLen: e, suffix: o, outputLen: i, rounds: n, enableXOF: r } = this;
-    return t || (t = new rt(e, o, i, r, n)), t.state32.set(this.state32), t.pos = this.pos, t.posOut = this.posOut, t.finished = this.finished, t.rounds = n, t.suffix = o, t.outputLen = i, t.enableXOF = r, t.destroyed = this.destroyed, t;
+  _cloneInto(e) {
+    const { blockLen: t, suffix: o, outputLen: i, rounds: n, enableXOF: r } = this;
+    return e || (e = new re(t, o, i, r, n)), e.state32.set(this.state32), e.pos = this.pos, e.posOut = this.posOut, e.finished = this.finished, e.rounds = n, e.suffix = o, e.outputLen = i, e.enableXOF = r, e.destroyed = this.destroyed, e;
   }
 }
-const ns = (s, t, e, o = {}) => _t(() => new rt(t, s, e), o), rs = /* @__PURE__ */ ns(1, 136, 32), Tt = 64, _ = 20, nt = 4, Dt = 2, is = 0, as = 1, D = [64, 64], cs = (s) => Array.from(s).map((t) => t.toString(16).padStart(2, "0")).join("");
-function it(s) {
-  return ze(Bt(s));
+const ns = (s, e, t, o = {}) => _e(() => new re(e, s, t), o), rs = /* @__PURE__ */ ns(1, 136, 32), Te = 64, _ = 20, ne = 4, Ue = 2, is = 0, as = 1, U = [64, 64], cs = (s) => Array.from(s).map((e) => e.toString(16).padStart(2, "0")).join("");
+function ie(s) {
+  return zt(Se(s));
 }
-function Lt(s) {
+function Le(s) {
   return (1 << s) - 1;
 }
 function ls(s) {
-  let t = 1;
-  for (; t * t < s + 1; ) t++;
-  return Math.max(t, 2);
+  let e = 1;
+  for (; e * e < s + 1; ) e++;
+  return Math.max(e, 2);
 }
 function us(s) {
-  const t = nt, e = s * Lt(t);
-  return { d: t, n: s, checksum_radix: ls(e) };
+  const e = ne, t = s * Le(e);
+  return { d: e, n: s, checksum_radix: ls(t) };
 }
-function z(s, t) {
-  const e = [];
-  let o = t;
+function z(s, e) {
+  const t = [];
+  let o = e;
   for (; o > 0; )
-    e.push(o & 255), o >>>= 8;
-  const i = new Uint8Array(s.length + e.length);
+    t.push(o & 255), o >>>= 8;
+  const i = new Uint8Array(s.length + t.length);
   i.set(s);
-  for (let n = 0; n < e.length; n++)
-    i[s.length + n] = e[n];
-  return it(i);
+  for (let n = 0; n < t.length; n++)
+    i[s.length + n] = t[n];
+  return ie(i);
 }
-function j(s, t) {
-  let e = s;
-  for (let o = 0; o < t; o++)
-    e = it(e);
-  return e;
+function j(s, e) {
+  let t = s;
+  for (let o = 0; o < e; o++)
+    t = ie(t);
+  return t;
 }
-function hs(s, t) {
-  const e = Lt(t.d), o = t.checksum_radix - 1, i = Math.floor(t.n * e / t.checksum_radix), n = [];
-  for (let h = 0; h < t.n; h++) {
-    const g = z(s, h + Dt), w = j(g, e);
-    n.push(Array.from(w));
+function hs(s, e) {
+  const t = Le(e.d), o = e.checksum_radix - 1, i = Math.floor(e.n * t / e.checksum_radix), n = [];
+  for (let d = 0; d < e.n; d++) {
+    const g = z(s, d + Ue), P = j(g, t);
+    n.push(Array.from(P));
   }
   const r = z(
     s,
@@ -396,83 +397,83 @@ function hs(s, t) {
   ), c = z(
     s,
     as
-  ), u = j(
+  ), h = j(
     c,
     i
   );
   return {
-    config: t,
+    config: e,
     message_terminals: n,
-    checksum_major_terminal: Array.from(u),
+    checksum_major_terminal: Array.from(h),
     checksum_minor_terminal: Array.from(a)
   };
 }
 async function ds(s) {
   try {
-    if (s.length !== Tt)
+    if (s.length !== Te)
       throw new Error(
-        `WOTS seed must be exactly ${Tt} bytes, got ${s.length}`
+        `WOTS seed must be exactly ${Te} bytes, got ${s.length}`
       );
-    const t = [];
-    for (let e = 0; e < D.length; e++) {
-      const o = D[e], i = us(o), n = new Uint8Array(s.length + 1);
-      n.set(s), n[s.length] = e;
-      const r = it(n);
+    const e = [];
+    for (let t = 0; t < U.length; t++) {
+      const o = U[t], i = us(o), n = new Uint8Array(s.length + 1);
+      n.set(s), n[s.length] = t;
+      const r = ie(n);
       try {
         const a = hs(r, i);
-        if (a.config.d !== nt)
+        if (a.config.d !== ne)
           throw new Error(
-            `Block ${e}: expected d=${nt}, got d=${a.config.d}`
+            `Block ${t}: expected d=${ne}, got d=${a.config.d}`
           );
         if (a.config.n !== o)
           throw new Error(
-            `Block ${e}: expected n=${o}, got n=${a.config.n}`
+            `Block ${t}: expected n=${o}, got n=${a.config.n}`
           );
         if (a.message_terminals.length !== o)
           throw new Error(
-            `Block ${e}: expected ${o} message terminals, got ${a.message_terminals.length}`
+            `Block ${t}: expected ${o} message terminals, got ${a.message_terminals.length}`
           );
         for (let c = 0; c < a.message_terminals.length; c++)
           if (a.message_terminals[c].length !== _)
             throw new Error(
-              `Block ${e} terminal ${c}: expected ${_} bytes, got ${a.message_terminals[c].length}`
+              `Block ${t} terminal ${c}: expected ${_} bytes, got ${a.message_terminals[c].length}`
             );
         if (a.checksum_minor_terminal.length !== _)
           throw new Error(
-            `Block ${e} checksum_minor: expected ${_} bytes`
+            `Block ${t} checksum_minor: expected ${_} bytes`
           );
         if (a.checksum_major_terminal.length !== _)
           throw new Error(
-            `Block ${e} checksum_major: expected ${_} bytes`
+            `Block ${t} checksum_major: expected ${_} bytes`
           );
-        t.push(a);
+        e.push(a);
       } finally {
         n.fill(0), r.fill(0);
       }
     }
-    if (t.length !== D.length)
+    if (e.length !== U.length)
       throw new Error(
-        `Expected ${D.length} blocks, got ${t.length}`
+        `Expected ${U.length} blocks, got ${e.length}`
       );
-    return t;
+    return e;
   } finally {
     s.fill(0);
   }
 }
-function Q(s, t, e) {
+function Q(s, e, t) {
   if (s.length !== _)
     throw new Error(
-      `Block ${t} ${e}: expected ${_} bytes, got ${s.length}`
+      `Block ${e} ${t}: expected ${_} bytes, got ${s.length}`
     );
   for (let o = 0; o < s.length; o++) {
     const i = s[o];
     if (!Number.isInteger(i) || i < 0 || i > 255)
       throw new Error(
-        `Block ${t} ${e}[${o}]: invalid byte value ${i}`
+        `Block ${e} ${t}[${o}]: invalid byte value ${i}`
       );
   }
 }
-function fs(s) {
+function ps(s) {
   if (s.length === 0)
     throw new Error("Public keys array must not be empty");
   for (let n = 0; n < s.length; n++) {
@@ -481,34 +482,34 @@ function fs(s) {
     for (let a = 0; a < r.message_terminals.length; a++)
       Q(r.message_terminals[a], n, `message_terminal[${a}]`);
   }
-  let t = 0;
+  let e = 0;
   for (const n of s)
-    t += Dt + n.message_terminals.length;
-  const e = new Uint8Array(t * _);
+    e += Ue + n.message_terminals.length;
+  const t = new Uint8Array(e * _);
   let o = 0;
   for (const n of s) {
-    e.set(n.checksum_minor_terminal, o), o += _, e.set(n.checksum_major_terminal, o), o += _;
+    t.set(n.checksum_minor_terminal, o), o += _, t.set(n.checksum_major_terminal, o), o += _;
     for (const r of n.message_terminals)
-      e.set(r, o), o += _;
+      t.set(r, o), o += _;
   }
-  const i = rs(e);
+  const i = rs(t);
   return `0x${cs(i)}`;
 }
-async function ps(s, t) {
-  const e = [], o = [], i = [], n = [];
+async function fs(s, e) {
+  const t = [], o = [], i = [], n = [];
   try {
-    for (let r = 0; r < t; r++) {
-      const a = await Zt(s, r);
+    for (let r = 0; r < e; r++) {
+      const a = await Ze(s, r);
       try {
-        const u = await ds(a);
-        e.push(u), o.push(fs(u));
+        const h = await ds(a);
+        t.push(h), o.push(ps(h));
       } finally {
         a.fill(0);
       }
-      const c = await Jt(s, r);
+      const c = await Je(s, r);
       try {
-        const u = st(c);
-        i.push(u), n.push(de(C(u)).slice(2));
+        const h = se(c);
+        i.push(h), n.push(dt(A(h)).slice(2));
       } finally {
         c.fill(0);
       }
@@ -516,23 +517,23 @@ async function ps(s, t) {
   } finally {
     s.fill(0);
   }
-  return { perVaultWotsKeys: e, wotsPkHashes: o, htlcSecretHexes: i, hashlocks: n };
+  return { perVaultWotsKeys: t, wotsPkHashes: o, htlcSecretHexes: i, hashlocks: n };
 }
-const gs = 1, ms = 2, ws = 33, bs = 2, Ps = 3, ys = 1, L = 64, xs = 0, Z = 1, vt = /^[0-9a-f]{64}$/i, ks = /^(?:[0-9a-f]{2})+$/;
+const gs = 1, ms = 2, Ps = 33, bs = 2, ws = 3, ys = 1, L = 64, xs = 0, Z = 1, ve = /^[0-9a-f]{64}$/i, ks = /^(?:[0-9a-f]{2})+$/;
 function Es(s) {
-  const t = s.slice(2);
-  if (!ks.test(t))
+  const e = s.slice(2);
+  if (!ks.test(e))
     throw new Error(
       "proof of possession witness is not even-length lowercase hex"
     );
-  return oe(
-    Uint8Array.from(O.from(t, "hex")),
+  return ot(
+    Uint8Array.from(O.from(e, "hex")),
     "proof of possession witness"
   );
 }
-function Ts(s, t, e) {
+function Ts(s, e, t) {
   var i;
-  const o = Es(e);
+  const o = Es(t);
   if (o.length === gs) {
     const [n] = o;
     let r, a;
@@ -544,39 +545,39 @@ function Ts(s, t, e) {
       throw new Error(
         "proof of possession witness item must be a 64-byte Schnorr signature (or 65 bytes ending in 0x01)"
       );
-    if (!vt.test(t))
+    if (!ve.test(e))
       throw new Error(
-        `depositor public key must be bare 64-char x-only hex, got "${t}"`
+        `depositor public key must be bare 64-char x-only hex, got "${e}"`
       );
-    const c = Uint8Array.from(O.from(t, "hex"));
-    if (!xe(s, c, r, a))
+    const c = Uint8Array.from(O.from(e, "hex"));
+    if (!xt(s, c, r, a))
       throw new Error(
         "proof of possession signature does not verify against the depositor key"
       );
     return { kind: "p2tr-verified" };
   }
   if (o.length === ms) {
-    if (!vt.test(t))
+    if (!ve.test(e))
       throw new Error(
-        `depositor public key must be bare 64-char x-only hex, got "${t}"`
+        `depositor public key must be bare 64-char x-only hex, got "${e}"`
       );
     const [n, r] = o;
-    if (r.length !== ws || r[0] !== bs && r[0] !== Ps)
+    if (r.length !== Ps || r[0] !== bs && r[0] !== ws)
       throw new Error(
         `proof of possession P2WPKH witness item 1 is not a compressed public key (${r.length} bytes, prefix 0x${((i = r[0]) == null ? void 0 : i.toString(16)) ?? "none"})`
       );
-    if (!Be.isPointCompressed(r))
+    if (!St.isPointCompressed(r))
       throw new Error(
         "proof of possession P2WPKH witness pubkey is not a valid secp256k1 point"
       );
     const a = O.from(
       r.subarray(ys)
     ).toString("hex");
-    if (a !== t.toLowerCase())
+    if (a !== e.toLowerCase())
       throw new Error(
-        `proof of possession witness pubkey does not match the depositor key: witness carries ${a}, expected ${t}`
+        `proof of possession witness pubkey does not match the depositor key: witness carries ${a}, expected ${e}`
       );
-    if (n.length < ke || n.length > Ee)
+    if (n.length < kt || n.length > Et)
       throw new Error(
         `proof of possession signature is ${n.length} bytes; vault ingestion accepts only 71/72-byte DER signatures with a sighash byte — try a different account or a Taproot address`
       );
@@ -584,7 +585,7 @@ function Ts(s, t, e) {
       throw new Error(
         `proof of possession P2WPKH signature must end in a SIGHASH_ALL (0x01) byte, got 0x${n[n.length - 1].toString(16)}`
       );
-    if (!Te(s, r, n))
+    if (!Tt(s, r, n))
       throw new Error(
         "proof of possession signature does not verify against the depositor key"
       );
@@ -594,40 +595,40 @@ function Ts(s, t, e) {
     `proof of possession witness has ${o.length} items; expected 1 (P2TR) or 2 (P2WPKH)`
   );
 }
-const Kt = 0, J = "00".repeat(32);
-function vs(s, t) {
-  const e = {
+const Ke = 0, J = "00".repeat(32), vs = "00".repeat(32);
+function Bs(s, e) {
+  const t = {
     bitcoin: "bc",
     testnet: "tb",
     signet: "tb",
     regtest: "bcrt"
   };
   try {
-    const o = At.address.fromBech32(s);
-    return o.prefix === e[t] && o.version === 0 && o.data.length === 20;
+    const o = Ce.address.fromBech32(s);
+    return o.prefix === t[e] && o.version === 0 && o.data.length === 20;
   } catch {
     return !1;
   }
 }
-function Ss(s, t, e, o) {
-  const i = e == null ? void 0 : e[`${s}:${t}`];
+function _s(s, e, t, o) {
+  const i = t == null ? void 0 : t[`${s}:${e}`];
   return i ? Promise.resolve({
     txid: s,
-    vout: t,
+    vout: e,
     value: i.value,
     scriptPubKey: i.scriptPubKey
-  }) : _e(s, t, o);
+  }) : _t(s, e, o);
 }
-const St = 12e4;
-class Zs {
+const Be = 12e4;
+class Js {
   /**
    * Creates a new PeginManager instance.
    *
    * @param config - Manager configuration including wallets and contract addresses
    */
-  constructor(t) {
+  constructor(e) {
     x(this, "config");
-    this.config = t;
+    this.config = e;
   }
   /**
    * Prepare a peg-in: sizing pass → vault-root derivation (one wallet
@@ -639,78 +640,92 @@ class Zs {
    * @throws If the wallet rejects, insufficient funds, or an internal
    *         invariant violation.
    */
-  async preparePegin(t) {
-    if (t.amounts.length === 0)
+  async preparePegin(e) {
+    if (e.amounts.length === 0)
       throw new Error("amounts must contain at least one entry");
-    const e = await this.config.btcWallet.getPublicKeyHex(), o = $(e);
-    if (U(this.config.btcWallet)) {
-      const f = (await fe(this.config.btcWallet)).trim();
-      if (t.changeAddress.trim() !== f)
+    const t = await this.config.btcWallet.getPublicKeyHex(), o = $(t);
+    if (F(this.config.btcWallet)) {
+      const p = (await pt(this.config.btcWallet)).trim();
+      if (e.changeAddress.trim() !== p)
         throw new Error(
-          `Pre-PegIn changeAddress "${t.changeAddress}" is not the approval wallet's change address ("${f}"). Refusing to build a tx the signing device would reject.`
+          `Pre-PegIn changeAddress "${e.changeAddress}" is not the approval wallet's change address ("${p}"). Refusing to build a tx the signing device would reject.`
         );
-    } else if (!mt(
-      t.changeAddress,
-      e,
+    } else if (!me(
+      e.changeAddress,
+      t,
       this.config.btcNetwork
     ))
       throw new Error(
-        `Pre-PegIn changeAddress "${t.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.`
+        `Pre-PegIn changeAddress "${e.changeAddress}" is not derived from the connected wallet's public key. Refusing to build a tx that would send change to an address the signing key doesn't control.`
+      );
+    const i = await this.prepareSizing(o, e);
+    if (F(this.config.btcWallet)) {
+      const { validateDepositTerms: p } = this.config.btcWallet;
+      typeof p == "function" && await p.call(
+        this.config.btcWallet,
+        this.buildPeginDepositTerms({
+          params: e,
+          prepeginTxid: vs,
+          prepeginMaxFee: i.fee,
+          depositorClaimValue: i.depositorClaimValue,
+          peginMaxFee: i.minPeginFee
+        })
       );
-    const i = await this.prepareSizing(o, t), n = i.selectedUTXOs.map(
-      (f) => ({
-        txid: et(f.txid),
-        vout: f.vout
+    }
+    const n = i.selectedUTXOs.map(
+      (p) => ({
+        txid: te(p.txid),
+        vout: p.vout
       })
-    ), r = await It(this.config.btcWallet, {
-      depositorBtcPubkey: et(o),
+    ), r = await Ie(this.config.btcWallet, {
+      depositorBtcPubkey: te(o),
       fundingOutpoints: n
     });
     let a, c;
     try {
-      const f = await te(r);
+      const p = await et(r);
       try {
-        a = st(f), c = st(Bt(f));
+        a = se(p), c = se(Se(p));
       } finally {
-        f.fill(0);
+        p.fill(0);
       }
-    } catch (f) {
-      throw r.fill(0), f;
+    } catch (p) {
+      throw r.fill(0), p;
     }
-    const u = await ps(r, t.amounts.length), { perVaultWotsKeys: h, wotsPkHashes: g, htlcSecretHexes: w, hashlocks: b } = u, d = await this.preparePeginCommit({
-      depositorBtcPubkeyRaw: e,
+    const h = await fs(r, e.amounts.length), { perVaultWotsKeys: d, wotsPkHashes: g, htlcSecretHexes: P, hashlocks: b } = h, l = await this.preparePeginCommit({
+      depositorBtcPubkeyRaw: t,
       depositorBtcPubkey: o,
       hashlocks: b,
       authAnchorHash: c,
       sizing: i,
-      params: t
+      params: e
     });
-    for (let f = 0; f < d.perVault.length; f++)
-      if (d.perVault[f].htlcVout !== f)
+    for (let p = 0; p < l.perVault.length; p++)
+      if (l.perVault[p].htlcVout !== p)
         throw new Error(
-          `Internal invariant violation: htlcVout/index mismatch at vault ${f} (expected ${f}, got ${d.perVault[f].htlcVout})`
+          `Internal invariant violation: htlcVout/index mismatch at vault ${p} (expected ${p}, got ${l.perVault[p].htlcVout})`
         );
-    pe(
-      d.fundedPrePeginTxHex,
-      t.amounts.length,
+    ft(
+      l.fundedPrePeginTxHex,
+      e.amounts.length,
       c
     );
-    const { depositTerms: E, ...k } = d;
+    const { depositTerms: T, ...E } = l;
     return {
       transaction: {
-        ...k,
+        ...E,
         selectedUTXOs: i.selectedUTXOs,
         fee: i.fee,
         changeAmount: i.changeAmount
       },
       depositorBtcPubkey: o,
       derivedSecrets: {
-        perVaultWotsKeys: h,
+        perVaultWotsKeys: d,
         wotsPkHashes: g,
-        htlcSecretHexes: w,
+        htlcSecretHexes: P,
         authAnchorHex: a
       },
-      depositTerms: E
+      depositTerms: T
     };
   }
   /**
@@ -729,47 +744,75 @@ class Zs {
    * real values. Output budget is identical (32-byte push regardless of
    * content), so UTXO selection is invariant under substitution.
    */
-  async prepareSizing(t, e) {
-    const o = e.amounts.map(
+  async prepareSizing(e, t) {
+    const o = t.amounts.map(
       () => J
-    ), i = e.vaultKeeperBtcPubkeys.length, n = await pt({
-      vaultCoreVersion: e.vaultCoreVersion,
-      depositorPubkey: t,
-      vaultProviderPubkey: S(e.vaultProviderBtcPubkey),
-      vaultKeeperPubkeys: e.vaultKeeperBtcPubkeys.map(S),
-      universalChallengerPubkeys: e.universalChallengerBtcPubkeys.map(S),
+    ), i = t.vaultKeeperBtcPubkeys.length, n = await fe({
+      vaultCoreVersion: t.vaultCoreVersion,
+      depositorPubkey: e,
+      vaultProviderPubkey: k(t.vaultProviderBtcPubkey),
+      vaultKeeperPubkeys: t.vaultKeeperBtcPubkeys.map(k),
+      universalChallengerPubkeys: t.universalChallengerBtcPubkeys.map(k),
       hashlocks: o,
-      timelockRefund: e.timelockRefund,
-      pegInAmounts: e.amounts,
-      feeRate: e.protocolFeeRate,
-      minPeginFeeRate: e.minPeginFeeRate,
+      timelockRefund: t.timelockRefund,
+      pegInAmounts: t.amounts,
+      feeRate: t.protocolFeeRate,
+      minPeginFeeRate: t.minPeginFeeRate,
       numLocalChallengers: i,
-      councilQuorum: e.councilQuorum,
-      councilSize: e.councilSize,
+      councilQuorum: t.councilQuorum,
+      councilSize: t.councilSize,
       network: this.config.btcNetwork,
       authAnchorHash: J
-    }), r = me(
-      [...e.availableUTXOs],
+    }), r = mt(
+      [...t.availableUTXOs],
       n.totalOutputValue,
-      e.mempoolFeeRate,
-      be(n.htlcValues.length, !0)
+      t.mempoolFeeRate,
+      bt(n.htlcValues.length, !0)
     );
     return {
       selectedUTXOs: r.selectedUTXOs,
       fee: r.fee,
-      changeAmount: r.changeAmount
+      changeAmount: r.changeAmount,
+      depositorClaimValue: n.depositorClaimValue,
+      minPeginFee: n.minPeginFee
     };
   }
+  /**
+   * One projection for both the provisional (pre-derive, placeholder-txid)
+   * terms and the final approved terms, so the fields the pre-check validated
+   * cannot drift from the fields the device later displays (#2110 T4).
+   */
+  buildPeginDepositTerms(e) {
+    const { params: t } = e;
+    return Vt({
+      vaultCoreVersion: t.vaultCoreVersion,
+      protocolFeeRate: t.protocolFeeRate,
+      timelockPegin: t.timelockPegin,
+      timelockAssert: t.timelockAssert,
+      timelockRefund: t.timelockRefund,
+      prepeginTxid: e.prepeginTxid,
+      prepeginMaxFee: e.prepeginMaxFee,
+      vaultProviderBtcPubkey: k(t.vaultProviderBtcPubkey),
+      vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys.map(k),
+      universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys.map(k),
+      maxAcceptableCommissionBps: Y(
+        t.commissionBps
+      ),
+      peginAmounts: t.amounts,
+      depositorClaimValue: e.depositorClaimValue,
+      peginMaxFee: e.peginMaxFee
+    });
+  }
   /** Build PegIn txs and batch-sign their inputs with real hashlocks. */
-  async preparePeginCommit(t) {
+  async preparePeginCommit(e) {
     const {
-      depositorBtcPubkeyRaw: e,
+      depositorBtcPubkeyRaw: t,
       depositorBtcPubkey: o,
       hashlocks: i,
       authAnchorHash: n,
       sizing: r,
       params: a
-    } = t, c = J.toLowerCase();
+    } = e, c = J.toLowerCase();
     for (let m = 0; m < i.length; m++)
       if (i[m].toLowerCase() === c)
         throw new Error(
@@ -779,114 +822,108 @@ class Zs {
       throw new Error(
         "preparePeginCommit refusing to build with sizing-pass placeholder auth-anchor hash — internal substitution bug"
       );
-    const u = S(
+    const h = k(
       a.vaultProviderBtcPubkey
-    ), h = a.vaultKeeperBtcPubkeys.map(S), g = a.universalChallengerBtcPubkeys.map(S), w = h.length, b = {
+    ), d = a.vaultKeeperBtcPubkeys.map(k), g = a.universalChallengerBtcPubkeys.map(k), P = d.length, b = {
       vaultCoreVersion: a.vaultCoreVersion,
       depositorPubkey: o,
-      vaultProviderPubkey: u,
-      vaultKeeperPubkeys: h,
+      vaultProviderPubkey: h,
+      vaultKeeperPubkeys: d,
       universalChallengerPubkeys: g,
       hashlocks: i,
       timelockRefund: a.timelockRefund,
       pegInAmounts: a.amounts,
       feeRate: a.protocolFeeRate,
       minPeginFeeRate: a.minPeginFeeRate,
-      numLocalChallengers: w,
+      numLocalChallengers: P,
       councilQuorum: a.councilQuorum,
       councilSize: a.councilSize,
       network: this.config.btcNetwork,
       authAnchorHash: n
-    }, d = await pt(b), E = wt(this.config.btcNetwork), k = Pe({
-      unfundedTxHex: d.psbtHex,
+    }, l = await fe(b);
+    if (l.depositorClaimValue !== r.depositorClaimValue || l.minPeginFee !== r.minPeginFee)
+      throw new Error(
+        `Pre-PegIn sizing/commit divergence: depositorClaimValue ${r.depositorClaimValue} -> ${l.depositorClaimValue}, minPeginFee ${r.minPeginFee} -> ${l.minPeginFee}. The provisional deposit terms validated before derivation would not match the terms sent for approval; refusing to continue.`
+      );
+    const T = Pe(this.config.btcNetwork), E = wt({
+      unfundedTxHex: l.psbtHex,
       selectedUTXOs: r.selectedUTXOs,
       changeAddress: a.changeAddress,
       changeAmount: r.changeAmount,
-      network: E
-    }), f = r.selectedUTXOs.reduce((m, T) => m + BigInt(T.value), 0n) - d.totalOutputValue - r.changeAmount;
-    if (f !== r.fee)
+      network: T
+    }), p = r.selectedUTXOs.reduce((m, v) => m + BigInt(v.value), 0n) - l.totalOutputValue - r.changeAmount;
+    if (p !== r.fee)
       throw new Error(
-        `Pre-PegIn funded fee ${f} does not match the sizing-pass fee ${r.fee}; refusing to publish a deposit-terms fee bound the funded transaction does not pay.`
+        `Pre-PegIn funded fee ${p} does not match the sizing-pass fee ${r.fee}; refusing to publish a deposit-terms fee bound the funded transaction does not pay.`
       );
-    const v = S(
-      q(k)
-    ), B = [], p = [], P = [];
+    const B = k(
+      q(E)
+    ), S = [], f = [], w = [];
     for (let m = 0; m < i.length; m++) {
-      const T = await ee({
+      const v = await tt({
         prePeginParams: b,
         timelockPegin: a.timelockPegin,
-        fundedPrePeginTxHex: k,
+        fundedPrePeginTxHex: E,
         htlcVout: m
-      }), I = await ne({
+      }), I = await nt({
         vaultCoreVersion: a.vaultCoreVersion,
-        peginTxHex: T.txHex,
-        fundedPrePeginTxHex: k,
+        peginTxHex: v.txHex,
+        fundedPrePeginTxHex: E,
         depositorPubkey: o,
-        vaultProviderPubkey: u,
-        vaultKeeperPubkeys: h,
+        vaultProviderPubkey: h,
+        vaultKeeperPubkeys: d,
         universalChallengerPubkeys: g,
         hashlock: i[m],
         timelockRefund: a.timelockRefund,
         network: this.config.btcNetwork
       });
-      B.push(T), p.push(I.psbtHex), P.push(
-        ue(e, 1)
+      S.push(v), f.push(I.psbtHex), w.push(
+        ut(t, 1)
       );
     }
-    const l = Ve({
-      vaultCoreVersion: a.vaultCoreVersion,
-      protocolFeeRate: a.protocolFeeRate,
-      timelockPegin: a.timelockPegin,
-      timelockAssert: a.timelockAssert,
-      timelockRefund: a.timelockRefund,
-      prepeginTxid: v,
+    const u = this.buildPeginDepositTerms({
+      params: a,
+      prepeginTxid: B,
       prepeginMaxFee: r.fee,
-      vaultProviderBtcPubkey: u,
-      vaultKeeperBtcPubkeys: h,
-      universalChallengerBtcPubkeys: g,
-      maxAcceptableCommissionBps: Y(
-        a.commissionBps
-      ),
-      peginAmounts: a.amounts,
-      depositorClaimValue: d.depositorClaimValue,
-      peginMaxFee: d.minPeginFee
+      depositorClaimValue: l.depositorClaimValue,
+      peginMaxFee: l.minPeginFee
     });
-    U(this.config.btcWallet) && await this.config.btcWallet.approveDepositTerms(l);
-    const y = await ge(
+    F(this.config.btcWallet) && await this.config.btcWallet.approveDepositTerms(u);
+    const y = await gt(
       this.config.btcWallet,
-      p,
-      P
-    ), A = [];
+      f,
+      w
+    ), C = [];
     for (let m = 0; m < y.length; m++) {
-      gt({
-        requestedPsbtHex: p[m],
+      ge({
+        requestedPsbtHex: f[m],
         returnedPsbtHex: y[m]
       });
-      const T = re(
+      const v = rt(
         y[m],
         o
       );
-      se({
-        requestedPsbtHex: p[m],
-        signatureHex: T,
+      st({
+        requestedPsbtHex: f[m],
+        signatureHex: v,
         signerXOnlyPubkeyHex: o,
         inputIndex: 0
       });
-      const I = ie(y[m]);
-      A.push({
+      const I = it(y[m]);
+      C.push({
         htlcVout: m,
-        htlcValue: d.htlcValues[m],
+        htlcValue: l.htlcValues[m],
         peginTxHex: I,
-        peginTxid: B[m].txid,
-        peginInputSignature: T,
-        vaultScriptPubKey: B[m].vaultScriptPubKey
+        peginTxid: S[m].txid,
+        peginInputSignature: v,
+        vaultScriptPubKey: S[m].vaultScriptPubKey
       });
     }
     return {
-      fundedPrePeginTxHex: k,
-      prePeginTxid: v,
-      perVault: A,
-      depositTerms: l
+      fundedPrePeginTxHex: E,
+      prePeginTxid: B,
+      perVault: C,
+      depositTerms: u
     };
   }
   /**
@@ -912,88 +949,88 @@ class Zs {
    * @returns The broadcasted Bitcoin transaction ID
    * @throws Error if signing or broadcasting fails
    */
-  async signAndBroadcast(t) {
-    const { fundedPrePeginTxHex: e, depositorBtcPubkey: o } = t, i = e.startsWith("0x") ? e.slice(2) : e, n = Ct.fromHex(i);
+  async signAndBroadcast(e) {
+    const { fundedPrePeginTxHex: t, depositorBtcPubkey: o } = e, i = t.startsWith("0x") ? t.slice(2) : t, n = Ae.fromHex(i);
     if (n.ins.length === 0)
       throw new Error("Transaction has no inputs");
-    const r = new ht();
+    const r = new he();
     r.setVersion(n.version), r.setLocktime(n.locktime);
     const a = O.from(
       $(o),
       "hex"
-    ), c = this.config.mempoolApiUrl, u = n.ins.map((p) => {
-      const P = O.from(p.hash).reverse().toString("hex"), l = p.index;
-      return Ss(P, l, t.localPrevouts, c).then(
-        (y) => ({ input: p, utxoData: y, txid: P, vout: l })
+    ), c = this.config.mempoolApiUrl, h = n.ins.map((f) => {
+      const w = O.from(f.hash).reverse().toString("hex"), u = f.index;
+      return _s(w, u, e.localPrevouts, c).then(
+        (y) => ({ input: f, utxoData: y, txid: w, vout: u })
       );
-    }), h = await Promise.all(u), g = h.reduce(
-      (p, P) => p + BigInt(P.utxoData.value),
+    }), d = await Promise.all(h), g = d.reduce(
+      (f, w) => f + BigInt(w.utxoData.value),
       0n
-    ), w = n.outs.reduce(
-      (p, P) => p + BigInt(P.value),
+    ), P = n.outs.reduce(
+      (f, w) => f + BigInt(w.value),
       0n
     );
-    if (g < w)
+    if (g < P)
       throw new Error(
-        `UTXO value mismatch: total input value (${g} sat) is less than total output value (${w} sat). This may indicate the mempool API returned manipulated UTXO data.`
+        `UTXO value mismatch: total input value (${g} sat) is less than total output value (${P} sat). This may indicate the mempool API returned manipulated UTXO data.`
       );
-    const b = g - w;
-    if (b > bt)
+    const b = g - P;
+    if (b > be)
       throw new Error(
-        `Implied transaction fee (${b} sat) exceeds maximum reasonable fee (${bt} sat). This may indicate manipulated UTXO data.`
+        `Implied transaction fee (${b} sat) exceeds maximum reasonable fee (${be} sat). This may indicate manipulated UTXO data.`
       );
-    for (const { input: p, utxoData: P, txid: l, vout: y } of h) {
-      const A = we(
+    for (const { input: f, utxoData: w, txid: u, vout: y } of d) {
+      const C = Pt(
         {
-          value: P.value,
-          scriptPubKey: P.scriptPubKey
+          value: w.value,
+          scriptPubKey: w.scriptPubKey
         },
         a
       );
       r.addInput({
-        hash: p.hash,
-        index: p.index,
-        sequence: p.sequence,
-        ...A
+        hash: f.hash,
+        index: f.index,
+        sequence: f.sequence,
+        ...C
       });
     }
-    for (const p of n.outs)
+    for (const f of n.outs)
       r.addOutput({
-        script: p.script,
-        value: p.value
+        script: f.script,
+        value: f.value
       });
-    await Fe({
+    await Nt({
       wallet: this.config.btcWallet,
-      depositTerms: t.depositTerms,
-      fundedPrePeginTxHex: e,
+      depositTerms: e.depositTerms,
+      fundedPrePeginTxHex: t,
       depositorBtcPubkey: o
     });
-    const d = r.toHex(), E = await this.config.btcWallet.signPsbt(d);
-    gt({
-      requestedPsbtHex: d,
-      returnedPsbtHex: E
+    const l = r.toHex(), T = await this.config.btcWallet.signPsbt(l);
+    ge({
+      requestedPsbtHex: l,
+      returnedPsbtHex: T
     });
-    const k = ae({
-      requestedPsbtHex: d,
-      returnedPsbtHex: E
+    const E = at({
+      requestedPsbtHex: l,
+      returnedPsbtHex: T
     });
-    if (U(this.config.btcWallet) && k !== r.data.inputs.length)
+    if (F(this.config.btcWallet) && E !== r.data.inputs.length)
       throw new Error(
-        `Key-path verification covered ${k} of ${r.data.inputs.length} Pre-PegIn inputs; an approval wallet signs every input key-path, so the unverified ones must not be broadcast.`
+        `Key-path verification covered ${E} of ${r.data.inputs.length} Pre-PegIn inputs; an approval wallet signs every input key-path, so the unverified ones must not be broadcast.`
       );
-    const f = ht.fromHex(E);
+    const p = he.fromHex(T);
     try {
-      f.finalizeAllInputs();
-    } catch (p) {
-      if (!f.data.inputs.every(
-        (l) => l.finalScriptWitness || l.finalScriptSig
+      p.finalizeAllInputs();
+    } catch (f) {
+      if (!p.data.inputs.every(
+        (u) => u.finalScriptWitness || u.finalScriptSig
       ))
         throw new Error(
-          `PSBT finalization failed and wallet did not auto-finalize: ${p}`
+          `PSBT finalization failed and wallet did not auto-finalize: ${f}`
         );
     }
-    const v = f.extractTransaction().toHex();
-    return await ve(v, c);
+    const B = p.extractTransaction().toHex();
+    return await vt(B, c);
   }
   /**
    * Registers a peg-in on Ethereum by calling the BTCVaultRegistry contract.
@@ -1019,41 +1056,41 @@ class Zs {
    * @throws Error if contract simulation fails (e.g., invalid signature,
    *         unauthorized)
    */
-  async registerPeginOnChain(t) {
+  async registerPeginOnChain(e) {
     const {
-      unsignedPrePeginTx: e,
+      unsignedPrePeginTx: t,
       depositorSignedPeginTx: o,
       vaultProvider: i,
       hashlock: n,
       htlcVout: r,
       depositorPayoutBtcAddress: a,
       depositorWotsPkHash: c,
-      popSignature: u
-    } = t;
+      popSignature: h
+    } = e;
     if (!this.config.ethWallet.account)
       throw new Error("Ethereum wallet account not found");
-    const h = this.config.ethWallet.account.address;
-    if (!dt(u.depositorEthAddress, h))
+    const d = this.config.ethWallet.account.address;
+    if (!de(h.depositorEthAddress, d))
       throw new Error(
-        `Proof of possession was signed for ${u.depositorEthAddress} but the Ethereum wallet is currently connected to ${h}. Reconnect the original account or call signProofOfPossession() again.`
+        `Proof of possession was signed for ${h.depositorEthAddress} but the Ethereum wallet is currently connected to ${d}. Reconnect the original account or call signProofOfPossession() again.`
       );
-    const g = await this.assertPopMatchesBtcWallet(u), w = u.btcPopSignature, b = C(
-      u.depositorBtcPubkey
-    ), d = C(e), E = C(o), k = a ?? await this.config.btcWallet.getAddress(), f = this.resolvePayoutScriptPubKey(
+    const g = await this.assertPopMatchesBtcWallet(h), P = h.btcPopSignature, b = A(
+      h.depositorBtcPubkey
+    ), l = A(t), T = A(o), E = a ?? await this.config.btcWallet.getAddress(), p = this.resolvePayoutScriptPubKey(
       g,
-      k
-    ), v = q(E), B = await ft(
-      S(v),
-      S(h)
-    ), p = C(B);
-    if (await this.checkVaultExists(p))
+      E
+    ), B = q(T), S = await pe(
+      k(B),
+      k(d)
+    ), f = A(S);
+    if (await this.checkVaultExists(f))
       throw new Error(
-        `Vault already exists (ID: ${p}, peginTxHash: ${v}). 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: ${f}, peginTxHash: ${B}). Vault IDs are derived from the pegin transaction hash and depositor address. To create a new vault, use different UTXOs or a different amount to generate a unique transaction.`
       );
-    const l = this.config.publicClient;
+    const u = this.config.publicClient;
     let y;
     try {
-      y = await l.readContract({
+      y = await u.readContract({
         address: this.config.vaultContracts.btcVaultRegistry,
         abi: H,
         functionName: "getPegInFee",
@@ -1065,29 +1102,29 @@ class Zs {
         { cause: V }
       );
     }
-    const A = await this.resolveMaxAcceptableCommissionBps(
+    const C = await this.resolveMaxAcceptableCommissionBps(
       i,
-      t.quotedCommissionBps
-    ), m = tt({
+      e.quotedCommissionBps
+    ), m = ee({
       abi: H,
       functionName: "submitPeginRequest",
       args: [
-        h,
-        b,
-        w,
         d,
-        E,
+        b,
+        P,
+        l,
+        T,
         i,
-        A,
+        C,
         n,
         r,
-        f,
+        p,
         c
       ]
     });
-    let T;
+    let v;
     try {
-      T = await l.estimateGas({
+      v = await u.estimateGas({
         to: this.config.vaultContracts.btcVaultRegistry,
         data: m,
         value: y,
@@ -1104,16 +1141,16 @@ class Zs {
         value: y,
         account: this.config.ethWallet.account,
         chain: this.config.ethChain,
-        gas: T
+        gas: v
       });
     } catch (V) {
       R(V);
     }
-    const G = await Pt({
-      publicClient: l,
+    const G = await we({
+      publicClient: u,
       walletAddress: this.config.ethWallet.account.address,
       hash: I,
-      timeout: St
+      timeout: Be
     });
     return G.status === "reverted" && R(
       new Error(
@@ -1121,8 +1158,8 @@ class Zs {
       )
     ), {
       ethTxHash: G.transactionHash,
-      vaultId: p,
-      peginTxHash: v
+      vaultId: f,
+      peginTxHash: B
     };
   }
   /**
@@ -1135,142 +1172,142 @@ class Zs {
    * @param params - Batch registration parameters
    * @returns Batch result with per-vault IDs and single ETH tx hash
    */
-  async registerPeginBatchOnChain(t) {
-    const { vaultProvider: e, unsignedPrePeginTx: o, requests: i, popSignature: n } = t;
+  async registerPeginBatchOnChain(e) {
+    const { vaultProvider: t, unsignedPrePeginTx: o, requests: i, popSignature: n } = e;
     if (i.length === 0)
       throw new Error("Batch pegin requires at least one request");
     if (!this.config.ethWallet.account)
       throw new Error("Ethereum wallet account not found");
     const r = this.config.ethWallet.account.address;
-    if (!dt(n.depositorEthAddress, r))
+    if (!de(n.depositorEthAddress, r))
       throw new Error(
         `Proof of possession was signed for ${n.depositorEthAddress} but the Ethereum wallet is currently connected to ${r}. Reconnect the original account or call signProofOfPossession() again.`
       );
-    const a = await this.assertPopMatchesBtcWallet(n), c = n.btcPopSignature, u = i.map(
-      (l) => this.resolvePayoutScriptPubKey(
+    const a = await this.assertPopMatchesBtcWallet(n), c = n.btcPopSignature, h = i.map(
+      (u) => this.resolvePayoutScriptPubKey(
         a,
-        l.depositorPayoutBtcAddress
+        u.depositorPayoutBtcAddress
       )
-    ), h = [];
-    for (const l of i) {
-      const y = C(
-        l.depositorSignedPeginTx
-      ), A = q(y), m = await ft(
-        S(A),
-        S(r)
-      ), T = C(m);
-      if (await this.checkVaultExists(T))
+    ), d = [];
+    for (const u of i) {
+      const y = A(
+        u.depositorSignedPeginTx
+      ), C = q(y), m = await pe(
+        k(C),
+        k(r)
+      ), v = A(m);
+      if (await this.checkVaultExists(v))
         throw new Error(
-          `Vault already exists (ID: ${T}, peginTxHash: ${A}). To create a new vault, use different UTXOs or a different amount.`
+          `Vault already exists (ID: ${v}, peginTxHash: ${C}). To create a new vault, use different UTXOs or a different amount.`
         );
-      h.push({ vaultId: T, peginTxHash: A });
+      d.push({ vaultId: v, peginTxHash: C });
     }
     const g = this.config.publicClient;
-    let w;
+    let P;
     try {
-      w = await g.readContract({
+      P = await g.readContract({
         address: this.config.vaultContracts.btcVaultRegistry,
         abi: H,
         functionName: "getPegInFee",
-        args: [e]
+        args: [t]
       });
-    } catch (l) {
+    } catch (u) {
       throw new Error(
         "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct.",
-        { cause: l }
+        { cause: u }
       );
     }
-    const b = w * BigInt(i.length), d = await this.resolveMaxAcceptableCommissionBps(
-      e,
-      t.quotedCommissionBps
-    ), E = C(
+    const b = P * BigInt(i.length), l = await this.resolveMaxAcceptableCommissionBps(
+      t,
+      e.quotedCommissionBps
+    ), T = A(
       n.depositorBtcPubkey
-    ), k = C(o), f = i.map((l, y) => ({
-      depositorBtcPubKey: E,
+    ), E = A(o), p = i.map((u, y) => ({
+      depositorBtcPubKey: T,
       btcPopSignature: c,
-      unsignedPrePeginTx: k,
-      depositorSignedPeginTx: C(
-        l.depositorSignedPeginTx
+      unsignedPrePeginTx: E,
+      depositorSignedPeginTx: A(
+        u.depositorSignedPeginTx
       ),
-      hashlock: l.hashlock,
-      htlcVout: l.htlcVout,
-      referralCode: Kt,
-      depositorPayoutBtcAddress: u[y],
-      depositorWotsPkHash: l.depositorWotsPkHash
-    })), v = tt({
+      hashlock: u.hashlock,
+      htlcVout: u.htlcVout,
+      referralCode: Ke,
+      depositorPayoutBtcAddress: h[y],
+      depositorWotsPkHash: u.depositorWotsPkHash
+    })), B = ee({
       abi: H,
       functionName: "submitPeginRequestBatch",
       args: [
         r,
-        e,
-        d,
-        f
+        t,
+        l,
+        p
       ]
     });
-    let B;
+    let S;
     try {
-      B = await g.estimateGas({
+      S = await g.estimateGas({
         to: this.config.vaultContracts.btcVaultRegistry,
-        data: v,
+        data: B,
         value: b,
         account: this.config.ethWallet.account.address
       });
-    } catch (l) {
-      R(l);
+    } catch (u) {
+      R(u);
     }
-    let p;
+    let f;
     try {
-      p = await this.config.ethWallet.sendTransaction({
+      f = await this.config.ethWallet.sendTransaction({
         to: this.config.vaultContracts.btcVaultRegistry,
-        data: v,
+        data: B,
         value: b,
         account: this.config.ethWallet.account,
         chain: this.config.ethChain,
-        gas: B
+        gas: S
       });
-    } catch (l) {
-      R(l);
+    } catch (u) {
+      R(u);
     }
-    const P = await Pt({
+    const w = await we({
       publicClient: g,
       walletAddress: this.config.ethWallet.account.address,
-      hash: p,
-      timeout: St
+      hash: f,
+      timeout: Be
     });
-    return P.status === "reverted" && R(
+    return w.status === "reverted" && R(
       new Error(
-        `Batch transaction reverted. Hash: ${P.transactionHash}. Check the transaction on block explorer for details.`
+        `Batch transaction reverted. Hash: ${w.transactionHash}. Check the transaction on block explorer for details.`
       )
     ), {
-      ethTxHash: P.transactionHash,
-      vaults: h
+      ethTxHash: w.transactionHash,
+      vaults: d
     };
   }
   // Anchor to quoted+headroom when supplied (refuse if chain drifted past it);
   // otherwise fall back to chain-current+headroom — see #1691.
-  async resolveMaxAcceptableCommissionBps(t, e) {
-    if (e === void 0 && U(this.config.btcWallet))
+  async resolveMaxAcceptableCommissionBps(e, t) {
+    if (t === void 0 && F(this.config.btcWallet))
       throw new Error(
         "quotedCommissionBps is required when the wallet approved deposit terms: the registration ceiling must anchor to the approved quote."
       );
     let o;
     try {
-      o = await new Se(
+      o = await new Bt(
         this.config.publicClient,
         this.config.vaultContracts.btcVaultRegistry
-      ).getVaultProviderCommission(t);
+      ).getVaultProviderCommission(e);
     } catch (i) {
       throw new Error(
         "Failed to query vault provider commission from the contract. Please check your network connection and that the contract address is correct.",
         { cause: i }
       );
     }
-    if (e !== void 0) {
-      if (o > e + ot)
+    if (t !== void 0) {
+      if (o > t + oe)
         throw new Error(
-          `Vault provider commission changed since quote: quoted ${e} bps, chain currently reports ${o} bps (allowed drift ${ot} bps). Please refresh to see the new commission and try again.`
+          `Vault provider commission changed since quote: quoted ${t} bps, chain currently reports ${o} bps (allowed drift ${oe} bps). Please refresh to see the new commission and try again.`
         );
-      return Y(e);
+      return Y(t);
     }
     return Y(o);
   }
@@ -1287,13 +1324,13 @@ class Zs {
    * @returns True if vault exists, false otherwise
    * @throws If the underlying RPC read fails
    */
-  async checkVaultExists(t) {
+  async checkVaultExists(e) {
     return (await this.config.publicClient.readContract({
       address: this.config.vaultContracts.btcVaultRegistry,
       abi: H,
       functionName: "getBtcVaultBasicInfo",
-      args: [t]
-    })).depositor !== Qt;
+      args: [e]
+    })).depositor !== Qe;
   }
   /**
    * Resolve the BTC scriptPubKey to register as the depositor's payout sink.
@@ -1311,23 +1348,23 @@ class Zs {
    * state-race or stale FE state that lets a non-wallet address reach the
    * on-chain payout-script registration.
    */
-  resolvePayoutScriptPubKey(t, e) {
-    if (!mt(
-      e,
+  resolvePayoutScriptPubKey(e, t) {
+    if (!me(
       t,
+      e,
       this.config.btcNetwork
     ))
-      throw S(t).length === le && vs(e, this.config.btcNetwork) ? new Error(
-        `BTC payout address "${e}" 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.`
+      throw k(e).length === lt && Bs(t, this.config.btcNetwork) ? new Error(
+        `BTC payout address "${t}" is a P2WPKH (Native SegWit) address, but the connected wallet only exposes an x-only public key. P2WPKH validation requires a compressed key with known y-parity. Use a P2TR (Taproot) payout address instead.`
       ) : new Error(
-        `BTC payout address "${e}" 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.`
+        `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 = wt(this.config.btcNetwork);
+    const o = Pe(this.config.btcNetwork);
     try {
-      return `0x${At.address.toOutputScript(e, o).toString("hex")}`;
+      return `0x${Ce.address.toOutputScript(t, o).toString("hex")}`;
     } catch {
       throw new Error(
-        `Invalid BTC payout address: "${e}". Please provide a valid Bitcoin address for the ${this.config.btcNetwork} network.`
+        `Invalid BTC payout address: "${t}". Please provide a valid Bitcoin address for the ${this.config.btcNetwork} network.`
       );
     }
   }
@@ -1347,17 +1384,17 @@ class Zs {
   async signProofOfPossession() {
     if (!this.config.ethWallet.account)
       throw new Error("Ethereum wallet account not found");
-    const t = this.config.ethWallet.account.address, e = $(
+    const e = this.config.ethWallet.account.address, t = $(
       await this.config.btcWallet.getPublicKeyHex()
-    ), o = this.config.vaultContracts.btcVaultRegistry, i = `${t.toLowerCase()}:${this.config.ethChain.id}:pegin:${o.toLowerCase()}`, n = await this.config.btcWallet.signMessage(
+    ), o = this.config.vaultContracts.btcVaultRegistry, i = `${e.toLowerCase()}:${this.config.ethChain.id}:pegin:${o.toLowerCase()}`, n = await this.config.btcWallet.signMessage(
       i,
       "bip322-simple"
-    ), r = Ne(n);
+    ), r = Dt(n);
     return Ts(
       new TextEncoder().encode(i),
-      e,
+      t,
       r
-    ), { btcPopSignature: r, depositorEthAddress: t, depositorBtcPubkey: e };
+    ), { btcPopSignature: r, depositorEthAddress: e, depositorBtcPubkey: t };
   }
   /**
    * Confirm the connected BTC wallet still matches the PoP it produced, and
@@ -1367,13 +1404,13 @@ class Zs {
    * a parity-bearing compressed key — an x-only form would let an attacker
    * substitute the opposite-parity P2WPKH address.
    */
-  async assertPopMatchesBtcWallet(t) {
-    const e = await this.config.btcWallet.getPublicKeyHex(), o = $(e), i = $(t.depositorBtcPubkey);
+  async assertPopMatchesBtcWallet(e) {
+    const t = await this.config.btcWallet.getPublicKeyHex(), o = $(t), i = $(e.depositorBtcPubkey);
     if (o !== i)
       throw new Error(
         `Proof of possession was signed with BTC pubkey ${i} but the BTC wallet is currently connected to ${o}. Reconnect the original wallet or call signProofOfPossession() again.`
       );
-    return e;
+    return t;
   }
   /**
    * Gets the configured Bitcoin network.
@@ -1392,32 +1429,32 @@ class Zs {
     return this.config.vaultContracts.btcVaultRegistry;
   }
 }
-const _s = 80, Bs = 250, As = 300, Cs = 22, Xt = "ab";
-function Is(s, t) {
-  const e = Xt.repeat(As), o = S(s).toLowerCase(), i = t.toString(16).padStart(8, "0"), n = `${o}${i}`, r = e.slice(n.length);
+const Ss = 80, Cs = 250, As = 300, Is = 22, Xe = "ab";
+function Hs(s, e) {
+  const t = Xe.repeat(As), o = k(s).toLowerCase(), i = e.toString(16).padStart(8, "0"), n = `${o}${i}`, r = t.slice(n.length);
   return `0x${n}${r}`;
 }
-function Hs(s, t) {
-  const e = (o) => `0x${Xt.repeat(o)}`;
+function Rs(s, e) {
+  const t = (o) => `0x${Xe.repeat(o)}`;
   return {
-    depositorBtcPubKey: e(32),
-    btcPopSignature: e(_s),
-    unsignedPrePeginTx: e(Bs),
-    depositorSignedPeginTx: Is(
+    depositorBtcPubKey: t(32),
+    btcPopSignature: t(Ss),
+    unsignedPrePeginTx: t(Cs),
+    depositorSignedPeginTx: Hs(
       s,
-      t
+      e
     ),
-    hashlock: e(32),
-    htlcVout: t,
-    referralCode: Kt,
-    depositorPayoutBtcAddress: e(Cs),
-    depositorWotsPkHash: e(32)
+    hashlock: t(32),
+    htlcVout: e,
+    referralCode: Ke,
+    depositorPayoutBtcAddress: t(Is),
+    depositorWotsPkHash: t(32)
   };
 }
-async function Js(s) {
+async function eo(s) {
   const {
-    publicClient: t,
-    btcVaultRegistry: e,
+    publicClient: e,
+    btcVaultRegistry: t,
     depositorEthAddress: o,
     vaultProvider: i,
     batchSize: n
@@ -1426,41 +1463,41 @@ async function Js(s) {
     throw new Error(
       `estimateSubmitPeginRequestBatchGas requires batchSize >= 1 (received ${n})`
     );
-  const a = await t.readContract({
-    address: e,
+  const a = await e.readContract({
+    address: t,
     abi: H,
     functionName: "getPegInFee",
     args: [i]
   }) * BigInt(n), c = Array.from(
     { length: n },
-    (h, g) => Hs(o, g)
-  ), u = tt({
+    (d, g) => Rs(o, g)
+  ), h = ee({
     abi: H,
     functionName: "submitPeginRequestBatch",
     args: [
       o,
       i,
-      Ht,
+      He,
       c
     ]
   });
-  return t.estimateGas({
-    to: e,
-    data: u,
+  return e.estimateGas({
+    to: t,
+    data: h,
     value: a,
     account: o
   });
 }
 export {
-  ot as C,
-  Ht as M,
-  Zs as P,
+  oe as C,
+  He as M,
+  Js as P,
   Y as a,
-  Ve as b,
-  fs as c,
+  Vt as b,
+  ps as c,
   ds as d,
-  Js as e,
-  Fe as f,
-  ps as g
+  eo as e,
+  Nt as f,
+  fs as g
 };
-//# sourceMappingURL=PeginManager-Bsv6caG3.js.map
+//# sourceMappingURL=PeginManager-BI3pacy0.js.map