@babylonlabs-io/ts-sdk 0.0.0-semantic-release.2 → 0.1.0

package/dist/challengeAssert-DVErOd8l.js

@@ -0,0 +1,423 @@
+import { createPegInTransaction as K, createPayoutConnector as L, tapInternalPubkey as x, getPeginPayoutScript as O, getAssertNoPayoutScriptInfo as W, getChallengeAssertScriptInfo as N } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import * as $ from "@bitcoin-js/tiny-secp256k1-asmjs";
+import { Buffer as a } from "buffer";
+import { payments as P, networks as H, initEccLib as T, Transaction as g, Psbt as w } from "bitcoinjs-lib";
+async function Y(t) {
+  const n = await K({
+    depositorPubkey: t.depositorPubkey,
+    vaultProviderPubkey: t.vaultProviderPubkey,
+    vaultKeeperPubkeys: t.vaultKeeperPubkeys,
+    universalChallengerPubkeys: t.universalChallengerPubkeys,
+    timelockPegin: t.timelockPegin,
+    pegInAmount: t.pegInAmount,
+    depositorClaimValue: t.depositorClaimValue,
+    network: t.network
+  });
+  return {
+    psbtHex: n.txHex,
+    txid: n.txid,
+    vaultScriptPubKey: n.vaultScriptPubKey,
+    vaultValue: n.vaultValue
+  };
+}
+async function F(t) {
+  const n = await L(
+    {
+      depositor: t.depositor,
+      vaultProvider: t.vaultProvider,
+      vaultKeepers: t.vaultKeepers,
+      universalChallengers: t.universalChallengers,
+      timelockPegin: t.timelockPegin
+    },
+    t.network
+  );
+  return {
+    payoutScript: n.payoutScript,
+    taprootScriptHash: n.taprootScriptHash,
+    scriptPubKey: n.scriptPubKey,
+    address: n.address
+  };
+}
+function p(t) {
+  return t.startsWith("0x") ? t.slice(2) : t;
+}
+function f(t) {
+  const n = p(t);
+  if (!E(n))
+    throw new Error(`Invalid hex string: ${t}`);
+  const e = new Uint8Array(n.length / 2);
+  for (let o = 0; o < n.length; o += 2)
+    e[o / 2] = parseInt(n.slice(o, o + 2), 16);
+  return e;
+}
+function v(t) {
+  return Array.from(t).map((n) => n.toString(16).padStart(2, "0")).join("");
+}
+function D(t) {
+  return t.length === 32 ? t : t.slice(1, 33);
+}
+function E(t) {
+  return /^[0-9a-fA-F]*$/.test(t) && t.length % 2 === 0;
+}
+function U(t) {
+  const n = p(t);
+  if (!E(n))
+    throw new Error(`Invalid hex characters in public key: ${t}`);
+  if (n.length === 64)
+    return n;
+  if (n.length !== 66 && n.length !== 130)
+    throw new Error(
+      `Invalid public key length: ${n.length} (expected 64, 66, or 130 hex chars)`
+    );
+  const e = f(n);
+  return v(D(e));
+}
+function Z(t) {
+  const n = p(t);
+  return E(n);
+}
+function tt(t, n) {
+  const e = U(t), o = n ?? e;
+  if (e.toLowerCase() !== o.toLowerCase())
+    throw new Error(
+      `Wallet public key does not match vault depositor. Expected: ${o}, Got: ${e}. Please connect the wallet that was used to create this vault.`
+    );
+  return { walletPubkeyRaw: t, walletPubkeyXOnly: e, depositorPubkey: o };
+}
+let C = !1;
+function M() {
+  C || (T($), C = !0);
+}
+function q(t) {
+  switch (t) {
+    case "bitcoin":
+      return H.bitcoin;
+    case "testnet":
+    case "signet":
+      return H.testnet;
+    case "regtest":
+      return H.regtest;
+    default:
+      throw new Error(`Unknown network: ${t}`);
+  }
+}
+function X(t, n) {
+  M();
+  const e = f(U(t)), { address: o } = P.p2tr({
+    internalPubkey: a.from(e),
+    network: q(n)
+  });
+  if (!o)
+    throw new Error("Failed to derive taproot address from public key");
+  return o;
+}
+function _(t, n) {
+  const e = p(t);
+  if (e.length !== 66)
+    throw new Error(
+      `Native SegWit requires a compressed public key (66 hex chars), got ${e.length}`
+    );
+  const { address: o } = P.p2wpkh({
+    pubkey: a.from(f(e)),
+    network: q(n)
+  });
+  if (!o)
+    throw new Error(
+      "Failed to derive native segwit address from public key"
+    );
+  return o;
+}
+function et(t, n, e) {
+  const o = p(n);
+  try {
+    if (t === X(o, e))
+      return !0;
+  } catch {
+  }
+  const s = [];
+  o.length === 66 ? s.push(o) : o.length === 64 && s.push(`02${o}`, `03${o}`);
+  for (const r of s)
+    try {
+      if (t === _(r, e))
+        return !0;
+    } catch {
+    }
+  return !1;
+}
+T($);
+async function nt(t) {
+  const n = p(t.payoutTxHex), e = p(t.peginTxHex), o = p(t.assertTxHex), s = await F({
+    depositor: t.depositorBtcPubkey,
+    vaultProvider: t.vaultProviderBtcPubkey,
+    vaultKeepers: t.vaultKeeperBtcPubkeys,
+    universalChallengers: t.universalChallengerBtcPubkeys,
+    timelockPegin: t.timelockPegin,
+    network: t.network
+  }), r = f(s.payoutScript), c = z(x, r), i = g.fromHex(n), u = g.fromHex(e), d = g.fromHex(o), l = new w();
+  if (l.setVersion(i.version), l.setLocktime(i.locktime), i.ins.length !== 2)
+    throw new Error(
+      `Payout transaction must have exactly 2 inputs, got ${i.ins.length}`
+    );
+  const h = i.ins[0], y = i.ins[1], k = v(
+    new Uint8Array(h.hash).slice().reverse()
+  ), B = u.getId();
+  if (k !== B)
+    throw new Error(
+      `Input 0 does not reference pegin transaction. Expected ${B}, got ${k}`
+    );
+  const b = v(
+    new Uint8Array(y.hash).slice().reverse()
+  ), I = d.getId();
+  if (b !== I)
+    throw new Error(
+      `Input 1 does not reference assert transaction. Expected ${I}, got ${b}`
+    );
+  const m = u.outs[h.index];
+  if (!m)
+    throw new Error(
+      `Previous output not found for input 0 (txid: ${k}, index: ${h.index})`
+    );
+  const S = d.outs[y.index];
+  if (!S)
+    throw new Error(
+      `Previous output not found for input 1 (txid: ${b}, index: ${y.index})`
+    );
+  l.addInput({
+    hash: h.hash,
+    index: h.index,
+    sequence: h.sequence,
+    witnessUtxo: {
+      script: m.script,
+      value: m.value
+    },
+    tapLeafScript: [
+      {
+        leafVersion: 192,
+        script: a.from(r),
+        controlBlock: a.from(c)
+      }
+    ],
+    tapInternalKey: a.from(x)
+    // sighashType omitted - defaults to SIGHASH_DEFAULT (0x00) for Taproot
+  }), l.addInput({
+    hash: y.hash,
+    index: y.index,
+    sequence: y.sequence,
+    witnessUtxo: {
+      script: S.script,
+      value: S.value
+    }
+    // No tapLeafScript - depositor doesn't sign this input
+  });
+  for (const A of i.outs)
+    l.addOutput({
+      script: A.script,
+      value: A.value
+    });
+  return {
+    psbtHex: l.toHex()
+  };
+}
+function ot(t, n, e = 0) {
+  const o = w.fromHex(t);
+  if (e >= o.data.inputs.length)
+    throw new Error(
+      `Input index ${e} out of range (${o.data.inputs.length} inputs)`
+    );
+  const s = o.data.inputs[e];
+  if (s.tapScriptSig && s.tapScriptSig.length > 0) {
+    const r = f(n);
+    for (const c of s.tapScriptSig)
+      if (c.pubkey.equals(a.from(r)))
+        return V(c.signature, e);
+    throw new Error(
+      `No signature found for depositor pubkey: ${n} at input ${e}`
+    );
+  }
+  if (s.finalScriptWitness && s.finalScriptWitness.length > 0) {
+    const r = j(s.finalScriptWitness);
+    if (r.length >= 1)
+      return V(r[0], e);
+  }
+  throw new Error(
+    `No tapScriptSig or finalScriptWitness found in signed PSBT at input ${e}`
+  );
+}
+function V(t, n) {
+  if (t.length === 64)
+    return v(new Uint8Array(t));
+  if (t.length === 65)
+    return v(new Uint8Array(t.subarray(0, 64)));
+  throw new Error(
+    `Unexpected signature length at input ${n}: ${t.length}`
+  );
+}
+function j(t) {
+  const n = [];
+  let e = 0;
+  const o = () => {
+    const r = t[e++];
+    if (r < 253) return r;
+    if (r === 253) {
+      const c = t[e] | t[e + 1] << 8;
+      return e += 2, c;
+    }
+    if (r === 254) {
+      const c = t[e] | t[e + 1] << 8 | t[e + 2] << 16 | t[e + 3] << 24;
+      return e += 4, c;
+    }
+    return e += 8, 0;
+  }, s = o();
+  for (let r = 0; r < s; r++) {
+    const c = o();
+    n.push(t.subarray(e, e + c)), e += c;
+  }
+  return n;
+}
+function z(t, n) {
+  const e = { output: a.from(n) }, s = P.p2tr({
+    internalPubkey: a.from(t),
+    scriptTree: e
+  }).pubkey;
+  if (!s)
+    throw new Error("Failed to compute output key");
+  const r = 192, c = s[0] === 3 ? 1 : 0, i = r | c, u = new Uint8Array(1 + t.length);
+  return u[0] = i, u.set(t, 1), u;
+}
+T($);
+async function rt(t) {
+  const n = p(t.payoutTxHex), e = g.fromHex(n), o = await O(t.connectorParams), s = f(o), r = G(x, s), c = new w();
+  c.setVersion(e.version), c.setLocktime(e.locktime);
+  for (let i = 0; i < e.ins.length; i++) {
+    const u = e.ins[i], d = t.prevouts[i];
+    if (!d)
+      throw new Error(`Missing prevout data for input ${i}`);
+    const l = {
+      hash: u.hash,
+      index: u.index,
+      sequence: u.sequence,
+      witnessUtxo: {
+        script: a.from(f(p(d.script_pubkey))),
+        value: d.value
+      }
+    };
+    i === 0 && (l.tapLeafScript = [
+      {
+        leafVersion: 192,
+        script: a.from(s),
+        controlBlock: a.from(r)
+      }
+    ], l.tapInternalKey = a.from(x)), c.addInput(l);
+  }
+  for (const i of e.outs)
+    c.addOutput({
+      script: i.script,
+      value: i.value
+    });
+  return c.toHex();
+}
+function G(t, n) {
+  const e = { output: a.from(n) }, s = P.p2tr({
+    internalPubkey: a.from(t),
+    scriptTree: e
+  }).pubkey;
+  if (!s)
+    throw new Error("Failed to compute output key");
+  const r = 192, c = s[0] === 3 ? 1 : 0, i = r | c, u = new Uint8Array(1 + t.length);
+  return u[0] = i, u.set(t, 1), u;
+}
+async function st(t) {
+  const n = p(t.noPayoutTxHex), e = g.fromHex(n), { noPayoutScript: o, noPayoutControlBlock: s } = await W(
+    t.connectorParams,
+    t.challengerPubkey
+  ), r = f(o), c = f(s), i = new w();
+  i.setVersion(e.version), i.setLocktime(e.locktime);
+  for (let u = 0; u < e.ins.length; u++) {
+    const d = e.ins[u], l = t.prevouts[u];
+    if (!l)
+      throw new Error(`Missing prevout data for input ${u}`);
+    const h = {
+      hash: d.hash,
+      index: d.index,
+      sequence: d.sequence,
+      witnessUtxo: {
+        script: a.from(f(p(l.script_pubkey))),
+        value: l.value
+      }
+    };
+    u === 0 && (h.tapLeafScript = [
+      {
+        leafVersion: 192,
+        script: a.from(r),
+        controlBlock: a.from(c)
+      }
+    ], h.tapInternalKey = a.from(x)), i.addInput(h);
+  }
+  for (const u of e.outs)
+    i.addOutput({
+      script: u.script,
+      value: u.value
+    });
+  return i.toHex();
+}
+async function it(t) {
+  const n = p(t.challengeAssertTxHex), e = g.fromHex(n);
+  if (t.connectorParamsPerInput.length !== e.ins.length)
+    throw new Error(
+      `Expected ${e.ins.length} connector params, got ${t.connectorParamsPerInput.length}`
+    );
+  const o = await Promise.all(
+    t.connectorParamsPerInput.map((r) => N(r))
+  ), s = new w();
+  s.setVersion(e.version), s.setLocktime(e.locktime);
+  for (let r = 0; r < e.ins.length; r++) {
+    const c = e.ins[r], i = t.prevouts[r];
+    if (!i)
+      throw new Error(`Missing prevout data for input ${r}`);
+    const { script: u, controlBlock: d } = o[r], l = f(u), h = f(d);
+    s.addInput({
+      hash: c.hash,
+      index: c.index,
+      sequence: c.sequence,
+      witnessUtxo: {
+        script: a.from(f(p(i.script_pubkey))),
+        value: i.value
+      },
+      tapLeafScript: [
+        {
+          leafVersion: 192,
+          script: a.from(l),
+          controlBlock: a.from(h)
+        }
+      ],
+      tapInternalKey: a.from(x)
+    });
+  }
+  for (const r of e.outs)
+    s.addOutput({
+      script: r.script,
+      value: r.value
+    });
+  return s.toHex();
+}
+export {
+  nt as a,
+  Y as b,
+  rt as c,
+  st as d,
+  ot as e,
+  it as f,
+  F as g,
+  _ as h,
+  X as i,
+  f as j,
+  et as k,
+  Z as l,
+  q as m,
+  U as p,
+  p as s,
+  D as t,
+  v as u,
+  tt as v
+};
+//# sourceMappingURL=challengeAssert-DVErOd8l.js.map

