@babylonlabs-io/ts-sdk 3.3.1 → 4.1.0

package/dist/{challengeAssert-B2otuf7y.js → challengeAssert-pJP7MKhG.js}

@@ -1,79 +1,79 @@
-import { Transaction as b, Psbt as _, payments as j } from "bitcoinjs-lib";
+import { Transaction as b, Psbt as H, payments as j } from "bitcoinjs-lib";
 import { Buffer as f } from "buffer";
-import { loadTbvWasm as J, tapInternalPubkey as N, getAssertNoPayoutScriptInfo as Z, getChallengeAssertScriptInfo as tt } from "./tbv/core/wasm/index.js";
-import { u as C, T as A, s as g, d as k, h as m, S as B, p as et, k as ot, l as Q } from "./bitcoin-C-TuHb-v.js";
-import { n as rt, l as nt, d as st, P as E, m as it } from "./verifyScriptPathSchnorrSignature-owu3BfyT.js";
-import { R as q, a as X, N as M, b as D, c as G, d as at, A as ut, C as Y, e as H, f as ct, g as lt, h as ht, i as pt } from "./constants-CvQZuxKv.js";
-import { D as z } from "./fundPeginTransaction-CwhRbCQC.js";
+import { loadTbvWasm as J, tapInternalPubkey as k, getAssertNoPayoutScriptInfo as Z, getChallengeAssertScriptInfo as ee } from "./tbv/core/wasm/index.js";
+import { u as R, T as A, s as g, d as N, h as m, S as B, p as te, k as oe, l as Q } from "./bitcoin-C-TuHb-v.js";
+import { n as re, l as ne, d as se, P as x, m as ie } from "./verifyScriptPathSchnorrSignature-D-fdi-sG.js";
+import { R as q, a as X, N as M, b as D, c as G, d as ae, A as ue, C as z, e as _, f as ce, g as le, h as he, i as pe } from "./constants-CmDDuM3L.js";
+import { D as Y } from "./fundPeginTransaction-CwhRbCQC.js";
 import { X as F } from "./validation-OSC0xTHB.js";
