@babylonlabs-io/ts-sdk 0.55.2 → 0.56.1

package/dist/{buildAndBroadcastRefund-BiSO4zg2.js → buildAndBroadcastRefund-BtXUqBkb.js}

@@ -1,58 +1,58 @@
 var J = Object.defineProperty;
 var Z = (e, t, r) => t in e ? J(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var $ = (e, t, r) => Z(e, typeof t != "symbol" ? t + "" : t, r);
+var A = (e, t, r) => Z(e, typeof t != "symbol" ? t + "" : t, r);
 import { B as ee } from "./BTCVaultRegistry.abi-Chs4AFBj.js";
-import { e as te, v as re, s as p, u as X, p as A, f as E } from "./bitcoin-B5aNKtsk.js";
-import { v as ne, s as oe, P as ae, f as se } from "./PayoutManager-BJmPnyRP.js";
-import { D as w, c as ie, a as ue, R as le, d as z } from "./types-CQDRQvV-.js";
-import { Transaction as S, Psbt as ce } from "bitcoinjs-lib";
-import { c as he, d as I, e as N, f as H } from "./verifyScriptPathSchnorrSignature-DA4Z4yZ3.js";
-import { c as de, a as pe, b as ge } from "./noPayout-CfBg3HzC.js";
+import { e as te, v as re, s as d, u as X, p as R, f as E } from "./bitcoin-B5aNKtsk.js";
+import { v as oe, b as ne, s as se, P as ae, d as ie } from "./PayoutManager-BVgmuKuK.js";
+import { D as x, c as ue, a as le, R as ce, d as z } from "./types-CQDRQvV-.js";
+import { Transaction as S, Psbt as he } from "bitcoinjs-lib";
+import { c as pe, d as I, e as N, f as H } from "./verifyScriptPathSchnorrSignature-CgrnAjMW.js";
+import { c as de, a as ge, b as fe } from "./noPayout-CihCk1HE.js";
 import { c as O } from "./signing-DaLvGwQe.js";
-import { a as fe } from "./constants-BhclpREj.js";
-const me = /^0x[0-9a-fA-F]{64}$/, Pe = /^0x[0-9a-fA-F]{40}$/, be = /^0x([0-9a-fA-F]{2})*$/;
-function V(e, t) {
+import { a as me } from "./constants-CDQE812z.js";
+const be = /^0x[0-9a-fA-F]{64}$/, Pe = /^0x[0-9a-fA-F]{40}$/, ye = /^0x([0-9a-fA-F]{2})*$/;
+function $(e, t) {
   if (e.length !== 66)
     throw new Error(
       `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
     );
-  if (!me.test(e))
+  if (!be.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function ye(e, t) {
+function we(e, t) {
   if (!Pe.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function we(e, t) {
-  if (!be.test(e))
+function ve(e, t) {
+  if (!ye.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-async function ut(e) {
+async function lt(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
-    hashlock: n,
-    activationMetadata: s,
+    hashlock: o,
+    activationMetadata: i,
     writeContract: l,
-    signal: a
+    signal: n
   } = e;
-  a == null || a.throwIfAborted(), ye(t, "btcVaultRegistryAddress"), V(r, "vaultId");
-  const i = te(e.secret);
-  if (V(i, "secret"), n !== void 0 && (V(n, "hashlock"), !ne(i, n)))
+  n == null || n.throwIfAborted(), we(t, "btcVaultRegistryAddress"), $(r, "vaultId");
+  const s = te(e.secret);
+  if ($(s, "secret"), o !== void 0 && ($(o, "hashlock"), !oe(s, o)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
-  return we(s, "activationMetadata"), l({
+  return ve(i, "activationMetadata"), l({
     address: t,
     abi: ee,
     functionName: "activateVaultWithSecret",
-    args: [r, i, s]
+    args: [r, s, i]
   });
 }
 const xe = 1e4;
@@ -60,146 +60,146 @@ async function G(e) {
   const {
     statusReader: t,
     peginTxid: r,
-    targetStatuses: n,
-    timeoutMs: s,
+    targetStatuses: o,
+    timeoutMs: i,
     pollIntervalMs: l = xe,
-    signal: a
-  } = e, i = Date.now();
+    signal: n
+  } = e, s = Date.now();
   for (; ; ) {
-    if (a != null && a.aborted)
+    if (n != null && n.aborted)
       throw new Error(
-        `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+        `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
       );
-    if (Date.now() - i >= s)
+    if (Date.now() - s >= i)
       throw new Error(
-        `Polling timeout after ${s}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+        `Polling timeout after ${i}ms for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
       );
     try {
-      const o = await t.getPeginStatus(
+      const u = await t.getPeginStatus(
         { pegin_txid: r },
-        a
+        n
       );
-      if (o.pegin_txid.toLowerCase() !== r.toLowerCase())
+      if (u.pegin_txid.toLowerCase() !== r.toLowerCase())
         throw new Error(
-          `getPeginStatus returned status for pegin ${o.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
+          `getPeginStatus returned status for pegin ${u.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
         );
-      const u = o.status;
-      if (n.has(u) || u === w.ACTIVATED)
-        return u;
-      if (u === w.EXPIRED || ie.has(u))
+      const a = u.status;
+      if (o.has(a) || a === x.ACTIVATED)
+        return a;
+      if (a === x.EXPIRED || ue.has(a))
         throw new Error(
-          `Pegin ${r.slice(0, 8)}… reached terminal status "${u}" while waiting for ${[...n].join(", ")}`
+          `Pegin ${r.slice(0, 8)}… reached terminal status "${a}" while waiting for ${[...o].join(", ")}`
         );
-    } catch (o) {
-      if (!(o instanceof ue && o.code === le.PEGIN_NOT_FOUND))
-        throw o;
+    } catch (u) {
+      if (!(u instanceof le && u.code === ce.PEGIN_NOT_FOUND))
+        throw u;
     }
-    await new Promise((o, u) => {
+    await new Promise((u, a) => {
       const h = () => {
-        clearTimeout(c), u(
+        clearTimeout(c), a(
           new Error(
-            `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+            `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
           )
         );
       }, c = setTimeout(() => {
-        a == null || a.removeEventListener("abort", h), o();
+        n == null || n.removeEventListener("abort", h), u();
       }, l);
-      a == null || a.addEventListener("abort", h, { once: !0 });
+      n == null || n.addEventListener("abort", h, { once: !0 });
     });
   }
 }
-const ve = 300 * 1e3, Ee = /* @__PURE__ */ new Set([
-  w.PENDING_DEPOSITOR_WOTS_PK,
+const Ee = 300 * 1e3, Te = /* @__PURE__ */ new Set([
+  x.PENDING_DEPOSITOR_WOTS_PK,
   ...z
 ]);
-async function lt(e) {
+async function ct(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
-    peginTxid: n,
-    depositorPk: s,
+    peginTxid: o,
+    depositorPk: i,
     wotsPublicKeys: l,
-    timeoutMs: a = ve,
-    signal: i
+    timeoutMs: n = Ee,
+    signal: s
   } = e;
-  i == null || i.throwIfAborted();
-  const o = await G({
+  s == null || s.throwIfAborted();
+  const u = await G({
     statusReader: t,
-    peginTxid: n,
-    targetStatuses: Ee,
-    timeoutMs: a,
-    signal: i
+    peginTxid: o,
+    targetStatuses: Te,
+    timeoutMs: n,
+    signal: s
   });
-  z.has(o) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
+  z.has(u) || (s == null || s.throwIfAborted(), await r.submitDepositorWotsKey(
     {
-      pegin_txid: n,
-      depositor_pk: s,
+      pegin_txid: o,
+      depositor_pk: i,
       wots_public_keys: l
     },
-    i
+    s
   ));
 }
-const K = 1, Te = 1;
-function ke(e, t) {
-  const r = p(t).toLowerCase(), s = e.map((l) => p(l).toLowerCase()).filter((l) => l !== r);
-  if (s.length === 0)
+const F = 1, ke = 1;
+function _e(e, t) {
+  const r = d(t).toLowerCase(), i = e.map((l) => d(l).toLowerCase()).filter((l) => l !== r);
+  if (i.length === 0)
     throw new Error(
       "Cannot derive localChallengers: vault keeper set is empty (or contains only the depositor)"
     );
-  if (new Set(s).size !== s.length)
+  if (new Set(i).size !== i.length)
     throw new Error(
       "Cannot derive localChallengers: duplicate vaultKeeper key — signing context is misconfigured"
     );
-  return s;
+  return i;
 }
-function _e(e, t, r) {
-  const n = r.map(
-    (c) => p(c).toLowerCase()
-  ), s = t.filter((c) => n.includes(c));
-  if (s.length > 0)
+function Ce(e, t, r) {
+  const o = r.map(
+    (c) => d(c).toLowerCase()
+  ), i = t.filter((c) => o.includes(c));
+  if (i.length > 0)
     throw new Error(
-      `Cannot validate challenger set: vault keepers and universal challengers overlap (${s.join(", ")})`
+      `Cannot validate challenger set: vault keepers and universal challengers overlap (${i.join(", ")})`
     );
-  const l = [...t, ...n], a = e.map(
-    (c) => p(c.challenger_pubkey).toLowerCase()
-  ), i = new Set(a);
-  if (i.size !== a.length)
+  const l = [...t, ...o], n = e.map(
+    (c) => d(c.challenger_pubkey).toLowerCase()
+  ), s = new Set(n);
+  if (s.size !== n.length)
     throw new Error(
       "Depositor graph contains duplicate challenger entries in challenger_presign_data"
     );
-  const o = new Set(l), u = l.filter((c) => !i.has(c)), h = a.filter((c) => !o.has(c));
-  if (u.length > 0 || h.length > 0)
+  const u = new Set(l), a = l.filter((c) => !s.has(c)), h = n.filter((c) => !u.has(c));
+  if (a.length > 0 || h.length > 0)
     throw new Error(
-      "Depositor graph challenger set does not match expected (local ∪ universal)" + (u.length > 0 ? ` (missing: ${u.join(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
+      "Depositor graph challenger set does not match expected (local ∪ universal)" + (a.length > 0 ? ` (missing: ${a.join(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
     );
 }
-function Ce(e, t) {
+function Se(e, t) {
   const r = e.ins[t];
   return X(new Uint8Array(r.hash).slice().reverse());
 }
-function R(e, t, r, n, s) {
+function V(e, t, r, o, i) {
   const l = e.ins[t];
   if (l.index !== 0)
     throw new Error(
-      `NoPayout (challenger ${s}) input ${t} expected to spend ${n} vout 0, got vout ${l.index}`
+      `NoPayout (challenger ${i}) input ${t} expected to spend ${o} vout 0, got vout ${l.index}`
     );
-  const a = r.getId(), i = Ce(e, t);
-  if (i !== a)
+  const n = r.getId(), s = Se(e, t);
+  if (s !== n)
     throw new Error(
-      `NoPayout (challenger ${s}) input ${t} does not reference ${n} (expected txid ${a}, got ${i})`
+      `NoPayout (challenger ${i}) input ${t} does not reference ${o} (expected txid ${n}, got ${s})`
     );
 }
-async function Se(e, t, r) {
-  const n = [], s = [], l = [], a = ke(
+async function Re(e, t, r) {
+  const o = [], i = [], l = [], n = _e(
     r.vaultKeeperBtcPubkeys,
     r.depositorBtcPubkey
   );
-  _e(
+  Ce(
     e.challenger_presign_data,
-    a,
+    n,
     r.universalChallengerBtcPubkeys
   );
-  const i = await he({
+  const s = await pe({
     vaultCoreVersion: r.vaultCoreVersion,
     payoutTxHex: e.payout_tx.tx_hex,
     peginTxHex: r.peginTxHex,
@@ -212,208 +212,208 @@ async function Se(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: Te
+    commissionBps: ke,
+    protocolFeeRate: r.protocolFeeRate,
+    councilSize: r.councilMembers.length
   });
-  n.push(i.psbtHex), s.push(
+  o.push(s.psbtHex), i.push(
     O(
       t,
-      K
+      F
     )
   );
-  const o = p(r.depositorBtcPubkey), u = S.fromHex(
-    p(e.assert_tx.tx_hex)
+  const u = d(r.depositorBtcPubkey), a = S.fromHex(
+    d(e.assert_tx.tx_hex)
   );
   for (const h of e.challenger_presign_data) {
-    const c = p(h.challenger_pubkey), d = n.length, P = await Ae({
+    const c = d(h.challenger_pubkey), p = o.length, b = await Ae({
       challenger: h,
       challengerPubkey: c,
-      claimerPubkey: o,
-      localChallengers: a,
-      assertTxParsed: u,
+      claimerPubkey: u,
+      localChallengers: n,
+      assertTxParsed: a,
       ctx: r
     });
-    n.push(P), s.push(
+    o.push(b), i.push(
       O(
         t,
-        K
+        F
       )
     ), l.push({
       challengerPubkey: c,
-      noPayoutIdx: d
+      noPayoutIdx: p
     });
   }
-  return { psbtHexes: n, signOptions: s, challengerEntries: l };
+  return { psbtHexes: o, signOptions: i, challengerEntries: l };
 }
 async function Ae(e) {
   const {
     challenger: t,
     challengerPubkey: r,
-    claimerPubkey: n,
-    localChallengers: s,
+    claimerPubkey: o,
+    localChallengers: i,
     assertTxParsed: l,
-    ctx: a
+    ctx: n
   } = e;
   de(
     t.nopayout_tx.tx_hex,
     r,
-    a.network
+    n.network
   );
-  const i = S.fromHex(
-    p(t.nopayout_tx.tx_hex)
-  ), o = S.fromHex(
-    p(t.challenge_assert_x_tx.tx_hex)
+  const s = S.fromHex(
+    d(t.nopayout_tx.tx_hex)
   ), u = S.fromHex(
-    p(t.challenge_assert_y_tx.tx_hex)
+    d(t.challenge_assert_x_tx.tx_hex)
+  ), a = S.fromHex(
+    d(t.challenge_assert_y_tx.tx_hex)
   );
-  if (i.ins.length !== 3)
+  if (s.ins.length !== 3)
     throw new Error(
-      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${i.ins.length}`
+      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${s.ins.length}`
     );
-  R(
-    i,
+  V(
+    s,
     0,
     l,
     "Assert",
     r
-  ), R(
-    i,
+  ), V(
+    s,
     1,
-    o,
+    u,
     "ChallengeAssertX",
     r
-  ), R(
-    i,
+  ), V(
+    s,
     2,
-    u,
+    a,
     "ChallengeAssertY",
     r
   );
   const h = [
     l.outs[0],
-    o.outs[0],
-    u.outs[0]
+    u.outs[0],
+    a.outs[0]
   ].map((c) => ({
     script_pubkey: X(new Uint8Array(c.script)),
     value: c.value
   }));
-  return pe({
+  return ge({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
     prevouts: h,
     connectorParams: {
-      txGraphVersion: a.vaultCoreVersion,
-      claimer: n,
-      localChallengers: s,
-      universalChallengers: a.universalChallengerBtcPubkeys,
-      timelockAssert: a.timelockAssert,
-      councilMembers: a.councilMembers,
-      councilQuorum: a.councilQuorum
+      txGraphVersion: n.vaultCoreVersion,
+      claimer: o,
+      localChallengers: i,
+      universalChallengers: n.universalChallengerBtcPubkeys,
+      timelockAssert: n.timelockAssert,
+      councilMembers: n.councilMembers,
+      councilQuorum: n.councilQuorum
     }
   });
 }
 function $e(e, t, r) {
   I(e[0]);
-  const s = N(
+  const i = N(
     e[0].returnedPsbtHex,
     r
   );
   H({
     requestedPsbtHex: e[0].requestedPsbtHex,
-    signatureHex: s,
+    signatureHex: i,
     signerXOnlyPubkeyHex: r,
     inputIndex: 0
   });
   const l = {};
-  for (const a of t) {
-    I(e[a.noPayoutIdx]);
-    const i = N(
-      e[a.noPayoutIdx].returnedPsbtHex,
+  for (const n of t) {
+    I(e[n.noPayoutIdx]);
+    const s = N(
+      e[n.noPayoutIdx].returnedPsbtHex,
       r
     );
     H({
-      requestedPsbtHex: e[a.noPayoutIdx].requestedPsbtHex,
-      signatureHex: i,
+      requestedPsbtHex: e[n.noPayoutIdx].requestedPsbtHex,
+      signatureHex: s,
       signerXOnlyPubkeyHex: r,
       inputIndex: 0
-    }), l[a.challengerPubkey] = {
-      nopayout_signature: i
+    }), l[n.challengerPubkey] = {
+      nopayout_signature: s
     };
   }
   return {
     payout_signatures: {
-      payout_signature: s
+      payout_signature: i
     },
     per_challenger: l
   };
 }
 async function Ve(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, s = await r.getPublicKeyHex(), { depositorPubkey: l } = re(
-    s,
-    p(n.depositorBtcPubkey)
-  ), { psbtHexes: a, signOptions: i, challengerEntries: o } = await Se(
+  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, i = await r.getPublicKeyHex(), { depositorPubkey: l } = re(
+    i,
+    d(o.depositorBtcPubkey)
+  ), { psbtHexes: n, signOptions: s, challengerEntries: u } = await Re(
     t,
-    s,
-    n
-  ), u = await oe(
+    i,
+    o
+  ), a = await ne(
     r,
-    a,
-    i
-  ), h = a.map((c, d) => ({
+    n,
+    s
+  ), h = n.map((c, p) => ({
     requestedPsbtHex: c,
-    returnedPsbtHex: u[d]
+    returnedPsbtHex: a[p]
   }));
   return $e(
     h,
-    o,
+    u,
     l
   );
 }
-const Re = 1200 * 1e3, q = /* @__PURE__ */ new Set([
-  w.PENDING_ACKS,
-  w.PENDING_ACTIVATION,
-  w.ACTIVATED_PENDING_BROADCAST,
-  w.ACTIVATED
-]), Be = /* @__PURE__ */ new Set([
-  w.PENDING_DEPOSITOR_SIGNATURES,
+const Be = 1200 * 1e3, q = /* @__PURE__ */ new Set([
+  x.PENDING_ACKS,
+  x.PENDING_ACTIVATION,
+  x.ACTIVATED_PENDING_BROADCAST,
+  x.ACTIVATED
+]), Ie = /* @__PURE__ */ new Set([
+  x.PENDING_DEPOSITOR_SIGNATURES,
   ...q
 ]);
-function Ie(e) {
+function Ne(e) {
   return e.map((t) => ({
-    claimerPubkeyXOnly: A(t.claimer_pubkey),
+    claimerPubkeyXOnly: R(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
 function _(e) {
-  return A(e).toLowerCase();
+  return R(e).toLowerCase();
 }
-function Ne(e, t, r, n) {
-  const s = _(n), l = [
+function He(e, t, r, o) {
+  const i = _(o), l = [
     _(t),
     ...r.map(_)
-  ], a = new Set(l);
-  if (a.size !== l.length)
+  ], n = new Set(l);
+  if (n.size !== l.length)
     throw new Error(
       "Cannot validate claimer set: signing context contains duplicate vault provider or vault keeper key"
     );
-  if (a.has(s))
+  if (n.has(i))
     throw new Error(
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
-  const i = e.map(
-    (d) => _(d.claimer_pubkey)
+  const s = e.map(
+    (p) => _(p.claimer_pubkey)
   );
-  if (new Set(i).size !== i.length)
-    throw new Error(
-      "Presign response contains duplicate claimer entries"
-    );
-  const o = i.filter((d) => d !== s), u = new Set(o), h = l.filter((d) => !u.has(d)), c = o.filter((d) => !a.has(d));
+  if (new Set(s).size !== s.length)
+    throw new Error("Presign response contains duplicate claimer entries");
+  const u = s.filter((p) => p !== i), a = new Set(u), h = l.filter((p) => !a.has(p)), c = u.filter((p) => !n.has(p));
   if (h.length > 0 || c.length > 0)
     throw new Error(
       "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (h.length > 0 ? ` (missing: ${h.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
     );
 }
-function U(e, t) {
+function K(e, t) {
   return {
     vaultCoreVersion: t.vaultCoreVersion,
     payoutTxHex: e.payoutTxHex,
@@ -426,125 +426,139 @@ function U(e, t) {
     timelockPegin: t.timelockPegin,
     registeredPayoutScriptPubKey: t.registeredPayoutScriptPubKey,
     claimerBtcPubkey: e.claimerPubkeyXOnly,
-    commissionBps: t.commissionBps
+    commissionBps: t.commissionBps,
+    protocolFeeRate: t.protocolFeeRate,
+    councilSize: t.councilMembers.length
   };
 }
-async function He(e, t, r, n) {
-  const s = new ae({
+async function Oe(e, t, r, o) {
+  const i = new ae({
     network: t.network,
     btcWallet: e
   }), l = r.length;
-  n == null || n(0, l);
-  let a;
-  if (s.supportsBatchSigning())
-    a = (await s.signPayoutTransactionsBatch(
-      r.map((u) => U(u, t))
-    )).map((u) => u.payoutSignature);
+  o == null || o(0, l);
+  let n;
+  if (i.supportsBatchSigning())
+    n = (await i.signPayoutTransactionsBatch(
+      r.map((a) => K(a, t))
+    )).map((a) => a.payoutSignature);
   else {
-    a = [];
-    for (let o = 0; o < r.length; o++) {
-      n == null || n(o, l);
-      const u = await s.signPayoutTransaction(
-        U(r[o], t)
+    n = [];
+    for (let u = 0; u < r.length; u++) {
+      o == null || o(u, l);
+      const a = await i.signPayoutTransaction(
+        K(r[u], t)
       );
-      a.push(u.signature);
+      n.push(a.signature);
     }
   }
-  const i = {};
-  for (let o = 0; o < r.length; o++)
-    i[r[o].claimerPubkeyXOnly] = {
-      payout_signature: a[o]
+  const s = {};
+  for (let u = 0; u < r.length; u++)
+    s[r[u].claimerPubkeyXOnly] = {
+      payout_signature: n[u]
     };
-  return n == null || n(l, l), i;
+  return o == null || o(l, l), s;
 }
-async function ct(e) {
+async function ht(e) {
   const {
     statusReader: t,
     presignClient: r,
-    btcWallet: n,
-    peginTxid: s,
+    btcWallet: o,
+    peginTxid: i,
     depositorPk: l,
-    signingContext: a,
-    timeoutMs: i = Re,
-    signal: o,
-    onProgress: u
-  } = e, h = await G({
+    signingContext: n,
+    depositTerms: s,
+    timeoutMs: u = Be,
+    signal: a,
+    onProgress: h
+  } = e, c = await G({
     statusReader: t,
-    peginTxid: s,
-    targetStatuses: Be,
-    timeoutMs: i,
-    signal: o
+    peginTxid: i,
+    targetStatuses: Ie,
+    timeoutMs: u,
+    signal: a
   });
-  if (q.has(h))
+  if (q.has(c))
     return;
-  o == null || o.throwIfAborted();
-  const c = await r.requestDepositorPresignTransactions(
+  if (a == null || a.throwIfAborted(), s !== void 0 && s.baseFeeRate !== n.protocolFeeRate)
+    throw new Error(
+      `Deposit terms baseFeeRate (${s.baseFeeRate} sat/vB) does not match the vault's version-locked protocolFeeRate (${n.protocolFeeRate} sat/vB); refusing to sign payouts against terms built from a different params version.`
+    );
+  if (se(o)) {
+    if (!s)
+      throw new Error(
+        "runDepositorPresignFlow: this wallet requires approved deposit terms but none were provided. Fresh deposits must pass PreparePeginResult.depositTerms; resume-path rebuild is not wired yet."
+      );
+    await o.approveDepositTerms(s);
+  }
+  const p = await r.requestDepositorPresignTransactions(
     {
-      pegin_txid: s,
+      pegin_txid: i,
       depositor_pk: l
     },
-    o
+    a
   );
-  o == null || o.throwIfAborted();
-  const d = _(l);
-  Ne(
-    c.txs,
-    a.vaultProviderBtcPubkey,
-    a.vaultKeeperBtcPubkeys,
+  a == null || a.throwIfAborted();
+  const b = _(l);
+  He(
+    p.txs,
+    n.vaultProviderBtcPubkey,
+    n.vaultKeeperBtcPubkeys,
     l
   );
-  const P = c.txs.filter(
-    (v) => _(v.claimer_pubkey) !== d
-  ), m = Ie(P), y = await He(
+  const m = p.txs.filter(
+    (v) => _(v.claimer_pubkey) !== b
+  ), y = Ne(m), T = await Oe(
+    o,
     n,
-    a,
-    m,
-    u
+    y,
+    h
   );
-  o == null || o.throwIfAborted();
-  const x = await Ve({
-    depositorGraph: c.depositor_graph,
-    btcWallet: n,
+  a == null || a.throwIfAborted();
+  const P = await Ve({
+    depositorGraph: p.depositor_graph,
+    btcWallet: o,
     signingContext: {
-      vaultCoreVersion: a.vaultCoreVersion,
-      peginTxHex: a.peginTxHex,
+      vaultCoreVersion: n.vaultCoreVersion,
+      peginTxHex: n.peginTxHex,
       depositorBtcPubkey: l,
-      vaultProviderBtcPubkey: a.vaultProviderBtcPubkey,
-      vaultKeeperBtcPubkeys: a.vaultKeeperBtcPubkeys,
-      universalChallengerBtcPubkeys: a.universalChallengerBtcPubkeys,
-      timelockPegin: a.timelockPegin,
-      timelockAssert: a.timelockAssert,
-      councilMembers: a.councilMembers,
-      councilQuorum: a.councilQuorum,
-      network: a.network,
-      registeredPayoutScriptPubKey: a.registeredPayoutScriptPubKey
+      vaultProviderBtcPubkey: n.vaultProviderBtcPubkey,
+      vaultKeeperBtcPubkeys: n.vaultKeeperBtcPubkeys,
+      universalChallengerBtcPubkeys: n.universalChallengerBtcPubkeys,
+      timelockPegin: n.timelockPegin,
+      timelockAssert: n.timelockAssert,
+      councilMembers: n.councilMembers,
+      councilQuorum: n.councilQuorum,
+      network: n.network,
+      registeredPayoutScriptPubKey: n.registeredPayoutScriptPubKey,
+      protocolFeeRate: n.protocolFeeRate
     }
   });
-  o == null || o.throwIfAborted();
-  const b = { ...y };
-  b[p(l)] = x.payout_signatures, await r.submitDepositorPresignatures(
+  a == null || a.throwIfAborted();
+  const w = { ...T };
+  w[d(l)] = P.payout_signatures, await r.submitDepositorPresignatures(
     {
-      pegin_txid: s,
+      pegin_txid: i,
       depositor_pk: l,
-      signatures: b,
-      depositor_claimer_presignatures: x
+      signatures: w,
+      depositor_claimer_presignatures: P
     },
-    o
+    a
   );
 }
-function Oe(e) {
+function De(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function ht(e) {
+function pt(e) {
   const {
     amountSats: t,
     minDeposit: r,
-    maxDeposit: n,
-    btcBalance: s,
+    maxDeposit: o,
+    btcBalance: i,
     estimatedFeeSats: l,
-    depositorClaimValue: a
+    depositorClaimValue: n
   } = e;
-  return !(t <= 0n || t < r || n && n > 0n && t > n || l == null || a == null || t + l + a > s);
+  return !(t <= 0n || t < r || o && o > 0n && t > o || l == null || n == null || t + l + n > i);
 }
 function dt(e, t, r) {
   return e <= 0n ? {
@@ -558,7 +572,7 @@ function dt(e, t, r) {
     error: `Maximum deposit is ${E(r)} BTC`
   } : { valid: !0 };
 }
-function pt(e) {
+function gt(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
@@ -568,51 +582,51 @@ function pt(e) {
     error: `Vault size exceeds remaining capacity (${E(r)} BTC)`
   } : { valid: !0 };
 }
-function gt(e, t) {
+function ft(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
       error: "At least one vault provider must be selected"
     };
   const r = t.map(
-    (s) => s.toLowerCase()
+    (i) => i.toLowerCase()
   );
   return e.filter(
-    (s) => !r.includes(s.toLowerCase())
+    (i) => !r.includes(i.toLowerCase())
   ).length > 0 ? {
     valid: !1,
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function De(e, t, r) {
+function Fe(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
       error: "At least one vault amount required"
     };
-  for (let n = 0; n < e.length; n++) {
-    const s = e[n];
-    if (s <= 0n)
+  for (let o = 0; o < e.length; o++) {
+    const i = e[o];
+    if (i <= 0n)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount must be positive`
+        error: `Vault ${o + 1} amount must be positive`
       };
-    if (t && s < t)
+    if (t && i < t)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${E(s)} BTC is below minimum deposit ${E(t)} BTC`
+        error: `Vault ${o + 1} amount ${E(i)} BTC is below minimum deposit ${E(t)} BTC`
       };
-    if (r && s > r)
+    if (r && i > r)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${E(s)} BTC exceeds maximum deposit ${E(r)} BTC`
+        error: `Vault ${o + 1} amount ${E(i)} BTC exceeds maximum deposit ${E(r)} BTC`
       };
   }
   return { valid: !0 };
 }
 function Ke(e) {
-  const t = p(e);
-  return Oe(t) ? { valid: !0 } : {
+  const t = d(e);
+  return De(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
@@ -623,85 +637,85 @@ function Ue(e) {
       "No vault keepers available. The system requires at least one vault keeper to create a deposit."
     );
 }
-function Fe(e) {
+function Me(e) {
   if (!e || e.length === 0)
     throw new Error(
       "No universal challengers available. The system requires at least one universal challenger to create a deposit."
     );
 }
-function Me(e) {
+function Le(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function ft(e) {
+function mt(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
-    vaultProviderBtcPubkey: n,
-    vaultKeeperBtcPubkeys: s,
+    vaultProviderBtcPubkey: o,
+    vaultKeeperBtcPubkeys: i,
     universalChallengerBtcPubkeys: l,
-    minDeposit: a,
-    maxDeposit: i
-  } = e, o = De(
+    minDeposit: n,
+    maxDeposit: s
+  } = e, u = Fe(
     t,
-    a,
-    i
+    n,
+    s
   );
-  if (!o.valid)
-    throw new Error(o.error);
-  const u = Ke(n);
   if (!u.valid)
     throw new Error(u.error);
-  Ue(s), Fe(l), Me(r);
+  const a = Ke(o);
+  if (!a.valid)
+    throw new Error(a.error);
+  Ue(i), Me(l), Le(r);
 }
-async function mt(e) {
+async function bt(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
-    universalChallengerReader: n,
-    vaultProviderEthAddress: s,
+    universalChallengerReader: o,
+    vaultProviderEthAddress: i,
     applicationEntryPoint: l,
-    expectedVaultProviderBtcPubkey: a,
-    expectedVaultKeeperBtcPubkeys: i,
-    expectedUniversalChallengerBtcPubkeys: o
+    expectedVaultProviderBtcPubkey: n,
+    expectedVaultKeeperBtcPubkeys: s,
+    expectedUniversalChallengerBtcPubkeys: u
   } = e, [
-    u,
+    a,
     h,
     c
   ] = await Promise.all([
-    t.getVaultProviderBtcPubKey(s),
+    t.getVaultProviderBtcPubKey(i),
     r.getCurrentVaultKeepersVersion(l),
-    n.getLatestUniversalChallengersVersion()
-  ]), [d, P] = await Promise.all([
+    o.getLatestUniversalChallengersVersion()
+  ]), [p, b] = await Promise.all([
     r.getVaultKeepersByVersion(
       l,
       h
     ),
-    n.getUniversalChallengersByVersion(
+    o.getUniversalChallengersByVersion(
       c
     )
-  ]), m = (g) => A(g).toLowerCase(), y = (g) => g.map(m).sort();
-  if (m(a) !== u)
+  ]), m = (g) => R(g).toLowerCase(), y = (g) => g.map(m).sort();
+  if (m(n) !== a)
     throw new Error(
-      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${s}. Refresh and try again.`
+      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${i}. Refresh and try again.`
     );
-  const b = y(i), v = y(
-    d.map((g) => g.btcPubKey)
+  const P = y(s), w = y(
+    p.map((g) => g.btcPubKey)
   );
-  if (b.length !== v.length || b.some((g, C) => g !== v[C]))
+  if (P.length !== w.length || P.some((g, C) => g !== w[C]))
     throw new Error(
       `Vault keeper BTC pubkeys (v${h}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  const T = y(o), k = y(
-    P.map((g) => g.btcPubKey)
+  const v = y(u), k = y(
+    b.map((g) => g.btcPubKey)
   );
-  if (T.length !== k.length || T.some((g, C) => g !== k[C]))
+  if (v.length !== k.length || v.some((g, C) => g !== k[C]))
     throw new Error(
       `Universal challenger BTC pubkeys (v${c}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
     );
   return {
-    vaultProviderBtcPubkeyXOnly: u,
-    vaultKeeperBtcPubkeysSorted: v,
+    vaultProviderBtcPubkeyXOnly: a,
+    vaultKeeperBtcPubkeysSorted: w,
     universalChallengerBtcPubkeysSorted: k,
     expectedAppVaultKeepersVersion: h,
     expectedUniversalChallengersVersion: c
@@ -715,54 +729,54 @@ class j extends Error {
 function Pt(e) {
   return e instanceof j || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function bt(e) {
+async function yt(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
-    expectedOffchainParamsVersion: n,
-    expectedAppVaultKeepersVersion: s,
+    expectedOffchainParamsVersion: o,
+    expectedAppVaultKeepersVersion: i,
     expectedUniversalChallengersVersion: l,
-    expectedVaultCoreVersion: a
-  } = e, i = await t.getProtocolInfoBatch(r), o = [];
-  if (i.forEach((u, h) => {
+    expectedVaultCoreVersion: n
+  } = e, s = await t.getProtocolInfoBatch(r), u = [];
+  if (s.forEach((a, h) => {
     const c = r[h];
-    u.offchainParamsVersion !== n && o.push(
-      `vault ${c}: offchainParams expected v${n}, got v${u.offchainParamsVersion}`
-    ), u.appVaultKeepersVersion !== s && o.push(
-      `vault ${c}: appVaultKeepers expected v${s}, got v${u.appVaultKeepersVersion}`
-    ), u.universalChallengersVersion !== l && o.push(
-      `vault ${c}: universalChallengers expected v${l}, got v${u.universalChallengersVersion}`
-    ), u.vaultCoreVersion !== a && o.push(
-      `vault ${c}: vaultCoreVersion expected v${a} (build-time active), got v${u.vaultCoreVersion}`
-    );
-  }), o.length > 0)
+    a.offchainParamsVersion !== o && u.push(
+      `vault ${c}: offchainParams expected v${o}, got v${a.offchainParamsVersion}`
+    ), a.appVaultKeepersVersion !== i && u.push(
+      `vault ${c}: appVaultKeepers expected v${i}, got v${a.appVaultKeepersVersion}`
+    ), a.universalChallengersVersion !== l && u.push(
+      `vault ${c}: universalChallengers expected v${l}, got v${a.universalChallengersVersion}`
+    ), a.vaultCoreVersion !== n && u.push(
+      `vault ${c}: vaultCoreVersion expected v${n} (build-time active), got v${a.vaultCoreVersion}`
+    );
+  }), u.length > 0)
     throw new j(
-      `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${o.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
+      `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${u.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
 var Q = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(Q || {});
-const Le = /* @__PURE__ */ new Set([
+const Xe = /* @__PURE__ */ new Set([
   "PayoutBroadcast",
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function yt(e) {
+function wt(e) {
   return Object.values(Q).includes(
     e
   );
 }
-function wt(e) {
-  return !!e && Le.has(e);
-}
-class Xe extends Error {
-  constructor(r, n) {
-    super(`Refund not yet mature (BIP68 not final): ${n.message}`);
-    $(this, "vaultId");
-    $(this, "cause");
-    this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = n;
+function vt(e) {
+  return !!e && Xe.has(e);
+}
+class ze extends Error {
+  constructor(r, o) {
+    super(`Refund not yet mature (BIP68 not final): ${o.message}`);
+    A(this, "vaultId");
+    A(this, "cause");
+    this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
   }
 }
-const ze = /^0x[0-9a-fA-F]{64}$/, Ge = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Y = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, W = 160, F = 2e3, M = 10n, L = 100n;
+const Ge = /^0x[0-9a-fA-F]{64}$/, qe = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Y = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, W = 160, U = 2e3, M = 10n, L = 100n;
 function xt(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
@@ -770,13 +784,13 @@ function xt(e) {
     );
   return BigInt(Math.ceil(e * W));
 }
-const qe = 1, je = /non-BIP68-final/i;
+const je = 1, Qe = /non-BIP68-final/i;
 function D(e, t) {
   if (e.length !== 66)
     throw new Error(
       `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
     );
-  if (!ze.test(e))
+  if (!Ge.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
@@ -785,7 +799,7 @@ function B(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function Qe(e) {
+function Ye(e) {
   if (D(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
     throw new Error(
       `htlcVout must be a non-negative integer, got ${e.htlcVout}`
@@ -797,14 +811,14 @@ function Qe(e) {
       `htlcVout ${e.htlcVout} is out of range for batch of size ${e.batch.length}`
     );
   for (let r = 0; r < e.batch.length; r++) {
-    const n = e.batch[r];
-    if (D(n.hashlock, `batch[${r}].hashlock`), !Number.isInteger(n.htlcVout) || n.htlcVout !== r)
+    const o = e.batch[r];
+    if (D(o.hashlock, `batch[${r}].hashlock`), !Number.isInteger(o.htlcVout) || o.htlcVout !== r)
       throw new Error(
-        `batch[${r}].htlcVout must equal ${r} (contiguous vout-ordered vector), got ${n.htlcVout}`
+        `batch[${r}].htlcVout must equal ${r} (contiguous vout-ordered vector), got ${o.htlcVout}`
       );
-    if (typeof n.amount != "bigint" || n.amount <= 0n)
+    if (typeof o.amount != "bigint" || o.amount <= 0n)
       throw new Error(
-        `batch[${r}].amount must be a positive bigint, got ${n.amount}`
+        `batch[${r}].amount must be a positive bigint, got ${o.amount}`
       );
   }
   const t = e.batch[e.htlcVout];
@@ -819,12 +833,12 @@ function Qe(e) {
   if (B(e.offchainParamsVersion, "offchainParamsVersion"), B(e.appVaultKeepersVersion, "appVaultKeepersVersion"), B(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), fe(
+  ), me(
     e.vaultCoreVersion,
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!Ge.test(e.unsignedPrePeginTxHex))
+  if (!qe.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
@@ -835,7 +849,7 @@ function Qe(e) {
   if (typeof e.amount != "bigint" || e.amount <= 0n)
     throw new Error(`amount must be a positive bigint, got ${e.amount}`);
 }
-function Ye(e) {
+function We(e) {
   if (!e.vaultProviderPubkey || !Y.test(e.vaultProviderPubkey))
     throw new Error("vaultProviderPubkey must be 32 or 33 bytes of hex");
   if (e.vaultKeeperPubkeys.length === 0)
@@ -861,150 +875,150 @@ function Ye(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-function We(e) {
-  const t = ce.fromHex(e);
+function Je(e) {
+  const t = he.fromHex(e);
   try {
     t.finalizeAllInputs();
   } catch (r) {
-    const n = r instanceof Error ? r.message : String(r);
-    if (!n.includes("already finalized"))
-      throw new Error(`Failed to finalize refund PSBT: ${n}`);
+    const o = r instanceof Error ? r.message : String(r);
+    if (!o.includes("already finalized"))
+      throw new Error(`Failed to finalize refund PSBT: ${o}`);
   }
   return t.extractTransaction().toHex();
 }
-async function vt(e) {
+async function Et(e) {
   const {
     vaultId: t,
     readVault: r,
-    readPrePeginContext: n,
-    feeRate: s,
+    readPrePeginContext: o,
+    feeRate: i,
     signPsbt: l,
-    broadcastTx: a,
-    signal: i
+    broadcastTx: n,
+    signal: s
   } = e;
-  i == null || i.throwIfAborted(), D(t, "vaultId");
-  const o = await r();
-  Qe(o), i == null || i.throwIfAborted();
-  const u = await n(o);
-  if (Ye(u), i == null || i.throwIfAborted(), !Number.isFinite(s) || s <= 0)
-    throw new Error(`feeRate must be a positive number, got ${s}`);
-  if (s > F)
+  s == null || s.throwIfAborted(), D(t, "vaultId");
+  const u = await r();
+  Ye(u), s == null || s.throwIfAborted();
+  const a = await o(u);
+  if (We(a), s == null || s.throwIfAborted(), !Number.isFinite(i) || i <= 0)
+    throw new Error(`feeRate must be a positive number, got ${i}`);
+  if (i > U)
     throw new Error(
-      `feeRate ${s} sat/vB exceeds refund safety cap ${F} sat/vB; refusing to sign refund.`
+      `feeRate ${i} sat/vB exceeds refund safety cap ${U} sat/vB; refusing to sign refund.`
     );
-  const h = BigInt(Math.ceil(s * W)), c = o.amount * M / L;
+  const h = BigInt(Math.ceil(i * W)), c = u.amount * M / L;
   if (h > c)
     throw new Error(
-      `Refund fee ${h} sats exceeds the per-vault safety cap of ${c} sats (${M}/${L} of vault.amount=${o.amount}); refusing to sign refund.`
+      `Refund fee ${h} sats exceeds the per-vault safety cap of ${c} sats (${M}/${L} of vault.amount=${u.amount}); refusing to sign refund.`
     );
-  i == null || i.throwIfAborted();
-  const d = A(
-    o.depositorBtcPubkey
-  ), P = p(o.unsignedPrePeginTxHex), m = se(P);
-  if (m !== void 0 && m.vout !== o.batch.length)
+  s == null || s.throwIfAborted();
+  const p = R(
+    u.depositorBtcPubkey
+  ), b = d(u.unsignedPrePeginTxHex), m = ie(b);
+  if (m !== void 0 && m.vout !== u.batch.length)
     throw new Error(
-      `Auth-anchor OP_RETURN at vout ${m.vout} does not match batch size (${o.batch.length} HTLC outputs expect the anchor at vout ${o.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
+      `Auth-anchor OP_RETURN at vout ${m.vout} does not match batch size (${u.batch.length} HTLC outputs expect the anchor at vout ${u.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
     );
   const y = m == null ? void 0 : m.hash;
-  let x;
+  let T;
   try {
-    x = S.fromHex(P);
+    T = S.fromHex(b);
   } catch (f) {
     throw new Error(
       `Failed to parse funded Pre-PegIn transaction hex: ${f instanceof Error ? f.message : String(f)}`
     );
   }
-  if (x.outs.length < o.batch.length)
+  if (T.outs.length < u.batch.length)
     throw new Error(
-      `Funded Pre-PegIn tx has ${x.outs.length} outputs but batch requires at least ${o.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
+      `Funded Pre-PegIn tx has ${T.outs.length} outputs but batch requires at least ${u.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const { psbtHex: b } = await ge({
+  const { psbtHex: P } = await fe({
     prePeginParams: {
-      vaultCoreVersion: o.vaultCoreVersion,
-      depositorPubkey: d,
-      vaultProviderPubkey: p(u.vaultProviderPubkey),
-      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(p),
-      universalChallengerPubkeys: u.universalChallengerPubkeys.map(p),
-      hashlocks: o.batch.map((f) => p(f.hashlock)),
-      timelockRefund: u.timelockRefund,
+      vaultCoreVersion: u.vaultCoreVersion,
+      depositorPubkey: p,
+      vaultProviderPubkey: d(a.vaultProviderPubkey),
+      vaultKeeperPubkeys: a.vaultKeeperPubkeys.map(d),
+      universalChallengerPubkeys: a.universalChallengerPubkeys.map(d),
+      hashlocks: u.batch.map((f) => d(f.hashlock)),
+      timelockRefund: a.timelockRefund,
       // `batch[i].amount` is the on-chain vault deposit (peg-in) amount, which
       // is exactly what WASM's `pegInAmounts` expects — it re-adds the protocol
       // reserve (`depositorClaimValue + minPeginFee`) internally when sizing the
       // HTLC output. `buildRefundPsbt`'s value cross-check then binds the result
       // to the funded tx bytes, refusing the refund if the template's HTLC value
       // disagrees with the on-chain commitment.
-      pegInAmounts: o.batch.map((f) => f.amount),
-      feeRate: u.feeRate,
-      minPeginFeeRate: u.minPeginFeeRate,
-      numLocalChallengers: u.numLocalChallengers,
-      councilQuorum: u.councilQuorum,
-      councilSize: u.councilSize,
-      network: u.network,
+      pegInAmounts: u.batch.map((f) => f.amount),
+      feeRate: a.feeRate,
+      minPeginFeeRate: a.minPeginFeeRate,
+      numLocalChallengers: a.numLocalChallengers,
+      councilQuorum: a.councilQuorum,
+      councilSize: a.councilSize,
+      network: a.network,
       authAnchorHash: y
     },
-    fundedPrePeginTxHex: P,
-    htlcVout: o.htlcVout,
+    fundedPrePeginTxHex: b,
+    htlcVout: u.htlcVout,
     refundFee: h,
     // buildRefundPsbt's top-level `hashlock` param is documented as "no 0x
     // prefix" and flows into the WASM HTLC connector derivation; a prefixed
     // value would derive the wrong refund script leaf and yield an
     // unspendable PSBT. Match the `hashlocks` array handling above.
-    hashlock: p(o.hashlock)
+    hashlock: d(u.hashlock)
   });
-  i == null || i.throwIfAborted();
-  const v = O(
-    o.depositorBtcPubkey,
-    qe
-  ), T = await l(b, v);
+  s == null || s.throwIfAborted();
+  const w = O(
+    u.depositorBtcPubkey,
+    je
+  ), v = await l(P, w);
   I({
-    requestedPsbtHex: b,
-    returnedPsbtHex: T
+    requestedPsbtHex: P,
+    returnedPsbtHex: v
   });
   const k = 0, g = N(
-    T,
-    d,
+    v,
+    p,
     k
   );
   H({
-    requestedPsbtHex: b,
+    requestedPsbtHex: P,
     signatureHex: g,
-    signerXOnlyPubkeyHex: d,
+    signerXOnlyPubkeyHex: p,
     inputIndex: k
   });
-  const C = We(T);
-  i == null || i.throwIfAborted();
+  const C = Je(v);
+  s == null || s.throwIfAborted();
   try {
-    return await a(C);
+    return await n(C);
   } catch (f) {
-    throw f instanceof Error && je.test(f.message) ? new Xe(t, f) : f;
+    throw f instanceof Error && Qe.test(f.message) ? new ze(t, f) : f;
   }
 }
 export {
-  Xe as B,
+  ze as B,
   Q as C,
   j as R,
-  ut as a,
+  lt as a,
   Ve as b,
-  pt as c,
-  gt as d,
-  De as e,
+  gt as c,
+  ft as d,
+  Fe as e,
   Ke as f,
-  ft as g,
-  mt as h,
-  ht as i,
+  mt as g,
+  bt as h,
+  pt as i,
   Pt as j,
-  bt as k,
-  yt as l,
-  wt as m,
-  vt as n,
+  yt as k,
+  wt as l,
+  vt as m,
+  Et as n,
   xt as o,
   L as p,
   M as q,
-  ct as r,
-  lt as s,
-  F as t,
+  ht as r,
+  ct as s,
+  U as t,
   W as u,
   dt as v,
   G as w
 };
-//# sourceMappingURL=buildAndBroadcastRefund-BiSO4zg2.js.map
+//# sourceMappingURL=buildAndBroadcastRefund-BtXUqBkb.js.map