package/dist/challengeAssert-DVErOd8l.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"challengeAssert-DVErOd8l.js","sources":["../src/tbv/core/primitives/psbt/pegin.ts","../src/tbv/core/primitives/scripts/payout.ts","../src/tbv/core/primitives/utils/bitcoin.ts","../src/tbv/core/primitives/psbt/payout.ts","../src/tbv/core/primitives/psbt/depositorPayout.ts","../src/tbv/core/primitives/psbt/noPayout.ts","../src/tbv/core/primitives/psbt/challengeAssert.ts"],"sourcesContent":["/**\n * Peg-in PSBT Builder Primitive\n *\n * This module provides pure functions for building unsigned peg-in PSBTs\n * by wrapping the WASM implementation from @babylonlabs-io/babylon-tbv-rust-wasm.\n *\n * @module primitives/psbt/pegin\n */\n\nimport {\n  createPegInTransaction,\n  type Network,\n} from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\n\n/**\n * Parameters for building an unsigned peg-in PSBT\n */\nexport interface PeginParams {\n  /**\n   * Depositor's BTC public key (x-only, 64-char hex without 0x prefix)\n   */\n  depositorPubkey: string;\n\n  /**\n   * Vault provider's BTC public key (x-only, 64-char hex)\n   */\n  vaultProviderPubkey: string;\n\n  /**\n   * Array of vault keeper BTC public keys (x-only, 64-char hex)\n   */\n  vaultKeeperPubkeys: string[];\n\n  /**\n   * Array of universal challenger BTC public keys (x-only, 64-char hex)\n   */\n  universalChallengerPubkeys: string[];\n\n  /**\n   * CSV timelock in blocks for the PegIn output\n   */\n  timelockPegin: number;\n\n  /**\n   * Amount to peg in (in satoshis)\n   */\n  pegInAmount: bigint;\n\n  /**\n   * Amount in satoshis for the depositor's claim output\n   */\n  depositorClaimValue: bigint;\n\n  /**\n   * Bitcoin network\n   */\n  network: Network;\n}\n\n/**\n * Result of building an unsigned peg-in PSBT\n */\nexport interface PeginPsbtResult {\n  /**\n   * Unsigned transaction hex\n   *\n   * Note: This is an unfunded transaction with no inputs and one output (the pegin output).\n   * The caller is responsible for:\n   * - Selecting UTXOs to fund the transaction\n   * - Calculating transaction fees\n   * - Adding inputs to cover pegInAmount + fees\n   * - Adding a change output if needed\n   * - Creating and signing the PSBT via wallet\n   */\n  psbtHex: string;\n\n  /**\n   * Transaction ID (will change after adding inputs and signing)\n   */\n  txid: string;\n\n  /**\n   * Vault script pubkey hex\n   */\n  vaultScriptPubKey: string;\n\n  /**\n   * Vault output value (in satoshis)\n   */\n  vaultValue: bigint;\n}\n\n/**\n * Build unsigned peg-in PSBT using WASM.\n *\n * This is a pure function that wraps the Rust WASM implementation.\n * It creates an unfunded Bitcoin transaction with no inputs and one output\n * (the peg-in output to the vault address).\n *\n * The returned transaction must be funded by the caller by:\n * 1. Selecting appropriate UTXOs from the wallet\n * 2. Calculating transaction fees based on selected inputs\n * 3. Adding inputs to cover pegInAmount + fees\n * 4. Adding a change output if the input value exceeds pegInAmount + fees\n * 5. Creating a PSBT and signing it via the wallet\n *\n * @param params - Peg-in parameters\n * @returns Unsigned PSBT and transaction details\n *\n * @throws If WASM initialization fails or parameters are invalid\n */\nexport async function buildPeginPsbt(\n  params: PeginParams,\n): Promise<PeginPsbtResult> {\n  // Call the WASM wrapper with the exact parameter names it expects\n  const result = await createPegInTransaction({\n    depositorPubkey: params.depositorPubkey,\n    vaultProviderPubkey: params.vaultProviderPubkey,\n    vaultKeeperPubkeys: params.vaultKeeperPubkeys,\n    universalChallengerPubkeys: params.universalChallengerPubkeys,\n    timelockPegin: params.timelockPegin,\n    pegInAmount: params.pegInAmount,\n    depositorClaimValue: params.depositorClaimValue,\n    network: params.network,\n  });\n\n  return {\n    psbtHex: result.txHex,\n    txid: result.txid,\n    vaultScriptPubKey: result.vaultScriptPubKey,\n    vaultValue: result.vaultValue,\n  };\n}\n","/**\n * Payout Script Generator Primitive\n *\n * This module provides pure functions for generating payout scripts and taproot information\n * by wrapping the WASM implementation from @babylonlabs-io/babylon-tbv-rust-wasm.\n *\n * The payout script is used for signing payout transactions in the vault system.\n * It defines the spending conditions for the vault output, enabling the depositor\n * to authorize payouts during the peg-in flow (Step 3).\n *\n * @remarks\n * This is a low-level primitive. For most use cases, prefer using {@link buildPayoutPsbt}\n * which handles script creation internally. For high-level wallet orchestration, use\n * PayoutManager from the managers module.\n *\n * @see {@link buildPayoutPsbt} - Higher-level function that uses this internally\n *\n * @module primitives/scripts/payout\n */\n\nimport {\n  createPayoutConnector,\n  type Network,\n} from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\n\n/**\n * Parameters for creating a payout script.\n *\n * These parameters define the participants in a vault and are used to generate\n * the taproot script that controls how funds can be spent from the vault.\n */\nexport interface PayoutScriptParams {\n  /**\n   * Depositor's BTC public key (x-only, 64-char hex without 0x prefix).\n   *\n   * This is the user depositing BTC into the vault. The depositor must sign\n   * payout transactions to authorize fund distribution.\n   */\n  depositor: string;\n\n  /**\n   * Vault provider's BTC public key (x-only, 64-char hex without 0x prefix).\n   *\n   * The service provider managing vault operations. Also referred to as\n   * \"claimer\" in the WASM layer.\n   */\n  vaultProvider: string;\n\n  /**\n   * Array of vault keeper BTC public keys (x-only, 64-char hex without 0x prefix).\n   *\n   * Vault keepers participate in vault operations and script spending conditions.\n   */\n  vaultKeepers: string[];\n\n  /**\n   * Array of universal challenger BTC public keys (x-only, 64-char hex without 0x prefix).\n   *\n   * These parties can challenge the vault under certain conditions.\n   */\n  universalChallengers: string[];\n\n  /**\n   * CSV timelock in blocks for the PegIn output.\n   */\n  timelockPegin: number;\n\n  /**\n   * Bitcoin network for script generation.\n   *\n   * Must match the network used for all other vault operations to ensure\n   * address encoding compatibility.\n   */\n  network: Network;\n}\n\n/**\n * Result of creating a payout script.\n *\n * Contains all the taproot-related data needed for constructing and signing\n * payout transactions from the vault.\n */\nexport interface PayoutScriptResult {\n  /**\n   * The payout script hex used in taproot script path spending.\n   *\n   * This is the raw script bytes that define the spending conditions,\n   * encoded as a hexadecimal string. Used when constructing the\n   * tapLeafScript for PSBT signing.\n   */\n  payoutScript: string;\n\n  /**\n   * The taproot script hash (leaf hash) for the payout script.\n   *\n   * This is the tagged hash of the script used in taproot tree construction.\n   * Required for computing the control block during script path spending.\n   */\n  taprootScriptHash: string;\n\n  /**\n   * The full scriptPubKey for the vault output address.\n   *\n   * This is the complete output script (OP_1 <32-byte-key>) that should be\n   * used when creating the vault output in a peg-in transaction.\n   */\n  scriptPubKey: string;\n\n  /**\n   * The vault Bitcoin address derived from the script.\n   *\n   * A human-readable bech32m address (bc1p... for mainnet, tb1p... for testnet/signet)\n   * that can be used to receive funds into the vault.\n   */\n  address: string;\n}\n\n/**\n * Create payout script and taproot information using WASM.\n *\n * This is a pure function that wraps the Rust WASM implementation.\n * The payout connector generates the necessary taproot scripts and information\n * required for signing payout transactions.\n *\n * @remarks\n * The generated script encodes spending conditions that require signatures from\n * the depositor and vault provider (or liquidators in challenge scenarios).\n * This script is used internally by {@link buildPayoutPsbt}.\n *\n * @param params - Payout script parameters defining vault participants and network\n * @returns Payout script and taproot information for PSBT construction\n *\n * @see {@link buildPayoutPsbt} - Use this for building complete payout PSBTs\n */\nexport async function createPayoutScript(\n  params: PayoutScriptParams,\n): Promise<PayoutScriptResult> {\n  // Call the WASM wrapper with the correct parameter structure\n  const connector = await createPayoutConnector(\n    {\n      depositor: params.depositor,\n      vaultProvider: params.vaultProvider,\n      vaultKeepers: params.vaultKeepers,\n      universalChallengers: params.universalChallengers,\n      timelockPegin: params.timelockPegin,\n    },\n    params.network,\n  );\n\n  return {\n    payoutScript: connector.payoutScript,\n    taprootScriptHash: connector.taprootScriptHash,\n    scriptPubKey: connector.scriptPubKey,\n    address: connector.address,\n  };\n}\n","/**\n * Bitcoin Utilities\n *\n * Common pure utility functions for Bitcoin operations including:\n * - Public key conversions (x-only format)\n * - Hex string manipulation\n * - Uint8Array conversions and validation\n * - Address derivation and validation\n *\n * All functions are pure (no side effects) and work in Node.js, browsers,\n * and serverless environments.\n *\n * @module primitives/utils/bitcoin\n */\n\nimport * as ecc from \"@bitcoin-js/tiny-secp256k1-asmjs\";\nimport { Buffer } from \"buffer\";\nimport { initEccLib, networks, payments } from \"bitcoinjs-lib\";\n\nimport type { Network } from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\n\n/**\n * Strip \"0x\" prefix from hex string if present.\n *\n * Bitcoin expects plain hex (no \"0x\" prefix), but frontend often uses\n * Ethereum-style \"0x\"-prefixed hex.\n *\n * @param hex - Hex string with or without \"0x\" prefix\n * @returns Hex string without \"0x\" prefix\n */\nexport function stripHexPrefix(hex: string): string {\n  return hex.startsWith(\"0x\") ? hex.slice(2) : hex;\n}\n\n/**\n * Convert hex string to Uint8Array.\n *\n * @param hex - Hex string (with or without 0x prefix)\n * @returns Uint8Array\n * @throws If hex is invalid\n */\nexport function hexToUint8Array(hex: string): Uint8Array {\n  const cleanHex = stripHexPrefix(hex);\n  if (!isValidHexRaw(cleanHex)) {\n    throw new Error(`Invalid hex string: ${hex}`);\n  }\n  const bytes = new Uint8Array(cleanHex.length / 2);\n  for (let i = 0; i < cleanHex.length; i += 2) {\n    bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);\n  }\n  return bytes;\n}\n\n/**\n * Convert Uint8Array to hex string (without 0x prefix).\n *\n * @param bytes - Uint8Array to convert\n * @returns Hex string without 0x prefix\n */\nexport function uint8ArrayToHex(bytes: Uint8Array): string {\n  return Array.from(bytes)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n\n/**\n * Convert a 33-byte public key to 32-byte x-only format (removes first byte).\n *\n * Used for Taproot/Schnorr signatures which only need the x-coordinate.\n * If the input is already 32 bytes, returns it unchanged.\n *\n * @param pubKey - 33-byte or 32-byte public key\n * @returns 32-byte x-only public key\n */\nexport function toXOnly(pubKey: Uint8Array): Uint8Array {\n  return pubKey.length === 32 ? pubKey : pubKey.slice(1, 33);\n}\n\n/**\n * Internal helper: Validate hex string format without stripping prefix\n *\n * @internal\n * @param hex - Hex string (must already have prefix stripped)\n * @returns true if valid hex string\n */\nfunction isValidHexRaw(hex: string): boolean {\n  return /^[0-9a-fA-F]*$/.test(hex) && hex.length % 2 === 0;\n}\n\n/**\n * Process and convert a public key to x-only format (32 bytes hex).\n *\n * Handles:\n * - 0x prefix removal\n * - Hex character validation\n * - Length validation\n * - Conversion to x-only format\n *\n * Accepts:\n * - 64 hex chars (32 bytes) - already x-only\n * - 66 hex chars (33 bytes) - compressed pubkey\n * - 130 hex chars (65 bytes) - uncompressed pubkey\n *\n * @param publicKeyHex - Public key in hex format (with or without 0x prefix)\n * @returns X-only public key as 32 bytes hex string (without 0x prefix)\n * @throws If public key format is invalid or contains invalid hex characters\n */\nexport function processPublicKeyToXOnly(publicKeyHex: string): string {\n  // Remove '0x' prefix if present\n  const cleanHex = stripHexPrefix(publicKeyHex);\n\n  // Validate hex characters early to prevent silent failures\n  if (!isValidHexRaw(cleanHex)) {\n    throw new Error(`Invalid hex characters in public key: ${publicKeyHex}`);\n  }\n\n  // If already 64 chars (32 bytes), it's already x-only format\n  if (cleanHex.length === 64) {\n    return cleanHex;\n  }\n\n  // Validate public key length (should be 66 chars for compressed or 130 for uncompressed)\n  if (cleanHex.length !== 66 && cleanHex.length !== 130) {\n    throw new Error(\n      `Invalid public key length: ${cleanHex.length} (expected 64, 66, or 130 hex chars)`,\n    );\n  }\n\n  const pubkeyBytes = hexToUint8Array(cleanHex);\n  return uint8ArrayToHex(toXOnly(pubkeyBytes));\n}\n\n/**\n * Validate hex string format.\n *\n * Checks that the string contains only valid hexadecimal characters (0-9, a-f, A-F)\n * and has an even length (since each byte is represented by 2 hex characters).\n *\n * @param hex - String to validate (with or without 0x prefix)\n * @returns true if valid hex string\n */\nexport function isValidHex(hex: string): boolean {\n  const cleanHex = stripHexPrefix(hex);\n  return isValidHexRaw(cleanHex);\n}\n\n/**\n * Result of validating a wallet public key against an expected depositor public key.\n */\nexport interface WalletPubkeyValidationResult {\n  /** Wallet's raw public key (as returned by wallet, may be compressed) */\n  walletPubkeyRaw: string;\n  /** Wallet's public key in x-only format (32 bytes, 64 hex chars) */\n  walletPubkeyXOnly: string;\n  /** The validated depositor public key (x-only format) */\n  depositorPubkey: string;\n}\n\n/**\n * Validate that a wallet's public key matches the expected depositor public key.\n *\n * This function:\n * 1. Converts the wallet pubkey to x-only format\n * 2. Uses the expected depositor pubkey if provided, otherwise falls back to wallet pubkey\n * 3. Validates they match (case-insensitive)\n *\n * @param walletPubkeyRaw - Raw public key from wallet (may be compressed 66 chars or x-only 64 chars)\n * @param expectedDepositorPubkey - Expected depositor public key (x-only, optional)\n * @returns Validation result with both pubkey formats\n * @throws If wallet pubkey doesn't match expected depositor pubkey\n */\nexport function validateWalletPubkey(\n  walletPubkeyRaw: string,\n  expectedDepositorPubkey?: string,\n): WalletPubkeyValidationResult {\n  const walletPubkeyXOnly = processPublicKeyToXOnly(walletPubkeyRaw);\n  const depositorPubkey = expectedDepositorPubkey ?? walletPubkeyXOnly;\n\n  if (walletPubkeyXOnly.toLowerCase() !== depositorPubkey.toLowerCase()) {\n    throw new Error(\n      `Wallet public key does not match vault depositor. ` +\n      `Expected: ${depositorPubkey}, Got: ${walletPubkeyXOnly}. ` +\n      `Please connect the wallet that was used to create this vault.`\n    );\n  }\n\n  return { walletPubkeyRaw, walletPubkeyXOnly, depositorPubkey };\n}\n\n// ============================================================================\n// Address derivation and validation\n// ============================================================================\n\nlet eccInitialized = false;\n\nfunction ensureEcc(): void {\n  if (!eccInitialized) {\n    initEccLib(ecc);\n    eccInitialized = true;\n  }\n}\n\n/**\n * Map SDK network type to bitcoinjs-lib Network object.\n *\n * @param network - Network type (\"bitcoin\", \"testnet\", \"signet\", \"regtest\")\n * @returns bitcoinjs-lib Network object\n */\nexport function getNetwork(network: Network): networks.Network {\n  switch (network) {\n    case \"bitcoin\":\n      return networks.bitcoin;\n    case \"testnet\":\n    case \"signet\":\n      return networks.testnet;\n    case \"regtest\":\n      return networks.regtest;\n    default:\n      throw new Error(`Unknown network: ${network}`);\n  }\n}\n\n/**\n * Derive a Taproot (P2TR) address from a public key.\n *\n * @param publicKeyHex - Compressed (66 hex) or x-only (64 hex) public key\n * @param network - Bitcoin network\n * @returns Taproot address (bc1p... / tb1p... / bcrt1p...)\n */\nexport function deriveTaprootAddress(\n  publicKeyHex: string,\n  network: Network,\n): string {\n  ensureEcc();\n  const xOnly = hexToUint8Array(processPublicKeyToXOnly(publicKeyHex));\n  const { address } = payments.p2tr({\n    internalPubkey: Buffer.from(xOnly),\n    network: getNetwork(network),\n  });\n  if (!address) {\n    throw new Error(\"Failed to derive taproot address from public key\");\n  }\n  return address;\n}\n\n/**\n * Derive a Native SegWit (P2WPKH) address from a compressed public key.\n *\n * @param publicKeyHex - Compressed public key (66 hex chars, with or without 0x prefix)\n * @param network - Bitcoin network\n * @returns Native SegWit address (bc1q... / tb1q... / bcrt1q...)\n * @throws If publicKeyHex is not a compressed public key (66 hex chars)\n */\nexport function deriveNativeSegwitAddress(\n  publicKeyHex: string,\n  network: Network,\n): string {\n  const cleanHex = stripHexPrefix(publicKeyHex);\n  if (cleanHex.length !== 66) {\n    throw new Error(\n      `Native SegWit requires a compressed public key (66 hex chars), got ${cleanHex.length}`,\n    );\n  }\n  const { address } = payments.p2wpkh({\n    pubkey: Buffer.from(hexToUint8Array(cleanHex)),\n    network: getNetwork(network),\n  });\n  if (!address) {\n    throw new Error(\n      \"Failed to derive native segwit address from public key\",\n    );\n  }\n  return address;\n}\n\n/**\n * Validate that a BTC address was derived from the given public key.\n *\n * Derives Taproot (P2TR) and Native SegWit (P2WPKH) addresses from the\n * public key and checks if the provided address matches any of them.\n *\n * When the input is an x-only key (64 hex chars), both possible compressed\n * keys (`02` + x and `03` + x) are tried for Native SegWit derivation,\n * since the y-parity is unknown.\n *\n * @param address - BTC address to validate\n * @param publicKeyHex - Public key from the wallet (x-only 64 or compressed 66 hex chars)\n * @param network - Bitcoin network\n * @returns true if the address matches the public key\n */\nexport function isAddressFromPublicKey(\n  address: string,\n  publicKeyHex: string,\n  network: Network,\n): boolean {\n  const cleanHex = stripHexPrefix(publicKeyHex);\n\n  // P2TR — works with both x-only and compressed keys\n  try {\n    if (address === deriveTaprootAddress(cleanHex, network)) {\n      return true;\n    }\n  } catch {\n    // derivation failed, continue\n  }\n\n  // Build the list of compressed keys to try for P2WPKH\n  const compressedKeys: string[] = [];\n  if (cleanHex.length === 66) {\n    compressedKeys.push(cleanHex);\n  } else if (cleanHex.length === 64) {\n    // x-only key — try both even (02) and odd (03) y-parity\n    compressedKeys.push(`02${cleanHex}`, `03${cleanHex}`);\n  }\n\n  for (const key of compressedKeys) {\n    try {\n      if (address === deriveNativeSegwitAddress(key, network)) {\n        return true;\n      }\n    } catch {\n      // derivation failed, continue\n    }\n  }\n\n  return false;\n}\n","/**\n * Payout PSBT Builder Primitives\n *\n * This module provides pure functions for building unsigned payout PSBTs and extracting\n * Schnorr signatures from signed PSBTs. It uses WASM-generated scripts from the payout\n * connector and bitcoinjs-lib for PSBT construction.\n *\n * The Payout transaction references the Assert transaction (input 1).\n *\n * @module primitives/psbt/payout\n */\n\nimport {\n  type Network,\n  tapInternalPubkey,\n} from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\nimport * as ecc from \"@bitcoin-js/tiny-secp256k1-asmjs\";\nimport { Buffer } from \"buffer\";\nimport { initEccLib, payments, Psbt, Transaction } from \"bitcoinjs-lib\";\nimport { createPayoutScript } from \"../scripts/payout\";\nimport {\n  hexToUint8Array,\n  stripHexPrefix,\n  uint8ArrayToHex,\n} from \"../utils/bitcoin\";\n\n// Initialize ECC library for bitcoinjs-lib\ninitEccLib(ecc);\n\n/**\n * Parameters for building an unsigned Payout PSBT\n *\n * Payout is used in the challenge path after Assert, when the claimer proves validity.\n * Input 1 references the Assert transaction.\n */\nexport interface PayoutParams {\n  /**\n   * Payout transaction hex (unsigned)\n   * This is the transaction that needs to be signed by the depositor\n   */\n  payoutTxHex: string;\n\n  /**\n   * Assert transaction hex\n   * Payout input 1 references Assert output 0\n   */\n  assertTxHex: string;\n\n  /**\n   * Peg-in transaction hex\n   * This transaction created the vault output that we're spending\n   */\n  peginTxHex: string;\n\n  /**\n   * Depositor's BTC public key (x-only, 64-char hex without 0x prefix)\n   */\n  depositorBtcPubkey: string;\n\n  /**\n   * Vault provider's BTC public key (x-only, 64-char hex)\n   */\n  vaultProviderBtcPubkey: string;\n\n  /**\n   * Vault keeper BTC public keys (x-only, 64-char hex)\n   */\n  vaultKeeperBtcPubkeys: string[];\n\n  /**\n   * Universal challenger BTC public keys (x-only, 64-char hex)\n   */\n  universalChallengerBtcPubkeys: string[];\n\n  /**\n   * CSV timelock in blocks for the PegIn output.\n   */\n  timelockPegin: number;\n\n  /**\n   * Bitcoin network\n   */\n  network: Network;\n}\n\n/**\n * Result of building an unsigned payout PSBT\n */\nexport interface PayoutPsbtResult {\n  /**\n   * Unsigned PSBT hex ready for signing\n   */\n  psbtHex: string;\n}\n\n/**\n * Build unsigned Payout PSBT for depositor to sign.\n *\n * Payout is used in the **challenge path** when the claimer proves validity:\n * 1. Vault provider submits Claim transaction\n * 2. Challenge is raised during challenge period\n * 3. Claimer submits Assert transaction to prove validity\n * 4. Payout can be executed (references Assert tx)\n *\n * Payout transactions have the following structure:\n * - Input 0: from PeginTx output0 (signed by depositor)\n * - Input 1: from Assert output0 (NOT signed by depositor)\n *\n * @param params - Payout parameters\n * @returns Unsigned PSBT ready for depositor to sign\n *\n * @throws If payout transaction does not have exactly 2 inputs\n * @throws If input 0 does not reference the pegin transaction\n * @throws If input 1 does not reference the assert transaction\n * @throws If previous output is not found for either input\n */\nexport async function buildPayoutPsbt(\n  params: PayoutParams,\n): Promise<PayoutPsbtResult> {\n  // Normalize hex inputs (strip 0x prefix if present)\n  const payoutTxHex = stripHexPrefix(params.payoutTxHex);\n  const peginTxHex = stripHexPrefix(params.peginTxHex);\n  const assertTxHex = stripHexPrefix(params.assertTxHex);\n\n  // Get payout script from WASM\n  const payoutConnector = await createPayoutScript({\n    depositor: params.depositorBtcPubkey,\n    vaultProvider: params.vaultProviderBtcPubkey,\n    vaultKeepers: params.vaultKeeperBtcPubkeys,\n    universalChallengers: params.universalChallengerBtcPubkeys,\n    timelockPegin: params.timelockPegin,\n    network: params.network,\n  });\n\n  const payoutScriptBytes = hexToUint8Array(payoutConnector.payoutScript);\n  const controlBlock = computeControlBlock(tapInternalPubkey, payoutScriptBytes);\n\n  // Parse transactions\n  const payoutTx = Transaction.fromHex(payoutTxHex);\n  const peginTx = Transaction.fromHex(peginTxHex);\n  const assertTx = Transaction.fromHex(assertTxHex);\n\n  // Create PSBT\n  const psbt = new Psbt();\n  psbt.setVersion(payoutTx.version);\n  psbt.setLocktime(payoutTx.locktime);\n\n  // PayoutTx has exactly 2 inputs:\n  // - Input 0: from PeginTx output0 (signed by depositor using taproot script path)\n  // - Input 1: from Assert output0 (signed by claimer/challengers, not depositor)\n  //\n  // IMPORTANT: For Taproot SIGHASH_DEFAULT (0x00), the sighash commits to ALL inputs'\n  // prevouts, not just the one being signed. Therefore, we must include BOTH inputs\n  // in the PSBT so the wallet computes the correct sighash that the VP expects.\n\n  // Verify payout transaction has expected structure\n  if (payoutTx.ins.length !== 2) {\n    throw new Error(\n      `Payout transaction must have exactly 2 inputs, got ${payoutTx.ins.length}`,\n    );\n  }\n\n  const input0 = payoutTx.ins[0];\n  const input1 = payoutTx.ins[1];\n\n  // Verify input 0 references the pegin transaction\n  const input0Txid = uint8ArrayToHex(\n    new Uint8Array(input0.hash).slice().reverse(),\n  );\n  const peginTxid = peginTx.getId();\n\n  if (input0Txid !== peginTxid) {\n    throw new Error(\n      `Input 0 does not reference pegin transaction. ` +\n        `Expected ${peginTxid}, got ${input0Txid}`,\n    );\n  }\n\n  // Verify input 1 references the assert transaction\n  const input1Txid = uint8ArrayToHex(\n    new Uint8Array(input1.hash).slice().reverse(),\n  );\n  const expectedInput1Txid = assertTx.getId();\n\n  if (input1Txid !== expectedInput1Txid) {\n    throw new Error(\n      `Input 1 does not reference assert transaction. ` +\n        `Expected ${expectedInput1Txid}, got ${input1Txid}`,\n    );\n  }\n\n  const peginPrevOut = peginTx.outs[input0.index];\n  if (!peginPrevOut) {\n    throw new Error(\n      `Previous output not found for input 0 (txid: ${input0Txid}, index: ${input0.index})`,\n    );\n  }\n\n  const input1PrevOut = assertTx.outs[input1.index];\n  if (!input1PrevOut) {\n    throw new Error(\n      `Previous output not found for input 1 (txid: ${input1Txid}, index: ${input1.index})`,\n    );\n  }\n\n  // Input 0: Depositor signs using Taproot script path spend\n  // This input includes tapLeafScript for signing\n  psbt.addInput({\n    hash: input0.hash,\n    index: input0.index,\n    sequence: input0.sequence,\n    witnessUtxo: {\n      script: peginPrevOut.script,\n      value: peginPrevOut.value,\n    },\n    tapLeafScript: [\n      {\n        leafVersion: 0xc0,\n        script: Buffer.from(payoutScriptBytes),\n        controlBlock: Buffer.from(controlBlock),\n      },\n    ],\n    tapInternalKey: Buffer.from(tapInternalPubkey),\n    // sighashType omitted - defaults to SIGHASH_DEFAULT (0x00) for Taproot\n  });\n\n  // Input 1: From Assert transaction (NOT signed by depositor)\n  // We include this with witnessUtxo so the sighash is computed correctly,\n  // but we do NOT include tapLeafScript since the depositor doesn't sign it.\n  psbt.addInput({\n    hash: input1.hash,\n    index: input1.index,\n    sequence: input1.sequence,\n    witnessUtxo: {\n      script: input1PrevOut.script,\n      value: input1PrevOut.value,\n    },\n    // No tapLeafScript - depositor doesn't sign this input\n  });\n\n  // Add outputs\n  for (const output of payoutTx.outs) {\n    psbt.addOutput({\n      script: output.script,\n      value: output.value,\n    });\n  }\n\n  return {\n    psbtHex: psbt.toHex(),\n  };\n}\n\n/**\n * Extract Schnorr signature from signed payout PSBT.\n *\n * This function supports two cases:\n * 1. Non-finalized PSBT: Extracts from tapScriptSig field\n * 2. Finalized PSBT: Extracts from witness data\n *\n * The signature is returned as a 64-byte hex string (128 hex characters)\n * with any sighash flag byte removed if present.\n *\n * @param signedPsbtHex - Signed PSBT hex\n * @param depositorPubkey - Depositor's public key (x-only, 64-char hex)\n * @param inputIndex - Input index to extract signature from (default: 0)\n * @returns 64-byte Schnorr signature (128 hex characters, no sighash flag)\n *\n * @throws If no signature is found in the PSBT\n * @throws If the signature has an unexpected length\n */\nexport function extractPayoutSignature(\n  signedPsbtHex: string,\n  depositorPubkey: string,\n  inputIndex = 0,\n): string {\n  const signedPsbt = Psbt.fromHex(signedPsbtHex);\n\n  if (inputIndex >= signedPsbt.data.inputs.length) {\n    throw new Error(\n      `Input index ${inputIndex} out of range (${signedPsbt.data.inputs.length} inputs)`,\n    );\n  }\n\n  const input = signedPsbt.data.inputs[inputIndex];\n\n  // Case 1: Non-finalized PSBT — extract from tapScriptSig\n  if (input.tapScriptSig && input.tapScriptSig.length > 0) {\n    const depositorPubkeyBytes = hexToUint8Array(depositorPubkey);\n\n    for (const sigEntry of input.tapScriptSig) {\n      if (sigEntry.pubkey.equals(Buffer.from(depositorPubkeyBytes))) {\n        return extractSchnorrSig(sigEntry.signature, inputIndex);\n      }\n    }\n\n    throw new Error(\n      `No signature found for depositor pubkey: ${depositorPubkey} at input ${inputIndex}`,\n    );\n  }\n\n  // Case 2: Finalized PSBT — extract from finalScriptWitness\n  // Taproot script-path witness: [signature, script, controlBlock]\n  if (input.finalScriptWitness && input.finalScriptWitness.length > 0) {\n    const witnessStack = parseWitnessStack(input.finalScriptWitness);\n    if (witnessStack.length >= 1) {\n      return extractSchnorrSig(witnessStack[0], inputIndex);\n    }\n  }\n\n  throw new Error(\n    `No tapScriptSig or finalScriptWitness found in signed PSBT at input ${inputIndex}`,\n  );\n}\n\n/**\n * Extract and validate a 64-byte Schnorr signature, stripping sighash flag if present.\n * @internal\n */\nfunction extractSchnorrSig(sig: Uint8Array, inputIndex: number): string {\n  if (sig.length === 64) {\n    return uint8ArrayToHex(new Uint8Array(sig));\n  } else if (sig.length === 65) {\n    return uint8ArrayToHex(new Uint8Array(sig.subarray(0, 64)));\n  }\n  throw new Error(\n    `Unexpected signature length at input ${inputIndex}: ${sig.length}`,\n  );\n}\n\n/**\n * Parse a BIP-141 serialized witness stack into individual stack items.\n * Format: [varint item_count] [varint len, data]...\n * @internal\n */\nfunction parseWitnessStack(witness: Buffer): Buffer[] {\n  const items: Buffer[] = [];\n  let offset = 0;\n\n  const readVarInt = (): number => {\n    const first = witness[offset++];\n    if (first < 0xfd) return first;\n    if (first === 0xfd) {\n      const val = witness[offset] | (witness[offset + 1] << 8);\n      offset += 2;\n      return val;\n    }\n    if (first === 0xfe) {\n      const val =\n        witness[offset] |\n        (witness[offset + 1] << 8) |\n        (witness[offset + 2] << 16) |\n        (witness[offset + 3] << 24);\n      offset += 4;\n      return val;\n    }\n    // 0xff — 8-byte, won't happen for witness data\n    offset += 8;\n    return 0;\n  };\n\n  const count = readVarInt();\n  for (let i = 0; i < count; i++) {\n    const len = readVarInt();\n    items.push(witness.subarray(offset, offset + len) as Buffer);\n    offset += len;\n  }\n\n  return items;\n}\n\n/**\n * Compute control block for Taproot script path spend.\n *\n * For a single script (no tree), the control block format is:\n * [leaf_version | parity] || [internal_key_x_only]\n *\n * The leaf version for Tapscript is 0xc0, and the parity bit indicates\n * whether the output key has an odd or even y-coordinate.\n *\n * @param internalKey - Taproot internal public key (x-only, 32 bytes)\n * @param script - Taproot script to compute control block for\n * @returns Control block buffer\n *\n * @internal\n */\nfunction computeControlBlock(\n  internalKey: Uint8Array,\n  script: Uint8Array,\n): Uint8Array {\n  // Convert to actual Buffer instances for bitcoinjs-lib runtime type checks\n  const scriptTree = { output: Buffer.from(script) };\n  const payment = payments.p2tr({\n    internalPubkey: Buffer.from(internalKey),\n    scriptTree,\n  });\n\n  const outputKey = payment.pubkey;\n  if (!outputKey) {\n    throw new Error(\"Failed to compute output key\");\n  }\n\n  // Control block: [leaf_version | parity] || [internal_key_x_only]\n  const leafVersion = 0xc0;\n  const parity = outputKey[0] === 0x03 ? 1 : 0; // 0x02 = even, 0x03 = odd\n  const controlByte = leafVersion | parity;\n\n  const result = new Uint8Array(1 + internalKey.length);\n  result[0] = controlByte;\n  result.set(internalKey, 1);\n  return result;\n}\n","/**\n * Depositor Payout PSBT Builder\n *\n * Builds unsigned PSBTs for the depositor's own Payout transaction\n * (depositor-as-claimer path). The depositor signs input 0 using the\n * payout taproot script from WasmPeginPayoutConnector (PegIn vault UTXO).\n *\n * Input 0 spends PegIn:0 (the vault UTXO) — the same connector used for\n * VP/VK payout signing. The VP verifies this signature using the\n * PeginPayoutConnector's payout script.\n *\n * @module primitives/psbt/depositorPayout\n * @see btc-vault crates/vault/src/sign.rs — verify_depositor_signature / get_payout_tap_leaf_hash\n */\n\nimport {\n  type PayoutConnectorParams,\n  getPeginPayoutScript,\n  tapInternalPubkey,\n} from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\nimport * as ecc from \"@bitcoin-js/tiny-secp256k1-asmjs\";\nimport { Buffer } from \"buffer\";\nimport { initEccLib, payments, Psbt, Transaction } from \"bitcoinjs-lib\";\n\nimport {\n  hexToUint8Array,\n  stripHexPrefix,\n} from \"../utils/bitcoin\";\n\n// Initialize ECC library for bitcoinjs-lib\ninitEccLib(ecc);\n\n/**\n * Parameters for building a depositor Payout PSBT\n */\nexport interface DepositorPayoutParams {\n  /** Payout transaction hex (unsigned) from VP */\n  payoutTxHex: string;\n  /** Prevouts for all inputs [{script_pubkey, value}] from VP */\n  prevouts: Array<{ script_pubkey: string; value: number }>;\n  /** Parameters for the PeginPayout connector (depositor, VP, VKs, UCs, timelock) */\n  connectorParams: PayoutConnectorParams;\n}\n\n/**\n * Build unsigned depositor Payout PSBT.\n *\n * The depositor's payout transaction has 2 inputs:\n * - Input 0: PegIn:0 (vault UTXO) — depositor signs using PeginPayoutConnector payout script\n * - Input 1: Assert:0 — NOT signed by depositor\n *\n * @param params - Depositor payout parameters\n * @returns Unsigned PSBT hex ready for signing\n */\nexport async function buildDepositorPayoutPsbt(\n  params: DepositorPayoutParams,\n): Promise<string> {\n  const payoutTxHex = stripHexPrefix(params.payoutTxHex);\n  const payoutTx = Transaction.fromHex(payoutTxHex);\n\n  // Get payout script from WASM (PeginPayoutConnector — same as VP/VK payout)\n  const payoutScriptHex = await getPeginPayoutScript(params.connectorParams);\n  const scriptBytes = hexToUint8Array(payoutScriptHex);\n  const controlBlock = computeControlBlock(tapInternalPubkey, scriptBytes);\n\n  const psbt = new Psbt();\n  psbt.setVersion(payoutTx.version);\n  psbt.setLocktime(payoutTx.locktime);\n\n  // Add all inputs - depositor signs input 0 only\n  for (let i = 0; i < payoutTx.ins.length; i++) {\n    const input = payoutTx.ins[i];\n    const prevout = params.prevouts[i];\n\n    if (!prevout) {\n      throw new Error(`Missing prevout data for input ${i}`);\n    }\n\n    const inputData: Parameters<typeof psbt.addInput>[0] = {\n      hash: input.hash,\n      index: input.index,\n      sequence: input.sequence,\n      witnessUtxo: {\n        script: Buffer.from(hexToUint8Array(stripHexPrefix(prevout.script_pubkey))),\n        value: prevout.value,\n      },\n    };\n\n    // Input 0: depositor signs using taproot script path\n    if (i === 0) {\n      inputData.tapLeafScript = [\n        {\n          leafVersion: 0xc0,\n          script: Buffer.from(scriptBytes),\n          controlBlock: Buffer.from(controlBlock),\n        },\n      ];\n      inputData.tapInternalKey = Buffer.from(tapInternalPubkey);\n    }\n\n    psbt.addInput(inputData);\n  }\n\n  // Add outputs\n  for (const output of payoutTx.outs) {\n    psbt.addOutput({\n      script: output.script,\n      value: output.value,\n    });\n  }\n\n  return psbt.toHex();\n}\n\n/**\n * Compute control block for Taproot script path spend.\n * @internal\n */\nfunction computeControlBlock(\n  internalKey: Uint8Array,\n  script: Uint8Array,\n): Uint8Array {\n  const scriptTree = { output: Buffer.from(script) };\n  const payment = payments.p2tr({\n    internalPubkey: Buffer.from(internalKey),\n    scriptTree,\n  });\n\n  const outputKey = payment.pubkey;\n  if (!outputKey) {\n    throw new Error(\"Failed to compute output key\");\n  }\n\n  const leafVersion = 0xc0;\n  const parity = outputKey[0] === 0x03 ? 1 : 0;\n  const controlByte = leafVersion | parity;\n\n  const result = new Uint8Array(1 + internalKey.length);\n  result[0] = controlByte;\n  result.set(internalKey, 1);\n  return result;\n}\n","/**\n * NoPayout PSBT Builder\n *\n * Builds unsigned PSBTs for the depositor's NoPayout transaction\n * (depositor-as-claimer path, per challenger). The depositor signs input 0\n * using the NoPayout taproot script from WasmAssertPayoutNoPayoutConnector.\n *\n * @module primitives/psbt/noPayout\n * @see btc-vault crates/vault/docs/btc-transactions-spec.md — Assert output 0 NoPayout connector\n */\n\nimport {\n  type AssertPayoutNoPayoutConnectorParams,\n  getAssertNoPayoutScriptInfo,\n  tapInternalPubkey,\n} from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\nimport { Buffer } from \"buffer\";\nimport { Psbt, Transaction } from \"bitcoinjs-lib\";\n\nimport {\n  hexToUint8Array,\n  stripHexPrefix,\n} from \"../utils/bitcoin\";\n\n/**\n * Parameters for building a NoPayout PSBT\n */\nexport interface NoPayoutParams {\n  /** NoPayout transaction hex (unsigned) from VP */\n  noPayoutTxHex: string;\n  /** Challenger's x-only public key (hex encoded) */\n  challengerPubkey: string;\n  /** Prevouts for all inputs [{script_pubkey, value}] from VP */\n  prevouts: Array<{ script_pubkey: string; value: number }>;\n  /** Parameters for the Assert Payout/NoPayout connector */\n  connectorParams: AssertPayoutNoPayoutConnectorParams;\n}\n\n/**\n * Build unsigned NoPayout PSBT.\n *\n * The NoPayout transaction is specific to each challenger.\n * Input 0 is the one the depositor signs using the NoPayout taproot script path.\n *\n * @param params - NoPayout parameters\n * @returns Unsigned PSBT hex ready for signing\n */\nexport async function buildNoPayoutPsbt(\n  params: NoPayoutParams,\n): Promise<string> {\n  const noPayoutTxHex = stripHexPrefix(params.noPayoutTxHex);\n  const noPayoutTx = Transaction.fromHex(noPayoutTxHex);\n\n  // Get NoPayout script and control block for this challenger\n  const { noPayoutScript, noPayoutControlBlock } =\n    await getAssertNoPayoutScriptInfo(\n      params.connectorParams,\n      params.challengerPubkey,\n    );\n\n  const scriptBytes = hexToUint8Array(noPayoutScript);\n  const controlBlockBytes = hexToUint8Array(noPayoutControlBlock);\n\n  const psbt = new Psbt();\n  psbt.setVersion(noPayoutTx.version);\n  psbt.setLocktime(noPayoutTx.locktime);\n\n  // Add all inputs - depositor signs input 0 only\n  for (let i = 0; i < noPayoutTx.ins.length; i++) {\n    const input = noPayoutTx.ins[i];\n    const prevout = params.prevouts[i];\n\n    if (!prevout) {\n      throw new Error(`Missing prevout data for input ${i}`);\n    }\n\n    const inputData: Parameters<typeof psbt.addInput>[0] = {\n      hash: input.hash,\n      index: input.index,\n      sequence: input.sequence,\n      witnessUtxo: {\n        script: Buffer.from(hexToUint8Array(stripHexPrefix(prevout.script_pubkey))),\n        value: prevout.value,\n      },\n    };\n\n    // Input 0: depositor signs using taproot script path\n    if (i === 0) {\n      inputData.tapLeafScript = [\n        {\n          leafVersion: 0xc0,\n          script: Buffer.from(scriptBytes),\n          controlBlock: Buffer.from(controlBlockBytes),\n        },\n      ];\n      inputData.tapInternalKey = Buffer.from(tapInternalPubkey);\n    }\n\n    psbt.addInput(inputData);\n  }\n\n  // Add outputs\n  for (const output of noPayoutTx.outs) {\n    psbt.addOutput({\n      script: output.script,\n      value: output.value,\n    });\n  }\n\n  return psbt.toHex();\n}\n","/**\n * ChallengeAssert PSBT Builder\n *\n * Builds an unsigned PSBT for a ChallengeAssert transaction\n * (depositor-as-claimer path, per challenger). The ChallengeAssert tx has\n * NUM_UTXOS_FOR_CHALLENGE_ASSERT (3) inputs, each spending a different Assert\n * output segment. The depositor signs ALL inputs, each with its own taproot\n * script derived from the per-segment connector params.\n *\n * @module primitives/psbt/challengeAssert\n * @see btc-vault crates/vault/docs/btc-transactions-spec.md — ChallengeAssert connector (NUM_UTXOS_FOR_CHALLENGE_ASSERT=3)\n */\n\nimport {\n  type ChallengeAssertConnectorParams,\n  getChallengeAssertScriptInfo,\n  tapInternalPubkey,\n} from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\nimport { Buffer } from \"buffer\";\nimport { Psbt, Transaction } from \"bitcoinjs-lib\";\n\nimport {\n  hexToUint8Array,\n  stripHexPrefix,\n} from \"../utils/bitcoin\";\n\n/**\n * Parameters for building a ChallengeAssert PSBT\n */\nexport interface ChallengeAssertParams {\n  /** ChallengeAssert transaction hex (unsigned) from VP */\n  challengeAssertTxHex: string;\n  /** Prevouts for all inputs [{script_pubkey, value}] from VP (flat, one per input) */\n  prevouts: Array<{ script_pubkey: string; value: number }>;\n  /** Per-input connector params (one per input/segment, determines the taproot script) */\n  connectorParamsPerInput: ChallengeAssertConnectorParams[];\n}\n\n/**\n * Build unsigned ChallengeAssert PSBT.\n *\n * The ChallengeAssert transaction has 3 inputs (one per Assert output segment).\n * Each input has its own taproot script derived from its connector params.\n * The depositor signs all inputs.\n *\n * @param params - ChallengeAssert parameters\n * @returns Unsigned PSBT hex ready for signing\n */\nexport async function buildChallengeAssertPsbt(\n  params: ChallengeAssertParams,\n): Promise<string> {\n  const challengeAssertTxHex = stripHexPrefix(params.challengeAssertTxHex);\n  const challengeAssertTx = Transaction.fromHex(challengeAssertTxHex);\n\n  if (params.connectorParamsPerInput.length !== challengeAssertTx.ins.length) {\n    throw new Error(\n      `Expected ${challengeAssertTx.ins.length} connector params, got ${params.connectorParamsPerInput.length}`,\n    );\n  }\n\n  // Get script and control block for each input from WASM\n  const scriptInfos = await Promise.all(\n    params.connectorParamsPerInput.map((cp) => getChallengeAssertScriptInfo(cp)),\n  );\n\n  const psbt = new Psbt();\n  psbt.setVersion(challengeAssertTx.version);\n  psbt.setLocktime(challengeAssertTx.locktime);\n\n  // Add all inputs — depositor signs every input\n  for (let i = 0; i < challengeAssertTx.ins.length; i++) {\n    const input = challengeAssertTx.ins[i];\n    const prevout = params.prevouts[i];\n\n    if (!prevout) {\n      throw new Error(`Missing prevout data for input ${i}`);\n    }\n\n    const { script, controlBlock } = scriptInfos[i];\n    const scriptBytes = hexToUint8Array(script);\n    const controlBlockBytes = hexToUint8Array(controlBlock);\n\n    psbt.addInput({\n      hash: input.hash,\n      index: input.index,\n      sequence: input.sequence,\n      witnessUtxo: {\n        script: Buffer.from(hexToUint8Array(stripHexPrefix(prevout.script_pubkey))),\n        value: prevout.value,\n      },\n      tapLeafScript: [\n        {\n          leafVersion: 0xc0,\n          script: Buffer.from(scriptBytes),\n          controlBlock: Buffer.from(controlBlockBytes),\n        },\n      ],\n      tapInternalKey: Buffer.from(tapInternalPubkey),\n    });\n  }\n\n  // Add outputs\n  for (const output of challengeAssertTx.outs) {\n    psbt.addOutput({\n      script: output.script,\n      value: output.value,\n    });\n  }\n\n  return psbt.toHex();\n}\n"],"names":["buildPeginPsbt","params","result","createPegInTransaction","createPayoutScript","connector","createPayoutConnector","stripHexPrefix","hex","hexToUint8Array","cleanHex","isValidHexRaw","bytes","i","uint8ArrayToHex","b","toXOnly","pubKey","processPublicKeyToXOnly","publicKeyHex","pubkeyBytes","isValidHex","validateWalletPubkey","walletPubkeyRaw","expectedDepositorPubkey","walletPubkeyXOnly","depositorPubkey","eccInitialized","ensureEcc","initEccLib","ecc","getNetwork","network","networks","deriveTaprootAddress","xOnly","address","payments","Buffer","deriveNativeSegwitAddress","isAddressFromPublicKey","compressedKeys","key","buildPayoutPsbt","payoutTxHex","peginTxHex","assertTxHex","payoutConnector","payoutScriptBytes","controlBlock","computeControlBlock","tapInternalPubkey","payoutTx","Transaction","peginTx","assertTx","psbt","Psbt","input0","input1","input0Txid","peginTxid","input1Txid","expectedInput1Txid","peginPrevOut","input1PrevOut","output","extractPayoutSignature","signedPsbtHex","inputIndex","signedPsbt","input","depositorPubkeyBytes","sigEntry","extractSchnorrSig","witnessStack","parseWitnessStack","sig","witness","items","offset","readVarInt","first","val","count","len","internalKey","script","scriptTree","outputKey","leafVersion","parity","controlByte","buildDepositorPayoutPsbt","payoutScriptHex","getPeginPayoutScript","scriptBytes","prevout","inputData","buildNoPayoutPsbt","noPayoutTxHex","noPayoutTx","noPayoutScript","noPayoutControlBlock","getAssertNoPayoutScriptInfo","controlBlockBytes","buildChallengeAssertPsbt","challengeAssertTxHex","challengeAssertTx","scriptInfos","cp","getChallengeAssertScriptInfo"],"mappings":"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"}

