@babylonlabs-io/ts-sdk 0.73.0 → 0.74.1

package/dist/{toRefundInputs-BkcFhvDp.js → toRefundInputs-BNSXIymn.js}

@@ -1,53 +1,54 @@
-var J = Object.defineProperty;
-var X = (e, t, r) => t in e ? J(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var I = (e, t, r) => X(e, typeof t != "symbol" ? t + "" : t, r);
-import { s as G } from "./sha2-CrlWM5S8.js";
-import { a as F } from "./signPsbtsWithFallback-0VBALhjS.js";
-import { b as Y, f as Z } from "./PeginManager-C9RPOd0L.js";
-import { s as P, h as ee, p as z, u as te, e as re } from "./bitcoin-C-TuHb-v.js";
-import { computeMinClaimValue as N, computeMinPeginFee as D, peginP2aAnchorOutput as U, getPrePeginHtlcConnectorInfo as ne, expandAuthAnchor as oe } from "./tbv/core/wasm/index.js";
-import { p as se, d as ae } from "./parseFundingOutpoints-B67CoXpF.js";
-import { Transaction as j } from "bitcoinjs-lib";
-import { m as ie, H as K } from "./verifyScriptPathSchnorrSignature-Ciq_xZhw.js";
-import { c as O } from "./fundPeginTransaction-B2wyjqp0.js";
-import { c as L } from "./signing-Cm-McVR2.js";
-const W = "DepositTermsRejectedError";
-class ce extends Error {
+var re = Object.defineProperty;
+var ne = (e, t, r) => t in e ? re(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var _ = (e, t, r) => ne(e, typeof t != "symbol" ? t + "" : t, r);
+import { keccak256 as G, toHex as oe, encodeAbiParameters as se, isAddress as ae, zeroAddress as ie } from "viem";
+import { s as ce } from "./sha2-CLpQd0Rd.js";
+import { a as M } from "./signPsbtsWithFallback-f7QLp0q8.js";
+import { b as ue, f as le } from "./PeginManager-DNimKlmw.js";
+import { s as P, h as he, p as W, u as de, e as me } from "./bitcoin-C-TuHb-v.js";
+import { computeMinClaimValue as Q, computeMinPeginFee as X, peginP2aAnchorOutput as q, getPrePeginHtlcConnectorInfo as pe, expandAuthAnchor as ge } from "./tbv/core/wasm/index.js";
+import { p as Pe, d as fe } from "./parseFundingOutpoints-BQWvINfm.js";
+import { Transaction as J } from "bitcoinjs-lib";
+import { o as ve, H as z } from "./verifyScriptPathSchnorrSignature-D_epga4j.js";
+import { c as O } from "./fundPeginTransaction-CwhRbCQC.js";
+import { c as Y } from "./signing-Cm-McVR2.js";
+const Z = "DepositTermsRejectedError";
+class be extends Error {
   constructor(r, n = "device-envelope") {
     super(r);
-    I(this, "reason");
-    this.name = W, this.reason = n;
+    _(this, "reason");
+    this.name = Z, this.reason = n;
   }
 }
-function Ae(e) {
-  if (e instanceof ce) return !0;
+function qe(e) {
+  if (e instanceof be) return !0;
   if (typeof e != "object" || e === null) return !1;
   const t = e;
-  return t.name === W && t.reason === "device-envelope";
+  return t.name === Z && t.reason === "device-envelope";
 }
-async function ue(e) {
+async function ye(e) {
   const t = e.siblings.length;
   if (t === 0)
     throw new Error(
       "rebuildDepositTermsCore: at least one sibling is required"
     );
-  for (const [o, v] of e.siblings.entries())
-    if (v.amount <= 0n)
+  for (const [o, b] of e.siblings.entries())
+    if (b.amount <= 0n)
       throw new Error(
-        `rebuildDepositTermsCore: sibling[${o}] has non-positive on-chain pegin amount ${v.amount}; the chain-read vault record is invalid. Resume refused.`
+        `rebuildDepositTermsCore: sibling[${o}] has non-positive on-chain pegin amount ${b.amount}; the chain-read vault record is invalid. Resume refused.`
       );
   if (e.prepeginMaxFee <= 0n)
     throw new Error(
       `rebuildDepositTermsCore: prepeginMaxFee must be > 0, got ${e.prepeginMaxFee}`
     );
   const r = P(e.prepeginTxid).toLowerCase(), n = P(
-    L(e.fundedPrePeginTxHex)
+    Y(e.fundedPrePeginTxHex)
   ).toLowerCase();
   if (n !== r)
     throw new Error(
       `Funded Pre-PegIn tx hashes to ${n}, expected ${r} (on-chain prepeginTxid). Resume refused.`
     );
-  const h = F(
+  const h = M(
     P(e.fundedPrePeginTxHex)
   );
   if (h === void 0)
@@ -58,19 +59,19 @@ async function ue(e) {
     throw new Error(
       `Auth-anchor OP_RETURN at vout ${h.vout} does not match the discovered sibling count ${t}; the discovered sibling set does not cover this transaction's HTLC outputs (a lagging index can cause this — retry later). Resume refused.`
     );
-  const c = e.vaultKeeperBtcPubkeys.length, u = e.universalChallengerBtcPubkeys.length, l = await N(
+  const c = e.vaultKeeperBtcPubkeys.length, u = e.universalChallengerBtcPubkeys.length, l = await Q(
     e.vaultCoreVersion,
     c,
     u,
     e.councilQuorum,
     e.councilSize,
     e.protocolFeeRate
-  ), i = await D(
+  ), i = await X(
     e.vaultCoreVersion,
     c,
     u,
     e.minPeginFeeRate
-  ), d = await U(e.vaultCoreVersion), s = (d == null ? void 0 : d.value) ?? 0n;
+  ), d = await q(e.vaultCoreVersion), s = (d == null ? void 0 : d.value) ?? 0n;
   if (l <= 0n)
     throw new Error(
       `WASM returned non-positive depositorClaimValue ${l}; expected > 0. Resume refused.`
@@ -83,15 +84,15 @@ async function ue(e) {
     throw new Error(
       `WASM returned negative P2A anchor value ${s}. Resume refused.`
     );
-  const a = i + s, f = e.minPeginFeeRate * O;
-  if (a <= 0n || a > f)
+  const a = i + s, v = e.minPeginFeeRate * O;
+  if (a <= 0n || a > v)
     throw new Error(
-      `WASM implied PegIn reserve ${a} sat is outside (0, ${f}] (minPeginFeeRate=${e.minPeginFeeRate} × ${O} vbytes). Resume refused.`
+      `WASM implied PegIn reserve ${a} sat is outside (0, ${v}] (minPeginFeeRate=${e.minPeginFeeRate} × ${O} vbytes). Resume refused.`
     );
   const w = e.siblings.map(
     (o) => o.amount + l + i + s
-  ), y = await Promise.all(
-    e.siblings.map(async (o) => (await ne({
+  ), C = await Promise.all(
+    e.siblings.map(async (o) => (await pe({
       txGraphVersion: e.vaultCoreVersion,
       depositorPubkey: e.depositorBtcPubkey,
       vaultProviderPubkey: e.vaultProviderBtcPubkey,
@@ -101,14 +102,14 @@ async function ue(e) {
       timelockRefund: e.timelockRefund,
       network: e.network
     })).scriptPubKey)
-  ), k = j.fromHex(
+  ), E = J.fromHex(
     P(e.fundedPrePeginTxHex)
   ).outs.map((o) => ({ value: o.value, script: o.script }));
-  return ie(
-    k,
+  return ve(
+    E,
     w,
-    y
-  ), Y({
+    C
+  ), ue({
     vaultCoreVersion: e.vaultCoreVersion,
     protocolFeeRate: e.protocolFeeRate,
     timelockPegin: e.timelockPegin,
@@ -125,85 +126,177 @@ async function ue(e) {
     peginMaxFee: i
   });
 }
-function Be(e) {
+function Je(e) {
   const t = (e instanceof Error ? e.message : typeof e == "string" ? e : "").toLowerCase();
   return t.includes("wots") && t.includes("hash") && t.includes("does not match");
 }
-class le extends Error {
+const we = "TBV.PeginFingerprint.v1", Ee = G(
+  oe(we)
+), U = 65535, D = 2n ** 64n - 1n, Ce = 2n ** 256n - 1n, Re = /^0x[0-9a-fA-F]{64}$/, L = 1;
+class f extends Error {
+  constructor(t) {
+    super(t), this.name = "PeginFingerprintInputError";
+  }
+}
+function B(e, t, r, n) {
+  if (typeof t != "bigint")
+    throw new f(
+      `${e} must be a bigint (Solidity ${n}), got ${typeof t}`
+    );
+  if (t < 0n || t > r)
+    throw new f(
+      `${e} must fit Solidity ${n} (0..${r}), got ${t}`
+    );
+}
+function $(e, t) {
+  if (!Number.isInteger(t) || t < 0 || t > U)
+    throw new f(
+      `${e} must be an integer fitting Solidity uint16 (0..${U}), got ${t}`
+    );
+}
+function ke(e, t) {
+  if (!Re.test(t))
+    throw new f(
+      `${e} must be 32 bytes as 0x-prefixed hex (66 characters), got "${t}"`
+    );
+  return t.toLowerCase();
+}
+function xe(e) {
+  if (!ae(e, { strict: !1 }))
+    throw new f(
+      `registryAddress must be a 20-byte 0x-prefixed address, got "${e}"`
+    );
+  const t = e.toLowerCase();
+  if (t === ie)
+    throw new f(
+      "registryAddress must not be the zero address; a zero here means the registry address was never resolved"
+    );
+  return t;
+}
+const Ve = [
+  { name: "domain", type: "bytes32" },
+  { name: "chainId", type: "uint256" },
+  { name: "registry", type: "address" },
+  { name: "vaultProviderBtcKey", type: "bytes32" },
+  { name: "appKeeperKeyEpoch", type: "uint64" },
+  { name: "ucKeyEpoch", type: "uint64" },
+  { name: "appVaultKeepersVersion", type: "uint16" },
+  { name: "universalChallengersVersion", type: "uint16" },
+  { name: "offchainParamsVersion", type: "uint16" },
+  { name: "vaultCoreVersion", type: "uint16" }
+];
+function $e(e) {
+  if (B("chainId", e.chainId, Ce, "uint256"), e.chainId === 0n)
+    throw new f(
+      "chainId must not be 0; a zero here means the chain id was never resolved"
+    );
+  const t = xe(e.registryAddress), r = ke(
+    "vaultProviderBtcKey",
+    e.vaultProviderBtcKey
+  );
+  if (B(
+    "appKeeperKeyEpoch",
+    e.appKeeperKeyEpoch,
+    D,
+    "uint64"
+  ), B("ucKeyEpoch", e.ucKeyEpoch, D, "uint64"), $("appVaultKeepersVersion", e.appVaultKeepersVersion), $(
+    "universalChallengersVersion",
+    e.universalChallengersVersion
+  ), $("offchainParamsVersion", e.offchainParamsVersion), $("vaultCoreVersion", e.vaultCoreVersion), e.vaultCoreVersion < L)
+    throw new f(
+      `vaultCoreVersion must be at least ${L}; ${e.vaultCoreVersion} means the version was never resolved`
+    );
+  return se(Ve, [
+    Ee,
+    e.chainId,
+    t,
+    r,
+    e.appKeeperKeyEpoch,
+    e.ucKeyEpoch,
+    e.appVaultKeepersVersion,
+    e.universalChallengersVersion,
+    e.offchainParamsVersion,
+    e.vaultCoreVersion
+  ]);
+}
+function Ye(e) {
+  return G($e(e));
+}
+class Te extends Error {
   constructor(t, r) {
     super(
       `Re-derived vault root does not match this Pre-PegIn: derived auth-anchor hash ${t}, transaction commits to ${r}. Connect the same wallet, on the same account and the same network, that created the deposit.`
     ), this.derivedAuthAnchorHash = t, this.onChainAuthAnchorHash = r, this.name = "VaultRootMismatchError";
   }
 }
-class B extends Error {
+class K extends Error {
   constructor(t) {
     super(t), this.name = "UnanchoredPrePeginError";
   }
 }
-class he extends Error {
+class Ae extends Error {
   constructor(t, r, n = []) {
     super(
       `No candidate parameter set reproduces this Pre-PegIn's HTLC outputs (${t} candidate(s) tried). ` + (n.length > 0 ? `${n.length} version(s) could not be resolved and may hold the answer: ${n.join(" | ")}. ` : "") + `Sample rejections: ${r.join(" | ")}`
     ), this.candidatesTried = t, this.sampleRejections = r, this.unresolvedLabels = n, this.name = "PeginParamsNotFoundError";
   }
 }
-class de extends Error {
+class Ie extends Error {
   constructor(t) {
     super(
       `${t.length} candidate parameter sets reproduce this Pre-PegIn's HTLC outputs, so the vault's stamped versions cannot be determined: ${t.join(" | ")}. Reconstruction refused.`
     ), this.survivorLabels = t, this.name = "PeginParamsAmbiguousError";
   }
 }
-class me extends Error {
+class Be extends Error {
   constructor(t, r) {
     super(
       `A candidate matched this Pre-PegIn (${t}), but ${r.length} version(s) could not be resolved, so the search space did not provably contain the true parameters: ${r.join(" | ")}. A version sharing the matched timelockRefund and participants is indistinguishable from the true one, so the match cannot be trusted. Reconstruction refused.`
     ), this.matchedLabel = t, this.unresolvedLabels = r, this.name = "PeginParamsIncompleteSpaceError";
   }
 }
-class $ extends Error {
+class T extends Error {
   constructor(t) {
     super(`${t}. Reconstruction refused.`), this.name = "PeginSizingIntegrityError";
   }
 }
-async function Fe(e) {
-  const { wallet: t, depositorBtcPubkey: r, fundedPrePeginTxHex: n } = e, h = P(n), c = F(h);
+async function Ze(e) {
+  const { wallet: t, depositorBtcPubkey: r, fundedPrePeginTxHex: n } = e, h = P(n), c = M(h);
   if (c === void 0)
-    throw new B(
+    throw new K(
       "Pre-PegIn carries no single, unambiguous auth-anchor OP_RETURN, so the number of HTLC outputs it funds cannot be determined. Legacy pre-anchor deposits are not recoverable by this path."
     );
   const u = c.vout;
   if (u === 0)
-    throw new B(
+    throw new K(
       "Pre-PegIn's auth-anchor OP_RETURN is at vout 0, implying zero HTLC outputs; there is nothing to recover."
     );
-  const l = se(h), i = await ae(t, {
+  const l = Pe(h), i = await fe(t, {
     // The vault context takes the 32-byte x-only key; a wallet's compressed
     // key would otherwise fail a byte-length check deep in the encoder with
     // nothing pointing back at the caller.
-    depositorBtcPubkey: ee(
-      z(r)
+    depositorBtcPubkey: he(
+      W(r)
     ),
     fundingOutpoints: l
   });
   try {
-    const s = await oe(i);
+    const s = await ge(i);
     let a;
     try {
-      a = te(G(s));
+      a = de(ce(s));
     } finally {
       s.fill(0);
     }
     if (a !== c.hash)
-      throw new le(a, c.hash);
+      throw new Te(a, c.hash);
   } catch (s) {
     throw i.fill(0), s;
   }
-  const { hashlocks: d } = await Z(i, u);
+  const { hashlocks: d } = await le(i, u);
   return { vaultCount: u, hashlocks: d, authAnchorHash: c.hash };
 }
-function He(e) {
+function et(e) {
   const { vaultCoreVersion: t, offchainParams: r, participantKeySets: n } = e;
   if (!Number.isInteger(t) || t < 1)
     throw new Error(
@@ -227,21 +320,21 @@ function He(e) {
       });
   return h;
 }
-function pe(e) {
+function Fe(e) {
   return `${e.axis} v${e.version} (${e.reason})`;
 }
-function A(e) {
+function F(e) {
   const { participants: t } = e;
   return `core=${e.vaultCoreVersion} offchain=${e.offchainParams.version} keepers=${t.appVaultKeepersVersion} challengers=${t.universalChallengersVersion} vp=${t.vaultProvider}`;
 }
-const _ = 5;
-function ge(e, t) {
+const j = 5;
+function Ke(e, t) {
   return JSON.stringify(
     { terms: e, peginAmounts: t },
     (r, n) => typeof n == "bigint" ? `${n}` : n
   );
 }
-function Pe(e) {
+function Me(e) {
   const { offchainParams: t, participants: r } = e;
   return [
     e.vaultCoreVersion,
@@ -253,9 +346,9 @@ function Pe(e) {
     t.minPeginFeeRate
   ].join("|");
 }
-async function fe(e) {
+async function Se(e) {
   const { offchainParams: t, participants: r } = e, n = r.vaultKeeperBtcPubkeys.length, h = r.universalChallengerBtcPubkeys.length, [c, u, l] = await Promise.all([
-    N(
+    Q(
       e.vaultCoreVersion,
       n,
       h,
@@ -263,29 +356,29 @@ async function fe(e) {
       t.councilSize,
       t.protocolFeeRate
     ),
-    D(
+    X(
       e.vaultCoreVersion,
       n,
       h,
       t.minPeginFeeRate
     ),
-    U(e.vaultCoreVersion)
+    q(e.vaultCoreVersion)
   ]), i = (l == null ? void 0 : l.value) ?? 0n;
   if (c <= 0n)
-    throw new $(
+    throw new T(
       `WASM returned non-positive depositorClaimValue ${c} for graph version ${e.vaultCoreVersion}`
     );
   if (u <= 0n)
-    throw new $(
+    throw new T(
       `WASM returned non-positive peginMaxFee ${u} for graph version ${e.vaultCoreVersion}`
     );
   if (i < 0n)
-    throw new $(
+    throw new T(
       `WASM returned negative P2A anchor value ${i} for graph version ${e.vaultCoreVersion}`
     );
   return { depositorClaimValue: c, peginMaxFee: u, p2aAnchorValue: i };
 }
-async function Se(e) {
+async function tt(e) {
   const {
     hashlocks: t,
     fundedPrePeginTxHex: r,
@@ -302,78 +395,78 @@ async function Se(e) {
     );
   if (l.length === 0)
     throw new Error("reconstructPeginParams: candidate space is empty");
-  const d = z(n), s = P(r), a = F(s);
+  const d = W(n), s = P(r), a = M(s);
   if (a === void 0)
-    throw new B(
+    throw new K(
       "Pre-PegIn carries no single, unambiguous auth-anchor OP_RETURN; the sibling set cannot be proven complete. Reconstruction refused."
     );
   if (a.vout !== t.length)
     throw new Error(
       `reconstructPeginParams: ${t.length} hashlock(s) supplied but the auth-anchor OP_RETURN sits at vout ${a.vout}, so the transaction funds ${a.vout} HTLC output(s). Reconstruction refused.`
     );
-  const f = j.fromHex(s).outs, w = t.map((m, p) => BigInt(f[p].value)), y = P(
-    L(s)
-  ).toLowerCase(), k = /* @__PURE__ */ new Map(), o = [], v = [], V = [];
-  let H = 0;
+  const v = J.fromHex(s).outs, w = t.map((m, p) => BigInt(v[p].value)), C = P(
+    Y(s)
+  ).toLowerCase(), E = /* @__PURE__ */ new Map(), o = [], b = [], A = [];
+  let S = 0;
   for (const m of l)
     try {
-      const p = Pe(m);
-      let g = k.get(p);
-      g === void 0 && (g = await fe(m), k.set(p, g));
-      const C = g.depositorClaimValue + g.peginMaxFee + g.p2aAnchorValue, R = w.map((x) => x - C), E = R.findIndex((x) => x <= 0n);
-      if (E !== -1)
-        throw new K(
-          `HTLC output[${E}] value ${w[E]} is not above this candidate's reserve ${C}, so it implies a non-positive pegin amount ${R[E]}.`
+      const p = Me(m);
+      let g = E.get(p);
+      g === void 0 && (g = await Se(m), E.set(p, g));
+      const R = g.depositorClaimValue + g.peginMaxFee + g.p2aAnchorValue, k = w.map((x) => x - R), V = k.findIndex((x) => x <= 0n);
+      if (V !== -1)
+        throw new z(
+          `HTLC output[${V}] value ${w[V]} is not above this candidate's reserve ${R}, so it implies a non-positive pegin amount ${k[V]}.`
         );
-      const { offchainParams: b, participants: T } = m, M = await ue({
+      const { offchainParams: y, participants: I } = m, N = await ye({
         vaultCoreVersion: m.vaultCoreVersion,
-        siblings: t.map((x, q) => ({
+        siblings: t.map((x, te) => ({
           hashlock: x,
-          amount: R[q]
+          amount: k[te]
         })),
         fundedPrePeginTxHex: s,
         depositorBtcPubkey: d,
-        vaultProviderBtcPubkey: T.vaultProviderBtcPubkey,
-        vaultKeeperBtcPubkeys: T.vaultKeeperBtcPubkeys,
-        universalChallengerBtcPubkeys: T.universalChallengerBtcPubkeys,
-        protocolFeeRate: b.protocolFeeRate,
-        minPeginFeeRate: b.minPeginFeeRate,
-        councilQuorum: b.councilQuorum,
-        councilSize: b.councilSize,
-        timelockPegin: b.timelockPegin,
-        timelockAssert: b.timelockAssert,
-        timelockRefund: b.timelockRefund,
-        prepeginTxid: y,
+        vaultProviderBtcPubkey: I.vaultProviderBtcPubkey,
+        vaultKeeperBtcPubkeys: I.vaultKeeperBtcPubkeys,
+        universalChallengerBtcPubkeys: I.universalChallengerBtcPubkeys,
+        protocolFeeRate: y.protocolFeeRate,
+        minPeginFeeRate: y.minPeginFeeRate,
+        councilQuorum: y.councilQuorum,
+        councilSize: y.councilSize,
+        timelockPegin: y.timelockPegin,
+        timelockAssert: y.timelockAssert,
+        timelockRefund: y.timelockRefund,
+        prepeginTxid: C,
         prepeginMaxFee: h,
         maxAcceptableCommissionBps: c,
         network: u
       });
       o.push({
         candidate: m,
-        terms: M,
-        peginAmounts: R,
-        fingerprint: ge(M, R)
+        terms: N,
+        peginAmounts: k,
+        fingerprint: Ke(N, k)
       });
     } catch (p) {
-      if (p instanceof $)
+      if (p instanceof T)
         throw p;
-      const g = A(m), C = p instanceof Error ? p.message : String(p);
-      p instanceof K ? v.length < _ && v.push(`[${g}] ${C}`) : (H++, V.length < _ && V.push(`${g} (${C})`));
+      const g = F(m), R = p instanceof Error ? p.message : String(p);
+      p instanceof z ? b.length < j && b.push(`[${g}] ${R}`) : (S++, A.length < j && A.push(`${g} (${R})`));
     }
-  const Q = i.length + H, S = [
-    ...i.map(pe),
-    ...V
+  const ee = i.length + S, H = [
+    ...i.map(Fe),
+    ...A
   ];
   if (o.length === 0)
-    throw new he(l.length, v, S);
+    throw new Ae(l.length, b, H);
   if (new Set(o.map((m) => m.fingerprint)).size > 1)
-    throw new de(
-      o.map((m) => A(m.candidate))
+    throw new Ie(
+      o.map((m) => F(m.candidate))
     );
-  if (Q > 0)
-    throw new me(
-      A(o[0].candidate),
-      S
+  if (ee > 0)
+    throw new Be(
+      F(o[0].candidate),
+      H
     );
   return {
     candidate: o[0].candidate,
@@ -384,7 +477,7 @@ async function Se(e) {
     matchedCandidates: o.map((m) => m.candidate)
   };
 }
-function Me(e, t) {
+function rt(e, t) {
   const {
     htlcVout: r,
     depositorBtcPubkey: n,
@@ -401,13 +494,13 @@ function Me(e, t) {
     throw new Error(
       `toRefundInputs: htlcVout ${r} is outside the reconstructed batch of ${d.length} vault(s).`
     );
-  const f = d.map((k, o) => ({
-    hashlock: re(u[o]),
-    amount: k,
+  const v = d.map((E, o) => ({
+    hashlock: me(u[o]),
+    amount: E,
     htlcVout: o
   })), w = {
     vaultCoreVersion: i.vaultCoreVersion,
-    hashlock: f[r].hashlock,
+    hashlock: v[r].hashlock,
     htlcVout: r,
     offchainParamsVersion: s.version,
     appVaultKeepersVersion: a.appVaultKeepersVersion,
@@ -417,8 +510,8 @@ function Me(e, t) {
     amount: d[r],
     unsignedPrePeginTxHex: c,
     depositorBtcPubkey: n,
-    batch: f
-  }, y = {
+    batch: v
+  }, C = {
     vaultProviderPubkey: a.vaultProviderBtcPubkey,
     vaultKeeperPubkeys: a.vaultKeeperBtcPubkeys,
     universalChallengerPubkeys: a.universalChallengerBtcPubkeys,
@@ -432,25 +525,30 @@ function Me(e, t) {
     councilSize: s.councilSize,
     network: l
   };
-  return { vault: w, context: y };
+  return { vault: w, context: C };
 }
 export {
-  W as D,
-  he as P,
-  B as U,
-  le as V,
-  ce as a,
-  Ae as b,
-  He as c,
-  Fe as d,
-  pe as e,
-  A as f,
-  Se as g,
-  de as h,
-  Be as i,
-  me as j,
-  $ as k,
-  ue as r,
-  Me as t
+  Z as D,
+  Ee as P,
+  K as U,
+  Te as V,
+  we as a,
+  f as b,
+  Ye as c,
+  be as d,
+  $e as e,
+  qe as f,
+  Ze as g,
+  et as h,
+  Je as i,
+  Fe as j,
+  F as k,
+  tt as l,
+  Ae as m,
+  Ie as n,
+  Be as o,
+  T as p,
+  ye as r,
+  rt as t
 };
-//# sourceMappingURL=toRefundInputs-BkcFhvDp.js.map
+//# sourceMappingURL=toRefundInputs-BNSXIymn.js.map