@babylonlabs-io/ts-sdk 5.1.0 → 6.0.1

package/dist/tbv/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/{toRefundInputs-DwXpKQxN.js → toRefundInputs-D5tx3eeA.js}

@@ -10,12 +10,12 @@ import { getUtxoInfo as de } from "./tbv/core/clients/mempool/index.js";
 import { M as D } from "./validation-OSC0xTHB.js";
 import { keccak256 as J, toHex as me, encodeAbiParameters as pe, isAddress as ge, zeroAddress as fe } from "viem";
 import { s as Pe } from "./sha2-YqVHJiFj.js";
-import { d as _ } from "./PayoutManager-BHeiLQ1j.js";
-import { b as ve, a as be } from "./PeginManager-CXNqbgA4.js";
+import { d as _ } from "./PayoutManager-3-MzBVLj.js";
+import { b as ve, a as be } from "./PeginManager-m3IlM4wS.js";
 import { computeMinClaimValue as Y, computeMinPeginFee as Z, peginP2aAnchorOutput as ee, getPrePeginHtlcConnectorInfo as we, expandAuthAnchor as ye } from "./tbv/core/wasm/index.js";
-import { d as Ce } from "./deriveVaultRoot-BcvmER1E.js";
-import { p as xe } from "./parseFundingOutpoints-GSM-IaaK.js";
-import { o as Ee, H as U } from "./verifyScriptPathSchnorrSignature-DLNGgm4j.js";
+import { d as xe } from "./deriveVaultRoot-BcvmER1E.js";
+import { p as Ce } from "./parseFundingOutpoints-GSM-IaaK.js";
+import { p as Ee, H as U } from "./verifyScriptPathSchnorrSignature-BVGPEZXW.js";
 import { c as j } from "./fundPeginTransaction-CwhRbCQC.js";
 const Re = [
   "vaultCoreVersion",
@@ -29,7 +29,7 @@ const Re = [
 function Ve(e, t) {
   const o = t.depositor.toLowerCase(), r = S(t).toLowerCase();
   return e.filter(
-    (n) => n.vaultId !== t.vaultId && n.depositor.toLowerCase() === o && S(n).toLowerCase() === r
+    (s) => s.vaultId !== t.vaultId && s.depositor.toLowerCase() === o && S(s).toLowerCase() === r
   );
 }
 function $e(e, t) {
@@ -57,7 +57,7 @@ function Ae(e) {
   return t.forEach((o, r) => {
     if (o.vault.protocol.htlcVout !== r)
       throw new Error(
-        `Sibling discovery produced a non-contiguous HTLC vector (${t.map((n) => n.vault.protocol.htlcVout).join(", ")}).`
+        `Sibling discovery produced a non-contiguous HTLC vector (${t.map((s) => s.vault.protocol.htlcVout).join(", ")}).`
       );
   }), t.map((o) => ({
     hashlock: o.vault.protocol.hashlock,
@@ -79,27 +79,27 @@ function dt(e) {
   return t.name === te && t.reason === "device-envelope";
 }
 async function Be(e, t) {
-  const o = M.fromHex(f(e)), n = (await Promise.all(
+  const o = M.fromHex(f(e)), s = (await Promise.all(
     o.ins.map(
-      (a) => (
+      (c) => (
         // Bitcoin stores the prev-txid in reverse (internal) byte order.
         de(
-          he.from(a.hash).reverse().toString("hex"),
-          a.index,
+          he.from(c.hash).reverse().toString("hex"),
+          c.index,
           t
         )
       )
     )
-  )).reduce((a, i) => a + BigInt(i.value), 0n), c = o.outs.reduce((a, i) => a + BigInt(i.value), 0n), s = n - c;
-  if (s <= 0n)
+  )).reduce((c, n) => c + BigInt(n.value), 0n), i = o.outs.reduce((c, n) => c + BigInt(n.value), 0n), a = s - i;
+  if (a <= 0n)
     throw new Error(
-      `The funded Pre-PegIn transaction's inputs do not cover its outputs plus a fee (computed fee: ${s} sats).`
+      `The funded Pre-PegIn transaction's inputs do not cover its outputs plus a fee (computed fee: ${a} sats).`
     );
-  if (s > D)
+  if (a > D)
     throw new Error(
-      `The funded Pre-PegIn transaction's computed fee (${s} sats) exceeds the maximum reasonable fee (${D} sats); the mempool API may have returned manipulated prevout data.`
+      `The funded Pre-PegIn transaction's computed fee (${a} sats) exceeds the maximum reasonable fee (${D} sats); the mempool API may have returned manipulated prevout data.`
     );
-  return s;
+  return a;
 }
 async function oe(e) {
   const t = e.siblings.length;
@@ -107,10 +107,10 @@ async function oe(e) {
     throw new Error(
       "rebuildDepositTermsCore: at least one sibling is required"
     );
-  for (const [m, d] of e.siblings.entries())
-    if (d.amount <= 0n)
+  for (const [m, h] of e.siblings.entries())
+    if (h.amount <= 0n)
       throw new Error(
-        `rebuildDepositTermsCore: sibling[${m}] has non-positive on-chain pegin amount ${d.amount}; the chain-read vault record is invalid. Resume refused.`
+        `rebuildDepositTermsCore: sibling[${m}] has non-positive on-chain pegin amount ${h.amount}; the chain-read vault record is invalid. Resume refused.`
       );
   if (e.prepeginMaxFee <= 0n)
     throw new Error(
@@ -123,51 +123,51 @@ async function oe(e) {
     throw new Error(
       `Funded Pre-PegIn tx hashes to ${r}, expected ${o} (on-chain prepeginTxid). Resume refused.`
     );
-  const n = _(
+  const s = _(
     f(e.fundedPrePeginTxHex)
   );
-  if (n === void 0)
+  if (s === void 0)
     throw new Error(
       "Funded Pre-PegIn carries no single, unambiguous auth-anchor OP_RETURN commitment — it either predates auth anchoring or is malformed. The intent resume path requires the anchor to prove sibling completeness. Resume refused."
     );
-  if (n.vout !== t)
+  if (s.vout !== t)
     throw new Error(
-      `Auth-anchor OP_RETURN at vout ${n.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.`
+      `Auth-anchor OP_RETURN at vout ${s.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, s = e.universalChallengerBtcPubkeys.length, a = await Y(
+  const i = e.vaultKeeperBtcPubkeys.length, a = e.universalChallengerBtcPubkeys.length, c = await Y(
     e.vaultCoreVersion,
-    c,
-    s,
+    i,
+    a,
     e.councilQuorum,
     e.councilSize,
     e.protocolFeeRate
-  ), i = await Z(
+  ), n = await Z(
     e.vaultCoreVersion,
-    c,
-    s,
+    i,
+    a,
     e.minPeginFeeRate
-  ), { value: l } = await ee(
+  ), { value: d } = await ee(
     e.vaultCoreVersion
   );
-  if (a <= 0n)
+  if (c <= 0n)
     throw new Error(
-      `WASM returned non-positive depositorClaimValue ${a}; expected > 0. Resume refused.`
+      `WASM returned non-positive depositorClaimValue ${c}; expected > 0. Resume refused.`
     );
-  if (i <= 0n)
+  if (n <= 0n)
     throw new Error(
-      `WASM returned non-positive peginMaxFee ${i}; expected > 0. Resume refused.`
+      `WASM returned non-positive peginMaxFee ${n}; expected > 0. Resume refused.`
     );
-  if (l < 0n)
+  if (d < 0n)
     throw new Error(
-      `WASM returned negative P2A anchor value ${l}. Resume refused.`
+      `WASM returned negative P2A anchor value ${d}. Resume refused.`
     );
-  const u = i + l, h = e.minPeginFeeRate * j;
-  if (u <= 0n || u > h)
+  const u = n + d, l = e.minPeginFeeRate * j;
+  if (u <= 0n || u > l)
     throw new Error(
-      `WASM implied PegIn reserve ${u} sat is outside (0, ${h}] (minPeginFeeRate=${e.minPeginFeeRate} × ${j} vbytes). Resume refused.`
+      `WASM implied PegIn reserve ${u} sat is outside (0, ${l}] (minPeginFeeRate=${e.minPeginFeeRate} × ${j} vbytes). Resume refused.`
     );
   const w = e.siblings.map(
-    (m) => m.amount + a + i + l
+    (m) => m.amount + c + n + d
   ), y = await Promise.all(
     e.siblings.map(async (m) => (await we({
       txGraphVersion: e.vaultCoreVersion,
@@ -179,11 +179,11 @@ async function oe(e) {
       timelockRefund: e.timelockRefund,
       network: e.network
     })).scriptPubKey)
-  ), C = M.fromHex(
+  ), x = M.fromHex(
     f(e.fundedPrePeginTxHex)
   ).outs.map((m) => ({ value: m.value, script: m.script }));
   return Ee(
-    C,
+    x,
     w,
     y
   ), ve({
@@ -199,8 +199,8 @@ async function oe(e) {
     universalChallengerBtcPubkeys: e.universalChallengerBtcPubkeys,
     maxAcceptableCommissionBps: e.maxAcceptableCommissionBps,
     peginAmounts: e.siblings.map((m) => m.amount),
-    depositorClaimValue: a,
-    peginMaxFee: i
+    depositorClaimValue: c,
+    peginMaxFee: n
   });
 }
 async function mt(e) {
@@ -209,40 +209,40 @@ async function mt(e) {
     throw new Error(
       "Connected wallet key is not the vault's depositor key; select the account that made the deposit."
     );
-  const r = f(t.prePeginTxHash).toLowerCase(), n = f(
+  const r = f(t.prePeginTxHash).toLowerCase(), s = f(
     H(e.fundedPrePeginTxHex)
   ).toLowerCase();
-  if (n !== r)
+  if (s !== r)
     throw new Error(
-      `Funded Pre-PegIn tx hashes to ${n}, expected ${r} (on-chain prePeginTxHash).`
+      `Funded Pre-PegIn tx hashes to ${s}, expected ${r} (on-chain prePeginTxHash).`
     );
-  const c = await Promise.all(
+  const i = await Promise.all(
     Ve(
       t.registrationRecords,
       t.registrationRecord
-    ).map(async (l) => {
-      const u = await e.siblingReader.getVaultData(l.vaultId);
-      if (u.protocol.prePeginTxHash.toLowerCase() !== S(l).toLowerCase())
+    ).map(async (d) => {
+      const u = await e.siblingReader.getVaultData(d.vaultId);
+      if (u.protocol.prePeginTxHash.toLowerCase() !== S(d).toLowerCase())
         throw new Error(
-          `Sibling ${l.vaultId} is registered against a different Pre-PegIn on chain than its registration log records; refusing an inconsistent node.`
+          `Sibling ${d.vaultId} is registered against a different Pre-PegIn on chain than its registration log records; refusing an inconsistent node.`
         );
       return {
         vault: u,
-        maxAcceptableCommissionBps: l.maxAcceptableCommissionBps
+        maxAcceptableCommissionBps: d.maxAcceptableCommissionBps
       };
     })
-  ), s = {
+  ), a = {
     vault: t.vault,
     maxAcceptableCommissionBps: t.registrationRecord.maxAcceptableCommissionBps
   };
-  $e(s, c);
-  const a = Ae([s, ...c]), i = await Be(
+  $e(a, i);
+  const c = Ae([a, ...i]), n = await Be(
     e.fundedPrePeginTxHex,
     e.mempoolApiUrl
   );
   return oe({
     vaultCoreVersion: t.vault.protocol.vaultCoreVersion,
-    siblings: a,
+    siblings: c,
     fundedPrePeginTxHex: e.fundedPrePeginTxHex,
     depositorBtcPubkey: o,
     vaultProviderBtcPubkey: t.participantKeys.vaultProvider.operationBtcPubkey,
@@ -256,7 +256,7 @@ async function mt(e) {
     timelockAssert: t.context.timelockAssert,
     timelockRefund: t.offchainParams.tRefund,
     prepeginTxid: r,
-    prepeginMaxFee: i,
+    prepeginMaxFee: n,
     // The submitted ceiling, verbatim: the device must see the terms the
     // depositor originally approved.
     maxAcceptableCommissionBps: t.registrationRecord.maxAcceptableCommissionBps,
@@ -401,40 +401,40 @@ class $ extends Error {
   }
 }
 async function Pt(e) {
-  const { wallet: t, depositorBtcPubkey: o, fundedPrePeginTxHex: r } = e, n = f(r), c = _(n);
-  if (c === void 0)
+  const { wallet: t, depositorBtcPubkey: o, fundedPrePeginTxHex: r } = e, s = f(r), i = _(s);
+  if (i === void 0)
     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 s = c.vout;
-  if (s === 0)
+  const a = i.vout;
+  if (a === 0)
     throw new K(
       "Pre-PegIn's auth-anchor OP_RETURN is at vout 0, implying zero HTLC outputs; there is nothing to recover."
     );
-  const a = xe(n), i = await Ce(t, {
+  const c = Ce(s), n = await xe(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: ce(
       q(o)
     ),
-    fundingOutpoints: a
+    fundingOutpoints: c
   });
   try {
-    const u = await ye(i);
-    let h;
+    const u = await ye(n);
+    let l;
     try {
-      h = ue(Pe(u));
+      l = ue(Pe(u));
     } finally {
       u.fill(0);
     }
-    if (h !== c.hash)
-      throw new Oe(h, c.hash);
+    if (l !== i.hash)
+      throw new Oe(l, i.hash);
   } catch (u) {
-    throw i.fill(0), u;
+    throw n.fill(0), u;
   }
-  const { hashlocks: l } = await be(i, s);
-  return { vaultCount: s, hashlocks: l, authAnchorHash: c.hash };
+  const { hashlocks: d } = await be(n, a);
+  return { vaultCount: a, hashlocks: d, authAnchorHash: i.hash };
 }
 function vt(e) {
   const { vaultCoreVersion: t, offchainParams: o, participantKeySets: r } = e;
@@ -450,15 +450,15 @@ function vt(e) {
     throw new Error(
       "buildPeginParamsCandidates: at least one participant key set is required"
     );
-  const n = [];
-  for (const c of o)
-    for (const s of r)
-      n.push({
+  const s = [];
+  for (const i of o)
+    for (const a of r)
+      s.push({
         vaultCoreVersion: t,
-        offchainParams: c,
-        participants: s
+        offchainParams: i,
+        participants: a
       });
-  return n;
+  return s;
 }
 function Ue(e) {
   return `${e.axis} v${e.version} (${e.reason})`;
@@ -487,11 +487,11 @@ function Ge(e) {
   ].join("|");
 }
 async function Qe(e) {
-  const { offchainParams: t, participants: o } = e, r = o.vaultKeeperBtcPubkeys.length, n = o.universalChallengerBtcPubkeys.length, [c, s, a] = await Promise.all([
+  const { offchainParams: t, participants: o } = e, r = o.vaultKeeperBtcPubkeys.length, s = o.universalChallengerBtcPubkeys.length, [i, a, c] = await Promise.all([
     Y(
       e.vaultCoreVersion,
       r,
-      n,
+      s,
       t.councilQuorum,
       t.councilSize,
       t.protocolFeeRate
@@ -499,64 +499,64 @@ async function Qe(e) {
     Z(
       e.vaultCoreVersion,
       r,
-      n,
+      s,
       t.minPeginFeeRate
     ),
     ee(e.vaultCoreVersion)
-  ]), i = a.value;
-  if (c <= 0n)
+  ]), n = c.value;
+  if (i <= 0n)
     throw new $(
-      `WASM returned non-positive depositorClaimValue ${c} for graph version ${e.vaultCoreVersion}`
+      `WASM returned non-positive depositorClaimValue ${i} for graph version ${e.vaultCoreVersion}`
     );
-  if (s <= 0n)
+  if (a <= 0n)
     throw new $(
-      `WASM returned non-positive peginMaxFee ${s} for graph version ${e.vaultCoreVersion}`
+      `WASM returned non-positive peginMaxFee ${a} for graph version ${e.vaultCoreVersion}`
     );
-  if (i < 0n)
+  if (n < 0n)
     throw new $(
-      `WASM returned negative P2A anchor value ${i} for graph version ${e.vaultCoreVersion}`
+      `WASM returned negative P2A anchor value ${n} for graph version ${e.vaultCoreVersion}`
     );
-  return { depositorClaimValue: c, peginMaxFee: s, p2aAnchorValue: i };
+  return { depositorClaimValue: i, peginMaxFee: a, p2aAnchorValue: n };
 }
 async function bt(e) {
   const {
     hashlocks: t,
     fundedPrePeginTxHex: o,
     depositorBtcPubkey: r,
-    prepeginMaxFee: n,
-    maxAcceptableCommissionBps: c,
-    network: s,
-    candidates: a,
-    unresolvedVersions: i
+    prepeginMaxFee: s,
+    maxAcceptableCommissionBps: i,
+    network: a,
+    candidates: c,
+    unresolvedVersions: n
   } = e;
   if (t.length === 0)
     throw new Error(
       "reconstructPeginParams: at least one hashlock is required"
     );
-  if (a.length === 0)
+  if (c.length === 0)
     throw new Error("reconstructPeginParams: candidate space is empty");
-  const l = q(r), u = f(o), h = _(u);
-  if (h === void 0)
+  const d = q(r), u = f(o), l = _(u);
+  if (l === void 0)
     throw new K(
       "Pre-PegIn carries no single, unambiguous auth-anchor OP_RETURN; the sibling set cannot be proven complete. Reconstruction refused."
     );
-  if (h.vout !== t.length)
+  if (l.vout !== t.length)
     throw new Error(
-      `reconstructPeginParams: ${t.length} hashlock(s) supplied but the auth-anchor OP_RETURN sits at vout ${h.vout}, so the transaction funds ${h.vout} HTLC output(s). Reconstruction refused.`
+      `reconstructPeginParams: ${t.length} hashlock(s) supplied but the auth-anchor OP_RETURN sits at vout ${l.vout}, so the transaction funds ${l.vout} HTLC output(s). Reconstruction refused.`
     );
-  const w = M.fromHex(u).outs, y = t.map((p, g) => BigInt(w[g].value)), C = f(
+  const w = M.fromHex(u).outs, y = t.map((p, g) => BigInt(w[g].value)), x = f(
     H(u)
-  ).toLowerCase(), m = /* @__PURE__ */ new Map(), d = [], A = [], T = [];
+  ).toLowerCase(), m = /* @__PURE__ */ new Map(), h = [], A = [], T = [];
   let N = 0;
-  for (const p of a)
+  for (const p of c)
     try {
       const g = Ge(p);
       let P = m.get(g);
       P === void 0 && (P = await Qe(p), m.set(g, P));
-      const x = P.depositorClaimValue + P.peginMaxFee + P.p2aAnchorValue, E = y.map((R) => R - x), k = E.findIndex((R) => R <= 0n);
+      const C = P.depositorClaimValue + P.peginMaxFee + P.p2aAnchorValue, E = y.map((R) => R - C), k = E.findIndex((R) => R <= 0n);
       if (k !== -1)
         throw new U(
-          `HTLC output[${k}] value ${y[k]} is not above this candidate's reserve ${x}, so it implies a non-positive pegin amount ${E[k]}.`
+          `HTLC output[${k}] value ${y[k]} is not above this candidate's reserve ${C}, so it implies a non-positive pegin amount ${E[k]}.`
         );
       const { offchainParams: b, participants: B } = p, L = await oe({
         vaultCoreVersion: p.vaultCoreVersion,
@@ -565,7 +565,7 @@ async function bt(e) {
           amount: E[ne]
         })),
         fundedPrePeginTxHex: u,
-        depositorBtcPubkey: l,
+        depositorBtcPubkey: d,
         vaultProviderBtcPubkey: B.vaultProviderBtcPubkey,
         vaultKeeperBtcPubkeys: B.vaultKeeperBtcPubkeys,
         universalChallengerBtcPubkeys: B.universalChallengerBtcPubkeys,
@@ -576,12 +576,12 @@ async function bt(e) {
         timelockPegin: b.timelockPegin,
         timelockAssert: b.timelockAssert,
         timelockRefund: b.timelockRefund,
-        prepeginTxid: C,
-        prepeginMaxFee: n,
-        maxAcceptableCommissionBps: c,
-        network: s
+        prepeginTxid: x,
+        prepeginMaxFee: s,
+        maxAcceptableCommissionBps: i,
+        network: a
       });
-      d.push({
+      h.push({
         candidate: p,
         terms: L,
         peginAmounts: E,
@@ -590,82 +590,82 @@ async function bt(e) {
     } catch (g) {
       if (g instanceof $)
         throw g;
-      const P = F(p), x = g instanceof Error ? g.message : String(g);
-      g instanceof U ? A.length < X && A.push(`[${P}] ${x}`) : (N++, T.length < X && T.push(`${P} (${x})`));
+      const P = F(p), C = g instanceof Error ? g.message : String(g);
+      g instanceof U ? A.length < X && A.push(`[${P}] ${C}`) : (N++, T.length < X && T.push(`${P} (${C})`));
     }
-  const re = i.length + N, O = [
-    ...i.map(Ue),
+  const re = n.length + N, O = [
+    ...n.map(Ue),
     ...T
   ];
-  if (d.length === 0)
-    throw new Le(a.length, A, O);
-  if (new Set(d.map((p) => p.fingerprint)).size > 1)
+  if (h.length === 0)
+    throw new Le(c.length, A, O);
+  if (new Set(h.map((p) => p.fingerprint)).size > 1)
     throw new ze(
-      d.map((p) => F(p.candidate))
+      h.map((p) => F(p.candidate))
     );
   if (re > 0)
     throw new De(
-      F(d[0].candidate),
+      F(h[0].candidate),
       O
     );
   return {
-    candidate: d[0].candidate,
-    terms: d[0].terms,
-    peginAmounts: d[0].peginAmounts,
-    authAnchorHash: h.hash,
-    candidatesTried: a.length,
-    matchedCandidates: d.map((p) => p.candidate)
+    candidate: h[0].candidate,
+    terms: h[0].terms,
+    peginAmounts: h[0].peginAmounts,
+    authAnchorHash: l.hash,
+    fundedPrePeginTxHex: u,
+    candidatesTried: c.length,
+    matchedCandidates: h.map((p) => p.candidate)
   };
 }
 function wt(e, t) {
   const {
     htlcVout: o,
     depositorBtcPubkey: r,
-    applicationEntryPoint: n,
-    fundedPrePeginTxHex: c,
-    hashlocks: s,
+    applicationEntryPoint: s,
+    hashlocks: i,
     network: a
-  } = t, { candidate: i, peginAmounts: l } = e, { offchainParams: u, participants: h } = i;
-  if (s.length !== l.length)
+  } = t, { candidate: c, peginAmounts: n, fundedPrePeginTxHex: d } = e, { offchainParams: u, participants: l } = c;
+  if (i.length !== n.length)
     throw new Error(
-      `toRefundInputs: ${s.length} hashlock(s) but ${l.length} reconstructed amount(s); the reconstruction and the hashlock vector describe different transactions.`
+      `toRefundInputs: ${i.length} hashlock(s) but ${n.length} reconstructed amount(s); the reconstruction and the hashlock vector describe different transactions.`
     );
-  if (!Number.isInteger(o) || o < 0 || o >= l.length)
+  if (!Number.isInteger(o) || o < 0 || o >= n.length)
     throw new Error(
-      `toRefundInputs: htlcVout ${o} is outside the reconstructed batch of ${l.length} vault(s).`
+      `toRefundInputs: htlcVout ${o} is outside the reconstructed batch of ${n.length} vault(s).`
     );
-  const w = l.map((m, d) => ({
-    hashlock: le(s[d]),
+  const w = n.map((m, h) => ({
+    hashlock: le(i[h]),
     amount: m,
-    htlcVout: d
+    htlcVout: h
   })), y = {
-    vaultCoreVersion: i.vaultCoreVersion,
+    vaultCoreVersion: c.vaultCoreVersion,
     hashlock: w[o].hashlock,
     htlcVout: o,
     offchainParamsVersion: u.version,
-    appVaultKeepersVersion: h.appVaultKeepersVersion,
-    universalChallengersVersion: h.universalChallengersVersion,
-    vaultProvider: h.vaultProvider,
-    applicationEntryPoint: n,
-    amount: l[o],
-    unsignedPrePeginTxHex: c,
+    appVaultKeepersVersion: l.appVaultKeepersVersion,
+    universalChallengersVersion: l.universalChallengersVersion,
+    vaultProvider: l.vaultProvider,
+    applicationEntryPoint: s,
+    amount: n[o],
+    unsignedPrePeginTxHex: d,
     depositorBtcPubkey: r,
     batch: w
-  }, C = {
-    vaultProviderPubkey: h.vaultProviderBtcPubkey,
-    vaultKeeperPubkeys: h.vaultKeeperBtcPubkeys,
-    universalChallengerPubkeys: h.universalChallengerBtcPubkeys,
+  }, x = {
+    vaultProviderPubkey: l.vaultProviderBtcPubkey,
+    vaultKeeperPubkeys: l.vaultKeeperBtcPubkeys,
+    universalChallengerPubkeys: l.universalChallengerBtcPubkeys,
     timelockRefund: u.timelockRefund,
     feeRate: u.protocolFeeRate,
     minPeginFeeRate: u.minPeginFeeRate,
     // Depositor-as-claimer: the local-challenger count is the keeper count,
     // the vault provider excluded — btc-vault graph.rs derive_challengers.
-    numLocalChallengers: h.vaultKeeperBtcPubkeys.length,
+    numLocalChallengers: l.vaultKeeperBtcPubkeys.length,
     councilQuorum: u.councilQuorum,
     councilSize: u.councilSize,
     network: a
   };
-  return { vault: y, context: C };
+  return { vault: y, context: x };
 }
 export {
   te as D,
@@ -697,4 +697,4 @@ export {
   $ as w,
   wt as x
 };
-//# sourceMappingURL=toRefundInputs-DwXpKQxN.js.map
+//# sourceMappingURL=toRefundInputs-D5tx3eeA.js.map