package/dist/index.cjs

@@ -1,2 +1,2 @@
-"use strict";
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./MockEthereumWallet-CKQlH2AM.cjs"),t=require("./challengeAssert-34HqeVFH.cjs"),e=require("./PayoutManager-Dg_i_S7w.cjs");exports.MockBitcoinWallet=r.MockBitcoinWallet;exports.MockEthereumWallet=r.MockEthereumWallet;exports.buildChallengeAssertPsbt=t.buildChallengeAssertPsbt;exports.buildDepositorPayoutPsbt=t.buildDepositorPayoutPsbt;exports.buildNoPayoutPsbt=t.buildNoPayoutPsbt;exports.buildPayoutPsbt=t.buildPayoutPsbt;exports.buildPeginPsbt=t.buildPeginPsbt;exports.createPayoutScript=t.createPayoutScript;exports.deriveNativeSegwitAddress=t.deriveNativeSegwitAddress;exports.deriveTaprootAddress=t.deriveTaprootAddress;exports.extractPayoutSignature=t.extractPayoutSignature;exports.getNetwork=t.getNetwork;exports.hexToUint8Array=t.hexToUint8Array;exports.isAddressFromPublicKey=t.isAddressFromPublicKey;exports.isValidHex=t.isValidHex;exports.processPublicKeyToXOnly=t.processPublicKeyToXOnly;exports.stripHexPrefix=t.stripHexPrefix;exports.toXOnly=t.toXOnly;exports.uint8ArrayToHex=t.uint8ArrayToHex;exports.validateWalletPubkey=t.validateWalletPubkey;exports.BTCVaultsManagerABI=e.BTCVaultsManagerABI;exports.BTC_DUST_SAT=e.BTC_DUST_SAT;exports.BitcoinScriptType=e.BitcoinScriptType;exports.CONTRACT_ERRORS=e.CONTRACT_ERRORS;exports.DUST_THRESHOLD=e.DUST_THRESHOLD;exports.FEE_SAFETY_MARGIN=e.FEE_SAFETY_MARGIN;exports.LOW_RATE_ESTIMATION_ACCURACY_BUFFER=e.LOW_RATE_ESTIMATION_ACCURACY_BUFFER;exports.MAX_NON_LEGACY_OUTPUT_SIZE=e.MAX_NON_LEGACY_OUTPUT_SIZE;exports.MEMPOOL_API_URLS=e.MEMPOOL_API_URLS;exports.P2TR_INPUT_SIZE=e.P2TR_INPUT_SIZE;exports.PayoutManager=e.PayoutManager;exports.PeginManager=e.PeginManager;exports.TX_BUFFER_SIZE_OVERHEAD=e.TX_BUFFER_SIZE_OVERHEAD;exports.WALLET_RELAY_FEE_RATE_THRESHOLD=e.WALLET_RELAY_FEE_RATE_THRESHOLD;exports.calculateBtcTxHash=e.calculateBtcTxHash;exports.createSplitTransaction=e.createSplitTransaction;exports.createSplitTransactionPsbt=e.createSplitTransactionPsbt;exports.extractErrorData=e.extractErrorData;exports.fundPeginTransaction=e.fundPeginTransaction;exports.getAddressTxs=e.getAddressTxs;exports.getAddressUtxos=e.getAddressUtxos;exports.getContractErrorMessage=e.getContractErrorMessage;exports.getDustThreshold=e.getDustThreshold;exports.getMempoolApiUrl=e.getMempoolApiUrl;exports.getNetworkFees=e.getNetworkFees;exports.getPsbtInputFields=e.getPsbtInputFields;exports.getScriptType=e.getScriptType;exports.getTxHex=e.getTxHex;exports.getTxInfo=e.getTxInfo;exports.getUtxoInfo=e.getUtxoInfo;exports.handleContractError=e.handleContractError;exports.isKnownContractError=e.isKnownContractError;exports.parseUnfundedWasmTransaction=e.parseUnfundedWasmTransaction;exports.pushTx=e.pushTx;exports.rateBasedTxBufferFee=e.rateBasedTxBufferFee;exports.selectUtxosForPegin=e.selectUtxosForPegin;exports.shouldAddChangeOutput=e.shouldAddChangeOutput;
 //# sourceMappingURL=index.cjs.map

