@babylonlabs-io/ts-sdk 0.19.0 → 0.20.1

package/dist/buildAndBroadcastRefund-DnTQkCgG.js

@@ -0,0 +1,1331 @@
+var ke = Object.defineProperty;
+var Be = (e, t, r) => t in e ? ke(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var f = (e, t, r) => Be(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as He, c as _e, a as Ie, R as Ce, d as be, D as O } from "./types-DWjaqVfP.js";
+import { v as ne, b as Le, s as g, e as $e, p as J, f as L } from "./bitcoin-nOOgeRyl.js";
+import * as Re from "bitcoinjs-lib";
+import { Transaction as Oe, Psbt as ee } from "bitcoinjs-lib";
+import { Buffer as xe } from "buffer";
+import { c as M } from "./signing-DeWVBl7m.js";
+import "@babylonlabs-io/babylon-tbv-rust-wasm";
+import { a as se, e as G, b as Ne } from "./payout-DzGsAnhf.js";
+class Ue {
+  /**
+   * Creates a new PayoutManager instance.
+   *
+   * @param config - Manager configuration including wallet
+   */
+  constructor(t) {
+    f(this, "config");
+    this.config = t;
+  }
+  /**
+   * Signs a Payout transaction and extracts the Schnorr signature.
+   *
+   * Flow:
+   * 1. Vault provider submits Claim transaction
+   * 2. Claimer submits Assert transaction to prove validity
+   * 3. Payout can be executed (references Assert tx)
+   *
+   * This method orchestrates the following steps:
+   * 1. Get wallet's public key and convert to x-only format
+   * 2. Validate wallet pubkey matches on-chain depositor pubkey (if provided)
+   * 3. Build unsigned PSBT using primitives
+   * 4. Sign PSBT via btcWallet.signPsbt()
+   * 5. Extract 64-byte Schnorr signature using primitives
+   *
+   * The returned signature can be submitted to the vault provider API.
+   *
+   * @param params - Payout signing parameters
+   * @returns Signature result with 64-byte Schnorr signature and depositor pubkey
+   * @throws Error if wallet pubkey doesn't match depositor pubkey
+   * @throws Error if wallet operations fail or signature extraction fails
+   */
+  async signPayoutTransaction(t) {
+    this.validatePayoutOutputs(
+      t.payoutTxHex,
+      t.registeredPayoutScriptPubKey
+    );
+    const r = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: n } = ne(
+      r,
+      t.depositorBtcPubkey
+    ), s = await se({
+      payoutTxHex: t.payoutTxHex,
+      peginTxHex: t.peginTxHex,
+      assertTxHex: t.assertTxHex,
+      depositorBtcPubkey: n,
+      vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
+      vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys,
+      universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
+      timelockPegin: t.timelockPegin,
+      network: this.config.network
+    }), c = await this.config.btcWallet.signPsbt(
+      s.psbtHex,
+      M(r, 1)
+    );
+    return {
+      signature: G(c, n),
+      depositorBtcPubkey: n
+    };
+  }
+  /**
+   * Gets the configured Bitcoin network.
+   *
+   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
+   */
+  getNetwork() {
+    return this.config.network;
+  }
+  /**
+   * Checks if the wallet supports batch signing (signPsbts).
+   *
+   * @returns true if batch signing is supported
+   */
+  supportsBatchSigning() {
+    return typeof this.config.btcWallet.signPsbts == "function";
+  }
+  /**
+   * Batch signs multiple payout transactions (1 per claimer).
+   * This allows signing all transactions with a single wallet interaction.
+   *
+   * @param transactions - Array of payout params to sign
+   * @returns Array of signature results matching input order
+   * @throws Error if wallet doesn't support batch signing
+   * @throws Error if any signing operation fails
+   */
+  async signPayoutTransactionsBatch(t) {
+    if (!this.supportsBatchSigning())
+      throw new Error(
+        "Wallet does not support batch signing (signPsbts method not available)"
+      );
+    const r = await this.config.btcWallet.getPublicKeyHex(), n = [], s = [], c = [];
+    for (const o of t) {
+      this.validatePayoutOutputs(
+        o.payoutTxHex,
+        o.registeredPayoutScriptPubKey
+      );
+      const { depositorPubkey: u } = ne(
+        r,
+        o.depositorBtcPubkey
+      );
+      c.push(u);
+      const h = await se({
+        payoutTxHex: o.payoutTxHex,
+        peginTxHex: o.peginTxHex,
+        assertTxHex: o.assertTxHex,
+        depositorBtcPubkey: u,
+        vaultProviderBtcPubkey: o.vaultProviderBtcPubkey,
+        vaultKeeperBtcPubkeys: o.vaultKeeperBtcPubkeys,
+        universalChallengerBtcPubkeys: o.universalChallengerBtcPubkeys,
+        timelockPegin: o.timelockPegin,
+        network: this.config.network
+      });
+      n.push(h.psbtHex), s.push(M(r, 1));
+    }
+    const a = await this.config.btcWallet.signPsbts(
+      n,
+      s
+    );
+    if (a.length !== t.length)
+      throw new Error(
+        `Expected ${t.length} signed PSBTs but received ${a.length}`
+      );
+    const i = [];
+    for (let o = 0; o < t.length; o++) {
+      const u = c[o], h = G(
+        a[o],
+        u
+      );
+      i.push({
+        payoutSignature: h,
+        depositorBtcPubkey: u
+      });
+    }
+    return i;
+  }
+  /**
+   * Validates that the payout transaction's largest output pays to the
+   * registered depositor payout address (scriptPubKey).
+   *
+   * This prevents two attack vectors from a malicious vault provider:
+   * 1. Substituting a completely different payout address
+   * 2. Including a dust output to the correct address while routing
+   *    the actual funds to an attacker-controlled address
+   *
+   * @param payoutTxHex - Raw payout transaction hex
+   * @param registeredPayoutScriptPubKey - On-chain registered scriptPubKey (hex, with or without 0x prefix)
+   * @throws Error if scriptPubKey is invalid hex
+   * @throws Error if the largest output does not pay to the registered address
+   */
+  validatePayoutOutputs(t, r) {
+    if (!Le(r))
+      throw new Error(
+        "Invalid registeredPayoutScriptPubKey: not valid hex"
+      );
+    const n = xe.from(
+      g(r),
+      "hex"
+    ), s = Oe.fromHex(g(t));
+    if (s.outs.length === 0)
+      throw new Error("Payout transaction has no outputs");
+    if (!s.outs.reduce(
+      (a, i) => i.value > a.value ? i : a
+    ).script.equals(n))
+      throw new Error(
+        "Payout transaction does not pay to the registered depositor payout address"
+      );
+  }
+}
+function De(e) {
+  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function oe(e, t = "") {
+  if (!Number.isSafeInteger(e) || e < 0) {
+    const r = t && `"${t}" `;
+    throw new Error(`${r}expected integer >= 0, got ${e}`);
+  }
+}
+function te(e, t, r = "") {
+  const n = De(e), s = e == null ? void 0 : e.length, c = t !== void 0;
+  if (!n || c && s !== t) {
+    const a = r && `"${r}" `, i = c ? ` of length ${t}` : "", o = n ? `length=${s}` : `type=${typeof e}`;
+    throw new Error(a + "expected Uint8Array" + i + ", got " + o);
+  }
+  return e;
+}
+function nr(e) {
+  if (typeof e != "function" || typeof e.create != "function")
+    throw new Error("Hash must wrapped by utils.createHasher");
+  oe(e.outputLen), oe(e.blockLen);
+}
+function ie(e, t = !0) {
+  if (e.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (t && e.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function Ve(e, t) {
+  te(e, void 0, "digestInto() output");
+  const r = t.outputLen;
+  if (e.length < r)
+    throw new Error('"digestInto() output" expected to be of length >=' + r);
+}
+function sr(e) {
+  return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
+}
+function N(...e) {
+  for (let t = 0; t < e.length; t++)
+    e[t].fill(0);
+}
+function Y(e) {
+  return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function m(e, t) {
+  return e << 32 - t | e >>> t;
+}
+function or(e, t) {
+  return e << t | e >>> 32 - t >>> 0;
+}
+const Fe = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function Ke(e) {
+  return e << 24 & 4278190080 | e << 8 & 16711680 | e >>> 8 & 65280 | e >>> 24 & 255;
+}
+function Me(e) {
+  for (let t = 0; t < e.length; t++)
+    e[t] = Ke(e[t]);
+  return e;
+}
+const ir = Fe ? (e) => e : Me;
+function Ge(e) {
+  if (typeof e != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(e));
+}
+function ar(e, t = "") {
+  return typeof e == "string" ? Ge(e) : te(e, void 0, t);
+}
+function cr(e, t) {
+  if (t !== void 0 && {}.toString.call(t) !== "[object Object]")
+    throw new Error("options must be object or undefined");
+  return Object.assign(e, t);
+}
+function pe(e, t = {}) {
+  const r = (s, c) => e(c).update(s).digest(), n = e(void 0);
+  return r.outputLen = n.outputLen, r.blockLen = n.blockLen, r.create = (s) => e(s), Object.assign(r, t), Object.freeze(r);
+}
+const ge = (e) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, e])
+});
+function We(e, t, r) {
+  return e & t ^ ~e & r;
+}
+function ze(e, t, r) {
+  return e & t ^ e & r ^ t & r;
+}
+class ye {
+  constructor(t, r, n, s) {
+    f(this, "blockLen");
+    f(this, "outputLen");
+    f(this, "padOffset");
+    f(this, "isLE");
+    // For partial updates less than block size
+    f(this, "buffer");
+    f(this, "view");
+    f(this, "finished", !1);
+    f(this, "length", 0);
+    f(this, "pos", 0);
+    f(this, "destroyed", !1);
+    this.blockLen = t, this.outputLen = r, this.padOffset = n, this.isLE = s, this.buffer = new Uint8Array(t), this.view = Y(this.buffer);
+  }
+  update(t) {
+    ie(this), te(t);
+    const { view: r, buffer: n, blockLen: s } = this, c = t.length;
+    for (let a = 0; a < c; ) {
+      const i = Math.min(s - this.pos, c - a);
+      if (i === s) {
+        const o = Y(t);
+        for (; s <= c - a; a += s)
+          this.process(o, a);
+        continue;
+      }
+      n.set(t.subarray(a, a + i), this.pos), this.pos += i, a += i, this.pos === s && (this.process(r, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    ie(this), Ve(t, this), this.finished = !0;
+    const { buffer: r, view: n, blockLen: s, isLE: c } = this;
+    let { pos: a } = this;
+    r[a++] = 128, N(this.buffer.subarray(a)), this.padOffset > s - a && (this.process(n, 0), a = 0);
+    for (let l = a; l < s; l++)
+      r[l] = 0;
+    n.setBigUint64(s - 8, BigInt(this.length * 8), c), this.process(n, 0);
+    const i = Y(t), o = this.outputLen;
+    if (o % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const u = o / 4, h = this.get();
+    if (u > h.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let l = 0; l < u; l++)
+      i.setUint32(4 * l, h[l], c);
+  }
+  digest() {
+    const { buffer: t, outputLen: r } = this;
+    this.digestInto(t);
+    const n = t.slice(0, r);
+    return this.destroy(), n;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: r, buffer: n, length: s, finished: c, destroyed: a, pos: i } = this;
+    return t.destroyed = a, t.finished = c, t.length = s, t.pos = i, s % r && t.buffer.set(n), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const B = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), w = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]), V = /* @__PURE__ */ BigInt(2 ** 32 - 1), ae = /* @__PURE__ */ BigInt(32);
+function Xe(e, t = !1) {
+  return t ? { h: Number(e & V), l: Number(e >> ae & V) } : { h: Number(e >> ae & V) | 0, l: Number(e & V) | 0 };
+}
+function je(e, t = !1) {
+  const r = e.length;
+  let n = new Uint32Array(r), s = new Uint32Array(r);
+  for (let c = 0; c < r; c++) {
+    const { h: a, l: i } = Xe(e[c], t);
+    [n[c], s[c]] = [a, i];
+  }
+  return [n, s];
+}
+const ce = (e, t, r) => e >>> r, ue = (e, t, r) => e << 32 - r | t >>> r, $ = (e, t, r) => e >>> r | t << 32 - r, R = (e, t, r) => e << 32 - r | t >>> r, F = (e, t, r) => e << 64 - r | t >>> r - 32, K = (e, t, r) => e >>> r - 32 | t << 64 - r, ur = (e, t, r) => e << r | t >>> 32 - r, lr = (e, t, r) => t << r | e >>> 32 - r, fr = (e, t, r) => t << r - 32 | e >>> 64 - r, hr = (e, t, r) => e << r - 32 | t >>> 64 - r;
+function S(e, t, r, n) {
+  const s = (t >>> 0) + (n >>> 0);
+  return { h: e + r + (s / 2 ** 32 | 0) | 0, l: s | 0 };
+}
+const Ye = (e, t, r) => (e >>> 0) + (t >>> 0) + (r >>> 0), qe = (e, t, r, n) => t + r + n + (e / 2 ** 32 | 0) | 0, Qe = (e, t, r, n) => (e >>> 0) + (t >>> 0) + (r >>> 0) + (n >>> 0), Je = (e, t, r, n, s) => t + r + n + s + (e / 2 ** 32 | 0) | 0, Ze = (e, t, r, n, s) => (e >>> 0) + (t >>> 0) + (r >>> 0) + (n >>> 0) + (s >>> 0), et = (e, t, r, n, s, c) => t + r + n + s + c + (e / 2 ** 32 | 0) | 0, tt = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), H = /* @__PURE__ */ new Uint32Array(64);
+class rt extends ye {
+  constructor(t) {
+    super(64, t, 8, !1);
+  }
+  get() {
+    const { A: t, B: r, C: n, D: s, E: c, F: a, G: i, H: o } = this;
+    return [t, r, n, s, c, a, i, o];
+  }
+  // prettier-ignore
+  set(t, r, n, s, c, a, i, o) {
+    this.A = t | 0, this.B = r | 0, this.C = n | 0, this.D = s | 0, this.E = c | 0, this.F = a | 0, this.G = i | 0, this.H = o | 0;
+  }
+  process(t, r) {
+    for (let l = 0; l < 16; l++, r += 4)
+      H[l] = t.getUint32(r, !1);
+    for (let l = 16; l < 64; l++) {
+      const d = H[l - 15], x = H[l - 2], y = m(d, 7) ^ m(d, 18) ^ d >>> 3, p = m(x, 17) ^ m(x, 19) ^ x >>> 10;
+      H[l] = p + H[l - 7] + y + H[l - 16] | 0;
+    }
+    let { A: n, B: s, C: c, D: a, E: i, F: o, G: u, H: h } = this;
+    for (let l = 0; l < 64; l++) {
+      const d = m(i, 6) ^ m(i, 11) ^ m(i, 25), x = h + d + We(i, o, u) + tt[l] + H[l] | 0, p = (m(n, 2) ^ m(n, 13) ^ m(n, 22)) + ze(n, s, c) | 0;
+      h = u, u = o, o = i, i = a + x | 0, a = c, c = s, s = n, n = x + p | 0;
+    }
+    n = n + this.A | 0, s = s + this.B | 0, c = c + this.C | 0, a = a + this.D | 0, i = i + this.E | 0, o = o + this.F | 0, u = u + this.G | 0, h = h + this.H | 0, this.set(n, s, c, a, i, o, u, h);
+  }
+  roundClean() {
+    N(H);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), N(this.buffer);
+  }
+}
+class nt extends rt {
+  constructor() {
+    super(32);
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    f(this, "A", B[0] | 0);
+    f(this, "B", B[1] | 0);
+    f(this, "C", B[2] | 0);
+    f(this, "D", B[3] | 0);
+    f(this, "E", B[4] | 0);
+    f(this, "F", B[5] | 0);
+    f(this, "G", B[6] | 0);
+    f(this, "H", B[7] | 0);
+  }
+}
+const we = je([
+  "0x428a2f98d728ae22",
+  "0x7137449123ef65cd",
+  "0xb5c0fbcfec4d3b2f",
+  "0xe9b5dba58189dbbc",
+  "0x3956c25bf348b538",
+  "0x59f111f1b605d019",
+  "0x923f82a4af194f9b",
+  "0xab1c5ed5da6d8118",
+  "0xd807aa98a3030242",
+  "0x12835b0145706fbe",
+  "0x243185be4ee4b28c",
+  "0x550c7dc3d5ffb4e2",
+  "0x72be5d74f27b896f",
+  "0x80deb1fe3b1696b1",
+  "0x9bdc06a725c71235",
+  "0xc19bf174cf692694",
+  "0xe49b69c19ef14ad2",
+  "0xefbe4786384f25e3",
+  "0x0fc19dc68b8cd5b5",
+  "0x240ca1cc77ac9c65",
+  "0x2de92c6f592b0275",
+  "0x4a7484aa6ea6e483",
+  "0x5cb0a9dcbd41fbd4",
+  "0x76f988da831153b5",
+  "0x983e5152ee66dfab",
+  "0xa831c66d2db43210",
+  "0xb00327c898fb213f",
+  "0xbf597fc7beef0ee4",
+  "0xc6e00bf33da88fc2",
+  "0xd5a79147930aa725",
+  "0x06ca6351e003826f",
+  "0x142929670a0e6e70",
+  "0x27b70a8546d22ffc",
+  "0x2e1b21385c26c926",
+  "0x4d2c6dfc5ac42aed",
+  "0x53380d139d95b3df",
+  "0x650a73548baf63de",
+  "0x766a0abb3c77b2a8",
+  "0x81c2c92e47edaee6",
+  "0x92722c851482353b",
+  "0xa2bfe8a14cf10364",
+  "0xa81a664bbc423001",
+  "0xc24b8b70d0f89791",
+  "0xc76c51a30654be30",
+  "0xd192e819d6ef5218",
+  "0xd69906245565a910",
+  "0xf40e35855771202a",
+  "0x106aa07032bbd1b8",
+  "0x19a4c116b8d2d0c8",
+  "0x1e376c085141ab53",
+  "0x2748774cdf8eeb99",
+  "0x34b0bcb5e19b48a8",
+  "0x391c0cb3c5c95a63",
+  "0x4ed8aa4ae3418acb",
+  "0x5b9cca4f7763e373",
+  "0x682e6ff3d6b2b8a3",
+  "0x748f82ee5defb2fc",
+  "0x78a5636f43172f60",
+  "0x84c87814a1f0ab72",
+  "0x8cc702081a6439ec",
+  "0x90befffa23631e28",
+  "0xa4506cebde82bde9",
+  "0xbef9a3f7b2c67915",
+  "0xc67178f2e372532b",
+  "0xca273eceea26619c",
+  "0xd186b8c721c0c207",
+  "0xeada7dd6cde0eb1e",
+  "0xf57d4f7fee6ed178",
+  "0x06f067aa72176fba",
+  "0x0a637dc5a2c898a6",
+  "0x113f9804bef90dae",
+  "0x1b710b35131c471b",
+  "0x28db77f523047d84",
+  "0x32caab7b40c72493",
+  "0x3c9ebe0a15c9bebc",
+  "0x431d67c49c100d4c",
+  "0x4cc5d4becb3e42b6",
+  "0x597f299cfc657e2a",
+  "0x5fcb6fab3ad6faec",
+  "0x6c44198c4a475817"
+].map((e) => BigInt(e))), st = we[0], ot = we[1], _ = /* @__PURE__ */ new Uint32Array(80), I = /* @__PURE__ */ new Uint32Array(80);
+class it extends ye {
+  constructor(t) {
+    super(128, t, 16, !1);
+  }
+  // prettier-ignore
+  get() {
+    const { Ah: t, Al: r, Bh: n, Bl: s, Ch: c, Cl: a, Dh: i, Dl: o, Eh: u, El: h, Fh: l, Fl: d, Gh: x, Gl: y, Hh: p, Hl: P } = this;
+    return [t, r, n, s, c, a, i, o, u, h, l, d, x, y, p, P];
+  }
+  // prettier-ignore
+  set(t, r, n, s, c, a, i, o, u, h, l, d, x, y, p, P) {
+    this.Ah = t | 0, this.Al = r | 0, this.Bh = n | 0, this.Bl = s | 0, this.Ch = c | 0, this.Cl = a | 0, this.Dh = i | 0, this.Dl = o | 0, this.Eh = u | 0, this.El = h | 0, this.Fh = l | 0, this.Fl = d | 0, this.Gh = x | 0, this.Gl = y | 0, this.Hh = p | 0, this.Hl = P | 0;
+  }
+  process(t, r) {
+    for (let b = 0; b < 16; b++, r += 4)
+      _[b] = t.getUint32(r), I[b] = t.getUint32(r += 4);
+    for (let b = 16; b < 80; b++) {
+      const v = _[b - 15] | 0, k = I[b - 15] | 0, W = $(v, k, 1) ^ $(v, k, 8) ^ ce(v, k, 7), z = R(v, k, 1) ^ R(v, k, 8) ^ ue(v, k, 7), E = _[b - 2] | 0, T = I[b - 2] | 0, U = $(E, T, 19) ^ F(E, T, 61) ^ ce(E, T, 6), X = R(E, T, 19) ^ K(E, T, 61) ^ ue(E, T, 6), D = Qe(z, X, I[b - 7], I[b - 16]), j = Je(D, W, U, _[b - 7], _[b - 16]);
+      _[b] = j | 0, I[b] = D | 0;
+    }
+    let { Ah: n, Al: s, Bh: c, Bl: a, Ch: i, Cl: o, Dh: u, Dl: h, Eh: l, El: d, Fh: x, Fl: y, Gh: p, Gl: P, Hh: A, Hl: C } = this;
+    for (let b = 0; b < 80; b++) {
+      const v = $(l, d, 14) ^ $(l, d, 18) ^ F(l, d, 41), k = R(l, d, 14) ^ R(l, d, 18) ^ K(l, d, 41), W = l & x ^ ~l & p, z = d & y ^ ~d & P, E = Ze(C, k, z, ot[b], I[b]), T = et(E, A, v, W, st[b], _[b]), U = E | 0, X = $(n, s, 28) ^ F(n, s, 34) ^ F(n, s, 39), D = R(n, s, 28) ^ K(n, s, 34) ^ K(n, s, 39), j = n & c ^ n & i ^ c & i, ve = s & a ^ s & o ^ a & o;
+      A = p | 0, C = P | 0, p = x | 0, P = y | 0, x = l | 0, y = d | 0, { h: l, l: d } = S(u | 0, h | 0, T | 0, U | 0), u = i | 0, h = o | 0, i = c | 0, o = a | 0, c = n | 0, a = s | 0;
+      const re = Ye(U, D, ve);
+      n = qe(re, T, X, j), s = re | 0;
+    }
+    ({ h: n, l: s } = S(this.Ah | 0, this.Al | 0, n | 0, s | 0)), { h: c, l: a } = S(this.Bh | 0, this.Bl | 0, c | 0, a | 0), { h: i, l: o } = S(this.Ch | 0, this.Cl | 0, i | 0, o | 0), { h: u, l: h } = S(this.Dh | 0, this.Dl | 0, u | 0, h | 0), { h: l, l: d } = S(this.Eh | 0, this.El | 0, l | 0, d | 0), { h: x, l: y } = S(this.Fh | 0, this.Fl | 0, x | 0, y | 0), { h: p, l: P } = S(this.Gh | 0, this.Gl | 0, p | 0, P | 0), { h: A, l: C } = S(this.Hh | 0, this.Hl | 0, A | 0, C | 0), this.set(n, s, c, a, i, o, u, h, l, d, x, y, p, P, A, C);
+  }
+  roundClean() {
+    N(_, I);
+  }
+  destroy() {
+    N(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+class at extends it {
+  constructor() {
+    super(64);
+    f(this, "Ah", w[0] | 0);
+    f(this, "Al", w[1] | 0);
+    f(this, "Bh", w[2] | 0);
+    f(this, "Bl", w[3] | 0);
+    f(this, "Ch", w[4] | 0);
+    f(this, "Cl", w[5] | 0);
+    f(this, "Dh", w[6] | 0);
+    f(this, "Dl", w[7] | 0);
+    f(this, "Eh", w[8] | 0);
+    f(this, "El", w[9] | 0);
+    f(this, "Fh", w[10] | 0);
+    f(this, "Fl", w[11] | 0);
+    f(this, "Gh", w[12] | 0);
+    f(this, "Gl", w[13] | 0);
+    f(this, "Hh", w[14] | 0);
+    f(this, "Hl", w[15] | 0);
+  }
+}
+const ct = /* @__PURE__ */ pe(
+  () => new nt(),
+  /* @__PURE__ */ ge(1)
+), dr = /* @__PURE__ */ pe(
+  () => new at(),
+  /* @__PURE__ */ ge(3)
+), le = 66;
+function Pe(e) {
+  if (!e.startsWith("0x") && !e.startsWith("0X"))
+    throw new Error("Expected 0x-prefixed hex string");
+  const t = e.slice(2);
+  if (t.length % 2 !== 0)
+    throw new Error(`Hex string has odd length: ${t.length}`);
+  if (!/^[0-9a-fA-F]*$/.test(t))
+    throw new Error("Hex string contains non-hex characters");
+  const r = new Uint8Array(t.length / 2);
+  for (let n = 0; n < r.length; n++)
+    r[n] = parseInt(t.slice(n * 2, n * 2 + 2), 16);
+  return r;
+}
+function ut(e) {
+  return `0x${Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("")}`;
+}
+function Z(e, t) {
+  if (e.length !== le)
+    throw new Error(
+      `${t} must be exactly 32 bytes (${le} hex chars with 0x prefix), got ${e.length}`
+    );
+}
+function lt(e) {
+  Z(e, "Secret");
+  const t = Pe(e), r = ct(t);
+  return ut(r);
+}
+function ft(e, t) {
+  return Z(e, "Secret"), Z(t, "Hashlock"), Pe(t), lt(e).toLowerCase() === t.toLowerCase();
+}
+const ht = /^0x[0-9a-fA-F]{64}$/, dt = /^0x[0-9a-fA-F]{40}$/, bt = /^0x([0-9a-fA-F]{2})*$/;
+function q(e, t) {
+  if (e.length !== 66)
+    throw new Error(
+      `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
+    );
+  if (!ht.test(e))
+    throw new Error(
+      `${t} must contain only hex characters after the 0x prefix`
+    );
+}
+function xt(e, t) {
+  if (!dt.test(e))
+    throw new Error(
+      `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
+    );
+}
+function pt(e, t) {
+  if (!bt.test(e))
+    throw new Error(
+      `${t} must be a 0x-prefixed hex string with an even number of hex chars`
+    );
+}
+async function br(e) {
+  const {
+    btcVaultRegistryAddress: t,
+    vaultId: r,
+    hashlock: n,
+    activationMetadata: s,
+    writeContract: c,
+    signal: a
+  } = e;
+  a == null || a.throwIfAborted(), xt(t, "btcVaultRegistryAddress"), q(r, "vaultId");
+  const i = $e(e.secret);
+  if (q(i, "secret"), n !== void 0 && (q(n, "hashlock"), !ft(i, n)))
+    throw new Error(
+      "Invalid secret: SHA256(secret) does not match the provided hashlock"
+    );
+  return pt(s, "activationMetadata"), c({
+    address: t,
+    abi: He,
+    functionName: "activateVaultWithSecret",
+    args: [r, i, s]
+  });
+}
+const gt = 1e4;
+async function me(e) {
+  const {
+    statusReader: t,
+    peginTxid: r,
+    targetStatuses: n,
+    timeoutMs: s,
+    pollIntervalMs: c = gt,
+    signal: a
+  } = e, i = Date.now();
+  for (; ; ) {
+    if (a != null && a.aborted)
+      throw new Error(
+        `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+      );
+    if (Date.now() - i >= s)
+      throw new Error(
+        `Polling timeout after ${s}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+      );
+    try {
+      const u = (await t.getPeginStatus(
+        { pegin_txid: r },
+        a
+      )).status;
+      if (n.has(u))
+        return u;
+      if (_e.has(u) && !n.has(u))
+        throw new Error(
+          `Pegin ${r.slice(0, 8)}… reached terminal status "${u}" while waiting for ${[...n].join(", ")}`
+        );
+    } catch (o) {
+      if (!(o instanceof Ie && o.code === Ce.NOT_FOUND || o instanceof Error && o.message.includes("PegIn not found")))
+        throw o;
+    }
+    await new Promise((o, u) => {
+      const h = () => {
+        clearTimeout(l), u(
+          new Error(
+            `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+          )
+        );
+      }, l = setTimeout(() => {
+        a == null || a.removeEventListener("abort", h), o();
+      }, c);
+      a == null || a.addEventListener("abort", h, { once: !0 });
+    });
+  }
+}
+const yt = 300 * 1e3, wt = /* @__PURE__ */ new Set([
+  O.PENDING_DEPOSITOR_WOTS_PK,
+  ...be
+]);
+async function xr(e) {
+  const {
+    statusReader: t,
+    wotsSubmitter: r,
+    peginTxid: n,
+    depositorPk: s,
+    wotsPublicKeys: c,
+    timeoutMs: a = yt,
+    signal: i
+  } = e;
+  i == null || i.throwIfAborted();
+  const o = await me({
+    statusReader: t,
+    peginTxid: n,
+    targetStatuses: wt,
+    timeoutMs: a,
+    signal: i
+  });
+  be.has(o) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
+    {
+      pegin_txid: n,
+      depositor_pk: s,
+      wots_public_keys: c
+    },
+    i
+  ));
+}
+const Pt = 1;
+function mt(e, t, r) {
+  const n = ee.fromBase64(e), s = n.data.getTransaction().toString("hex").toLowerCase(), c = g(t).toLowerCase();
+  if (s !== c)
+    throw new Error(
+      `PSBT integrity check failed for ${r}: unsigned transaction does not match tx_hex`
+    );
+  return n;
+}
+function Et(e) {
+  const t = ee.fromHex(e.toHex());
+  for (const r of t.data.inputs)
+    delete r.tapBip32Derivation, delete r.tapMerkleRoot;
+  return t;
+}
+function fe(e, t, r) {
+  if (!e)
+    throw new Error(`Missing ${r} PSBT`);
+  const n = mt(e, t, r);
+  return Et(n).toHex();
+}
+function Tt(e, t) {
+  const r = [], n = [], s = [], c = M(
+    t,
+    Pt
+  ), a = fe(
+    e.payout_psbt,
+    e.payout_tx.tx_hex,
+    "depositor payout"
+  );
+  r.push(a), n.push(c);
+  for (const i of e.challenger_presign_data) {
+    const o = g(i.challenger_pubkey), u = r.length, h = fe(
+      i.nopayout_psbt,
+      i.nopayout_tx.tx_hex,
+      `nopayout (challenger ${o})`
+    );
+    r.push(h), n.push(c), s.push({
+      challengerPubkey: o,
+      noPayoutIdx: u
+    });
+  }
+  return { psbtHexes: r, signOptions: n, challengerEntries: s };
+}
+function St(e, t, r) {
+  const n = G(
+    e[0],
+    r
+  ), s = {};
+  for (const c of t)
+    s[c.challengerPubkey] = {
+      nopayout_signature: G(
+        e[c.noPayoutIdx],
+        r
+      )
+    };
+  return {
+    payout_signatures: {
+      payout_signature: n
+    },
+    per_challenger: s
+  };
+}
+async function At(e, t, r) {
+  if (typeof e.signPsbts == "function")
+    return e.signPsbts(t, r);
+  const n = [];
+  for (let s = 0; s < t.length; s++)
+    n.push(await e.signPsbt(t[s], r == null ? void 0 : r[s]));
+  return n;
+}
+async function vt(e) {
+  const { depositorGraph: t, depositorBtcPubkey: r, btcWallet: n } = e, s = g(r), c = await n.getPublicKeyHex(), { psbtHexes: a, signOptions: i, challengerEntries: o } = Tt(t, c), u = await At(
+    n,
+    a,
+    i
+  );
+  if (u.length !== a.length)
+    throw new Error(
+      `Wallet returned ${u.length} signed PSBTs, expected ${a.length}`
+    );
+  return St(
+    u,
+    o,
+    s
+  );
+}
+const kt = 1200 * 1e3, Ee = /* @__PURE__ */ new Set([
+  O.PENDING_ACKS,
+  O.PENDING_ACTIVATION,
+  O.ACTIVATED
+]), Bt = /* @__PURE__ */ new Set([
+  O.PENDING_DEPOSITOR_SIGNATURES,
+  ...Ee
+]);
+function Ht(e) {
+  return e.map((t) => ({
+    claimerPubkeyXOnly: J(t.claimer_pubkey),
+    payoutTxHex: t.payout_tx.tx_hex,
+    assertTxHex: t.assert_tx.tx_hex
+  }));
+}
+function _t(e) {
+  const { output: t } = Re.payments.p2tr({
+    internalPubkey: xe.from(e, "hex")
+  });
+  if (!t)
+    throw new Error("Failed to derive BIP-86 P2TR scriptPubKey");
+  return t.toString("hex");
+}
+function It(e, t) {
+  const r = g(e).toLowerCase(), n = g(
+    t.vaultProviderBtcPubkey
+  ).toLowerCase(), s = g(
+    t.depositorBtcPubkey
+  ).toLowerCase();
+  if (r === n || r === s)
+    return t.registeredPayoutScriptPubKey;
+  if (!t.vaultKeeperBtcPubkeys.some(
+    (i) => g(i).toLowerCase() === r
+  ))
+    throw new Error(
+      `Unknown claimer pubkey ${r}: not VP, depositor, or a registered vault keeper`
+    );
+  return `0x${_t(r)}`;
+}
+function he(e, t) {
+  return {
+    payoutTxHex: e.payoutTxHex,
+    peginTxHex: t.peginTxHex,
+    assertTxHex: e.assertTxHex,
+    vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
+    vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys,
+    universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
+    depositorBtcPubkey: t.depositorBtcPubkey,
+    timelockPegin: t.timelockPegin,
+    registeredPayoutScriptPubKey: It(
+      e.claimerPubkeyXOnly,
+      t
+    )
+  };
+}
+async function Ct(e, t, r, n) {
+  const s = new Ue({
+    network: t.network,
+    btcWallet: e
+  }), c = r.length;
+  n == null || n(0, c);
+  let a;
+  if (s.supportsBatchSigning())
+    a = (await s.signPayoutTransactionsBatch(
+      r.map((u) => he(u, t))
+    )).map((u) => u.payoutSignature);
+  else {
+    a = [];
+    for (let o = 0; o < r.length; o++) {
+      n == null || n(o, c);
+      const u = await s.signPayoutTransaction(
+        he(r[o], t)
+      );
+      a.push(u.signature);
+    }
+  }
+  const i = {};
+  for (let o = 0; o < r.length; o++)
+    i[r[o].claimerPubkeyXOnly] = {
+      payout_signature: a[o]
+    };
+  return n == null || n(c, c), i;
+}
+async function pr(e) {
+  const {
+    statusReader: t,
+    presignClient: r,
+    btcWallet: n,
+    peginTxid: s,
+    depositorPk: c,
+    signingContext: a,
+    timeoutMs: i = kt,
+    signal: o,
+    onProgress: u
+  } = e, h = await me({
+    statusReader: t,
+    peginTxid: s,
+    targetStatuses: Bt,
+    timeoutMs: i,
+    signal: o
+  });
+  if (Ee.has(h))
+    return;
+  o == null || o.throwIfAborted();
+  const l = await r.requestDepositorPresignTransactions(
+    {
+      pegin_txid: s,
+      depositor_pk: c
+    },
+    o
+  );
+  o == null || o.throwIfAborted();
+  const d = J(c), x = l.txs.filter(
+    (C) => J(C.claimer_pubkey) !== d
+  ), y = Ht(x), p = await Ct(
+    n,
+    a,
+    y,
+    u
+  );
+  o == null || o.throwIfAborted();
+  const P = await vt({
+    depositorGraph: l.depositor_graph,
+    depositorBtcPubkey: c,
+    btcWallet: n
+  });
+  o == null || o.throwIfAborted();
+  const A = { ...p };
+  A[g(c)] = P.payout_signatures, await r.submitDepositorPresignatures(
+    {
+      pegin_txid: s,
+      depositor_pk: c,
+      signatures: A,
+      depositor_claimer_presignatures: P
+    },
+    o
+  );
+}
+function Lt(e) {
+  return /^[0-9a-fA-F]{64}$/.test(e);
+}
+function gr(e) {
+  const {
+    amountSats: t,
+    minDeposit: r,
+    maxDeposit: n,
+    btcBalance: s,
+    estimatedFeeSats: c,
+    depositorClaimValue: a
+  } = e;
+  return !(t <= 0n || t < r || n && n > 0n && t > n || c == null || a == null || t + c + a > s);
+}
+function yr(e, t, r) {
+  return e <= 0n ? {
+    valid: !1,
+    error: "Deposit amount must be greater than zero"
+  } : e < t ? {
+    valid: !1,
+    error: `Minimum deposit is ${L(t)} BTC`
+  } : r && r > 0n && e > r ? {
+    valid: !1,
+    error: `Maximum deposit is ${L(r)} BTC`
+  } : { valid: !0 };
+}
+function wr(e) {
+  const { amount: t, effectiveRemaining: r } = e;
+  return r === null ? { valid: !0 } : r === 0n ? {
+    valid: !1,
+    error: "Supply cap reached — deposits temporarily paused"
+  } : t > r ? {
+    valid: !1,
+    error: `Vault size exceeds remaining capacity (${L(r)} BTC)`
+  } : { valid: !0 };
+}
+function Pr(e, t) {
+  if (!e || e.length === 0)
+    return {
+      valid: !1,
+      error: "At least one vault provider must be selected"
+    };
+  const r = t.map(
+    (s) => s.toLowerCase()
+  );
+  return e.filter(
+    (s) => !r.includes(s.toLowerCase())
+  ).length > 0 ? {
+    valid: !1,
+    error: "Invalid vault provider selected"
+  } : { valid: !0 };
+}
+function $t(e, t, r) {
+  if (!e || e.length === 0)
+    return {
+      valid: !1,
+      error: "At least one vault amount required"
+    };
+  for (let n = 0; n < e.length; n++) {
+    const s = e[n];
+    if (s <= 0n)
+      return {
+        valid: !1,
+        error: `Vault ${n + 1} amount must be positive`
+      };
+    if (t && s < t)
+      return {
+        valid: !1,
+        error: `Vault ${n + 1} amount ${L(s)} BTC is below minimum deposit ${L(t)} BTC`
+      };
+    if (r && s > r)
+      return {
+        valid: !1,
+        error: `Vault ${n + 1} amount ${L(s)} BTC exceeds maximum deposit ${L(r)} BTC`
+      };
+  }
+  return { valid: !0 };
+}
+function Rt(e) {
+  const t = g(e);
+  return Lt(t) ? { valid: !0 } : {
+    valid: !1,
+    error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
+  };
+}
+function Ot(e) {
+  if (!e || e.length === 0)
+    throw new Error(
+      "No vault keepers available. The system requires at least one vault keeper to create a deposit."
+    );
+}
+function Nt(e) {
+  if (!e || e.length === 0)
+    throw new Error(
+      "No universal challengers available. The system requires at least one universal challenger to create a deposit."
+    );
+}
+function Ut(e) {
+  if (e.length === 0)
+    throw new Error("No spendable UTXOs available");
+}
+function mr(e) {
+  const {
+    vaultAmounts: t,
+    confirmedUTXOs: r,
+    vaultProviderBtcPubkey: n,
+    vaultKeeperBtcPubkeys: s,
+    universalChallengerBtcPubkeys: c,
+    minDeposit: a,
+    maxDeposit: i,
+    htlcSecretHexesLength: o,
+    depositorSecretHashesLength: u
+  } = e, h = t.length;
+  if (o !== h)
+    throw new Error(
+      `htlcSecretHexes length (${o}) must match vaultAmounts length (${h})`
+    );
+  if (u !== h)
+    throw new Error(
+      `depositorSecretHashes length (${u}) must match vaultAmounts length (${h})`
+    );
+  const l = $t(
+    t,
+    a,
+    i
+  );
+  if (!l.valid)
+    throw new Error(l.error);
+  const d = Rt(n);
+  if (!d.valid)
+    throw new Error(d.error);
+  Ot(s), Nt(c), Ut(r);
+}
+var Te = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.CHALLENGE_ASSERT_OBSERVED = "ChallengeAssertObserved", e.WRONGLY_CHALLENGED_BROADCAST = "WronglyChallengedBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.FAILED = "Failed", e))(Te || {});
+const Dt = /* @__PURE__ */ new Set([
+  "PayoutBroadcast",
+  "Failed"
+  /* FAILED */
+]);
+function Er(e) {
+  return Object.values(Te).includes(
+    e
+  );
+}
+function Tr(e) {
+  return !!e && Dt.has(e);
+}
+class Vt extends Error {
+  constructor(r, n) {
+    super(`Refund not yet mature (BIP68 not final): ${n.message}`);
+    f(this, "vaultId");
+    f(this, "cause");
+    this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = n;
+  }
+}
+const Ft = /^0x[0-9a-fA-F]{64}$/, Kt = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Se = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Mt = 160, Gt = 1, de = 65535, Wt = /non-BIP68-final/i;
+function Ae(e, t) {
+  if (e.length !== 66)
+    throw new Error(
+      `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
+    );
+  if (!Ft.test(e))
+    throw new Error(
+      `${t} must contain only hex characters after the 0x prefix`
+    );
+}
+function Q(e, t) {
+  if (!Number.isInteger(e) || e < 0)
+    throw new Error(`${t} must be a non-negative integer, got ${e}`);
+}
+function zt(e) {
+  if (Ae(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0 || e.htlcVout > de)
+    throw new Error(
+      `htlcVout must be an integer 0-${de}, got ${e.htlcVout}`
+    );
+  if (Q(e.offchainParamsVersion, "offchainParamsVersion"), Q(e.appVaultKeepersVersion, "appVaultKeepersVersion"), Q(
+    e.universalChallengersVersion,
+    "universalChallengersVersion"
+  ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
+    throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
+  if (!Kt.test(e.unsignedPrePeginTxHex))
+    throw new Error(
+      "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
+    );
+  if (!e.depositorBtcPubkey || !Se.test(e.depositorBtcPubkey))
+    throw new Error(
+      "depositorBtcPubkey must be 32 or 33 bytes of hex (optional 0x prefix)"
+    );
+  if (typeof e.amount != "bigint" || e.amount <= 0n)
+    throw new Error(`amount must be a positive bigint, got ${e.amount}`);
+}
+function Xt(e) {
+  if (!e.vaultProviderPubkey || !Se.test(e.vaultProviderPubkey))
+    throw new Error("vaultProviderPubkey must be 32 or 33 bytes of hex");
+  if (e.vaultKeeperPubkeys.length === 0)
+    throw new Error("vaultKeeperPubkeys must be non-empty");
+  if (e.universalChallengerPubkeys.length === 0)
+    throw new Error("universalChallengerPubkeys must be non-empty");
+  if (!Number.isInteger(e.timelockRefund) || e.timelockRefund <= 0)
+    throw new Error(
+      `timelockRefund must be a positive integer, got ${e.timelockRefund}`
+    );
+  if (typeof e.feeRate != "bigint" || e.feeRate <= 0n)
+    throw new Error(
+      `protocol feeRate must be a positive bigint, got ${e.feeRate}`
+    );
+  if (!Number.isInteger(e.numLocalChallengers) || e.numLocalChallengers < 0)
+    throw new Error("numLocalChallengers must be a non-negative integer");
+  if (!Number.isInteger(e.councilQuorum) || !Number.isInteger(e.councilSize) || e.councilQuorum <= 0 || e.councilSize <= 0 || e.councilQuorum > e.councilSize)
+    throw new Error(
+      `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
+    );
+}
+function jt(e) {
+  const t = ee.fromHex(e);
+  try {
+    t.finalizeAllInputs();
+  } catch (r) {
+    const n = r instanceof Error ? r.message : String(r);
+    if (!n.includes("already finalized"))
+      throw new Error(`Failed to finalize refund PSBT: ${n}`);
+  }
+  return t.extractTransaction().toHex();
+}
+async function Sr(e) {
+  const {
+    vaultId: t,
+    readVault: r,
+    readPrePeginContext: n,
+    feeRate: s,
+    signPsbt: c,
+    broadcastTx: a,
+    signal: i
+  } = e;
+  i == null || i.throwIfAborted(), Ae(t, "vaultId");
+  const o = await r();
+  zt(o), i == null || i.throwIfAborted();
+  const u = await n(o);
+  if (Xt(u), i == null || i.throwIfAborted(), !Number.isFinite(s) || s <= 0)
+    throw new Error(`feeRate must be a positive number, got ${s}`);
+  const h = BigInt(Math.ceil(s * Mt));
+  i == null || i.throwIfAborted();
+  const { psbtHex: l } = await Ne({
+    prePeginParams: {
+      depositorPubkey: g(o.depositorBtcPubkey),
+      vaultProviderPubkey: g(u.vaultProviderPubkey),
+      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(g),
+      universalChallengerPubkeys: u.universalChallengerPubkeys.map(g),
+      hashlocks: [g(o.hashlock)],
+      timelockRefund: u.timelockRefund,
+      pegInAmounts: [o.amount],
+      feeRate: u.feeRate,
+      numLocalChallengers: u.numLocalChallengers,
+      councilQuorum: u.councilQuorum,
+      councilSize: u.councilSize,
+      network: u.network
+    },
+    fundedPrePeginTxHex: g(o.unsignedPrePeginTxHex),
+    htlcVout: o.htlcVout,
+    refundFee: h,
+    // buildRefundPsbt's top-level `hashlock` param is documented as "no 0x
+    // prefix" and flows into the WASM HTLC connector derivation; a prefixed
+    // value would derive the wrong refund script leaf and yield an
+    // unspendable PSBT. Match the `hashlocks` array handling above.
+    hashlock: g(o.hashlock)
+  });
+  i == null || i.throwIfAborted();
+  const d = M(
+    o.depositorBtcPubkey,
+    Gt
+  ), x = await c(l, d), y = jt(x);
+  i == null || i.throwIfAborted();
+  try {
+    return await a(y);
+  } catch (p) {
+    throw p instanceof Error && Wt.test(p.message) ? new Vt(t, p) : p;
+  }
+}
+export {
+  ir as A,
+  Vt as B,
+  Te as C,
+  Ve as D,
+  ur as E,
+  lr as F,
+  fr as G,
+  ye as H,
+  hr as I,
+  Y as J,
+  cr as K,
+  ar as L,
+  dr as M,
+  ct as N,
+  Ue as P,
+  br as a,
+  vt as b,
+  wr as c,
+  Pr as d,
+  $t as e,
+  Rt as f,
+  mr as g,
+  lt as h,
+  gr as i,
+  ft as j,
+  Er as k,
+  Tr as l,
+  Sr as m,
+  nr as n,
+  te as o,
+  pr as p,
+  N as q,
+  ie as r,
+  xr as s,
+  pe as t,
+  or as u,
+  yr as v,
+  me as w,
+  je as x,
+  oe as y,
+  sr as z
+};
+//# sourceMappingURL=buildAndBroadcastRefund-DnTQkCgG.js.map