@babylonlabs-io/ts-sdk 3.3.0 → 4.0.0

package/dist/{toRefundInputs-Dzw1cteD.js → toRefundInputs-BbbvPb2A.js}

@@ -1,8 +1,8 @@
 var se = Object.defineProperty;
 var ie = (e, t, o) => t in e ? se(e, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : e[t] = o;
 var z = (e, t, o) => ie(e, typeof t != "symbol" ? t + "" : t, o);
-import { r as S } from "./registration-records-DJJC2NiO.js";
-import { s as g, c as ae, h as ce, p as q, u as ue, e as le } from "./bitcoin-C-TuHb-v.js";
+import { r as S } from "./registration-records-D39ApuHS.js";
+import { s as f, c as ae, h as ce, p as q, u as ue, e as le } from "./bitcoin-C-TuHb-v.js";
 import { c as H } from "./btcTxHash-BRZ8_EZq.js";
 import { Transaction as M } from "bitcoinjs-lib";
 import { Buffer as he } from "buffer";
@@ -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-xEGvTbhL.js";
-import { b as ve, a as be } from "./PeginManager-BJnUgW8C.js";
+import { d as _ } from "./PayoutManager-BUWP-H-q.js";
+import { b as ve, a as be } from "./PeginManager-Cas6_j7t.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-owu3BfyT.js";
+import { o as Ee, H as U } from "./verifyScriptPathSchnorrSignature-D-fdi-sG.js";
 import { c as j } from "./fundPeginTransaction-CwhRbCQC.js";
 const Re = [
   "vaultCoreVersion",
@@ -79,18 +79,18 @@ function dt(e) {
   return t.name === te && t.reason === "device-envelope";
 }
 async function Be(e, t) {
-  const o = M.fromHex(g(e)), n = (await Promise.all(
+  const o = M.fromHex(f(e)), n = (await Promise.all(
     o.ins.map(
-      (i) => (
+      (a) => (
         // Bitcoin stores the prev-txid in reverse (internal) byte order.
         de(
-          he.from(i.hash).reverse().toString("hex"),
-          i.index,
+          he.from(a.hash).reverse().toString("hex"),
+          a.index,
           t
         )
       )
     )
-  )).reduce((i, a) => i + BigInt(a.value), 0n), u = o.outs.reduce((i, a) => i + BigInt(a.value), 0n), s = n - u;
+  )).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)
     throw new Error(
       `The funded Pre-PegIn transaction's inputs do not cover its outputs plus a fee (computed fee: ${s} sats).`
@@ -107,16 +107,16 @@ async function oe(e) {
     throw new Error(
       "rebuildDepositTermsCore: at least one sibling is required"
     );
-  for (const [l, b] of e.siblings.entries())
-    if (b.amount <= 0n)
+  for (const [m, d] of e.siblings.entries())
+    if (d.amount <= 0n)
       throw new Error(
-        `rebuildDepositTermsCore: sibling[${l}] has non-positive on-chain pegin amount ${b.amount}; the chain-read vault record is invalid. Resume refused.`
+        `rebuildDepositTermsCore: sibling[${m}] has non-positive on-chain pegin amount ${d.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 o = g(e.prepeginTxid).toLowerCase(), r = g(
+  const o = f(e.prepeginTxid).toLowerCase(), r = f(
     H(e.fundedPrePeginTxHex)
   ).toLowerCase();
   if (r !== o)
@@ -124,7 +124,7 @@ async function oe(e) {
       `Funded Pre-PegIn tx hashes to ${r}, expected ${o} (on-chain prepeginTxid). Resume refused.`
     );
   const n = _(
-    g(e.fundedPrePeginTxHex)
+    f(e.fundedPrePeginTxHex)
   );
   if (n === void 0)
     throw new Error(
@@ -134,56 +134,58 @@ async function oe(e) {
     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.`
     );
-  const u = e.vaultKeeperBtcPubkeys.length, s = e.universalChallengerBtcPubkeys.length, i = await Y(
+  const c = e.vaultKeeperBtcPubkeys.length, s = e.universalChallengerBtcPubkeys.length, a = await Y(
     e.vaultCoreVersion,
-    u,
+    c,
     s,
     e.councilQuorum,
     e.councilSize,
     e.protocolFeeRate
-  ), a = await Z(
+  ), i = await Z(
     e.vaultCoreVersion,
-    u,
+    c,
     s,
     e.minPeginFeeRate
-  ), d = await ee(e.vaultCoreVersion), c = (d == null ? void 0 : d.value) ?? 0n;
-  if (i <= 0n)
+  ), { value: l } = await ee(
+    e.vaultCoreVersion
+  );
+  if (a <= 0n)
     throw new Error(
-      `WASM returned non-positive depositorClaimValue ${i}; expected > 0. Resume refused.`
+      `WASM returned non-positive depositorClaimValue ${a}; expected > 0. Resume refused.`
     );
-  if (a <= 0n)
+  if (i <= 0n)
     throw new Error(
-      `WASM returned non-positive peginMaxFee ${a}; expected > 0. Resume refused.`
+      `WASM returned non-positive peginMaxFee ${i}; expected > 0. Resume refused.`
     );
-  if (c < 0n)
+  if (l < 0n)
     throw new Error(
-      `WASM returned negative P2A anchor value ${c}. Resume refused.`
+      `WASM returned negative P2A anchor value ${l}. Resume refused.`
     );
-  const h = a + c, v = e.minPeginFeeRate * j;
-  if (h <= 0n || h > v)
+  const u = i + l, h = e.minPeginFeeRate * j;
+  if (u <= 0n || u > h)
     throw new Error(
-      `WASM implied PegIn reserve ${h} sat is outside (0, ${v}] (minPeginFeeRate=${e.minPeginFeeRate} × ${j} vbytes). Resume refused.`
+      `WASM implied PegIn reserve ${u} sat is outside (0, ${h}] (minPeginFeeRate=${e.minPeginFeeRate} × ${j} vbytes). Resume refused.`
     );
-  const y = e.siblings.map(
-    (l) => l.amount + i + a + c
-  ), x = await Promise.all(
-    e.siblings.map(async (l) => (await we({
+  const w = e.siblings.map(
+    (m) => m.amount + a + i + l
+  ), y = await Promise.all(
+    e.siblings.map(async (m) => (await we({
       txGraphVersion: e.vaultCoreVersion,
       depositorPubkey: e.depositorBtcPubkey,
       vaultProviderPubkey: e.vaultProviderBtcPubkey,
       vaultKeeperPubkeys: [...e.vaultKeeperBtcPubkeys],
       universalChallengerPubkeys: [...e.universalChallengerBtcPubkeys],
-      hashlock: g(l.hashlock),
+      hashlock: f(m.hashlock),
       timelockRefund: e.timelockRefund,
       network: e.network
     })).scriptPubKey)
   ), C = M.fromHex(
-    g(e.fundedPrePeginTxHex)
-  ).outs.map((l) => ({ value: l.value, script: l.script }));
+    f(e.fundedPrePeginTxHex)
+  ).outs.map((m) => ({ value: m.value, script: m.script }));
   return Ee(
     C,
-    y,
-    x
+    w,
+    y
   ), ve({
     vaultCoreVersion: e.vaultCoreVersion,
     protocolFeeRate: e.protocolFeeRate,
@@ -196,9 +198,9 @@ async function oe(e) {
     vaultKeeperBtcPubkeys: e.vaultKeeperBtcPubkeys,
     universalChallengerBtcPubkeys: e.universalChallengerBtcPubkeys,
     maxAcceptableCommissionBps: e.maxAcceptableCommissionBps,
-    peginAmounts: e.siblings.map((l) => l.amount),
-    depositorClaimValue: i,
-    peginMaxFee: a
+    peginAmounts: e.siblings.map((m) => m.amount),
+    depositorClaimValue: a,
+    peginMaxFee: i
   });
 }
 async function mt(e) {
@@ -207,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 = g(t.prePeginTxHash).toLowerCase(), n = g(
+  const r = f(t.prePeginTxHash).toLowerCase(), n = f(
     H(e.fundedPrePeginTxHex)
   ).toLowerCase();
   if (n !== r)
     throw new Error(
       `Funded Pre-PegIn tx hashes to ${n}, expected ${r} (on-chain prePeginTxHash).`
     );
-  const u = await Promise.all(
+  const c = await Promise.all(
     Ve(
       t.registrationRecords,
       t.registrationRecord
-    ).map(async (d) => {
-      const c = await e.siblingReader.getVaultData(d.vaultId);
-      if (c.protocol.prePeginTxHash.toLowerCase() !== S(d).toLowerCase())
+    ).map(async (l) => {
+      const u = await e.siblingReader.getVaultData(l.vaultId);
+      if (u.protocol.prePeginTxHash.toLowerCase() !== S(l).toLowerCase())
         throw new Error(
-          `Sibling ${d.vaultId} is registered against a different Pre-PegIn on chain than its registration log records; refusing an inconsistent node.`
+          `Sibling ${l.vaultId} is registered against a different Pre-PegIn on chain than its registration log records; refusing an inconsistent node.`
         );
       return {
-        vault: c,
-        maxAcceptableCommissionBps: d.maxAcceptableCommissionBps
+        vault: u,
+        maxAcceptableCommissionBps: l.maxAcceptableCommissionBps
       };
     })
   ), s = {
     vault: t.vault,
     maxAcceptableCommissionBps: t.registrationRecord.maxAcceptableCommissionBps
   };
-  $e(s, u);
-  const i = Ae([s, ...u]), a = await Be(
+  $e(s, c);
+  const a = Ae([s, ...c]), i = await Be(
     e.fundedPrePeginTxHex,
     e.mempoolApiUrl
   );
   return oe({
     vaultCoreVersion: t.vault.protocol.vaultCoreVersion,
-    siblings: i,
+    siblings: a,
     fundedPrePeginTxHex: e.fundedPrePeginTxHex,
     depositorBtcPubkey: o,
     vaultProviderBtcPubkey: t.participantKeys.vaultProvider.operationBtcPubkey,
@@ -254,7 +256,7 @@ async function mt(e) {
     timelockAssert: t.context.timelockAssert,
     timelockRefund: t.offchainParams.tRefund,
     prepeginTxid: r,
-    prepeginMaxFee: a,
+    prepeginMaxFee: i,
     // The submitted ceiling, verbatim: the device must see the terms the
     // depositor originally approved.
     maxAcceptableCommissionBps: t.registrationRecord.maxAcceptableCommissionBps,
@@ -268,45 +270,45 @@ function pt(e) {
 const Ie = "TBV.PeginFingerprint.v1", Fe = J(
   me(Ie)
 ), G = 65535, Q = 2n ** 64n - 1n, Se = 2n ** 256n - 1n, Ke = /^0x[0-9a-fA-F]{64}$/, W = 1;
-class P extends Error {
+class v extends Error {
   constructor(t) {
     super(t), this.name = "PeginFingerprintInputError";
   }
 }
 function gt(e) {
-  return e instanceof P || e instanceof Error && e.name === "PeginFingerprintInputError";
+  return e instanceof v || e instanceof Error && e.name === "PeginFingerprintInputError";
 }
 function I(e, t, o, r) {
   if (typeof t != "bigint")
-    throw new P(
+    throw new v(
       `${e} must be a bigint (Solidity ${r}), got ${typeof t}`
     );
   if (t < 0n || t > o)
-    throw new P(
+    throw new v(
       `${e} must fit Solidity ${r} (0..${o}), got ${t}`
     );
 }
-function $(e, t) {
+function V(e, t) {
   if (!Number.isInteger(t) || t < 0 || t > G)
-    throw new P(
+    throw new v(
       `${e} must be an integer fitting Solidity uint16 (0..${G}), got ${t}`
     );
 }
 function He(e, t) {
   if (!Ke.test(t))
-    throw new P(
+    throw new v(
       `${e} must be 32 bytes as 0x-prefixed hex (66 characters), got "${t}"`
     );
   return t.toLowerCase();
 }
 function Me(e) {
   if (!ge(e, { strict: !1 }))
-    throw new P(
+    throw new v(
       `registryAddress must be a 20-byte 0x-prefixed address, got "${e}"`
     );
   const t = e.toLowerCase();
   if (t === fe)
-    throw new P(
+    throw new v(
       "registryAddress must not be the zero address; a zero here means the registry address was never resolved"
     );
   return t;
@@ -325,7 +327,7 @@ const _e = [
 ];
 function Ne(e) {
   if (I("chainId", e.chainId, Se, "uint256"), e.chainId === 0n)
-    throw new P(
+    throw new v(
       "chainId must not be 0; a zero here means the chain id was never resolved"
     );
   const t = Me(e.registryAddress), o = He(
@@ -337,11 +339,11 @@ function Ne(e) {
     e.appKeeperKeyEpoch,
     Q,
     "uint64"
-  ), I("ucKeyEpoch", e.ucKeyEpoch, Q, "uint64"), $("appVaultKeepersVersion", e.appVaultKeepersVersion), $(
+  ), I("ucKeyEpoch", e.ucKeyEpoch, Q, "uint64"), V("appVaultKeepersVersion", e.appVaultKeepersVersion), V(
     "universalChallengersVersion",
     e.universalChallengersVersion
-  ), $("offchainParamsVersion", e.offchainParamsVersion), $("vaultCoreVersion", e.vaultCoreVersion), e.vaultCoreVersion < W)
-    throw new P(
+  ), V("offchainParamsVersion", e.offchainParamsVersion), V("vaultCoreVersion", e.vaultCoreVersion), e.vaultCoreVersion < W)
+    throw new v(
       `vaultCoreVersion must be at least ${W}; ${e.vaultCoreVersion} means the version was never resolved`
     );
   return pe(_e, [
@@ -393,46 +395,46 @@ class De extends Error {
     ), this.matchedLabel = t, this.unresolvedLabels = o, this.name = "PeginParamsIncompleteSpaceError";
   }
 }
-class A extends Error {
+class $ extends Error {
   constructor(t) {
     super(`${t}. Reconstruction refused.`), this.name = "PeginSizingIntegrityError";
   }
 }
 async function Pt(e) {
-  const { wallet: t, depositorBtcPubkey: o, fundedPrePeginTxHex: r } = e, n = g(r), u = _(n);
-  if (u === void 0)
+  const { wallet: t, depositorBtcPubkey: o, fundedPrePeginTxHex: r } = e, n = f(r), c = _(n);
+  if (c === 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 = u.vout;
+  const s = c.vout;
   if (s === 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 i = xe(n), a = await Ce(t, {
+  const a = xe(n), i = await Ce(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: i
+    fundingOutpoints: a
   });
   try {
-    const c = await ye(a);
+    const u = await ye(i);
     let h;
     try {
-      h = ue(Pe(c));
+      h = ue(Pe(u));
     } finally {
-      c.fill(0);
+      u.fill(0);
     }
-    if (h !== u.hash)
-      throw new Oe(h, u.hash);
-  } catch (c) {
-    throw a.fill(0), c;
+    if (h !== c.hash)
+      throw new Oe(h, c.hash);
+  } catch (u) {
+    throw i.fill(0), u;
   }
-  const { hashlocks: d } = await be(a, s);
-  return { vaultCount: s, hashlocks: d, authAnchorHash: u.hash };
+  const { hashlocks: l } = await be(i, s);
+  return { vaultCount: s, hashlocks: l, authAnchorHash: c.hash };
 }
 function vt(e) {
   const { vaultCoreVersion: t, offchainParams: o, participantKeySets: r } = e;
@@ -449,11 +451,11 @@ function vt(e) {
       "buildPeginParamsCandidates: at least one participant key set is required"
     );
   const n = [];
-  for (const u of o)
+  for (const c of o)
     for (const s of r)
       n.push({
         vaultCoreVersion: t,
-        offchainParams: u,
+        offchainParams: c,
         participants: s
       });
   return n;
@@ -485,7 +487,7 @@ function Ge(e) {
   ].join("|");
 }
 async function Qe(e) {
-  const { offchainParams: t, participants: o } = e, r = o.vaultKeeperBtcPubkeys.length, n = o.universalChallengerBtcPubkeys.length, [u, s, i] = await Promise.all([
+  const { offchainParams: t, participants: o } = e, r = o.vaultKeeperBtcPubkeys.length, n = o.universalChallengerBtcPubkeys.length, [c, s, a] = await Promise.all([
     Y(
       e.vaultCoreVersion,
       r,
@@ -501,20 +503,20 @@ async function Qe(e) {
       t.minPeginFeeRate
     ),
     ee(e.vaultCoreVersion)
-  ]), a = (i == null ? void 0 : i.value) ?? 0n;
-  if (u <= 0n)
-    throw new A(
-      `WASM returned non-positive depositorClaimValue ${u} for graph version ${e.vaultCoreVersion}`
+  ]), i = a.value;
+  if (c <= 0n)
+    throw new $(
+      `WASM returned non-positive depositorClaimValue ${c} for graph version ${e.vaultCoreVersion}`
     );
   if (s <= 0n)
-    throw new A(
+    throw new $(
       `WASM returned non-positive peginMaxFee ${s} for graph version ${e.vaultCoreVersion}`
     );
-  if (a < 0n)
-    throw new A(
-      `WASM returned negative P2A anchor value ${a} for graph version ${e.vaultCoreVersion}`
+  if (i < 0n)
+    throw new $(
+      `WASM returned negative P2A anchor value ${i} for graph version ${e.vaultCoreVersion}`
     );
-  return { depositorClaimValue: u, peginMaxFee: s, p2aAnchorValue: a };
+  return { depositorClaimValue: c, peginMaxFee: s, p2aAnchorValue: i };
 }
 async function bt(e) {
   const {
@@ -522,18 +524,18 @@ async function bt(e) {
     fundedPrePeginTxHex: o,
     depositorBtcPubkey: r,
     prepeginMaxFee: n,
-    maxAcceptableCommissionBps: u,
+    maxAcceptableCommissionBps: c,
     network: s,
-    candidates: i,
-    unresolvedVersions: a
+    candidates: a,
+    unresolvedVersions: i
   } = e;
   if (t.length === 0)
     throw new Error(
       "reconstructPeginParams: at least one hashlock is required"
     );
-  if (i.length === 0)
+  if (a.length === 0)
     throw new Error("reconstructPeginParams: candidate space is empty");
-  const d = q(r), c = g(o), h = _(c);
+  const l = q(r), u = f(o), h = _(u);
   if (h === void 0)
     throw new K(
       "Pre-PegIn carries no single, unambiguous auth-anchor OP_RETURN; the sibling set cannot be proven complete. Reconstruction refused."
@@ -542,77 +544,77 @@ async function bt(e) {
     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.`
     );
-  const v = M.fromHex(c).outs, y = t.map((m, p) => BigInt(v[p].value)), x = g(
-    H(c)
-  ).toLowerCase(), C = /* @__PURE__ */ new Map(), l = [], b = [], T = [];
+  const w = M.fromHex(u).outs, y = t.map((p, g) => BigInt(w[g].value)), C = f(
+    H(u)
+  ).toLowerCase(), m = /* @__PURE__ */ new Map(), d = [], A = [], T = [];
   let N = 0;
-  for (const m of i)
+  for (const p of a)
     try {
-      const p = Ge(m);
-      let f = C.get(p);
-      f === void 0 && (f = await Qe(m), C.set(p, f));
-      const E = f.depositorClaimValue + f.peginMaxFee + f.p2aAnchorValue, R = y.map((k) => k - E), V = R.findIndex((k) => k <= 0n);
-      if (V !== -1)
+      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);
+      if (k !== -1)
         throw new U(
-          `HTLC output[${V}] value ${y[V]} is not above this candidate's reserve ${E}, so it implies a non-positive pegin amount ${R[V]}.`
+          `HTLC output[${k}] value ${y[k]} is not above this candidate's reserve ${x}, so it implies a non-positive pegin amount ${E[k]}.`
         );
-      const { offchainParams: w, participants: B } = m, L = await oe({
-        vaultCoreVersion: m.vaultCoreVersion,
-        siblings: t.map((k, ne) => ({
-          hashlock: k,
-          amount: R[ne]
+      const { offchainParams: b, participants: B } = p, L = await oe({
+        vaultCoreVersion: p.vaultCoreVersion,
+        siblings: t.map((R, ne) => ({
+          hashlock: R,
+          amount: E[ne]
         })),
-        fundedPrePeginTxHex: c,
-        depositorBtcPubkey: d,
+        fundedPrePeginTxHex: u,
+        depositorBtcPubkey: l,
         vaultProviderBtcPubkey: B.vaultProviderBtcPubkey,
         vaultKeeperBtcPubkeys: B.vaultKeeperBtcPubkeys,
         universalChallengerBtcPubkeys: B.universalChallengerBtcPubkeys,
-        protocolFeeRate: w.protocolFeeRate,
-        minPeginFeeRate: w.minPeginFeeRate,
-        councilQuorum: w.councilQuorum,
-        councilSize: w.councilSize,
-        timelockPegin: w.timelockPegin,
-        timelockAssert: w.timelockAssert,
-        timelockRefund: w.timelockRefund,
-        prepeginTxid: x,
+        protocolFeeRate: b.protocolFeeRate,
+        minPeginFeeRate: b.minPeginFeeRate,
+        councilQuorum: b.councilQuorum,
+        councilSize: b.councilSize,
+        timelockPegin: b.timelockPegin,
+        timelockAssert: b.timelockAssert,
+        timelockRefund: b.timelockRefund,
+        prepeginTxid: C,
         prepeginMaxFee: n,
-        maxAcceptableCommissionBps: u,
+        maxAcceptableCommissionBps: c,
         network: s
       });
-      l.push({
-        candidate: m,
+      d.push({
+        candidate: p,
         terms: L,
-        peginAmounts: R,
-        fingerprint: je(L, R)
+        peginAmounts: E,
+        fingerprint: je(L, E)
       });
-    } catch (p) {
-      if (p instanceof A)
-        throw p;
-      const f = F(m), E = p instanceof Error ? p.message : String(p);
-      p instanceof U ? b.length < X && b.push(`[${f}] ${E}`) : (N++, T.length < X && T.push(`${f} (${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 re = a.length + N, O = [
-    ...a.map(Ue),
+  const re = i.length + N, O = [
+    ...i.map(Ue),
     ...T
   ];
-  if (l.length === 0)
-    throw new Le(i.length, b, O);
-  if (new Set(l.map((m) => m.fingerprint)).size > 1)
+  if (d.length === 0)
+    throw new Le(a.length, A, O);
+  if (new Set(d.map((p) => p.fingerprint)).size > 1)
     throw new ze(
-      l.map((m) => F(m.candidate))
+      d.map((p) => F(p.candidate))
     );
   if (re > 0)
     throw new De(
-      F(l[0].candidate),
+      F(d[0].candidate),
       O
     );
   return {
-    candidate: l[0].candidate,
-    terms: l[0].terms,
-    peginAmounts: l[0].peginAmounts,
+    candidate: d[0].candidate,
+    terms: d[0].terms,
+    peginAmounts: d[0].peginAmounts,
     authAnchorHash: h.hash,
-    candidatesTried: i.length,
-    matchedCandidates: l.map((m) => m.candidate)
+    candidatesTried: a.length,
+    matchedCandidates: d.map((p) => p.candidate)
   };
 }
 function wt(e, t) {
@@ -620,50 +622,50 @@ function wt(e, t) {
     htlcVout: o,
     depositorBtcPubkey: r,
     applicationEntryPoint: n,
-    fundedPrePeginTxHex: u,
+    fundedPrePeginTxHex: c,
     hashlocks: s,
-    network: i
-  } = t, { candidate: a, peginAmounts: d } = e, { offchainParams: c, participants: h } = a;
-  if (s.length !== d.length)
+    network: a
+  } = t, { candidate: i, peginAmounts: l } = e, { offchainParams: u, participants: h } = i;
+  if (s.length !== l.length)
     throw new Error(
-      `toRefundInputs: ${s.length} hashlock(s) but ${d.length} reconstructed amount(s); the reconstruction and the hashlock vector describe different transactions.`
+      `toRefundInputs: ${s.length} hashlock(s) but ${l.length} reconstructed amount(s); the reconstruction and the hashlock vector describe different transactions.`
     );
-  if (!Number.isInteger(o) || o < 0 || o >= d.length)
+  if (!Number.isInteger(o) || o < 0 || o >= l.length)
     throw new Error(
-      `toRefundInputs: htlcVout ${o} is outside the reconstructed batch of ${d.length} vault(s).`
+      `toRefundInputs: htlcVout ${o} is outside the reconstructed batch of ${l.length} vault(s).`
     );
-  const v = d.map((C, l) => ({
-    hashlock: le(s[l]),
-    amount: C,
-    htlcVout: l
+  const w = l.map((m, d) => ({
+    hashlock: le(s[d]),
+    amount: m,
+    htlcVout: d
   })), y = {
-    vaultCoreVersion: a.vaultCoreVersion,
-    hashlock: v[o].hashlock,
+    vaultCoreVersion: i.vaultCoreVersion,
+    hashlock: w[o].hashlock,
     htlcVout: o,
-    offchainParamsVersion: c.version,
+    offchainParamsVersion: u.version,
     appVaultKeepersVersion: h.appVaultKeepersVersion,
     universalChallengersVersion: h.universalChallengersVersion,
     vaultProvider: h.vaultProvider,
     applicationEntryPoint: n,
-    amount: d[o],
-    unsignedPrePeginTxHex: u,
+    amount: l[o],
+    unsignedPrePeginTxHex: c,
     depositorBtcPubkey: r,
-    batch: v
-  }, x = {
+    batch: w
+  }, C = {
     vaultProviderPubkey: h.vaultProviderBtcPubkey,
     vaultKeeperPubkeys: h.vaultKeeperBtcPubkeys,
     universalChallengerPubkeys: h.universalChallengerBtcPubkeys,
-    timelockRefund: c.timelockRefund,
-    feeRate: c.protocolFeeRate,
-    minPeginFeeRate: c.minPeginFeeRate,
+    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,
-    councilQuorum: c.councilQuorum,
-    councilSize: c.councilSize,
-    network: i
+    councilQuorum: u.councilQuorum,
+    councilSize: u.councilSize,
+    network: a
   };
-  return { vault: y, context: x };
+  return { vault: y, context: C };
 }
 export {
   te as D,
@@ -671,7 +673,7 @@ export {
   K as U,
   Oe as V,
   Ie as a,
-  P as b,
+  v as b,
   ft as c,
   gt as d,
   Ne as e,
@@ -692,7 +694,7 @@ export {
   Le as t,
   ze as u,
   De as v,
-  A as w,
+  $ as w,
   wt as x
 };
-//# sourceMappingURL=toRefundInputs-Dzw1cteD.js.map
+//# sourceMappingURL=toRefundInputs-BbbvPb2A.js.map