@babylonlabs-io/ts-sdk 0.69.1 → 0.70.1

package/dist/{buildAndBroadcastRefund-DY4ZZcFL.js → buildAndBroadcastReclaim-kBHwOL02.js}

@@ -1,237 +1,237 @@
-var me = Object.defineProperty;
-var ve = (e, t, r) => t in e ? me(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var _ = (e, t, r) => ve(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as re } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
-import { e as ye, v as be, s as m, u as ne, p as L, c as x, f as C } from "./bitcoin-Ch_jxnDa.js";
-import { v as we, d as ke, s as Ee, P as xe, a as Te } from "./signPsbtsWithFallback-DCZO2h6i.js";
-import { zeroAddress as Ce } from "viem";
-import { D as T, c as Se, b as Ae, R as Be, d as oe } from "./json-rpc-client-DuUARJvV.js";
-import { Transaction as A, Psbt as Re } from "bitcoinjs-lib";
-import { j as _e, d as $e, f as H, e as D, g as F } from "./verifyScriptPathSchnorrSignature-Dy9gF5RF.js";
-import { c as Ie, a as Ve, b as Ke } from "./noPayout-CXn-geIS.js";
-import { c as M } from "./signing-DaLvGwQe.js";
-import { a as X } from "./onChainBtcPubkey-BAHZyKQL.js";
-import { a as Ne } from "./constants-GjWXdaqV.js";
-const Oe = /^0x[0-9a-fA-F]{64}$/, He = /^0x[0-9a-fA-F]{40}$/, De = /^0x([0-9a-fA-F]{2})*$/;
-function $(e, t) {
+var Ee = Object.defineProperty;
+var ke = (e, t, r) => t in e ? Ee(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var C = (e, t, r) => ke(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as ae } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
+import { e as xe, v as Te, s as y, u as ie, p as O, c as x, f as R } from "./bitcoin-Ch_jxnDa.js";
+import { v as Ae, d as Re, s as Ce, P as _e, a as Se } from "./signPsbtsWithFallback-X6ivsbh7.js";
+import { zeroAddress as $e } from "viem";
+import { D as T, c as Be, b as Ie, R as Ve, d as ue } from "./json-rpc-client-DuUARJvV.js";
+import { Transaction as _, Psbt as le } from "bitcoinjs-lib";
+import { m as Ke, f as Oe, i as B, g as I, j as V } from "./verifyScriptPathSchnorrSignature-CQYucnJA.js";
+import { D as X, a as Ne } from "./constants-DRiWbItj.js";
+import { d as He, c as De, b as Fe, e as Me, a as Ue } from "./noPayout-BdATUPjF.js";
+import { c as K } from "./signing-DaLvGwQe.js";
+import { a as G } from "./onChainBtcPubkey-BAHZyKQL.js";
+const Le = /^0x[0-9a-fA-F]{64}$/, ze = /^0x[0-9a-fA-F]{40}$/, Xe = /^0x([0-9a-fA-F]{2})*$/;
+function N(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 (!Oe.test(e))
+  if (!Le.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function Fe(e, t) {
-  if (!He.test(e))
+function Ge(e, t) {
+  if (!ze.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function Me(e, t) {
-  if (!De.test(e))
+function qe(e, t) {
+  if (!Xe.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-function ae(e) {
-  Fe(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), $(e.vaultId, "vaultId");
-  const t = ye(e.secret);
-  if ($(t, "secret"), e.hashlock !== void 0 && ($(e.hashlock, "hashlock"), !we(t, e.hashlock)))
+function ce(e) {
+  Ge(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), N(e.vaultId, "vaultId");
+  const t = xe(e.secret);
+  if (N(t, "secret"), e.hashlock !== void 0 && (N(e.hashlock, "hashlock"), !Ae(t, e.hashlock)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
   return t;
 }
-async function Ft(e) {
+async function qt(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
-    hashlock: n,
-    activationMetadata: s,
+    hashlock: o,
+    activationMetadata: a,
     writeContract: l,
-    signal: o
+    signal: s
   } = e;
-  o == null || o.throwIfAborted();
-  const a = ae({
+  s == null || s.throwIfAborted();
+  const n = ce({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
-    hashlock: n
+    hashlock: o
   });
-  return Me(s, "activationMetadata"), l({
+  return qe(a, "activationMetadata"), l({
     address: t,
-    abi: re,
+    abi: ae,
     functionName: "activateVaultWithSecret",
-    args: [r, a, s]
+    args: [r, n, a]
   });
 }
-async function Mt(e) {
-  const { btcVaultRegistryAddress: t, vaultId: r, hashlock: n, writeContract: s, signal: l } = e;
+async function jt(e) {
+  const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: a, signal: l } = e;
   l == null || l.throwIfAborted();
-  const o = ae({
+  const s = ce({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
-    hashlock: n
+    hashlock: o
   });
-  return s({
+  return a({
     address: t,
-    abi: re,
+    abi: ae,
     functionName: "activateVaultWithSecretAndRedeem",
-    args: [r, o]
+    args: [r, s]
   });
 }
-const Ue = 8, Le = 6e3, ze = 10 * 6e4, Xe = 10;
-class se extends Error {
+const je = 8, Qe = 6e3, We = 10 * 6e4, Ye = 10;
+class he extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationMissingError";
   }
 }
-class ie extends Error {
+class de extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationNotFinalError";
   }
 }
-function Ge(e) {
-  return e instanceof se || e instanceof Error && e.name === "PeginRegistrationMissingError";
+function Je(e) {
+  return e instanceof he || e instanceof Error && e.name === "PeginRegistrationMissingError";
 }
-function Ut(e) {
-  return e instanceof ie || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
+function Qt(e) {
+  return e instanceof de || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
 }
-function G(e) {
-  const { currentBlock: t, createdAtBlock: r } = e, n = t - r + 1n;
-  return n < 0n ? 0 : Number(n);
+function q(e) {
+  const { currentBlock: t, createdAtBlock: r } = e, o = t - r + 1n;
+  return o < 0n ? 0 : Number(o);
 }
-async function Lt(e) {
+async function Wt(e) {
   const {
     vaultRegistryReader: t,
     getBlockNumber: r,
-    vaultIds: n,
-    required: s = Ue,
-    pollIntervalMs: l = Le,
-    timeoutMs: o = ze,
-    signal: a,
+    vaultIds: o,
+    required: a = je,
+    pollIntervalMs: l = Qe,
+    timeoutMs: s = We,
+    signal: n,
     onProgress: i
   } = e;
-  if (n.length === 0)
+  if (o.length === 0)
     throw new Error(
       "waitForPeginRegistrationDepth requires at least one vault ID"
     );
   const u = Date.now();
-  let h = !1, c = 0, p;
+  let h = !1, c = 0, d;
   for (; ; ) {
-    if (a != null && a.aborted)
+    if (n != null && n.aborted)
       throw new Error(
-        `Aborted while waiting for peg-in registration depth (${n.length} vault(s))`
+        `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
       );
-    if (Date.now() - u >= o)
-      throw new ie(
-        `Peg-in registration did not reach ${s} Ethereum confirmations within ${o}ms. The registration transaction was submitted but is not yet final, so the Pre-PegIn Bitcoin transaction was never sent and no funds are at risk. Resume this deposit from the dashboard once the network settles.` + (p instanceof Error ? ` Last read error: ${p.message}` : "")
+    if (Date.now() - u >= s)
+      throw new de(
+        `Peg-in registration did not reach ${a} Ethereum confirmations within ${s}ms. The registration transaction was submitted but is not yet final, so the Pre-PegIn Bitcoin transaction was never sent and no funds are at risk. Resume this deposit from the dashboard once the network settles.` + (d instanceof Error ? ` Last read error: ${d.message}` : "")
       );
     try {
-      const d = await r(), g = await Promise.all(
-        n.map((f) => t.getVaultBasicInfo(f))
+      const p = await r(), g = await Promise.all(
+        o.map((f) => t.getVaultBasicInfo(f))
       ), b = g.findIndex(
-        (f) => f.depositor === Ce || f.createdAt === 0n
+        (f) => f.depositor === $e || f.createdAt === 0n
       );
       if (b !== -1) {
-        if (c += 1, !h && c > Xe)
-          throw new se(
-            `Vault ${n[b]} is still not visible on-chain after ${c} reads — the registration does not exist.`
+        if (c += 1, !h && c > Ye)
+          throw new he(
+            `Vault ${o[b]} is still not visible on-chain after ${c} reads — the registration does not exist.`
           );
         console.warn(
-          `Peg-in registration for vault ${n[b]} is not visible in chain state at block ${d} — a lagging RPC backend or an Ethereum reorg. Still polling.`
-        ), i == null || i({ confirmations: 0, required: s });
+          `Peg-in registration for vault ${o[b]} is not visible in chain state at block ${p} — a lagging RPC backend or an Ethereum reorg. Still polling.`
+        ), i == null || i({ confirmations: 0, required: a });
       } else {
-        h = !0, c = 0, p = void 0;
-        let f = g[0], P = G({
-          currentBlock: d,
+        h = !0, c = 0, d = void 0;
+        let f = g[0], P = q({
+          currentBlock: p,
           createdAtBlock: g[0].createdAt
         });
-        for (const w of g.slice(1)) {
-          const v = G({
-            currentBlock: d,
-            createdAtBlock: w.createdAt
+        for (const v of g.slice(1)) {
+          const m = q({
+            currentBlock: p,
+            createdAtBlock: v.createdAt
           });
-          v < P && (P = v, f = w);
+          m < P && (P = m, f = v);
         }
-        if (i == null || i({ confirmations: P, required: s }), P >= s)
+        if (i == null || i({ confirmations: P, required: a }), P >= a)
           return { confirmations: P, basicInfo: f };
       }
-    } catch (d) {
-      if (Ge(d))
-        throw d;
+    } catch (p) {
+      if (Je(p))
+        throw p;
       console.warn(
-        `Registration-depth read failed (retrying in ${l}ms): ` + (d instanceof Error ? d.message : String(d))
-      ), p = d;
+        `Registration-depth read failed (retrying in ${l}ms): ` + (p instanceof Error ? p.message : String(p))
+      ), d = p;
     }
-    await new Promise((d, g) => {
+    await new Promise((p, g) => {
       const b = () => {
         clearTimeout(f), g(
           new Error(
-            `Aborted while waiting for peg-in registration depth (${n.length} vault(s))`
+            `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
           )
         );
       }, f = setTimeout(() => {
-        a == null || a.removeEventListener("abort", b), d();
+        n == null || n.removeEventListener("abort", b), p();
       }, l);
-      a == null || a.addEventListener("abort", b, { once: !0 });
+      n == null || n.addEventListener("abort", b, { once: !0 });
     });
   }
 }
-const j = 1, je = 1;
-function qe(e, t, r) {
-  const n = r.map(
-    (c) => m(c).toLowerCase()
-  ), s = t.filter((c) => n.includes(c));
-  if (s.length > 0)
+const Ze = 1;
+function et(e, t, r) {
+  const o = r.map(
+    (c) => y(c).toLowerCase()
+  ), a = t.filter((c) => o.includes(c));
+  if (a.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 (${a.join(", ")})`
     );
-  const l = [...t, ...n], o = e.map(
-    (c) => m(c.challenger_pubkey).toLowerCase()
-  ), a = new Set(o);
-  if (a.size !== o.length)
+  const l = [...t, ...o], s = e.map(
+    (c) => y(c.challenger_pubkey).toLowerCase()
+  ), n = new Set(s);
+  if (n.size !== s.length)
     throw new Error(
       "Depositor graph contains duplicate challenger entries in challenger_presign_data"
     );
-  const i = new Set(l), u = l.filter((c) => !a.has(c)), h = o.filter((c) => !i.has(c));
+  const i = new Set(l), u = l.filter((c) => !n.has(c)), h = s.filter((c) => !i.has(c));
   if (u.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(", ")})` : "")
     );
 }
-function Qe(e, t) {
+function tt(e, t) {
   const r = e.ins[t];
-  return ne(new Uint8Array(r.hash).slice().reverse());
+  return ie(new Uint8Array(r.hash).slice().reverse());
 }
-function I(e, t, r, n, s) {
+function H(e, t, r, o, a) {
   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 ${a}) input ${t} expected to spend ${o} vout 0, got vout ${l.index}`
     );
-  const o = r.getId(), a = Qe(e, t);
-  if (a !== o)
+  const s = r.getId(), n = tt(e, t);
+  if (n !== s)
     throw new Error(
-      `NoPayout (challenger ${s}) input ${t} does not reference ${n} (expected txid ${o}, got ${a})`
+      `NoPayout (challenger ${a}) input ${t} does not reference ${o} (expected txid ${s}, got ${n})`
     );
 }
-async function We(e, t, r) {
-  const n = [], s = [], l = [], o = _e({
+async function rt(e, t, r) {
+  const o = [], a = [], l = [], s = Ke({
     claimerBtcPubkey: r.depositorBtcPubkey,
     depositorBtcPubkey: r.depositorBtcPubkey,
     vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
     vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys
   });
-  qe(
+  et(
     e.challenger_presign_data,
-    o,
+    s,
     r.universalChallengerBtcPubkeys
   );
-  const a = await $e({
+  const n = await Oe({
     vaultCoreVersion: r.vaultCoreVersion,
     vkClaimerPayoutScriptPubKeys: r.vkClaimerPayoutScriptPubKeys,
     vpCommissionScriptPubKey: r.vpCommissionScriptPubKey,
@@ -247,80 +247,80 @@ async function We(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: je,
+    commissionBps: Ze,
     protocolFeeRate: r.protocolFeeRate,
     councilMembers: r.councilMembers,
     councilQuorum: r.councilQuorum
   });
-  n.push(a.psbtHex), s.push(
-    M(
+  o.push(n.psbtHex), a.push(
+    K(
       t,
-      j
+      X
     )
   );
-  const i = m(r.depositorBtcPubkey), u = A.fromHex(
-    m(e.assert_tx.tx_hex)
+  const i = y(r.depositorBtcPubkey), u = _.fromHex(
+    y(e.assert_tx.tx_hex)
   );
   for (const h of e.challenger_presign_data) {
-    const c = m(h.challenger_pubkey), p = n.length, d = await Ye({
+    const c = y(h.challenger_pubkey), d = o.length, p = await ot({
       challenger: h,
       challengerPubkey: c,
       claimerPubkey: i,
-      localChallengers: o,
+      localChallengers: s,
       assertTxParsed: u,
       ctx: r
     });
-    n.push(d), s.push(
-      M(
+    o.push(p), a.push(
+      K(
         t,
-        j
+        X
       )
     ), l.push({
       challengerPubkey: c,
-      noPayoutIdx: p
+      noPayoutIdx: d
     });
   }
-  return { psbtHexes: n, signOptions: s, challengerEntries: l };
+  return { psbtHexes: o, signOptions: a, challengerEntries: l };
 }
-async function Ye(e) {
+async function ot(e) {
   const {
     challenger: t,
     challengerPubkey: r,
-    claimerPubkey: n,
-    localChallengers: s,
+    claimerPubkey: o,
+    localChallengers: a,
     assertTxParsed: l,
-    ctx: o
+    ctx: s
   } = e;
-  Ie(
+  He(
     t.nopayout_tx.tx_hex,
     r,
-    o.network
+    s.network
   );
-  const a = A.fromHex(
-    m(t.nopayout_tx.tx_hex)
-  ), i = A.fromHex(
-    m(t.challenge_assert_x_tx.tx_hex)
-  ), u = A.fromHex(
-    m(t.challenge_assert_y_tx.tx_hex)
+  const n = _.fromHex(
+    y(t.nopayout_tx.tx_hex)
+  ), i = _.fromHex(
+    y(t.challenge_assert_x_tx.tx_hex)
+  ), u = _.fromHex(
+    y(t.challenge_assert_y_tx.tx_hex)
   );
-  if (a.ins.length !== 3)
+  if (n.ins.length !== 3)
     throw new Error(
-      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${a.ins.length}`
+      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${n.ins.length}`
     );
-  I(
-    a,
+  H(
+    n,
     0,
     l,
     "Assert",
     r
-  ), I(
-    a,
+  ), H(
+    n,
     1,
     i,
     "ChallengeAssertX",
     r
-  ), I(
-    a,
+  ), H(
+    n,
     2,
     u,
     "ChallengeAssertY",
@@ -331,169 +331,169 @@ async function Ye(e) {
     i.outs[0],
     u.outs[0]
   ].map((c) => ({
-    script_pubkey: ne(new Uint8Array(c.script)),
+    script_pubkey: ie(new Uint8Array(c.script)),
     value: c.value
   }));
-  return Ve({
+  return De({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
     prevouts: h,
     connectorParams: {
-      txGraphVersion: o.vaultCoreVersion,
-      claimer: n,
-      localChallengers: s,
-      universalChallengers: o.universalChallengerBtcPubkeys,
-      timelockAssert: o.timelockAssert,
-      councilMembers: o.councilMembers,
-      councilQuorum: o.councilQuorum
+      txGraphVersion: s.vaultCoreVersion,
+      claimer: o,
+      localChallengers: a,
+      universalChallengers: s.universalChallengerBtcPubkeys,
+      timelockAssert: s.timelockAssert,
+      councilMembers: s.councilMembers,
+      councilQuorum: s.councilQuorum
     }
   });
 }
-function Je(e, t, r) {
-  H(e[0]);
-  const s = D(
+function nt(e, t, r) {
+  B(e[0]);
+  const a = I(
     e[0].returnedPsbtHex,
     r
   );
-  F({
+  V({
     requestedPsbtHex: e[0].requestedPsbtHex,
-    signatureHex: s,
+    signatureHex: a,
     signerXOnlyPubkeyHex: r,
     inputIndex: 0
   });
   const l = {};
-  for (const o of t) {
-    H(e[o.noPayoutIdx]);
-    const a = D(
-      e[o.noPayoutIdx].returnedPsbtHex,
+  for (const s of t) {
+    B(e[s.noPayoutIdx]);
+    const n = I(
+      e[s.noPayoutIdx].returnedPsbtHex,
       r
     );
-    F({
-      requestedPsbtHex: e[o.noPayoutIdx].requestedPsbtHex,
-      signatureHex: a,
+    V({
+      requestedPsbtHex: e[s.noPayoutIdx].requestedPsbtHex,
+      signatureHex: n,
       signerXOnlyPubkeyHex: r,
       inputIndex: 0
-    }), l[o.challengerPubkey] = {
-      nopayout_signature: a
+    }), l[s.challengerPubkey] = {
+      nopayout_signature: n
     };
   }
   return {
     payout_signatures: {
-      payout_signature: s
+      payout_signature: a
     },
     per_challenger: l
   };
 }
-async function Ze(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, s = await r.getPublicKeyHex(), { depositorPubkey: l } = be(
-    s,
-    m(n.depositorBtcPubkey)
-  ), { psbtHexes: o, signOptions: a, challengerEntries: i } = await We(
+async function st(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, a = await r.getPublicKeyHex(), { depositorPubkey: l } = Te(
+    a,
+    y(o.depositorBtcPubkey)
+  ), { psbtHexes: s, signOptions: n, challengerEntries: i } = await rt(
     t,
+    a,
+    o
+  ), u = await Re(
+    r,
     s,
     n
-  ), u = await ke(
-    r,
-    o,
-    a
-  ), h = o.map((c, p) => ({
+  ), h = s.map((c, d) => ({
     requestedPsbtHex: c,
-    returnedPsbtHex: u[p]
+    returnedPsbtHex: u[d]
   }));
-  return Je(
+  return nt(
     h,
     i,
     l
   );
 }
-const et = 1e4;
-async function ue(e) {
+const at = 1e4;
+async function pe(e) {
   const {
     statusReader: t,
     peginTxid: r,
-    targetStatuses: n,
-    timeoutMs: s,
-    pollIntervalMs: l = et,
-    signal: o
-  } = e, a = Date.now();
+    targetStatuses: o,
+    timeoutMs: a,
+    pollIntervalMs: l = at,
+    signal: s
+  } = e, n = Date.now();
   for (; ; ) {
-    if (o != null && o.aborted)
+    if (s != null && s.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() - a >= s)
+    if (Date.now() - n >= a)
       throw new Error(
-        `Polling timeout after ${s}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+        `Polling timeout after ${a}ms for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
       );
     try {
       const i = await t.getPeginStatus(
         { pegin_txid: r },
-        o
+        s
       );
       if (i.pegin_txid.toLowerCase() !== r.toLowerCase())
         throw new Error(
           `getPeginStatus returned status for pegin ${i.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
         );
       const u = i.status;
-      if (n.has(u) || u === T.ACTIVATED)
+      if (o.has(u) || u === T.ACTIVATED)
         return u;
-      if (u === T.EXPIRED || Se.has(u))
+      if (u === T.EXPIRED || Be.has(u))
         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 "${u}" while waiting for ${[...o].join(", ")}`
         );
     } catch (i) {
-      if (!(i instanceof Ae && i.code === Be.PEGIN_NOT_FOUND))
+      if (!(i instanceof Ie && i.code === Ve.PEGIN_NOT_FOUND))
         throw i;
     }
     await new Promise((i, u) => {
       const h = () => {
         clearTimeout(c), u(
           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(() => {
-        o == null || o.removeEventListener("abort", h), i();
+        s == null || s.removeEventListener("abort", h), i();
       }, l);
-      o == null || o.addEventListener("abort", h, { once: !0 });
+      s == null || s.addEventListener("abort", h, { once: !0 });
     });
   }
 }
-const tt = 1200 * 1e3, le = /* @__PURE__ */ new Set([
+const it = 1200 * 1e3, ge = /* @__PURE__ */ new Set([
   T.PENDING_ACKS,
   T.PENDING_ACTIVATION,
   T.ACTIVATED_PENDING_BROADCAST,
   T.ACTIVATED
-]), rt = /* @__PURE__ */ new Set([
+]), ut = /* @__PURE__ */ new Set([
   T.PENDING_DEPOSITOR_SIGNATURES,
-  ...le
+  ...ge
 ]);
-function nt(e) {
+function lt(e) {
   return e.map((t) => ({
-    claimerPubkeyXOnly: L(t.claimer_pubkey),
+    claimerPubkeyXOnly: O(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
-function E(e) {
-  return L(e).toLowerCase();
+function k(e) {
+  return O(e).toLowerCase();
 }
-function ot(e, t) {
+function ct(e, t) {
   const r = (i, u, h) => {
     throw new Error(
       `Deposit terms ${i} (${String(u)}) does not match the vault's version-locked signing context (${String(h)}); refusing to sign payouts against terms that describe a different graph.`
     );
-  }, n = [
+  }, o = [
     ["protocolFeeRate", e.protocolFeeRate, t.protocolFeeRate],
     ["vaultCoreVersion", e.vaultCoreVersion, t.vaultCoreVersion],
     ["timelockPegin", e.timelockPegin, t.timelockPegin],
     ["timelockAssert", e.timelockAssert, t.timelockAssert]
   ];
-  for (const [i, u, h] of n)
+  for (const [i, u, h] of o)
     u !== h && r(i, u, h);
-  const s = (i) => i.map(E).sort(), l = (i, u) => {
-    const h = s(i), c = s(u);
-    return h.length === c.length && h.every((p, d) => p === c[d]);
+  const a = (i) => i.map(k).sort(), l = (i, u) => {
+    const h = a(i), c = a(u);
+    return h.length === c.length && h.every((d, p) => d === c[p]);
   };
   l(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
     "vaultKeeperBtcPubkeys",
@@ -507,40 +507,40 @@ function ot(e, t) {
     e.universalChallengerBtcPubkeys.join(","),
     t.universalChallengerBtcPubkeys.join(",")
   );
-  const o = E(t.vaultProviderBtcPubkey), a = e.vaults.map(
-    (i) => E(i.vaultProviderBtcPubkey)
+  const s = k(t.vaultProviderBtcPubkey), n = e.vaults.map(
+    (i) => k(i.vaultProviderBtcPubkey)
   );
-  a.includes(o) || r(
+  n.includes(s) || r(
     "vaults[].vaultProviderBtcPubkey",
-    a.join(",") || "<no vaults>",
+    n.join(",") || "<no vaults>",
     t.vaultProviderBtcPubkey
   );
 }
-function at(e, t, r, n) {
-  const s = E(n), l = [
-    E(t),
-    ...r.map(E)
-  ], o = new Set(l);
-  if (o.size !== l.length)
+function ht(e, t, r, o) {
+  const a = k(o), l = [
+    k(t),
+    ...r.map(k)
+  ], s = new Set(l);
+  if (s.size !== l.length)
     throw new Error(
       "Cannot validate claimer set: signing context contains duplicate vault provider or vault keeper key"
     );
-  if (o.has(s))
+  if (s.has(a))
     throw new Error(
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
-  const a = e.map(
-    (p) => E(p.claimer_pubkey)
+  const n = e.map(
+    (d) => k(d.claimer_pubkey)
   );
-  if (new Set(a).size !== a.length)
+  if (new Set(n).size !== n.length)
     throw new Error("Presign response contains duplicate claimer entries");
-  const i = a.filter((p) => p !== s), u = new Set(i), h = l.filter((p) => !u.has(p)), c = i.filter((p) => !o.has(p));
+  const i = n.filter((d) => d !== a), u = new Set(i), h = l.filter((d) => !u.has(d)), c = i.filter((d) => !s.has(d));
   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 q(e, t) {
+function j(e, t) {
   return {
     vaultCoreVersion: t.vaultCoreVersion,
     payoutTxHex: e.payoutTxHex,
@@ -562,609 +562,609 @@ function q(e, t) {
     vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
   };
 }
-async function st(e, t, r, n) {
-  const s = new xe({
+async function dt(e, t, r, o) {
+  const a = new _e({
     network: t.network,
     btcWallet: e
   }), l = r.length;
-  n == null || n(0, l);
-  let o;
-  if (s.supportsBatchSigning())
-    o = (await s.signPayoutTransactionsBatch(
-      r.map((u) => q(u, t))
+  o == null || o(0, l);
+  let s;
+  if (a.supportsBatchSigning())
+    s = (await a.signPayoutTransactionsBatch(
+      r.map((u) => j(u, t))
     )).map((u) => u.payoutSignature);
   else {
-    o = [];
+    s = [];
     for (let i = 0; i < r.length; i++) {
-      n == null || n(i, l);
-      const u = await s.signPayoutTransaction(
-        q(r[i], t)
+      o == null || o(i, l);
+      const u = await a.signPayoutTransaction(
+        j(r[i], t)
       );
-      o.push(u.signature);
+      s.push(u.signature);
     }
   }
-  const a = {};
+  const n = {};
   for (let i = 0; i < r.length; i++)
-    a[r[i].claimerPubkeyXOnly] = {
-      payout_signature: o[i]
+    n[r[i].claimerPubkeyXOnly] = {
+      payout_signature: s[i]
     };
-  return n == null || n(l, l), a;
+  return o == null || o(l, l), n;
 }
-async function zt(e) {
+async function Yt(e) {
   const {
     statusReader: t,
     presignClient: r,
-    btcWallet: n,
-    peginTxid: s,
+    btcWallet: o,
+    peginTxid: a,
     depositorPk: l,
-    signingContext: o,
-    depositTerms: a,
-    timeoutMs: i = tt,
+    signingContext: s,
+    depositTerms: n,
+    timeoutMs: i = it,
     signal: u,
     onProgress: h
-  } = e, c = await ue({
+  } = e, c = await pe({
     statusReader: t,
-    peginTxid: s,
-    targetStatuses: rt,
+    peginTxid: a,
+    targetStatuses: ut,
     timeoutMs: i,
     signal: u
   });
-  if (le.has(c))
+  if (ge.has(c))
     return;
-  if (u == null || u.throwIfAborted(), a !== void 0 && ot(a, o), Ee(n)) {
-    if (!a)
+  if (u == null || u.throwIfAborted(), n !== void 0 && ct(n, s), Ce(o)) {
+    if (!n)
       throw new Error(
         "runDepositorPresignFlow: this wallet requires approved deposit terms but none were provided. Fresh deposits must pass PreparePeginResult.depositTerms; resume flows must rebuild them from on-chain state (the vault app's rebuildDepositTerms)."
       );
-    typeof n.validateDepositTerms == "function" && await n.validateDepositTerms(a), await n.approveDepositTerms(a);
+    typeof o.validateDepositTerms == "function" && await o.validateDepositTerms(n), await o.approveDepositTerms(n);
   }
-  const p = await r.requestDepositorPresignTransactions(
+  const d = await r.requestDepositorPresignTransactions(
     {
-      pegin_txid: s,
+      pegin_txid: a,
       depositor_pk: l
     },
     u
   );
   u == null || u.throwIfAborted();
-  const d = E(l);
-  at(
-    p.txs,
-    o.vaultProviderBtcPubkey,
-    o.vaultKeeperBtcPubkeys,
+  const p = k(l);
+  ht(
+    d.txs,
+    s.vaultProviderBtcPubkey,
+    s.vaultKeeperBtcPubkeys,
     l
   );
-  const g = p.txs.filter(
-    (v) => E(v.claimer_pubkey) !== d
-  ), b = nt(g), f = await st(
-    n,
+  const g = d.txs.filter(
+    (m) => k(m.claimer_pubkey) !== p
+  ), b = lt(g), f = await dt(
     o,
+    s,
     b,
     h
   );
   u == null || u.throwIfAborted();
-  const P = await Ze({
-    depositorGraph: p.depositor_graph,
-    btcWallet: n,
+  const P = await st({
+    depositorGraph: d.depositor_graph,
+    btcWallet: o,
     signingContext: {
-      vaultCoreVersion: o.vaultCoreVersion,
-      peginTxHex: o.peginTxHex,
+      vaultCoreVersion: s.vaultCoreVersion,
+      peginTxHex: s.peginTxHex,
       depositorBtcPubkey: l,
-      vaultProviderBtcPubkey: o.vaultProviderBtcPubkey,
-      vaultKeeperBtcPubkeys: o.vaultKeeperBtcPubkeys,
-      universalChallengerBtcPubkeys: o.universalChallengerBtcPubkeys,
-      timelockPegin: o.timelockPegin,
-      timelockAssert: o.timelockAssert,
-      councilMembers: o.councilMembers,
-      councilQuorum: o.councilQuorum,
-      network: o.network,
-      registeredPayoutScriptPubKey: o.registeredPayoutScriptPubKey,
-      protocolFeeRate: o.protocolFeeRate,
-      vkClaimerPayoutScriptPubKeys: o.vkClaimerPayoutScriptPubKeys,
-      vpCommissionScriptPubKey: o.vpCommissionScriptPubKey
+      vaultProviderBtcPubkey: s.vaultProviderBtcPubkey,
+      vaultKeeperBtcPubkeys: s.vaultKeeperBtcPubkeys,
+      universalChallengerBtcPubkeys: s.universalChallengerBtcPubkeys,
+      timelockPegin: s.timelockPegin,
+      timelockAssert: s.timelockAssert,
+      councilMembers: s.councilMembers,
+      councilQuorum: s.councilQuorum,
+      network: s.network,
+      registeredPayoutScriptPubKey: s.registeredPayoutScriptPubKey,
+      protocolFeeRate: s.protocolFeeRate,
+      vkClaimerPayoutScriptPubKeys: s.vkClaimerPayoutScriptPubKeys,
+      vpCommissionScriptPubKey: s.vpCommissionScriptPubKey
     }
   });
   u == null || u.throwIfAborted();
-  const w = { ...f };
-  w[m(l)] = P.payout_signatures, await r.submitDepositorPresignatures(
+  const v = { ...f };
+  v[y(l)] = P.payout_signatures, await r.submitDepositorPresignatures(
     {
-      pegin_txid: s,
+      pegin_txid: a,
       depositor_pk: l,
-      signatures: w,
+      signatures: v,
       depositor_claimer_presignatures: P
     },
     u
   );
 }
-const it = 300 * 1e3, ut = /* @__PURE__ */ new Set([
+const pt = 300 * 1e3, gt = /* @__PURE__ */ new Set([
   T.PENDING_DEPOSITOR_WOTS_PK,
-  ...oe
+  ...ue
 ]);
-async function Xt(e) {
+async function Jt(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
-    peginTxid: n,
-    depositorPk: s,
+    peginTxid: o,
+    depositorPk: a,
     wotsPublicKeys: l,
-    timeoutMs: o = it,
-    signal: a
+    timeoutMs: s = pt,
+    signal: n
   } = e;
-  a == null || a.throwIfAborted();
-  const i = await ue({
+  n == null || n.throwIfAborted();
+  const i = await pe({
     statusReader: t,
-    peginTxid: n,
-    targetStatuses: ut,
-    timeoutMs: o,
-    signal: a
+    peginTxid: o,
+    targetStatuses: gt,
+    timeoutMs: s,
+    signal: n
   });
-  oe.has(i) || (a == null || a.throwIfAborted(), await r.submitDepositorWotsKey(
+  ue.has(i) || (n == null || n.throwIfAborted(), await r.submitDepositorWotsKey(
     {
-      pegin_txid: n,
-      depositor_pk: s,
+      pegin_txid: o,
+      depositor_pk: a,
       wots_public_keys: l
     },
-    a
+    n
   ));
 }
-function V(e) {
+function D(e) {
   return e.registration || e.operation;
 }
-function lt(e, t, r) {
-  const n = x(e);
+function ft(e, t, r) {
+  const o = x(e);
   return {
-    registration: n === x(t),
-    operation: n === x(r)
+    registration: o === x(t),
+    operation: o === x(r)
   };
 }
 function Q(e, t, r) {
-  const n = K(e);
+  const o = F(e);
   return {
-    registration: W(n, K(t)),
-    operation: W(n, K(r))
+    registration: W(o, F(t)),
+    operation: W(o, F(r))
   };
 }
-function K(e) {
+function F(e) {
   return e.map(x).sort();
 }
 function W(e, t) {
-  return e.length === t.length && e.every((r, n) => r === t[n]);
+  return e.length === t.length && e.every((r, o) => r === t[o]);
 }
-async function Gt(e) {
+async function Zt(e) {
   const {
     vaultProviderEthAddress: t,
     hintBtcPubkey: r,
-    registrationBtcPubkey: n,
-    readCurrentOperationBtcPubkey: s,
+    registrationBtcPubkey: o,
+    readCurrentOperationBtcPubkey: a,
     context: l
   } = e;
   if (!r) return;
-  const o = x(r);
-  if (o === x(n)) return;
-  const a = x(
-    await s()
+  const s = x(r);
+  if (s === x(o)) return;
+  const n = x(
+    await a()
   );
-  if (o !== a)
+  if (s !== n)
     throw new Error(
       `Vault provider BTC pubkey mismatch for ${t}: indexer hint matches neither the registration key nor the current operation key on-chain.${l ? ` ${l}` : ""}`
     );
 }
-function N(e, t, r) {
-  const n = `${e} operation key (admin=${t.ethAddress})`, s = X(
+function M(e, t, r) {
+  const o = `${e} operation key (admin=${t.ethAddress})`, a = G(
     t.btcPubKey,
     `${e} roster key (admin=${t.ethAddress})`
-  ), l = X(r, n);
+  ), l = G(r, o);
   return {
     adminAddress: t.ethAddress,
-    genesisBtcPubkey: s,
+    genesisBtcPubkey: a,
     operationBtcPubkey: l,
-    rotated: l !== s
+    rotated: l !== a
   };
 }
-function ct(e) {
+function mt(e) {
   const t = /* @__PURE__ */ new Map();
   for (const r of e) {
-    const n = t.get(r.operationBtcPubkey);
-    if (n)
+    const o = t.get(r.operationBtcPubkey);
+    if (o)
       throw new Error(
-        `Participant operation key collision: ${n} and ${r.adminAddress} both resolve to operation key ${r.operationBtcPubkey}`
+        `Participant operation key collision: ${o} and ${r.adminAddress} both resolve to operation key ${r.operationBtcPubkey}`
       );
     t.set(r.operationBtcPubkey, r.adminAddress);
   }
 }
-function ce(e, t, r) {
+function fe(e, t, r) {
   if (t.vaultKeepers.length !== e.vaultKeepers.length || t.universalChallengers.length !== e.universalChallengers.length)
     throw new Error(
       `Operation-key resolution returned ${t.vaultKeepers.length} keeper and ${t.universalChallengers.length} challenger keys for a roster of ${e.vaultKeepers.length} keepers and ${e.universalChallengers.length} challengers`
     );
-  const n = N(
+  const o = M(
     "vault provider",
     {
       ethAddress: e.vaultProviderEthAddress,
       btcPubKey: e.vaultProviderGenesisBtcPubkey
     },
     t.vaultProvider
-  ), s = e.vaultKeepers.map(
-    (o, a) => N("vault keeper", o, t.vaultKeepers[a])
+  ), a = e.vaultKeepers.map(
+    (s, n) => M("vault keeper", s, t.vaultKeepers[n])
   ), l = e.universalChallengers.map(
-    (o, a) => N("universal challenger", o, t.universalChallengers[a])
+    (s, n) => M("universal challenger", s, t.universalChallengers[n])
   );
-  return ct([
-    n,
-    ...s,
+  return mt([
+    o,
+    ...a,
     ...l
   ]), {
-    vaultProvider: n,
-    vaultKeepers: s,
+    vaultProvider: o,
+    vaultKeepers: a,
     universalChallengers: l,
     // Derived from the pairs, never the reverse — see ParticipantKeySet.
-    vaultKeeperOperationKeysSorted: s.map((o) => o.operationBtcPubkey).sort(),
-    universalChallengerOperationKeysSorted: l.map((o) => o.operationBtcPubkey).sort(),
+    vaultKeeperOperationKeysSorted: a.map((s) => s.operationBtcPubkey).sort(),
+    universalChallengerOperationKeysSorted: l.map((s) => s.operationBtcPubkey).sort(),
     resolvedAt: r,
     query: e
   };
 }
-async function ht(e) {
+async function Pt(e) {
   const t = await e.operationKeyReader.getCurrentOperationKeys(
     e.query
   );
-  return ce(e.query, t, { mode: "current" });
+  return fe(e.query, t, { mode: "current" });
 }
-async function pt(e) {
+async function vt(e) {
   const t = await e.operationKeyReader.getOperationKeysAtEpochs(
     e.query,
     e.epochs
   );
-  return ce(e.query, t, {
+  return fe(e.query, t, {
     mode: "epochs",
     epochs: e.epochs
   });
 }
 const Y = (e) => e.map(x).sort();
-async function jt(e) {
+async function er(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
-    universalChallengerReader: n,
-    vaultProviderEthAddress: s,
+    universalChallengerReader: o,
+    vaultProviderEthAddress: a,
     applicationEntryPoint: l,
-    expectedVaultProviderBtcPubkey: o,
-    expectedVaultKeeperBtcPubkeys: a,
+    expectedVaultProviderBtcPubkey: s,
+    expectedVaultKeeperBtcPubkeys: n,
     expectedUniversalChallengerBtcPubkeys: i,
     operationKeyReader: u,
     onIndexerServingOperationKeys: h,
     onIndexerHintsInconsistent: c
   } = e, [
-    p,
     d,
+    p,
     g
   ] = await Promise.all([
     t.getVaultProviderGenesisBtcPubKey(
-      s
+      a
     ),
     r.getCurrentVaultKeepersVersion(l),
-    n.getLatestUniversalChallengersVersion()
+    o.getLatestUniversalChallengersVersion()
   ]), [b, f] = await Promise.all([
     r.getVaultKeepersByVersion(
       l,
-      d
+      p
     ),
-    n.getUniversalChallengersByVersion(
+    o.getUniversalChallengersByVersion(
       g
     )
   ]), P = {
-    vaultProvider: x(p),
-    vaultKeepers: Y(b.map((k) => k.btcPubKey)),
-    universalChallengers: Y(f.map((k) => k.btcPubKey))
-  }, w = await ht({
+    vaultProvider: x(d),
+    vaultKeepers: Y(b.map((E) => E.btcPubKey)),
+    universalChallengers: Y(f.map((E) => E.btcPubKey))
+  }, v = await Pt({
     operationKeyReader: u,
     query: {
-      vaultProviderEthAddress: s,
-      vaultProviderGenesisBtcPubkey: `0x${p}`,
+      vaultProviderEthAddress: a,
+      vaultProviderGenesisBtcPubkey: `0x${d}`,
       applicationEntryPoint: l,
       vaultKeepers: b,
       universalChallengers: f
     }
-  }), v = {
-    vaultProvider: w.vaultProvider.operationBtcPubkey,
-    vaultKeepers: [...w.vaultKeeperOperationKeysSorted],
+  }), m = {
+    vaultProvider: v.vaultProvider.operationBtcPubkey,
+    vaultKeepers: [...v.vaultKeeperOperationKeysSorted],
     universalChallengers: [
-      ...w.universalChallengerOperationKeysSorted
+      ...v.universalChallengerOperationKeysSorted
     ]
-  }, S = lt(
-    o,
+  }, A = ft(
+    s,
     P.vaultProvider,
-    v.vaultProvider
-  ), B = Q(
-    a,
+    m.vaultProvider
+  ), S = Q(
+    n,
     P.vaultKeepers,
-    v.vaultKeepers
-  ), R = Q(
+    m.vaultKeepers
+  ), $ = Q(
     i,
     P.universalChallengers,
-    v.universalChallengers
+    m.universalChallengers
   );
-  if (!V(S))
+  if (!D(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 ${a}. Refresh and try again.`
     );
-  if (!V(B))
+  if (!D(S))
     throw new Error(
-      `Vault keeper BTC pubkeys (v${d}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
+      `Vault keeper BTC pubkeys (v${p}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  if (!V(R))
+  if (!D($))
     throw new Error(
       `Universal challenger BTC pubkeys (v${g}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
     );
-  const y = [S, B, R], Pe = y.some((k) => k.registration && !k.operation), z = y.some((k) => k.operation && !k.registration);
-  if (Pe && z) {
-    const k = `Indexer participant hints are internally inconsistent for vault provider ${s}: some roles match the registration keys while others match the rotated operation keys.`;
-    throw c == null || c(k), new Error(`${k} Refresh and try again.`);
+  const w = [A, S, $], we = w.some((E) => E.registration && !E.operation), z = w.some((E) => E.operation && !E.registration);
+  if (we && z) {
+    const E = `Indexer participant hints are internally inconsistent for vault provider ${a}: some roles match the registration keys while others match the rotated operation keys.`;
+    throw c == null || c(E), new Error(`${E} Refresh and try again.`);
   }
   return z && (h == null || h(
-    `Indexer is serving rotated operation keys for vault provider ${s}`
+    `Indexer is serving rotated operation keys for vault provider ${a}`
   )), {
-    vaultProviderBtcPubkeyXOnly: v.vaultProvider,
-    vaultKeeperBtcPubkeysSorted: v.vaultKeepers,
-    universalChallengerBtcPubkeysSorted: v.universalChallengers,
-    expectedAppVaultKeepersVersion: d,
+    vaultProviderBtcPubkeyXOnly: m.vaultProvider,
+    vaultKeeperBtcPubkeysSorted: m.vaultKeepers,
+    universalChallengerBtcPubkeysSorted: m.universalChallengers,
+    expectedAppVaultKeepersVersion: p,
     expectedUniversalChallengersVersion: g,
     registrationKeys: P,
-    participantKeys: w
+    participantKeys: v
   };
 }
-function dt(e) {
+function yt(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function qt(e) {
+function tr(e) {
   const {
     amountSats: t,
     minDeposit: r,
-    maxDeposit: n,
-    btcBalance: s,
+    maxDeposit: o,
+    btcBalance: a,
     estimatedFeeSats: l,
-    depositorClaimValue: o
+    depositorClaimValue: s
   } = e;
-  return !(t <= 0n || t < r || n && n > 0n && t > n || l == null || o == null || t + l + o > s);
+  return !(t <= 0n || t < r || o && o > 0n && t > o || l == null || s == null || t + l + s > a);
 }
-function Qt(e, t, r) {
+function rr(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
   } : e < t ? {
     valid: !1,
-    error: `Minimum deposit is ${C(t)} BTC`
+    error: `Minimum deposit is ${R(t)} BTC`
   } : r && r > 0n && e > r ? {
     valid: !1,
-    error: `Maximum deposit is ${C(r)} BTC`
+    error: `Maximum deposit is ${R(r)} BTC`
   } : { valid: !0 };
 }
-function Wt(e) {
+function or(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
     error: "Supply cap reached — deposits temporarily paused"
   } : t > r ? {
     valid: !1,
-    error: `Vault size exceeds remaining capacity (${C(r)} BTC)`
+    error: `Vault size exceeds remaining capacity (${R(r)} BTC)`
   } : { valid: !0 };
 }
-function Yt(e, t) {
+function nr(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()
+    (a) => a.toLowerCase()
   );
   return e.filter(
-    (s) => !r.includes(s.toLowerCase())
+    (a) => !r.includes(a.toLowerCase())
   ).length > 0 ? {
     valid: !1,
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function gt(e, t, r) {
+function bt(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 a = e[o];
+    if (a <= 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 && a < t)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${C(s)} BTC is below minimum deposit ${C(t)} BTC`
+        error: `Vault ${o + 1} amount ${R(a)} BTC is below minimum deposit ${R(t)} BTC`
       };
-    if (r && s > r)
+    if (r && a > r)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${C(s)} BTC exceeds maximum deposit ${C(r)} BTC`
+        error: `Vault ${o + 1} amount ${R(a)} BTC exceeds maximum deposit ${R(r)} BTC`
       };
   }
   return { valid: !0 };
 }
-function ft(e) {
-  const t = m(e);
-  return dt(t) ? { valid: !0 } : {
+function wt(e) {
+  const t = y(e);
+  return yt(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function Pt(e) {
+function Et(e) {
   if (!e || e.length === 0)
     throw new Error(
       "No vault keepers available. The system requires at least one vault keeper to create a deposit."
     );
 }
-function mt(e) {
+function kt(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 vt(e) {
+function xt(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function Jt(e) {
+function sr(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
-    vaultProviderBtcPubkey: n,
-    vaultKeeperBtcPubkeys: s,
+    vaultProviderBtcPubkey: o,
+    vaultKeeperBtcPubkeys: a,
     universalChallengerBtcPubkeys: l,
-    minDeposit: o,
-    maxDeposit: a
-  } = e, i = gt(
+    minDeposit: s,
+    maxDeposit: n
+  } = e, i = bt(
     t,
-    o,
-    a
+    s,
+    n
   );
   if (!i.valid)
     throw new Error(i.error);
-  const u = ft(n);
+  const u = wt(o);
   if (!u.valid)
     throw new Error(u.error);
-  Pt(s), mt(l), vt(r);
+  Et(a), kt(l), xt(r);
 }
-class he extends Error {
+class me extends Error {
   constructor(t) {
     super(t), this.name = "ParticipantKeyDriftError";
   }
 }
-function Zt(e) {
-  return e instanceof he || e instanceof Error && e.name === "ParticipantKeyDriftError";
+function ar(e) {
+  return e instanceof me || e instanceof Error && e.name === "ParticipantKeyDriftError";
 }
 function J(e, t, r) {
-  return t.length === r.length && t.every((n, s) => n === r[s]) ? null : `${e} expected [${t.join(", ")}], got [${r.join(", ")}]`;
-}
-async function er(e) {
-  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: n, expected: s } = e, l = s.query;
-  if (n.length === 0) return;
-  const o = await t.getVaultKeyEpochsBatch(n), a = [];
-  for (const [i, u] of o.entries()) {
-    const h = n[i];
+  return t.length === r.length && t.every((o, a) => o === r[a]) ? null : `${e} expected [${t.join(", ")}], got [${r.join(", ")}]`;
+}
+async function ir(e) {
+  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: a } = e, l = a.query;
+  if (o.length === 0) return;
+  const s = await t.getVaultKeyEpochsBatch(o), n = [];
+  for (const [i, u] of s.entries()) {
+    const h = o[i];
     let c;
     try {
-      c = await pt({
+      c = await vt({
         operationKeyReader: r,
         query: l,
         epochs: u
       });
     } catch (g) {
-      a.push(
+      n.push(
         `vault ${h}: could not resolve participants at frozen epochs (vp=${u.vpKeyEpoch}, keeper=${u.appKeeperKeyEpoch}, uc=${u.ucKeyEpoch}): ${g.message}`
       );
       continue;
     }
-    c.vaultProvider.operationBtcPubkey !== s.vaultProvider.operationBtcPubkey && a.push(
-      `vault ${h}: vault provider key expected ${s.vaultProvider.operationBtcPubkey}, got ${c.vaultProvider.operationBtcPubkey}`
+    c.vaultProvider.operationBtcPubkey !== a.vaultProvider.operationBtcPubkey && n.push(
+      `vault ${h}: vault provider key expected ${a.vaultProvider.operationBtcPubkey}, got ${c.vaultProvider.operationBtcPubkey}`
     );
-    const p = J(
+    const d = J(
       `vault ${h}: vault keeper keys`,
-      s.vaultKeeperOperationKeysSorted,
+      a.vaultKeeperOperationKeysSorted,
       c.vaultKeeperOperationKeysSorted
     );
-    p && a.push(p);
-    const d = J(
+    d && n.push(d);
+    const p = J(
       `vault ${h}: universal challenger keys`,
-      s.universalChallengerOperationKeysSorted,
+      a.universalChallengerOperationKeysSorted,
       c.universalChallengerOperationKeysSorted
     );
-    d && a.push(d);
+    p && n.push(p);
   }
-  if (a.length > 0)
-    throw new he(
-      `Aborting BTC broadcast: participant operation keys changed during registration (${a.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
+  if (n.length > 0)
+    throw new me(
+      `Aborting BTC broadcast: participant operation keys changed during registration (${n.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-class pe extends Error {
+class Pe extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function tr(e) {
-  return e instanceof pe || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function ur(e) {
+  return e instanceof Pe || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function rr(e) {
+async function lr(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
-    expectedOffchainParamsVersion: n,
-    expectedAppVaultKeepersVersion: s,
+    expectedOffchainParamsVersion: o,
+    expectedAppVaultKeepersVersion: a,
     expectedUniversalChallengersVersion: l,
-    expectedVaultCoreVersion: o
-  } = e, a = await t.getProtocolInfoBatch(r), i = [];
-  if (a.forEach((u, h) => {
+    expectedVaultCoreVersion: s
+  } = e, n = await t.getProtocolInfoBatch(r), i = [];
+  if (n.forEach((u, h) => {
     const c = r[h];
-    u.offchainParamsVersion !== n && i.push(
-      `vault ${c}: offchainParams expected v${n}, got v${u.offchainParamsVersion}`
-    ), u.appVaultKeepersVersion !== s && i.push(
-      `vault ${c}: appVaultKeepers expected v${s}, got v${u.appVaultKeepersVersion}`
+    u.offchainParamsVersion !== o && i.push(
+      `vault ${c}: offchainParams expected v${o}, got v${u.offchainParamsVersion}`
+    ), u.appVaultKeepersVersion !== a && i.push(
+      `vault ${c}: appVaultKeepers expected v${a}, got v${u.appVaultKeepersVersion}`
     ), u.universalChallengersVersion !== l && i.push(
       `vault ${c}: universalChallengers expected v${l}, got v${u.universalChallengersVersion}`
-    ), u.vaultCoreVersion !== o && i.push(
-      `vault ${c}: vaultCoreVersion expected v${o} (build-time active), got v${u.vaultCoreVersion}`
+    ), u.vaultCoreVersion !== s && i.push(
+      `vault ${c}: vaultCoreVersion expected v${s} (build-time active), got v${u.vaultCoreVersion}`
     );
   }), i.length > 0)
-    throw new pe(
+    throw new Pe(
       `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${i.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-var de = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(de || {});
-const yt = /* @__PURE__ */ new Set([
+var ve = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(ve || {});
+const Tt = /* @__PURE__ */ new Set([
   "PayoutBroadcast",
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function nr(e) {
-  return Object.values(de).includes(
+function cr(e) {
+  return Object.values(ve).includes(
     e
   );
 }
-function or(e) {
-  return !!e && yt.has(e);
-}
-class bt 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 hr(e) {
+  return !!e && Tt.has(e);
+}
+class At extends Error {
+  constructor(r, o) {
+    super(`Refund not yet mature (BIP68 not final): ${o.message}`);
+    C(this, "vaultId");
+    C(this, "cause");
+    this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
   }
 }
-const wt = /^0x[0-9a-fA-F]{64}$/, kt = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, ge = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, fe = 160, Z = 2e3, ee = 10n, te = 100n;
-function ar(e) {
+const Rt = /^0x[0-9a-fA-F]{64}$/, Ct = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, ye = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, be = 160, Z = 2e3, ee = 10n, te = 100n;
+function dr(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * fe));
+  return BigInt(Math.ceil(e * be));
 }
-const Et = 1, xt = /non-BIP68-final/i;
-function U(e, t) {
+const _t = 1, St = /non-BIP68-final/i;
+function L(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 (!wt.test(e))
+  if (!Rt.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function O(e, t) {
+function U(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function Tt(e) {
-  if (U(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
+function $t(e) {
+  if (L(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
     throw new Error(
       `htlcVout must be a non-negative integer, got ${e.htlcVout}`
     );
@@ -1175,14 +1175,14 @@ function Tt(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 (U(n.hashlock, `batch[${r}].hashlock`), !Number.isInteger(n.htlcVout) || n.htlcVout !== r)
+    const o = e.batch[r];
+    if (L(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];
@@ -1194,7 +1194,7 @@ function Tt(e) {
     throw new Error(
       `batch[${e.htlcVout}].amount (${t.amount}) does not match target amount (${e.amount})`
     );
-  if (O(e.offchainParamsVersion, "offchainParamsVersion"), O(e.appVaultKeepersVersion, "appVaultKeepersVersion"), O(
+  if (U(e.offchainParamsVersion, "offchainParamsVersion"), U(e.appVaultKeepersVersion, "appVaultKeepersVersion"), U(
     e.universalChallengersVersion,
     "universalChallengersVersion"
   ), Ne(
@@ -1202,19 +1202,19 @@ function Tt(e) {
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!kt.test(e.unsignedPrePeginTxHex))
+  if (!Ct.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !ge.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !ye.test(e.depositorBtcPubkey))
     throw new Error(
       "depositorBtcPubkey must be 32 or 33 bytes of hex (optional 0x prefix)"
     );
   if (typeof e.amount != "bigint" || e.amount <= 0n)
     throw new Error(`amount must be a positive bigint, got ${e.amount}`);
 }
-function Ct(e) {
-  if (!e.vaultProviderPubkey || !ge.test(e.vaultProviderPubkey))
+function Bt(e) {
+  if (!e.vaultProviderPubkey || !ye.test(e.vaultProviderPubkey))
     throw new Error("vaultProviderPubkey must be 32 or 33 bytes of hex");
   if (e.vaultKeeperPubkeys.length === 0)
     throw new Error("vaultKeeperPubkeys must be non-empty");
@@ -1239,46 +1239,46 @@ function Ct(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-function St(e) {
-  const t = Re.fromHex(e);
+function It(e) {
+  const t = le.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 sr(e) {
+async function pr(e) {
   const {
     vaultId: t,
     readVault: r,
-    readPrePeginContext: n,
-    feeRate: s,
+    readPrePeginContext: o,
+    feeRate: a,
     signPsbt: l,
-    broadcastTx: o,
-    signal: a
+    broadcastTx: s,
+    signal: n
   } = e;
-  a == null || a.throwIfAborted(), U(t, "vaultId");
+  n == null || n.throwIfAborted(), L(t, "vaultId");
   const i = await r();
-  Tt(i), a == null || a.throwIfAborted();
-  const u = await n(i);
-  if (Ct(u), a == null || a.throwIfAborted(), !Number.isFinite(s) || s <= 0)
-    throw new Error(`feeRate must be a positive number, got ${s}`);
-  if (s > Z)
+  $t(i), n == null || n.throwIfAborted();
+  const u = await o(i);
+  if (Bt(u), n == null || n.throwIfAborted(), !Number.isFinite(a) || a <= 0)
+    throw new Error(`feeRate must be a positive number, got ${a}`);
+  if (a > Z)
     throw new Error(
-      `feeRate ${s} sat/vB exceeds refund safety cap ${Z} sat/vB; refusing to sign refund.`
+      `feeRate ${a} sat/vB exceeds refund safety cap ${Z} sat/vB; refusing to sign refund.`
     );
-  const h = BigInt(Math.ceil(s * fe)), c = i.amount * ee / te;
+  const h = BigInt(Math.ceil(a * be)), c = i.amount * ee / te;
   if (h > c)
     throw new Error(
       `Refund fee ${h} sats exceeds the per-vault safety cap of ${c} sats (${ee}/${te} of vault.amount=${i.amount}); refusing to sign refund.`
     );
-  a == null || a.throwIfAborted();
-  const p = L(
+  n == null || n.throwIfAborted();
+  const d = O(
     i.depositorBtcPubkey
-  ), d = m(i.unsignedPrePeginTxHex), g = Te(d);
+  ), p = y(i.unsignedPrePeginTxHex), g = Se(p);
   if (g !== void 0 && g.vout !== i.batch.length)
     throw new Error(
       `Auth-anchor OP_RETURN at vout ${g.vout} does not match batch size (${i.batch.length} HTLC outputs expect the anchor at vout ${i.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
@@ -1286,24 +1286,24 @@ async function sr(e) {
   const b = g == null ? void 0 : g.hash;
   let f;
   try {
-    f = A.fromHex(d);
-  } catch (y) {
+    f = _.fromHex(p);
+  } catch (w) {
     throw new Error(
-      `Failed to parse funded Pre-PegIn transaction hex: ${y instanceof Error ? y.message : String(y)}`
+      `Failed to parse funded Pre-PegIn transaction hex: ${w instanceof Error ? w.message : String(w)}`
     );
   }
   if (f.outs.length < i.batch.length)
     throw new Error(
       `Funded Pre-PegIn tx has ${f.outs.length} outputs but batch requires at least ${i.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const { psbtHex: P } = await Ke({
+  const { psbtHex: P } = await Fe({
     prePeginParams: {
       vaultCoreVersion: i.vaultCoreVersion,
-      depositorPubkey: p,
-      vaultProviderPubkey: m(u.vaultProviderPubkey),
-      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(m),
-      universalChallengerPubkeys: u.universalChallengerPubkeys.map(m),
-      hashlocks: i.batch.map((y) => m(y.hashlock)),
+      depositorPubkey: d,
+      vaultProviderPubkey: y(u.vaultProviderPubkey),
+      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(y),
+      universalChallengerPubkeys: u.universalChallengerPubkeys.map(y),
+      hashlocks: i.batch.map((w) => y(w.hashlock)),
       timelockRefund: u.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
@@ -1311,7 +1311,7 @@ async function sr(e) {
       // 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: i.batch.map((y) => y.amount),
+      pegInAmounts: i.batch.map((w) => w.amount),
       feeRate: u.feeRate,
       minPeginFeeRate: u.minPeginFeeRate,
       numLocalChallengers: u.numLocalChallengers,
@@ -1320,85 +1320,179 @@ async function sr(e) {
       network: u.network,
       authAnchorHash: b
     },
-    fundedPrePeginTxHex: d,
+    fundedPrePeginTxHex: p,
     htlcVout: i.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: m(i.hashlock)
+    hashlock: y(i.hashlock)
   });
-  a == null || a.throwIfAborted();
-  const w = M(
+  n == null || n.throwIfAborted();
+  const v = K(
     i.depositorBtcPubkey,
-    Et
-  ), v = await l(P, w);
-  H({
+    _t
+  ), m = await l(P, v);
+  B({
     requestedPsbtHex: P,
-    returnedPsbtHex: v
+    returnedPsbtHex: m
   });
-  const S = 0, B = D(
-    v,
-    p,
-    S
+  const A = 0, S = I(
+    m,
+    d,
+    A
   );
-  F({
+  V({
     requestedPsbtHex: P,
-    signatureHex: B,
-    signerXOnlyPubkeyHex: p,
-    inputIndex: S
+    signatureHex: S,
+    signerXOnlyPubkeyHex: d,
+    inputIndex: A
   });
-  const R = St(v);
-  a == null || a.throwIfAborted();
+  const $ = It(m);
+  n == null || n.throwIfAborted();
   try {
-    return await o(R);
-  } catch (y) {
-    throw y instanceof Error && xt.test(y.message) ? new bt(t, y) : y;
+    return await s($);
+  } catch (w) {
+    throw w instanceof Error && St.test(w.message) ? new At(t, w) : w;
+  }
+}
+class re extends Error {
+  constructor(r, o, a) {
+    super(r);
+    /** Fee the reclaim would have paid, in satoshis. */
+    C(this, "feeSats");
+    /** Sum of the reserves the reclaim would have swept, in satoshis. */
+    C(this, "sweptTotalSats");
+    this.name = "ReclaimUneconomicalError", this.feeSats = o, this.sweptTotalSats = a;
   }
 }
+const oe = 2e3, ne = 25n, se = 100n, gr = 10n;
+function Vt(e) {
+  const t = le.fromHex(e);
+  try {
+    t.finalizeAllInputs();
+  } catch (r) {
+    const o = r instanceof Error ? r.message : String(r);
+    if (!o.includes("already finalized"))
+      throw new Error(`Failed to finalize reclaim PSBT: ${o}`);
+  }
+  return t.extractTransaction().toHex();
+}
+async function fr(e) {
+  const {
+    vaultIds: t,
+    depositorBtcPubkey: r,
+    readVaults: o,
+    feeRate: a,
+    signPsbt: l,
+    broadcastTx: s,
+    signal: n
+  } = e;
+  if (n == null || n.throwIfAborted(), t.length === 0)
+    throw new Error("Reclaim requires at least one vault id; got none.");
+  if (!Number.isFinite(a) || a <= 0)
+    throw new Error(`feeRate must be a positive number, got ${a}`);
+  if (a > oe)
+    throw new re(
+      `Fee rate ${a} sat/vB exceeds the reclaim safety cap of ${oe} sat/vB; refusing to sign.`,
+      0n,
+      0n
+    );
+  const i = await o();
+  if (n == null || n.throwIfAborted(), i.length !== t.length)
+    throw new Error(
+      `readVaults returned ${i.length} reserves for ${t.length} vault id(s); refusing to sweep a set that does not match the request.`
+    );
+  const u = O(r), h = i.map((v) => ({
+    depositorSignedPeginTxHex: v.depositorSignedPeginTxHex,
+    observed: v.observed,
+    expectedValue: v.expectedClaimValue
+  })), c = Me(a, h.length), d = h.reduce((v, m) => v + m.expectedValue, 0n), p = d * ne / se;
+  if (c > p)
+    throw new re(
+      `Reclaim fee ${c} sats exceeds ${ne}/${se} of the swept total (${d} sats, cap ${p} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
+      c,
+      d
+    );
+  n == null || n.throwIfAborted();
+  const { psbtHex: g } = Ue({
+    depositorPubkey: u,
+    inputs: h,
+    feeSats: c
+  });
+  n == null || n.throwIfAborted();
+  const b = K(
+    r,
+    h.length
+  ), f = await l(g, b);
+  B({
+    requestedPsbtHex: g,
+    returnedPsbtHex: f
+  }), h.forEach((v, m) => {
+    const A = I(
+      f,
+      u,
+      m
+    );
+    V({
+      requestedPsbtHex: g,
+      signatureHex: A,
+      signerXOnlyPubkeyHex: u,
+      inputIndex: m
+    });
+  });
+  const P = Vt(f);
+  return n == null || n.throwIfAborted(), s(P);
+}
 export {
-  lt as A,
+  ft as A,
   Q as B,
-  ht as C,
-  pt as D,
-  de as E,
-  nr as F,
-  or as G,
-  bt as H,
-  sr as I,
-  ar as J,
+  Pt as C,
+  vt as D,
+  ve as E,
+  cr as F,
+  hr as G,
+  At as H,
+  pr as I,
+  dr as J,
   te as K,
   ee as L,
   Z as M,
-  fe as N,
-  Ue as P,
-  pe as R,
-  Ft as a,
-  Mt as b,
-  se as c,
-  ie as d,
-  Ut as e,
-  Xt as f,
-  qt as g,
-  Qt as h,
-  Ge as i,
-  Jt as j,
-  Yt as k,
-  Wt as l,
-  gt as m,
-  ft as n,
-  he as o,
-  Zt as p,
-  er as q,
-  zt as r,
-  Ze as s,
-  tr as t,
-  rr as u,
-  jt as v,
-  Lt as w,
-  ue as x,
-  Gt as y,
-  V as z
+  be as N,
+  re as O,
+  je as P,
+  fr as Q,
+  Pe as R,
+  se as S,
+  ne as T,
+  oe as U,
+  gr as V,
+  qt as a,
+  jt as b,
+  he as c,
+  de as d,
+  Qt as e,
+  Jt as f,
+  tr as g,
+  rr as h,
+  Je as i,
+  sr as j,
+  nr as k,
+  or as l,
+  bt as m,
+  wt as n,
+  me as o,
+  ar as p,
+  ir as q,
+  Yt as r,
+  st as s,
+  ur as t,
+  lr as u,
+  er as v,
+  Wt as w,
+  pe as x,
+  Zt as y,
+  D as z
 };
-//# sourceMappingURL=buildAndBroadcastRefund-DY4ZZcFL.js.map
+//# sourceMappingURL=buildAndBroadcastReclaim-kBHwOL02.js.map