package/dist/index.js

@@ -1,2 +1,63 @@
-
+import { M as e, a as t } from "./MockEthereumWallet-ibdry7pZ.js";
+import { f as o, c as i, d as T, a as n, b as l, g as d, h as u, i as c, e as E, m as A, j as P, k as g, l as _, p, s as x, t as S, u as b, v as y } from "./challengeAssert-DVErOd8l.js";
+import { x as U, B as C, e as M, C as O, D as F, F as f, L as h, M as I, v as B, P as H, k as L, j as N, T as m, W as D, c as k, b as W, d as v, y as w, f as X, l as Y, m as K, z as V, g as Z, n as j, o as G, i as q, h as z, q as J, t as Q, u as $, E as aa, A as sa, p as ea, w as ta, r as ra, s as oa, a as ia } from "./PayoutManager-rMj54HDh.js";
+export {
+  U as BTCVaultsManagerABI,
+  C as BTC_DUST_SAT,
+  M as BitcoinScriptType,
+  O as CONTRACT_ERRORS,
+  F as DUST_THRESHOLD,
+  f as FEE_SAFETY_MARGIN,
+  h as LOW_RATE_ESTIMATION_ACCURACY_BUFFER,
+  I as MAX_NON_LEGACY_OUTPUT_SIZE,
+  B as MEMPOOL_API_URLS,
+  e as MockBitcoinWallet,
+  t as MockEthereumWallet,
+  H as P2TR_INPUT_SIZE,
+  L as PayoutManager,
+  N as PeginManager,
+  m as TX_BUFFER_SIZE_OVERHEAD,
+  D as WALLET_RELAY_FEE_RATE_THRESHOLD,
+  o as buildChallengeAssertPsbt,
+  i as buildDepositorPayoutPsbt,
+  T as buildNoPayoutPsbt,
+  n as buildPayoutPsbt,
+  l as buildPeginPsbt,
+  k as calculateBtcTxHash,
+  d as createPayoutScript,
+  W as createSplitTransaction,
+  v as createSplitTransactionPsbt,
+  u as deriveNativeSegwitAddress,
+  c as deriveTaprootAddress,
+  w as extractErrorData,
+  E as extractPayoutSignature,
+  X as fundPeginTransaction,
+  Y as getAddressTxs,
+  K as getAddressUtxos,
+  V as getContractErrorMessage,
+  Z as getDustThreshold,
+  j as getMempoolApiUrl,
+  A as getNetwork,
+  G as getNetworkFees,
+  q as getPsbtInputFields,
+  z as getScriptType,
+  J as getTxHex,
+  Q as getTxInfo,
+  $ as getUtxoInfo,
+  aa as handleContractError,
+  P as hexToUint8Array,
+  g as isAddressFromPublicKey,
+  sa as isKnownContractError,
+  _ as isValidHex,
+  ea as parseUnfundedWasmTransaction,
+  p as processPublicKeyToXOnly,
+  ta as pushTx,
+  ra as rateBasedTxBufferFee,
+  oa as selectUtxosForPegin,
+  ia as shouldAddChangeOutput,
+  x as stripHexPrefix,
+  S as toXOnly,
+  b as uint8ArrayToHex,
+  y as validateWalletPubkey
+};
 //# sourceMappingURL=index.js.map