-const dt = (1n << 64n) - 1n;
-function ft(e, n) {
-  if (!Array.isArray(e))
+const de = (1n << 64n) - 1n;
+function fe(t, n) {
+  if (!Array.isArray(t))
     throw new Error(
-      `${n} must be an array of positive bigints (got ${typeof e}).`
+      `${n} must be an array of positive bigints (got ${typeof t}).`
     );
-  if (e.length === 0)
+  if (t.length === 0)
     throw new Error(`${n} must not be empty.`);
-  return e.forEach((t, i) => {
-    if (typeof t != "bigint")
+  return t.forEach((e, i) => {
+    if (typeof e != "bigint")
       throw new Error(
-        `${n}[${i}] must be a bigint (got ${typeof t}); refusing to feed it into satoshi math.`
+        `${n}[${i}] must be a bigint (got ${typeof e}); refusing to feed it into satoshi math.`
       );
-    if (t <= 0n)
-      throw new Error(`${n}[${i}] must be > 0 (got ${t}).`);
-    if (t > dt)
+    if (e <= 0n)
+      throw new Error(`${n}[${i}] must be > 0 (got ${e}).`);
+    if (e > de)
       throw new Error(
-        `${n}[${i}] must fit in a u64 (got ${t}); refusing to feed it into satoshi math.`
+        `${n}[${i}] must fit in a u64 (got ${e}); refusing to feed it into satoshi math.`
       );
-  }), e;
+  }), t;
 }
-async function Ct(e) {
-  const { WasmPrePeginTx: n } = await J(), { prePeginParams: t, fundedPrePeginTxHex: i, htlcVout: a, refundFee: c, hashlock: s } = e, r = rt(
-    t.authAnchorHash
+async function Re(t) {
+  const { WasmPrePeginTx: n } = await J(), { prePeginParams: e, fundedPrePeginTxHex: i, htlcVout: a, refundFee: c, hashlock: s } = t, r = re(
+    e.authAnchorHash
   ), o = new n(
-    t.vaultCoreVersion,
-    t.depositorPubkey,
-    t.vaultProviderPubkey,
-    t.vaultKeeperPubkeys,
-    t.universalChallengerPubkeys,
-    [...t.hashlocks],
+    e.vaultCoreVersion,
+    e.depositorPubkey,
+    e.vaultProviderPubkey,
+    e.vaultKeeperPubkeys,
+    e.universalChallengerPubkeys,
+    [...e.hashlocks],
     new BigUint64Array(
-      ft(t.pegInAmounts, "pegInAmounts")
+      fe(e.pegInAmounts, "pegInAmounts")
     ),
-    t.timelockRefund,
-    t.feeRate,
-    t.minPeginFeeRate,
-    t.numLocalChallengers,
-    t.councilQuorum,
-    t.councilSize,
-    t.network,
+    e.timelockRefund,
+    e.feeRate,
+    e.minPeginFeeRate,
+    e.numLocalChallengers,
+    e.councilQuorum,
+    e.councilSize,
+    e.network,
     r
   );
   let u = null;
   try {
-    const p = o.getHtlcScriptPubKey(a).toLowerCase(), l = nt(t, s), d = l.scriptPubKey.toString("hex");
+    const p = o.getHtlcScriptPubKey(a).toLowerCase(), l = ne(e, s), d = l.scriptPubKey.toString("hex");
     if (p !== d)
       throw new Error(
         `WASM HTLC scriptPubKey ${p} does not match the independently derived scriptPubKey ${d}.`
       );
-    const x = o.getHtlcValue(a);
+    const E = o.getHtlcValue(a);
     u = o.fromFundedTransaction(i);
     const w = u.buildRefundTx(c, a), T = i.startsWith("0x") ? i.slice(2) : i, v = b.fromHex(T), P = v.outs[a];
     if (!P)
       throw new Error(
         `HTLC output at vout ${a} not found in funded Pre-PegIn tx (tx has ${v.outs.length} outputs)`
       );
-    const I = C(
+    const I = R(
       new Uint8Array(P.script)
     ).toLowerCase();
     if (I !== d)
       throw new Error(
-        `HTLC scriptPubKey mismatch at vout ${a}: reconstructed template expects ${d}, funded tx carries ${I}. Refund refused — the (hashlocks, pegInAmounts) vector does not match the on-chain commitment.`
+        `HTLC scriptPubKey mismatch at vout ${a}: reconstructed template expects ${d}, funded tx carries ${I}. Refund refused — the rebuilt HTLC does not commit to the funded output. Check the participant keys first: the vault provider, vault keeper and universal challenger keys must be the operation keys at the vault's frozen epochs (readRefundPrePeginContext, or readStampedParticipantKeys), not roster, indexer or current keys. Then check the hashlock at this vout and timelockRefund, and that the funded transaction is this vault's Pre-PegIn (its txid must equal the vault's on-chain prePeginTxHash).`
       );
     const $ = BigInt(P.value);
-    if ($ !== x)
+    if ($ !== E)
       throw new Error(
-        `HTLC value mismatch at vout ${a}: reconstructed template expects ${x} sat, funded tx carries ${$} sat. Refund refused — the pegInAmounts vector does not match the on-chain commitment.`
+        `HTLC value mismatch at vout ${a}: reconstructed template expects ${E} sat, funded tx carries ${$} sat. Refund refused — the pegInAmounts vector does not match the on-chain commitment.`
       );
     const h = b.fromHex(w);
     if (h.version !== q)
@@ -88,22 +88,22 @@ async function Ct(e) {
       throw new Error(
         `Refund transaction must have exactly 1 input, got ${h.ins.length}`
       );
-    const y = h.ins[0], O = v.getId(), L = C(
+    const y = h.ins[0], L = v.getId(), O = R(
       new Uint8Array(y.hash).slice().reverse()
     );
-    if (L !== O)
+    if (O !== L)
       throw new Error(
-        `Refund input does not reference the Pre-PegIn transaction. Expected ${O}, got ${L}`
+        `Refund input does not reference the Pre-PegIn transaction. Expected ${L}, got ${O}`
       );
     if (y.index !== a)
       throw new Error(
         `Refund input index ${y.index} does not match expected htlcVout ${a}`
       );
-    if (y.sequence !== t.timelockRefund)
+    if (y.sequence !== e.timelockRefund)
       throw new Error(
-        `Refund input sequence ${y.sequence} does not match timelockRefund ${t.timelockRefund}.`
+        `Refund input sequence ${y.sequence} does not match timelockRefund ${e.timelockRefund}.`
       );
-    const S = new _();
+    const S = new H();
     if (S.setVersion(h.version), S.setLocktime(h.locktime), S.addInput({
       hash: y.hash,
       index: y.index,
@@ -119,114 +119,114 @@ async function Ct(e) {
           controlBlock: l.refundControlBlock
         }
       ],
-      tapInternalKey: f.from(N),
+      tapInternalKey: f.from(k),
       tapMerkleRoot: l.tapMerkleRoot
     }), h.outs.length !== 1)
       throw new Error(
         `Refund transaction must have exactly 1 output, got ${h.outs.length}`
       );
-    const R = h.outs[0], U = g(
-      k(t.depositorPubkey)
-    ).toLowerCase(), V = C(
-      new Uint8Array(R.script)
+    const C = h.outs[0], U = g(
+      N(e.depositorPubkey)
+    ).toLowerCase(), K = R(
+      new Uint8Array(C.script)
     ).toLowerCase();
-    if (V !== U)
+    if (K !== U)
       throw new Error(
-        `Refund output scriptPubKey ${V} does not match the depositor's BIP-86 address ${U}. Refund refused — the reclaimed funds would not return to the depositor.`
+        `Refund output scriptPubKey ${K} does not match the depositor's BIP-86 address ${U}. Refund refused — the reclaimed funds would not return to the depositor.`
       );
-    const K = $ - c;
-    if (BigInt(R.value) !== K)
+    const V = $ - c;
+    if (BigInt(C.value) !== V)
       throw new Error(
-        `Refund output value ${BigInt(R.value)} sat does not equal the HTLC value ${$} sat minus the requested fee ${c} sat (expected ${K} sat). Refund refused — the reclaimed amount would be burned as excess fee.`
+        `Refund output value ${BigInt(C.value)} sat does not equal the HTLC value ${$} sat minus the requested fee ${c} sat (expected ${V} sat). Refund refused — the reclaimed amount would be burned as excess fee.`
       );
     return S.addOutput({
-      script: R.script,
-      value: R.value
+      script: C.script,
+      value: C.value
     }), { psbtHex: S.toHex() };
   } finally {
     u == null || u.free(), o.free();
   }
 }
-const gt = 2, wt = 4294967293, mt = 214, $t = 299, Et = 4;
-function xt(e) {
-  if (!Number.isInteger(e) || e < 1)
+const ge = 2, we = 4294967293, me = 214, $e = 299, xe = 4;
+function Ee(t) {
+  if (!Number.isInteger(t) || t < 1)
     throw new Error(
-      `Reclaim input count must be a positive integer, got ${e}.`
+      `Reclaim input count must be a positive integer, got ${t}.`
     );
   return Math.ceil(
-    (mt + $t * e) / Et
+    (me + $e * t) / xe
   );
 }
-function _t(e, n) {
-  if (!Number.isFinite(e) || e <= 0)
+function He(t, n) {
+  if (!Number.isFinite(t) || t <= 0)
     throw new Error(
-      `Reclaim fee rate must be a positive number, got ${e}.`
+      `Reclaim fee rate must be a positive number, got ${t}.`
     );
-  return BigInt(Math.ceil(e * xt(n)));
+  return BigInt(Math.ceil(t * Ee(n)));
 }
-function Ht(e) {
-  const { depositorPubkey: n, inputs: t, feeSats: i } = e;
-  if (t.length === 0)
+function _e(t) {
+  const { depositorPubkey: n, inputs: e, feeSats: i } = t;
+  if (e.length === 0)
     throw new Error("Reclaim requires at least one input; got none.");
   if (i <= 0n)
     throw new Error(
       `Reclaim fee must be positive, got ${i} sat. Refusing to build a transaction that would not relay.`
     );
-  const a = st(n), c = C(
+  const a = se(n), c = R(
     new Uint8Array(a.scriptPubKey)
-  ).toLowerCase(), s = new _();
-  s.setVersion(gt), s.setLocktime(0);
+  ).toLowerCase(), s = new H();
+  s.setVersion(ge), s.setLocktime(0);
   let r = 0n;
   const o = /* @__PURE__ */ new Set();
-  if (t.forEach((l, d) => {
-    const x = b.fromHex(
+  if (e.forEach((l, d) => {
+    const E = b.fromHex(
       g(l.depositorSignedPeginTxHex)
-    ), w = x.getId(), T = x.outs[E];
+    ), w = E.getId(), T = E.outs[x];
     if (!T)
       throw new Error(
-        `PegIn ${w} has no output at vout ${E} (tx has ${x.outs.length}); there is no depositor-claim reserve to reclaim.`
+        `PegIn ${w} has no output at vout ${x} (tx has ${E.outs.length}); there is no depositor-claim reserve to reclaim.`
       );
     const v = g(l.observed.txid).toLowerCase();
     if (v !== w)
       throw new Error(
         `Input ${d}: the observation is of ${v}, but this input spends PegIn ${w}. Reclaim refused — the reserve that was looked up is not the one being swept.`
       );
-    if (l.observed.vout !== E)
+    if (l.observed.vout !== x)
       throw new Error(
-        `Input ${d}: the observation is of vout ${l.observed.vout}, but the depositor-claim reserve is at vout ${E}. Reclaim refused.`
+        `Input ${d}: the observation is of vout ${l.observed.vout}, but the depositor-claim reserve is at vout ${x}. Reclaim refused.`
       );
-    const P = C(
+    const P = R(
       new Uint8Array(T.script)
     ).toLowerCase();
     if (P !== c)
       throw new Error(
-        `Input ${d}: PegIn ${w} vout ${E} pays ${P}, but the connected wallet's depositor-claim script is ${c}. Reclaim refused — this reserve belongs to a different wallet.`
+        `Input ${d}: PegIn ${w} vout ${x} pays ${P}, but the connected wallet's depositor-claim script is ${c}. Reclaim refused — this reserve belongs to a different wallet.`
       );
     const I = g(
       l.observed.scriptPubKey
     ).toLowerCase();
     if (I !== c)
       throw new Error(
-        `Input ${d}: the observed UTXO ${w}:${E} pays ${I}, expected ${c}. Reclaim refused — chain state disagrees with the contract's PegIn.`
+        `Input ${d}: the observed UTXO ${w}:${x} pays ${I}, expected ${c}. Reclaim refused — chain state disagrees with the contract's PegIn.`
       );
     const $ = BigInt(T.value);
     if ($ !== l.observed.value)
       throw new Error(
-        `Input ${d}: PegIn ${w} vout ${E} carries ${$} sat, but the observed UTXO carries ${l.observed.value} sat. Reclaim refused.`
+        `Input ${d}: PegIn ${w} vout ${x} carries ${$} sat, but the observed UTXO carries ${l.observed.value} sat. Reclaim refused.`
       );
     if ($ !== l.expectedValue)
       throw new Error(
-        `Input ${d}: PegIn ${w} vout ${E} carries ${$} sat, but this vault's parameters compute a depositor-claim value of ${l.expectedValue} sat. Reclaim refused.`
+        `Input ${d}: PegIn ${w} vout ${x} carries ${$} sat, but this vault's parameters compute a depositor-claim value of ${l.expectedValue} sat. Reclaim refused.`
       );
-    const h = `${w}:${E}`;
+    const h = `${w}:${x}`;
     if (o.has(h))
       throw new Error(
         `Input ${d} repeats outpoint ${h}, which is already being swept by an earlier input. Reclaim refused.`
       );
     o.add(h), r += $, s.addInput({
       hash: w,
-      index: E,
-      sequence: wt,
+      index: x,
+      sequence: we,
       witnessUtxo: { script: T.script, value: T.value },
       tapLeafScript: [
         {
@@ -242,28 +242,28 @@ function Ht(e) {
       `Reclaim fee ${i} sat is not less than the swept total ${r} sat. Refusing to build a transaction with no output.`
     );
   const u = r - i;
-  if (u <= z)
+  if (u <= Y)
     throw new Error(
-      `Reclaim output ${u} sat is at or below the dust threshold ${z} sat. The reserve is not at risk — it stays where it is until fee rates fall.`
+      `Reclaim output ${u} sat is at or below the dust threshold ${Y} sat. The reserve is not at risk — it stays where it is until fee rates fall.`
     );
   const p = g(
-    k(n)
+    N(n)
   );
   return s.addOutput({
     script: f.from(m(p)),
     value: Number(u)
   }), { psbtHex: s.toHex(), outputValue: u, totalInputValue: r };
 }
-function Nt(e) {
-  const { requestedPsbtHex: n, signaturesHex: t, signerXOnlyPubkeyHex: i } = e, a = g(i);
+function ke(t) {
+  const { requestedPsbtHex: n, signaturesHex: e, signerXOnlyPubkeyHex: i } = t, a = g(i);
   if (a.length !== F)
     throw new Error(
       `Signer x-only pubkey must be ${F} hex chars (32 bytes), got ${a.length}.`
     );
-  const c = f.from(m(a)), s = _.fromHex(n);
-  if (t.length !== s.data.inputs.length)
+  const c = f.from(m(a)), s = H.fromHex(n);
+  if (e.length !== s.data.inputs.length)
     throw new Error(
-      `Cannot finalize: got ${t.length} signature(s) for ${s.data.inputs.length} input(s). Every input must be signed — refusing to broadcast a partially signed transaction.`
+      `Cannot finalize: got ${e.length} signature(s) for ${s.data.inputs.length} input(s). Every input must be signed — refusing to broadcast a partially signed transaction.`
     );
   return s.data.inputs.forEach((r, o) => {
     if (r.tapKeySig)
@@ -280,7 +280,7 @@ function Nt(e) {
       throw new Error(
         `Cannot finalize: input ${o} tapLeafScript has leaf version 0x${p.leafVersion.toString(16)}, expected 0x${A.toString(16)}.`
       );
-    const l = g(t[o]);
+    const l = g(e[o]);
     if (l.length !== B)
       throw new Error(
         `Signature for input ${o} must be ${B} hex chars (64 bytes), got ${l.length}.`
@@ -289,7 +289,7 @@ function Nt(e) {
       tapScriptSig: [
         {
           pubkey: c,
-          leafHash: it(p.leafVersion, p.script),
+          leafHash: ie(p.leafVersion, p.script),
           signature: f.from(m(l))
         }
       ]
@@ -297,14 +297,14 @@ function Nt(e) {
   }), s.finalizeAllInputs(), s.extractTransaction().toHex();
 }
 const W = 65535;
-async function kt(e) {
-  const n = g(e.noPayoutTxHex), t = b.fromHex(n), { noPayoutScript: i, noPayoutControlBlock: a } = await Z(
-    e.connectorParams,
-    e.challengerPubkey
-  ), c = m(i), s = m(a), r = new _();
-  r.setVersion(t.version), r.setLocktime(t.locktime);
-  for (let o = 0; o < t.ins.length; o++) {
-    const u = t.ins[o], p = e.prevouts[o];
+async function Ne(t) {
+  const n = g(t.noPayoutTxHex), e = b.fromHex(n), { noPayoutScript: i, noPayoutControlBlock: a } = await Z(
+    t.connectorParams,
+    t.challengerPubkey
+  ), c = m(i), s = m(a), r = new H();
+  r.setVersion(e.version), r.setLocktime(e.locktime);
+  for (let o = 0; o < e.ins.length; o++) {
+    const u = e.ins[o], p = t.prevouts[o];
     if (!p)
       throw new Error(`Missing prevout data for input ${o}`);
     const l = {
@@ -322,24 +322,24 @@ async function kt(e) {
         script: f.from(c),
         controlBlock: f.from(s)
       }
-    ], l.tapInternalKey = f.from(N)), r.addInput(l);
+    ], l.tapInternalKey = f.from(k)), r.addInput(l);
   }
-  for (const o of t.outs)
+  for (const o of e.outs)
     r.addOutput({
       script: o.script,
       value: o.value
     });
   return r.toHex();
 }
-function Ot(e, n, t) {
-  const i = b.fromHex(g(e));
+function Le(t, n, e) {
+  const i = b.fromHex(g(t));
   if (i.outs.length !== 1)
     throw new Error(
       `NoPayout transaction must have exactly 1 output, got ${i.outs.length}`
     );
-  const a = m(et(n)), { output: c } = j.p2tr({
+  const a = m(te(n)), { output: c } = j.p2tr({
     internalPubkey: f.from(a),
-    network: ot(t)
+    network: oe(e)
   });
   if (!c)
     throw new Error(
@@ -350,11 +350,11 @@ function Ot(e, n, t) {
       "NoPayout transaction does not pay to the expected challenger BIP-86 P2TR address"
     );
 }
-function Lt(e) {
-  const { noPayoutTx: n, timelockChallengeAssert: t } = e;
-  if (!Number.isInteger(t) || t < 1 || t > W)
+function Oe(t) {
+  const { noPayoutTx: n, timelockChallengeAssert: e } = t;
+  if (!Number.isInteger(e) || e < 1 || e > W)
     throw new Error(
-      `timelockChallengeAssert must be an integer in 1..${W}, got ${t}`
+      `timelockChallengeAssert must be an integer in 1..${W}, got ${e}`
     );
   if (n.version !== M)
     throw new Error(
@@ -371,21 +371,21 @@ function Lt(e) {
   [
     {
       label: "Assert",
-      txid: e.assertTxid,
-      vout: ut,
-      sequence: at
+      txid: t.assertTxid,
+      vout: ue,
+      sequence: ae
     },
     {
       label: "ChallengeAssertX",
-      txid: e.challengeAssertXTxid,
-      vout: Y,
-      sequence: t
+      txid: t.challengeAssertXTxid,
+      vout: z,
+      sequence: e
     },
     {
       label: "ChallengeAssertY",
-      txid: e.challengeAssertYTxid,
-      vout: Y,
-      sequence: t
+      txid: t.challengeAssertYTxid,
+      vout: z,
+      sequence: e
     }
   ].forEach((s, r) => {
     const o = n.ins[r], u = Q(o);
@@ -398,19 +398,19 @@ function Lt(e) {
         `NoPayout input ${r} (${s.label}) sequence must be ${s.sequence}, got ${o.sequence}`
       );
   });
-  const a = e.prevoutValues.reduce((s, r) => s + r, 0), c = n.outs.reduce((s, r) => s + r.value, 0);
+  const a = t.prevoutValues.reduce((s, r) => s + r, 0), c = n.outs.reduce((s, r) => s + r.value, 0);
   if (c > a)
     throw new Error(
       `NoPayout output value ${c} exceeds its inputs (${a} sats)`
     );
 }
-async function Ut(e) {
+async function Ue(t) {
   const n = b.fromHex(
-    g(e.challengeAssertTxHex)
-  ), t = b.fromHex(g(e.assertTxHex)), i = t.getId();
-  if (e.connectorParamsPerInput.length !== n.ins.length)
+    g(t.challengeAssertTxHex)
+  ), e = b.fromHex(g(t.assertTxHex)), i = e.getId();
+  if (t.connectorParamsPerInput.length !== n.ins.length)
     throw new Error(
-      `Expected ${n.ins.length} connector params, got ${e.connectorParamsPerInput.length}`
+      `Expected ${n.ins.length} connector params, got ${t.connectorParamsPerInput.length}`
     );
   const a = /* @__PURE__ */ new Set();
   for (let r = 0; r < n.ins.length; r++) {
@@ -419,7 +419,7 @@ async function Ut(e) {
       throw new Error(
         `ChallengeAssert input ${r} must spend an Assert output. Expected txid ${i}, got ${u}`
       );
-    if (!t.outs[o.index])
+    if (!e.outs[o.index])
       throw new Error(
         `Assert output ${o.index} not found for ChallengeAssert input ${r} (txid: ${i})`
       );
@@ -430,11 +430,11 @@ async function Ut(e) {
     a.add(o.index);
   }
   const c = await Promise.all(
-    e.connectorParamsPerInput.map((r) => tt(r))
-  ), s = new _();
+    t.connectorParamsPerInput.map((r) => ee(r))
+  ), s = new H();
   s.setVersion(n.version), s.setLocktime(n.locktime);
   for (let r = 0; r < n.ins.length; r++) {
-    const o = n.ins[r], u = t.outs[o.index], { script: p, controlBlock: l } = c[r], d = m(p), x = m(l);
+    const o = n.ins[r], u = e.outs[o.index], { script: p, controlBlock: l } = c[r], d = m(p), E = m(l);
     s.addInput({
       hash: o.hash,
       index: o.index,
@@ -447,10 +447,10 @@ async function Ut(e) {
         {
           leafVersion: A,
           script: f.from(d),
-          controlBlock: f.from(x)
+          controlBlock: f.from(E)
         }
       ],
-      tapInternalKey: f.from(N)
+      tapInternalKey: f.from(k)
     });
   }
   for (const r of n.outs)
@@ -460,50 +460,50 @@ async function Ut(e) {
     });
   return s.toHex();
 }
-function Vt(e) {
-  const n = Pt(e).getId(), t = e.challengeAssertTx.getId();
-  if (t !== n)
+function Ke(t) {
+  const n = Pe(t).getId(), e = t.challengeAssertTx.getId();
+  if (e !== n)
     throw new Error(
-      `ChallengeAssert${e.half} (challenger ${e.challengerPubkey}) is not the canonical transaction for this Assert: expected txid ${n}, got ${t}`
+      `ChallengeAssert${t.half} (challenger ${t.challengerPubkey}) is not the canonical transaction for this Assert: expected txid ${n}, got ${e}`
     );
 }
-function Pt(e) {
-  const { assertTx: n, half: t, challengerIndex: i, challengerCount: a } = e;
+function Pe(t) {
+  const { assertTx: n, half: e, challengerIndex: i, challengerCount: a } = t;
   if (!Number.isInteger(i) || i < 0 || i >= a)
     throw new Error(
-      `ChallengeAssert${t} challenger index ${i} is outside 0..${a - 1}`
+      `ChallengeAssert${e} challenger index ${i} is outside 0..${a - 1}`
     );
-  const c = pt + (t === "Y" ? a : 0) + i, s = n.outs[c];
+  const c = pe + (e === "Y" ? a : 0) + i, s = n.outs[c];
   if (!s)
     throw new Error(
-      `Assert has no output ${c} for the ChallengeAssert${t} of challenger index ${i}`
+      `Assert has no output ${c} for the ChallengeAssert${e} of challenger index ${i}`
     );
-  const r = s.value - H;
+  const r = s.value - _;
   if (r < 0)
     throw new Error(
-      `Assert output ${c} (${s.value} sats) cannot fund the ${H}-sat ChallengeAssert${t} anchor`
+      `Assert output ${c} (${s.value} sats) cannot fund the ${_}-sat ChallengeAssert${e} anchor`
     );
   const o = new b();
-  return o.version = ct, o.locktime = lt, o.addInput(n.getHash(), c, ht), o.addOutput(
-    f.from(m(e.outputConnectorScriptPubKey)),
+  return o.version = ce, o.locktime = le, o.addInput(n.getHash(), c, he), o.addOutput(
+    f.from(m(t.outputConnectorScriptPubKey)),
     r
   ), o.addOutput(
     f.from(
-      m(k(e.challengerPubkey))
+      m(N(t.challengerPubkey))
     ),
-    H
+    _
   ), o;
 }
 export {
-  Ht as a,
-  Ct as b,
-  kt as c,
-  Ut as d,
-  _t as e,
-  Nt as f,
-  Ot as g,
-  Vt as h,
-  Lt as i,
-  xt as r
+  _e as a,
+  Re as b,
+  Ne as c,
+  Ue as d,
+  He as e,
+  ke as f,
+  Le as g,
+  Ke as h,
+  Oe as i,
+  Ee as r
 };
-//# sourceMappingURL=challengeAssert-B2otuf7y.js.map
+//# sourceMappingURL=challengeAssert-pJP7MKhG.js.map