@babylonlabs-io/ts-sdk 0.55.1 → 0.56.0

package/dist/verifyScriptPathSchnorrSignature-CgrnAjMW.js

@@ -0,0 +1,724 @@
+import { computeMinClaimValue as D, peginP2aAnchorOutput as G, computeMinPeginFee as Z, buildPeginTxFromPrePegin as j, createPrePeginTransaction as J, validatePeginP2aAnchor as ee, tapInternalPubkey as Y, createPayoutConnector as te, computePayoutFeeFloor as ne } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import { Buffer as d } from "buffer";
+import { Transaction as S, script as oe, opcodes as re, payments as ie, Psbt as A, crypto as se } from "bitcoinjs-lib";
+import { c as V, d as ue } from "./fundPeginTransaction-B2wyjqp0.js";
+import { s as P, u as _, h as m, c as ce, d as ae, T as I, S as k, X as H } from "./bitcoin-B5aNKtsk.js";
+import { D as O, P as R, M as L, b, c as le, A as he, B as de, V as pe, N as U } from "./constants-CDQE812z.js";
+import * as Pe from "@bitcoin-js/tiny-secp256k1-asmjs";
+async function ge(e, t) {
+  const n = t.pegInAmounts.length;
+  if (e.htlcValues.length !== n)
+    throw new Error(
+      `WASM Pre-PegIn returned ${e.htlcValues.length} HTLC value(s), expected ${n} (one per requested deposit).`
+    );
+  if (e.peginAmounts.length !== n || e.htlcScriptPubKeys.length !== n || e.htlcAddresses.length !== n)
+    throw new Error(
+      `WASM Pre-PegIn returned mismatched array lengths (htlcValues=${e.htlcValues.length}, peginAmounts=${e.peginAmounts.length}, htlcScriptPubKeys=${e.htlcScriptPubKeys.length}, htlcAddresses=${e.htlcAddresses.length}); expected ${n} each.`
+    );
+  if (e.depositorClaimValue <= 0n)
+    throw new Error(
+      `WASM Pre-PegIn returned non-positive depositorClaimValue ${e.depositorClaimValue}; expected > 0.`
+    );
+  const i = await D(
+    // Must price the same graph version the builder constructed.
+    t.vaultCoreVersion,
+    t.numLocalChallengers,
+    t.universalChallengerPubkeys.length,
+    t.councilQuorum,
+    t.councilSize,
+    t.feeRate
+  );
+  if (e.depositorClaimValue !== i)
+    throw new Error(
+      `WASM Pre-PegIn depositorClaimValue ${e.depositorClaimValue} does not match the independently computed minimum claim value ${i} (vaultCoreVersion=${t.vaultCoreVersion}, numLocalChallengers=${t.numLocalChallengers}, numUniversalChallengers=${t.universalChallengerPubkeys.length}, councilQuorum=${t.councilQuorum}, councilSize=${t.councilSize}, feeRate=${t.feeRate}).`
+    );
+  const o = await G(t.vaultCoreVersion), r = (o == null ? void 0 : o.value) ?? 0n, s = await Z(
+    t.vaultCoreVersion,
+    t.vaultKeeperPubkeys.length,
+    t.universalChallengerPubkeys.length,
+    t.minPeginFeeRate
+  ), u = s + r, l = t.minPeginFeeRate * V;
+  for (let c = 0; c < n; c++) {
+    const h = t.pegInAmounts[c], p = e.peginAmounts[c], g = e.htlcValues[c];
+    if (p !== h)
+      throw new Error(
+        `WASM Pre-PegIn peginAmount[${c}] ${p} does not match the requested amount ${h}; refusing to build a tx whose recorded amount differs from the depositor's request.`
+      );
+    if (p <= 0n)
+      throw new Error(
+        `WASM Pre-PegIn peginAmount[${c}] is non-positive (${p}); expected > 0.`
+      );
+    if (g <= 0n)
+      throw new Error(
+        `WASM Pre-PegIn htlcValue[${c}] is non-positive (${g}); expected > 0.`
+      );
+    const a = g - p - e.depositorClaimValue;
+    if (a <= 0n)
+      throw new Error(
+        `WASM Pre-PegIn htlcValue[${c}] ${g} does not strictly cover peginAmount ${p} + depositorClaimValue ${e.depositorClaimValue} + a PegIn reserve (implied reserve ${a}).`
+      );
+    if (a > l)
+      throw new Error(
+        `WASM Pre-PegIn implied reserve for HTLC[${c}] (${a} sat) exceeds the plausibility cap ${l} sat (minPeginFeeRate=${t.minPeginFeeRate} × ${V} vbytes); htlcValue ${g} appears grossly inflated.`
+      );
+    if (a !== u)
+      throw new Error(
+        `WASM Pre-PegIn htlcValue[${c}] ${g} implies a PegIn fee+anchor reserve of ${a} sat, expected exactly ${u} sat (minPeginFee ${s} + p2aAnchor ${r} for vaultCoreVersion ${t.vaultCoreVersion}, vaultKeepers=${t.vaultKeeperPubkeys.length}, universalChallengers=${t.universalChallengerPubkeys.length}, minPeginFeeRate=${t.minPeginFeeRate}).`
+      );
+  }
+  return s;
+}
+function fe(e, t, n) {
+  if (e.length < t.length)
+    throw new Error(
+      `Encoded Pre-PegIn tx has ${e.length} output(s), fewer than the ${t.length} HTLC output(s) the cross-check validated.`
+    );
+  for (let i = 0; i < t.length; i++) {
+    const o = BigInt(e[i].value);
+    if (o !== t[i])
+      throw new Error(
+        `Encoded Pre-PegIn HTLC output[${i}] value ${o} does not match the cross-checked htlcValue ${t[i]}; the funded/signed tx would not pay the validated amount.`
+      );
+    const r = e[i].script.toString("hex").toLowerCase(), s = n[i].toLowerCase();
+    if (r !== s)
+      throw new Error(
+        `Encoded Pre-PegIn HTLC output[${i}] scriptPubKey ${r} does not match the cross-checked htlcScriptPubKey ${s}.`
+      );
+  }
+}
+const B = 64, ve = /^[0-9a-fA-F]+$/;
+async function We(e) {
+  const t = Q(e.authAnchorHash), n = await J({
+    txGraphVersion: e.vaultCoreVersion,
+    depositorPubkey: e.depositorPubkey,
+    vaultProviderPubkey: e.vaultProviderPubkey,
+    vaultKeeperPubkeys: e.vaultKeeperPubkeys,
+    universalChallengerPubkeys: e.universalChallengerPubkeys,
+    hashlocks: [...e.hashlocks],
+    timelockRefund: e.timelockRefund,
+    pegInAmounts: [...e.pegInAmounts],
+    feeRate: e.feeRate,
+    minPeginFeeRate: e.minPeginFeeRate,
+    numLocalChallengers: e.numLocalChallengers,
+    councilQuorum: e.councilQuorum,
+    councilSize: e.councilSize,
+    network: e.network,
+    authAnchorHash: t
+  }), i = await ge(n, e), o = ue(n.txHex);
+  fe(
+    o.outputs,
+    n.htlcValues,
+    n.htlcScriptPubKeys
+  );
+  const r = o.outputs.reduce(
+    (u, l) => u + BigInt(l.value),
+    0n
+  ), s = t !== void 0 ? n.htlcValues.length : null;
+  return {
+    psbtHex: n.txHex,
+    totalOutputValue: r,
+    htlcValues: n.htlcValues,
+    htlcScriptPubKeys: n.htlcScriptPubKeys,
+    htlcAddresses: n.htlcAddresses,
+    peginAmounts: n.peginAmounts,
+    depositorClaimValue: n.depositorClaimValue,
+    authAnchorVout: s,
+    minPeginFee: i
+  };
+}
+function Q(e) {
+  if (e === void 0) return;
+  const t = e.startsWith("0x") || e.startsWith("0X") ? e.slice(2) : e;
+  if (t.length !== B || !ve.test(t))
+    throw new Error(
+      `authAnchorHash must be 32-byte hex (${B} chars, no 0x prefix); got length ${t.length}`
+    );
+  return t.toLowerCase();
+}
+async function Xe(e) {
+  const t = await j(
+    {
+      txGraphVersion: e.prePeginParams.vaultCoreVersion,
+      depositorPubkey: e.prePeginParams.depositorPubkey,
+      vaultProviderPubkey: e.prePeginParams.vaultProviderPubkey,
+      vaultKeeperPubkeys: e.prePeginParams.vaultKeeperPubkeys,
+      universalChallengerPubkeys: e.prePeginParams.universalChallengerPubkeys,
+      hashlocks: [...e.prePeginParams.hashlocks],
+      timelockRefund: e.prePeginParams.timelockRefund,
+      pegInAmounts: [...e.prePeginParams.pegInAmounts],
+      feeRate: e.prePeginParams.feeRate,
+      minPeginFeeRate: e.prePeginParams.minPeginFeeRate,
+      numLocalChallengers: e.prePeginParams.numLocalChallengers,
+      councilQuorum: e.prePeginParams.councilQuorum,
+      councilSize: e.prePeginParams.councilSize,
+      network: e.prePeginParams.network,
+      authAnchorHash: Q(
+        e.prePeginParams.authAnchorHash
+      )
+    },
+    e.timelockPegin,
+    e.fundedPrePeginTxHex,
+    e.htlcVout
+  );
+  return await xe(t, e), {
+    txHex: t.txHex,
+    txid: t.txid,
+    vaultScriptPubKey: t.vaultScriptPubKey,
+    vaultValue: t.vaultValue
+  };
+}
+const we = 2, $e = 1;
+async function xe(e, t) {
+  const n = t.prePeginParams.vaultCoreVersion;
+  await ee(n, e.txHex);
+  const i = await G(n), o = we + (i ? 1 : 0), r = S.fromHex(P(e.txHex));
+  if (r.ins.length !== 1)
+    throw new Error(
+      `PegIn tx has ${r.ins.length} input(s), expected exactly 1 (the Pre-PegIn HTLC outpoint).`
+    );
+  const s = S.fromHex(
+    P(t.fundedPrePeginTxHex)
+  ).getId(), u = _(
+    new Uint8Array(r.ins[0].hash).slice().reverse()
+  );
+  if (u !== s)
+    throw new Error(
+      `PegIn input spends txid ${u}, expected the funded Pre-PegIn ${s}.`
+    );
+  if (r.ins[0].index !== t.htlcVout)
+    throw new Error(
+      `PegIn input spends Pre-PegIn output ${r.ins[0].index}, expected the requested HTLC vout ${t.htlcVout}.`
+    );
+  if (r.outs.length !== o)
+    throw new Error(
+      `PegIn tx has ${r.outs.length} output(s), expected exactly ${o} for vaultCoreVersion ${n} (vault + depositor claim${i ? " + P2A anchor" : ""}).`
+    );
+  const l = t.prePeginParams.pegInAmounts[t.htlcVout];
+  if (e.vaultValue !== l)
+    throw new Error(
+      `PegIn vault output value ${e.vaultValue} does not match the requested peg-in amount ${l} for HTLC ${t.htlcVout}; refusing to sign a vault that locks a different amount than requested.`
+    );
+  const c = r.outs[0];
+  if (BigInt(c.value) !== e.vaultValue)
+    throw new Error(
+      `Encoded PegIn vault output value ${c.value} does not match the WASM-reported vaultValue ${e.vaultValue}.`
+    );
+  const h = c.script.toString("hex"), p = P(
+    e.vaultScriptPubKey
+  ).toLowerCase();
+  if (h.toLowerCase() !== p)
+    throw new Error(
+      `Encoded PegIn vault output scriptPubKey ${h} does not match the WASM-reported vaultScriptPubKey ${e.vaultScriptPubKey}.`
+    );
+  const g = r.getId();
+  if (g !== P(e.txid).toLowerCase())
+    throw new Error(
+      `Encoded PegIn txid ${g} does not match the WASM-reported txid ${e.txid}.`
+    );
+  const a = await D(
+    n,
+    t.prePeginParams.numLocalChallengers,
+    t.prePeginParams.universalChallengerPubkeys.length,
+    t.prePeginParams.councilQuorum,
+    t.prePeginParams.councilSize,
+    t.prePeginParams.feeRate
+  ), v = r.outs[$e];
+  if (BigInt(v.value) !== a)
+    throw new Error(
+      `Encoded PegIn depositor-claim output value ${v.value} does not match the independently computed claim value ${a} for vaultCoreVersion ${n}.`
+    );
+  const $ = Se(
+    t.prePeginParams.depositorPubkey
+  );
+  if (!v.script.equals($))
+    throw new Error(
+      `Encoded PegIn depositor-claim output scriptPubKey ${v.script.toString("hex")} does not pay to the depositor's claim script (expected ${$.toString("hex")}).`
+    );
+}
+function Se(e) {
+  const t = oe.compile([
+    d.from(m(e)),
+    re.OP_CHECKSIG
+  ]), { output: n } = ie.p2tr({
+    internalPubkey: d.from(Y),
+    scriptTree: { output: t }
+  });
+  if (!n)
+    throw new Error(
+      "Failed to derive the depositor-claim P2TR scriptPubKey for PegIn output validation"
+    );
+  return n;
+}
+async function me(e) {
+  const t = await te(
+    {
+      txGraphVersion: e.vaultCoreVersion,
+      depositor: e.depositor,
+      vaultProvider: e.vaultProvider,
+      vaultKeepers: e.vaultKeepers,
+      universalChallengers: e.universalChallengers,
+      timelockPegin: e.timelockPegin
+    },
+    e.network
+  );
+  return {
+    payoutScript: t.payoutScript,
+    taprootScriptHash: t.taprootScriptHash,
+    scriptPubKey: t.scriptPubKey,
+    address: t.address,
+    payoutControlBlock: t.payoutControlBlock
+  };
+}
+const ye = 500, Ee = 55, F = 0xffffffffn, K = 32, Ce = 34;
+function be(e) {
+  if (typeof e.protocolFeeRate != "bigint" || e.protocolFeeRate <= 0n || e.protocolFeeRate > F)
+    throw new Error(
+      `protocolFeeRate must be in [1, ${F}] sat/vB, got ${e.protocolFeeRate}`
+    );
+  for (const [t, n] of [
+    ["keepers", e.numVaultKeepers],
+    ["challengers", e.numUniversalChallengers]
+  ])
+    if (!Number.isInteger(n) || n < 1 || n > K)
+      throw new Error(
+        `Participant count for ${t} (${n}) is outside the device range [1, ${K}].`
+      );
+  if (!Number.isInteger(e.councilSize) || e.councilSize < 1)
+    throw new Error(
+      `councilSize must be an integer >= 1, got ${e.councilSize}`
+    );
+}
+async function Ae(e, t) {
+  const { implicitFeeSats: n, out0Len: i, out1Len: o } = t, r = e.numVaultKeepers + e.numUniversalChallengers, s = BigInt(n), u = Math.max(0, i - Ce), l = ye + Ee * r + u, c = e.protocolFeeRate * BigInt(l);
+  if (s > c)
+    throw new Error(
+      `Payout implicit fee ${n} sats exceeds the safety cap of ${c} sats (${e.protocolFeeRate} sat/vB x ${l} vB for ${r} participants); refusing to sign payout.`
+    );
+  const h = await ne(
+    e.vaultCoreVersion,
+    e.numVaultKeepers,
+    e.numUniversalChallengers,
+    e.numVaultKeepers,
+    e.councilSize,
+    i,
+    o,
+    e.protocolFeeRate
+  );
+  if (s < h)
+    throw new Error(
+      `Payout implicit fee ${n} sats is below the floor of ${h} sats (the smallest fee any known vault-provider build produces for this shape); refusing to sign payout.`
+    );
+}
+const N = 3;
+async function ze(e) {
+  const t = {
+    vaultCoreVersion: e.vaultCoreVersion,
+    numVaultKeepers: e.vaultKeeperBtcPubkeys.length,
+    numUniversalChallengers: e.universalChallengerBtcPubkeys.length,
+    councilSize: e.councilSize,
+    protocolFeeRate: e.protocolFeeRate
+  };
+  be(t);
+  const n = S.fromHex(P(e.payoutTxHex)), i = S.fromHex(P(e.peginTxHex)), o = S.fromHex(P(e.assertTxHex));
+  if (n.ins.length !== O)
+    throw new Error(
+      `Payout transaction must have exactly ${O} inputs, got ${n.ins.length}`
+    );
+  const r = M(
+    n.ins[0],
+    0,
+    i,
+    "PegIn",
+    le
+  ), s = M(
+    n.ins[1],
+    1,
+    o,
+    "Assert",
+    he
+  ), { out0Len: u, out1Len: l } = Te(
+    n,
+    r.value,
+    e
+  ), c = r.value + s.value;
+  let h = 0;
+  for (const a of n.outs) h += a.value;
+  if (h > c)
+    throw new Error(
+      `Payout outputs (${h} sats) exceed inputs (${c} sats); invalid transaction.`
+    );
+  const p = c - h;
+  await Ae(t, {
+    implicitFeeSats: p,
+    out0Len: u,
+    out1Len: l
+  });
+  const g = await me({
+    vaultCoreVersion: e.vaultCoreVersion,
+    depositor: e.depositorBtcPubkey,
+    vaultProvider: e.vaultProviderBtcPubkey,
+    vaultKeepers: e.vaultKeeperBtcPubkeys,
+    universalChallengers: e.universalChallengerBtcPubkeys,
+    timelockPegin: e.timelockPegin,
+    network: e.network
+  });
+  return {
+    psbtHex: Ie(
+      n,
+      r,
+      s,
+      g
+    )
+  };
+}
+function M(e, t, n, i, o) {
+  const r = _(
+    new Uint8Array(e.hash).slice().reverse()
+  ), s = n.getId();
+  if (r !== s || e.index !== o)
+    throw new Error(
+      `Input ${t} must spend ${i}:${o}. Expected ${s}:${o}, got ${r}:${e.index}`
+    );
+  const u = n.outs[e.index];
+  if (!u)
+    throw new Error(
+      `Previous output not found for input ${t} (txid: ${r}, index: ${e.index})`
+    );
+  return u;
+}
+function Ie(e, t, n, i) {
+  const o = new A();
+  o.setVersion(e.version), o.setLocktime(e.locktime);
+  const [r, s] = e.ins;
+  o.addInput({
+    hash: r.hash,
+    index: r.index,
+    sequence: r.sequence,
+    witnessUtxo: {
+      script: t.script,
+      value: t.value
+    },
+    tapLeafScript: [
+      {
+        leafVersion: I,
+        script: d.from(m(i.payoutScript)),
+        controlBlock: d.from(
+          m(i.payoutControlBlock)
+        )
+      }
+    ],
+    tapInternalKey: d.from(Y)
+    // sighashType omitted - defaults to SIGHASH_DEFAULT (0x00) for Taproot
+  }), o.addInput({
+    hash: s.hash,
+    index: s.index,
+    sequence: s.sequence,
+    witnessUtxo: {
+      script: n.script,
+      value: n.value
+    }
+  });
+  for (const u of e.outs)
+    o.addOutput({
+      script: u.script,
+      value: u.value
+    });
+  return o.toHex();
+}
+function Te(e, t, n) {
+  const {
+    claimerBtcPubkey: i,
+    vaultProviderBtcPubkey: o,
+    depositorBtcPubkey: r,
+    vaultKeeperBtcPubkeys: s,
+    registeredPayoutScriptPubKey: u,
+    commissionBps: l
+  } = n;
+  if (!ce(u))
+    throw new Error("Invalid registeredPayoutScriptPubKey: not valid hex");
+  const c = P(i).toLowerCase(), h = P(o).toLowerCase(), p = P(r).toLowerCase(), g = s.map(
+    (C) => P(C).toLowerCase()
+  );
+  let a, v, $;
+  if (c === h)
+    a = "vp-claimer", v = pe, $ = P(u);
+  else if (c === p)
+    a = "depositor-as-claimer", v = U, $ = P(u);
+  else if (g.includes(c))
+    a = "vk-claimer", v = U, $ = P(ae(c));
+  else
+    throw new Error(
+      `Unknown claimer pubkey ${c}: not VP, depositor, or a registered vault keeper`
+    );
+  if (e.outs.length !== v)
+    throw new Error(
+      `Payout transaction has ${e.outs.length} output(s), expected exactly ${v} for role ${a}.`
+    );
+  const f = d.from($, "hex");
+  if (!e.outs[0].script.equals(f))
+    throw new Error(
+      `Payout transaction output 0 does not pay the expected scriptPubKey for role ${a}`
+    );
+  const x = v - 1;
+  if (e.outs[x].value !== R)
+    throw new Error(
+      `Payout CPFP anchor (out ${x}) value ${e.outs[x].value} sats must equal ${R} sats`
+    );
+  if (a === "vp-claimer") {
+    if (!Number.isInteger(l) || l < 0 || l >= L)
+      throw new Error(
+        `commissionBps must be an integer in [0, ${L}), got ${l}`
+      );
+    const C = Math.floor(
+      t * l / de
+    );
+    if (e.outs[1].value > C)
+      throw new Error(
+        `Payout VP commission (out 1) value ${e.outs[1].value} sats exceeds cap ${C} sats (${l} bps of peginValue=${t})`
+      );
+  }
+  const E = f.length;
+  if (E === 0 || E > b)
+    throw new Error(
+      `Payout receiver scriptPubKey length ${E} is outside the contract's registration cap [1, ${b}]; refusing to sign payout.`
+    );
+  const y = a === "vp-claimer" ? e.outs[1].script.length : void 0;
+  if (y !== void 0 && (y === 0 || y > b))
+    throw new Error(
+      `Payout commission scriptPubKey length ${y} is outside the contract's registration cap [1, ${b}]; refusing to sign payout.`
+    );
+  return { out0Len: E, out1Len: y };
+}
+function De(e, t, n = 0) {
+  const i = A.fromHex(e);
+  if (n >= i.data.inputs.length)
+    throw new Error(
+      `Input index ${n} out of range (${i.data.inputs.length} inputs)`
+    );
+  const o = i.data.inputs[n];
+  if (o.tapScriptSig && o.tapScriptSig.length > 0) {
+    const r = m(t);
+    for (const s of o.tapScriptSig)
+      if (s.pubkey.equals(d.from(r)))
+        return q(s.signature, n);
+    throw new Error(
+      `No signature found for depositor pubkey: ${t} at input ${n}`
+    );
+  }
+  if (o.finalScriptWitness && o.finalScriptWitness.length > 0) {
+    const r = _e(o.finalScriptWitness);
+    if (r.length !== N)
+      throw new Error(
+        `Unexpected finalized witness stack size at input ${n}: expected ${N} items (signature, script, controlBlock), got ${r.length}`
+      );
+    return q(r[0], n);
+  }
+  throw new Error(
+    `No tapScriptSig or finalScriptWitness found in signed PSBT at input ${n}`
+  );
+}
+function q(e, t) {
+  if (e.length === 64)
+    return _(new Uint8Array(e));
+  throw e.length === 65 ? new Error(
+    `Unexpected sighash byte 0x${e[64].toString(16).padStart(2, "0")} at input ${t}. Expected implicit SIGHASH_DEFAULT as a 64-byte signature.`
+  ) : new Error(
+    `Unexpected signature length at input ${t}: ${e.length}`
+  );
+}
+function _e(e) {
+  const t = [];
+  let n = 0;
+  const i = (s) => {
+    if (n + s > e.length)
+      throw new Error(
+        `Malformed witness data: need ${s} byte(s) at offset ${n}, only ${e.length - n} remaining`
+      );
+  }, o = () => {
+    i(1);
+    const s = e[n++];
+    if (s < 253) return s;
+    if (s === 253) {
+      i(2);
+      const u = (e[n] | e[n + 1] << 8) >>> 0;
+      return n += 2, u;
+    }
+    if (s === 254) {
+      i(4);
+      const u = (e[n] | e[n + 1] << 8 | e[n + 2] << 16 | e[n + 3] << 24) >>> 0;
+      return n += 4, u;
+    }
+    throw new Error(
+      `Malformed witness data: 8-byte varint (0xff) not supported at offset ${n - 1}`
+    );
+  }, r = o();
+  for (let s = 0; s < r; s++) {
+    const u = o();
+    i(u), t.push(d.from(e.subarray(n, n + u))), n += u;
+  }
+  if (n !== e.length)
+    throw new Error(
+      `Malformed witness data: ${e.length - n} trailing byte(s) after parsing ${r} item(s)`
+    );
+  return t;
+}
+class w extends Error {
+  constructor(t) {
+    super(
+      `Wallet returned a PSBT for a different transaction: ${t}`
+    ), this.name = "PsbtSubstitutionError";
+  }
+}
+function W(e, t) {
+  try {
+    return A.fromHex(t);
+  } catch (n) {
+    const i = n instanceof Error ? n.message : String(n);
+    throw new Error(`Failed to parse ${e} PSBT: ${i}`);
+  }
+}
+const Ve = 8;
+function T(e) {
+  return `${e.toString("hex").slice(0, Ve)}…`;
+}
+function X(e) {
+  const t = d.from(e).reverse();
+  return T(t);
+}
+function Ge(e) {
+  const t = W("requested", e.requestedPsbtHex), n = W("returned", e.returnedPsbtHex);
+  if (t.version !== n.version)
+    throw new w(
+      `tx version differs (requested=${t.version}, returned=${n.version})`
+    );
+  if (t.locktime !== n.locktime)
+    throw new w(
+      `tx locktime differs (requested=${t.locktime}, returned=${n.locktime})`
+    );
+  if (t.txInputs.length !== n.txInputs.length)
+    throw new w(
+      `input count differs (requested=${t.txInputs.length}, returned=${n.txInputs.length})`
+    );
+  if (t.txOutputs.length !== n.txOutputs.length)
+    throw new w(
+      `output count differs (requested=${t.txOutputs.length}, returned=${n.txOutputs.length})`
+    );
+  for (let i = 0; i < t.txInputs.length; i++) {
+    const o = t.txInputs[i], r = n.txInputs[i];
+    if (!o.hash.equals(r.hash))
+      throw new w(
+        `input ${i} prevout txid differs (requested=${X(o.hash)}, returned=${X(r.hash)})`
+      );
+    if (o.index !== r.index)
+      throw new w(
+        `input ${i} prevout vout differs (requested=${o.index}, returned=${r.index})`
+      );
+    if (o.sequence !== r.sequence)
+      throw new w(
+        `input ${i} sequence differs (requested=${o.sequence}, returned=${r.sequence})`
+      );
+  }
+  for (let i = 0; i < t.txOutputs.length; i++) {
+    const o = t.txOutputs[i], r = n.txOutputs[i];
+    if (!o.script.equals(r.script))
+      throw new w(
+        `output ${i} scriptPubKey differs (requested=${T(o.script)}, returned=${T(r.script)})`
+      );
+    if (o.value !== r.value)
+      throw new w(
+        `output ${i} value differs (requested=${o.value}, returned=${r.value})`
+      );
+  }
+}
+const z = 253, ke = 254, He = 65535, Oe = 4294967295;
+function Re(e) {
+  if (e < z)
+    return d.from([e]);
+  if (e <= He) {
+    const t = d.alloc(2);
+    return t.writeUInt16LE(e), d.concat([d.from([z]), t]);
+  }
+  if (e <= Oe) {
+    const t = d.alloc(4);
+    return t.writeUInt32LE(e), d.concat([d.from([ke]), t]);
+  }
+  throw new Error(`Script too large to encode as CompactSize: ${e} bytes`);
+}
+const Le = "TapLeaf";
+function Ue(e, t) {
+  const n = d.concat([
+    d.from([e]),
+    Re(t.length),
+    d.from(t)
+  ]);
+  return se.taggedHash(Le, n);
+}
+function Ye(e) {
+  const { requestedPsbtHex: t, signatureHex: n, signerXOnlyPubkeyHex: i, inputIndex: o } = e, r = P(n);
+  if (r.length !== k)
+    throw new Error(
+      `Schnorr signature for input ${o} must be ${k} hex chars (64 bytes), got ${r.length}.`
+    );
+  const s = P(i);
+  if (s.length !== H)
+    throw new Error(
+      `Signer x-only pubkey for input ${o} must be ${H} hex chars (32 bytes), got ${s.length}.`
+    );
+  const u = A.fromHex(t);
+  if (o < 0 || o >= u.data.inputs.length)
+    throw new Error(
+      `Input index ${o} out of range (${u.data.inputs.length} inputs).`
+    );
+  const l = [], c = [];
+  for (let f = 0; f < u.data.inputs.length; f++) {
+    const x = u.data.inputs[f].witnessUtxo;
+    if (!x)
+      throw new Error(
+        `Cannot verify signature: input ${f} of the requested PSBT has no witnessUtxo (required to recompute the Taproot sighash).`
+      );
+    l.push(x.script), c.push(x.value);
+  }
+  const h = u.data.inputs[o].tapLeafScript;
+  if (!h || h.length !== 1)
+    throw new Error(
+      `Cannot verify signature: input ${o} of the requested PSBT must have exactly one tapLeafScript, got ${(h == null ? void 0 : h.length) ?? 0}.`
+    );
+  const p = h[0];
+  if (p.leafVersion !== I)
+    throw new Error(
+      `Cannot verify signature: input ${o} tapLeafScript has leaf version 0x${p.leafVersion.toString(16)}, expected 0x${I.toString(16)}.`
+    );
+  const g = Ue(p.leafVersion, p.script), a = new S();
+  a.version = u.version, a.locktime = u.locktime;
+  for (const f of u.txInputs)
+    a.addInput(f.hash, f.index, f.sequence);
+  for (const f of u.txOutputs)
+    a.addOutput(f.script, f.value);
+  const v = a.hashForWitnessV1(
+    o,
+    l,
+    c,
+    S.SIGHASH_DEFAULT,
+    g
+  );
+  if (!Pe.verifySchnorr(
+    v,
+    m(s),
+    m(r)
+  ))
+    throw new Error(
+      `Schnorr signature for input ${o} (signer ${s}) does not verify against the expected Taproot script-path sighash. The wallet may have signed with the tweaked key, signed a different transaction, or returned an invalid signature.`
+    );
+}
+export {
+  w as P,
+  We as a,
+  Xe as b,
+  ze as c,
+  Ge as d,
+  De as e,
+  Ye as f,
+  me as g,
+  Q as n
+};
+//# sourceMappingURL=verifyScriptPathSchnorrSignature-CgrnAjMW.js.map