package/dist/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/shared/index.cjs

@@ -1,2 +1,2 @@
-"use strict";
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../MockEthereumWallet-CKQlH2AM.cjs");exports.MockBitcoinWallet=e.MockBitcoinWallet;exports.MockEthereumWallet=e.MockEthereumWallet;
 //# sourceMappingURL=index.cjs.map

package/dist/shared/index.d.ts

@@ -1,2 +1,4 @@
-export {};
+export type { BitcoinNetwork, BitcoinWallet, Hash, SignPsbtOptions, } from './wallets';
+export { MockBitcoinWallet, MockEthereumWallet } from './wallets';
+export type { MockBitcoinWalletConfig, MockEthereumWalletConfig, } from './wallets';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAIA,YAAY,EACV,cAAc,EACd,aAAa,EACb,IAAI,EACJ,eAAe,GAChB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAElE,YAAY,EACV,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,WAAW,CAAC"}

package/dist/shared/index.js

@@ -1,2 +1,6 @@
-
+import { M as o, a as t } from "../MockEthereumWallet-ibdry7pZ.js";
+export {
+  o as MockBitcoinWallet,
+  t as MockEthereumWallet
+};
 //# sourceMappingURL=index.js.map

package/dist/shared/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/shared/wallets/__tests__/BitcoinWallet.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BitcoinWallet.test.d.ts.map