@babylonlabs-io/ts-sdk 0.55.1 → 0.56.0

package/dist/PeginManager-D22MLWfM.js

@@ -1,1295 +0,0 @@
-var qt = Object.defineProperty;
-var zt = (n, t, e) => t in n ? qt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
-var x = (n, t, e) => zt(n, typeof t != "symbol" ? t + "" : t, e);
-import { s as it, c as At, H as Yt, r as V, a as W, b as lt, u as jt, d as ut, e as ht, f as dt, g as Zt } from "./sha2-BYVxyZzX.js";
-import * as Ct from "bitcoinjs-lib";
-import { Transaction as Qt, Psbt as gt } from "bitcoinjs-lib";
-import { Buffer as J } from "buffer";
-import { isAddressEqual as ft, encodeFunctionData as tt, zeroAddress as Jt } from "viem";
-import { B as A } from "./BTCVaultRegistry.abi-Chs4AFBj.js";
-import { h as H } from "./errors-Blc-JWnI.js";
-import { expandWotsSeed as te, expandHashlockSecret as ee, expandAuthAnchor as ne, deriveVaultId as pt } from "@babylonlabs-io/babylon-tbv-rust-wasm";
-import { a as mt, b as se, d as bt, f as oe } from "./verifyScriptPathSchnorrSignature-DA4Z4yZ3.js";
-import { b as re, e as ie, f as ae } from "./peginInput-BKD_b3gq.js";
-import { u as X, h as et, e as v, p as ce, i as Pt, s as T, j as wt, X as le } from "./bitcoin-B5aNKtsk.js";
-import { c as ue } from "./signing-DaLvGwQe.js";
-import { M as yt } from "./validation-CxqROCno.js";
-import { c as he, a as de, s as ge } from "./PayoutManager-BJmPnyRP.js";
-import { s as fe, f as q, i as pe, w as xt } from "./waitForTransactionReceiptSmartAware-lobLm0q0.js";
-import { p as me, f as be } from "./fundPeginTransaction-B2wyjqp0.js";
-import { p as Pe, V as we, i as ye } from "./mempoolApi-CB7bHuwi.js";
-const M = /* @__PURE__ */ BigInt(2 ** 32 - 1), kt = /* @__PURE__ */ BigInt(32);
-function xe(n, t = !1) {
-  return t ? { h: Number(n & M), l: Number(n >> kt & M) } : { h: Number(n >> kt & M) | 0, l: Number(n & M) | 0 };
-}
-function ke(n, t = !1) {
-  const e = n.length;
-  let s = new Uint32Array(e), o = new Uint32Array(e);
-  for (let r = 0; r < e; r++) {
-    const { h: i, l: a } = xe(n[r], t);
-    [s[r], o[r]] = [i, a];
-  }
-  return [s, o];
-}
-const Ee = (n, t, e) => n << e | t >>> 32 - e, Te = (n, t, e) => t << e | n >>> 32 - e, _e = (n, t, e) => t << e - 32 | n >>> 64 - e, Be = (n, t, e) => n << e - 32 | t >>> 64 - e, U = 32, z = 32, nt = 36, Ht = 32, K = 4, ve = K + U + K + Ht;
-function st(n, t, e) {
-  n[t] = e >>> 24 & 255, n[t + 1] = e >>> 16 & 255, n[t + 2] = e >>> 8 & 255, n[t + 3] = e & 255;
-}
-function Se(n) {
-  if (n.txid.length !== z)
-    throw new Error(
-      `outpoint.txid must be exactly ${z} bytes, got ${n.txid.length}`
-    );
-  if (!Number.isInteger(n.vout) || n.vout < 0 || n.vout > 4294967295)
-    throw new Error(`outpoint.vout must be a u32, got ${n.vout}`);
-  const t = new Uint8Array(nt);
-  return t.set(n.txid, 0), st(t, z, n.vout), t;
-}
-function Et(n, t) {
-  const e = Math.min(n.length, t.length);
-  for (let s = 0; s < e; s++)
-    if (n[s] !== t[s]) return n[s] - t[s];
-  return n.length - t.length;
-}
-function Ie(n) {
-  if (n.length === 0)
-    throw new Error(
-      "buildFundingOutpointsCommitment: outpoints must be non-empty"
-    );
-  const t = n.map(Se);
-  t.sort(Et);
-  for (let s = 1; s < t.length; s++)
-    if (Et(t[s - 1], t[s]) === 0)
-      throw new Error(
-        "buildFundingOutpointsCommitment: duplicate outpoint detected"
-      );
-  const e = new Uint8Array(t.length * nt);
-  for (let s = 0; s < t.length; s++)
-    e.set(t[s], s * nt);
-  return it(e);
-}
-function Ae(n) {
-  if (n.depositorBtcPubkey.length !== U)
-    throw new Error(
-      `vaultContext: depositorBtcPubkey must be exactly ${U} bytes, got ${n.depositorBtcPubkey.length}`
-    );
-  const t = Ie(n.fundingOutpoints), e = new Uint8Array(ve);
-  let s = 0;
-  return st(e, s, U), s += K, e.set(n.depositorBtcPubkey, s), s += U, st(e, s, Ht), s += K, e.set(t, s), e;
-}
-const Ce = "babylon-btc-vault", Ot = 32, Tt = Ot * 2, He = /^[0-9a-f]+$/;
-async function Oe(n, t) {
-  const e = Ae(t), s = X(e), o = await n.deriveContextHash(Ce, s);
-  if (typeof o != "string")
-    throw new Error(
-      `deriveVaultRoot: wallet must return a string, got ${typeof o}`
-    );
-  if (o.length !== Tt)
-    throw new Error(
-      `deriveVaultRoot: wallet must return a ${Tt}-character hex string (${Ot} bytes), got length ${o.length}`
-    );
-  if (!He.test(o))
-    throw new Error(
-      "deriveVaultRoot: wallet must return lowercase hex per derive-context-hash.md §2.1; got value with non-lowercase or non-hex characters"
-    );
-  return et(o);
-}
-const Re = /* @__PURE__ */ Uint8Array.from([
-  7,
-  4,
-  13,
-  1,
-  10,
-  6,
-  15,
-  3,
-  12,
-  0,
-  9,
-  5,
-  2,
-  14,
-  11,
-  8
-]), Rt = Uint8Array.from(new Array(16).fill(0).map((n, t) => t)), $e = Rt.map((n) => (9 * n + 5) % 16), $t = /* @__PURE__ */ (() => {
-  const e = [[Rt], [$e]];
-  for (let s = 0; s < 4; s++)
-    for (let o of e)
-      o.push(o[s].map((r) => Re[r]));
-  return e;
-})(), Ut = $t[0], Vt = $t[1], Mt = /* @__PURE__ */ [
-  [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
-  [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
-  [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
-  [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
-  [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
-].map((n) => Uint8Array.from(n)), Ue = /* @__PURE__ */ Ut.map((n, t) => n.map((e) => Mt[t][e])), Ve = /* @__PURE__ */ Vt.map((n, t) => n.map((e) => Mt[t][e])), Me = /* @__PURE__ */ Uint32Array.from([
-  0,
-  1518500249,
-  1859775393,
-  2400959708,
-  2840853838
-]), Ne = /* @__PURE__ */ Uint32Array.from([
-  1352829926,
-  1548603684,
-  1836072691,
-  2053994217,
-  0
-]);
-function _t(n, t, e, s) {
-  return n === 0 ? t ^ e ^ s : n === 1 ? t & e | ~t & s : n === 2 ? (t | ~e) ^ s : n === 3 ? t & s | e & ~s : t ^ (e | ~s);
-}
-const N = /* @__PURE__ */ new Uint32Array(16);
-class Fe extends Yt {
-  constructor() {
-    super(64, 20, 8, !0);
-    x(this, "h0", 1732584193);
-    x(this, "h1", -271733879);
-    x(this, "h2", -1732584194);
-    x(this, "h3", 271733878);
-    x(this, "h4", -1009589776);
-  }
-  get() {
-    const { h0: e, h1: s, h2: o, h3: r, h4: i } = this;
-    return [e, s, o, r, i];
-  }
-  set(e, s, o, r, i) {
-    this.h0 = e | 0, this.h1 = s | 0, this.h2 = o | 0, this.h3 = r | 0, this.h4 = i | 0;
-  }
-  process(e, s) {
-    for (let g = 0; g < 16; g++, s += 4)
-      N[g] = e.getUint32(s, !0);
-    let o = this.h0 | 0, r = o, i = this.h1 | 0, a = i, c = this.h2 | 0, h = c, l = this.h3 | 0, m = l, b = this.h4 | 0, P = b;
-    for (let g = 0; g < 5; g++) {
-      const f = 4 - g, k = Me[g], S = Ne[g], E = Ut[g], p = Vt[g], w = Ue[g], y = Ve[g];
-      for (let d = 0; d < 16; d++) {
-        const u = V(o + _t(g, i, c, l) + N[E[d]] + k, w[d]) + b | 0;
-        o = b, b = l, l = V(c, 10) | 0, c = i, i = u;
-      }
-      for (let d = 0; d < 16; d++) {
-        const u = V(r + _t(f, a, h, m) + N[p[d]] + S, y[d]) + P | 0;
-        r = P, P = m, m = V(h, 10) | 0, h = a, a = u;
-      }
-    }
-    this.set(this.h1 + c + m | 0, this.h2 + l + P | 0, this.h3 + b + r | 0, this.h4 + o + a | 0, this.h0 + i + h | 0);
-  }
-  roundClean() {
-    W(N);
-  }
-  destroy() {
-    this.destroyed = !0, W(this.buffer), this.set(0, 0, 0, 0, 0);
-  }
-}
-const Le = /* @__PURE__ */ At(() => new Fe()), We = BigInt(0), R = BigInt(1), Xe = BigInt(2), Ke = BigInt(7), De = BigInt(256), Ge = BigInt(113), Nt = [], Ft = [], Lt = [];
-for (let n = 0, t = R, e = 1, s = 0; n < 24; n++) {
-  [e, s] = [s, (2 * e + 3 * s) % 5], Nt.push(2 * (5 * s + e)), Ft.push((n + 1) * (n + 2) / 2 % 64);
-  let o = We;
-  for (let r = 0; r < 7; r++)
-    t = (t << R ^ (t >> Ke) * Ge) % De, t & Xe && (o ^= R << (R << BigInt(r)) - R);
-  Lt.push(o);
-}
-const Wt = ke(Lt, !0), qe = Wt[0], ze = Wt[1], Bt = (n, t, e) => e > 32 ? _e(n, t, e) : Ee(n, t, e), vt = (n, t, e) => e > 32 ? Be(n, t, e) : Te(n, t, e);
-function Ye(n, t = 24) {
-  const e = new Uint32Array(10);
-  for (let s = 24 - t; s < 24; s++) {
-    for (let i = 0; i < 10; i++)
-      e[i] = n[i] ^ n[i + 10] ^ n[i + 20] ^ n[i + 30] ^ n[i + 40];
-    for (let i = 0; i < 10; i += 2) {
-      const a = (i + 8) % 10, c = (i + 2) % 10, h = e[c], l = e[c + 1], m = Bt(h, l, 1) ^ e[a], b = vt(h, l, 1) ^ e[a + 1];
-      for (let P = 0; P < 50; P += 10)
-        n[i + P] ^= m, n[i + P + 1] ^= b;
-    }
-    let o = n[2], r = n[3];
-    for (let i = 0; i < 24; i++) {
-      const a = Ft[i], c = Bt(o, r, a), h = vt(o, r, a), l = Nt[i];
-      o = n[l], r = n[l + 1], n[l] = c, n[l + 1] = h;
-    }
-    for (let i = 0; i < 50; i += 10) {
-      for (let a = 0; a < 10; a++)
-        e[a] = n[i + a];
-      for (let a = 0; a < 10; a++)
-        n[i + a] ^= ~e[(a + 2) % 10] & e[(a + 4) % 10];
-    }
-    n[0] ^= qe[s], n[1] ^= ze[s];
-  }
-  W(e);
-}
-class at {
-  // NOTE: we accept arguments in bytes instead of bits here.
-  constructor(t, e, s, o = !1, r = 24) {
-    x(this, "state");
-    x(this, "pos", 0);
-    x(this, "posOut", 0);
-    x(this, "finished", !1);
-    x(this, "state32");
-    x(this, "destroyed", !1);
-    x(this, "blockLen");
-    x(this, "suffix");
-    x(this, "outputLen");
-    x(this, "enableXOF", !1);
-    x(this, "rounds");
-    if (this.blockLen = t, this.suffix = e, this.outputLen = s, this.enableXOF = o, this.rounds = r, lt(s, "outputLen"), !(0 < t && t < 200))
-      throw new Error("only keccak-f1600 function is supported");
-    this.state = new Uint8Array(200), this.state32 = jt(this.state);
-  }
-  clone() {
-    return this._cloneInto();
-  }
-  keccak() {
-    ut(this.state32), Ye(this.state32, this.rounds), ut(this.state32), this.posOut = 0, this.pos = 0;
-  }
-  update(t) {
-    ht(this), dt(t);
-    const { blockLen: e, state: s } = this, o = t.length;
-    for (let r = 0; r < o; ) {
-      const i = Math.min(e - this.pos, o - r);
-      for (let a = 0; a < i; a++)
-        s[this.pos++] ^= t[r++];
-      this.pos === e && this.keccak();
-    }
-    return this;
-  }
-  finish() {
-    if (this.finished)
-      return;
-    this.finished = !0;
-    const { state: t, suffix: e, pos: s, blockLen: o } = this;
-    t[s] ^= e, (e & 128) !== 0 && s === o - 1 && this.keccak(), t[o - 1] ^= 128, this.keccak();
-  }
-  writeInto(t) {
-    ht(this, !1), dt(t), this.finish();
-    const e = this.state, { blockLen: s } = this;
-    for (let o = 0, r = t.length; o < r; ) {
-      this.posOut >= s && this.keccak();
-      const i = Math.min(s - this.posOut, r - o);
-      t.set(e.subarray(this.posOut, this.posOut + i), o), this.posOut += i, o += i;
-    }
-    return t;
-  }
-  xofInto(t) {
-    if (!this.enableXOF)
-      throw new Error("XOF is not possible for this instance");
-    return this.writeInto(t);
-  }
-  xof(t) {
-    return lt(t), this.xofInto(new Uint8Array(t));
-  }
-  digestInto(t) {
-    if (Zt(t, this), this.finished)
-      throw new Error("digest() was already called");
-    return this.writeInto(t), this.destroy(), t;
-  }
-  digest() {
-    return this.digestInto(new Uint8Array(this.outputLen));
-  }
-  destroy() {
-    this.destroyed = !0, W(this.state);
-  }
-  _cloneInto(t) {
-    const { blockLen: e, suffix: s, outputLen: o, rounds: r, enableXOF: i } = this;
-    return t || (t = new at(e, s, o, i, r)), t.state32.set(this.state32), t.pos = this.pos, t.posOut = this.posOut, t.finished = this.finished, t.rounds = r, t.suffix = s, t.outputLen = o, t.enableXOF = i, t.destroyed = this.destroyed, t;
-  }
-}
-const je = (n, t, e, s = {}) => At(() => new at(t, n, e), s), Ze = /* @__PURE__ */ je(1, 136, 32), St = 64, _ = 20, ot = 4, Xt = 2, Qe = 0, Je = 1, F = [64, 64], tn = (n) => Array.from(n).map((t) => t.toString(16).padStart(2, "0")).join("");
-function ct(n) {
-  return Le(it(n));
-}
-function Kt(n) {
-  return (1 << n) - 1;
-}
-function en(n) {
-  let t = 1;
-  for (; t * t < n + 1; ) t++;
-  return Math.max(t, 2);
-}
-function nn(n) {
-  const t = ot, e = n * Kt(t);
-  return { d: t, n, checksum_radix: en(e) };
-}
-function Y(n, t) {
-  const e = [];
-  let s = t;
-  for (; s > 0; )
-    e.push(s & 255), s >>>= 8;
-  const o = new Uint8Array(n.length + e.length);
-  o.set(n);
-  for (let r = 0; r < e.length; r++)
-    o[n.length + r] = e[r];
-  return ct(o);
-}
-function j(n, t) {
-  let e = n;
-  for (let s = 0; s < t; s++)
-    e = ct(e);
-  return e;
-}
-function sn(n, t) {
-  const e = Kt(t.d), s = t.checksum_radix - 1, o = Math.floor(t.n * e / t.checksum_radix), r = [];
-  for (let l = 0; l < t.n; l++) {
-    const m = Y(n, l + Xt), b = j(m, e);
-    r.push(Array.from(b));
-  }
-  const i = Y(
-    n,
-    Qe
-  ), a = j(
-    i,
-    s
-  ), c = Y(
-    n,
-    Je
-  ), h = j(
-    c,
-    o
-  );
-  return {
-    config: t,
-    message_terminals: r,
-    checksum_major_terminal: Array.from(h),
-    checksum_minor_terminal: Array.from(a)
-  };
-}
-async function on(n) {
-  try {
-    if (n.length !== St)
-      throw new Error(
-        `WOTS seed must be exactly ${St} bytes, got ${n.length}`
-      );
-    const t = [];
-    for (let e = 0; e < F.length; e++) {
-      const s = F[e], o = nn(s), r = new Uint8Array(n.length + 1);
-      r.set(n), r[n.length] = e;
-      const i = ct(r);
-      try {
-        const a = sn(i, o);
-        if (a.config.d !== ot)
-          throw new Error(
-            `Block ${e}: expected d=${ot}, got d=${a.config.d}`
-          );
-        if (a.config.n !== s)
-          throw new Error(
-            `Block ${e}: expected n=${s}, got n=${a.config.n}`
-          );
-        if (a.message_terminals.length !== s)
-          throw new Error(
-            `Block ${e}: expected ${s} message terminals, got ${a.message_terminals.length}`
-          );
-        for (let c = 0; c < a.message_terminals.length; c++)
-          if (a.message_terminals[c].length !== _)
-            throw new Error(
-              `Block ${e} terminal ${c}: expected ${_} bytes, got ${a.message_terminals[c].length}`
-            );
-        if (a.checksum_minor_terminal.length !== _)
-          throw new Error(
-            `Block ${e} checksum_minor: expected ${_} bytes`
-          );
-        if (a.checksum_major_terminal.length !== _)
-          throw new Error(
-            `Block ${e} checksum_major: expected ${_} bytes`
-          );
-        t.push(a);
-      } finally {
-        r.fill(0), i.fill(0);
-      }
-    }
-    if (t.length !== F.length)
-      throw new Error(
-        `Expected ${F.length} blocks, got ${t.length}`
-      );
-    return t;
-  } finally {
-    n.fill(0);
-  }
-}
-function Z(n, t, e) {
-  if (n.length !== _)
-    throw new Error(
-      `Block ${t} ${e}: expected ${_} bytes, got ${n.length}`
-    );
-  for (let s = 0; s < n.length; s++) {
-    const o = n[s];
-    if (!Number.isInteger(o) || o < 0 || o > 255)
-      throw new Error(
-        `Block ${t} ${e}[${s}]: invalid byte value ${o}`
-      );
-  }
-}
-function rn(n) {
-  if (n.length === 0)
-    throw new Error("Public keys array must not be empty");
-  for (let r = 0; r < n.length; r++) {
-    const i = n[r];
-    Z(i.checksum_minor_terminal, r, "checksum_minor_terminal"), Z(i.checksum_major_terminal, r, "checksum_major_terminal");
-    for (let a = 0; a < i.message_terminals.length; a++)
-      Z(i.message_terminals[a], r, `message_terminal[${a}]`);
-  }
-  let t = 0;
-  for (const r of n)
-    t += Xt + r.message_terminals.length;
-  const e = new Uint8Array(t * _);
-  let s = 0;
-  for (const r of n) {
-    e.set(r.checksum_minor_terminal, s), s += _, e.set(r.checksum_major_terminal, s), s += _;
-    for (const i of r.message_terminals)
-      e.set(i, s), s += _;
-  }
-  const o = Ze(e);
-  return `0x${tn(o)}`;
-}
-async function an(n, t) {
-  const e = [], s = [], o = [], r = [];
-  try {
-    for (let i = 0; i < t; i++) {
-      const a = await te(n, i);
-      try {
-        const h = await on(a);
-        e.push(h), s.push(rn(h));
-      } finally {
-        a.fill(0);
-      }
-      const c = await ee(n, i);
-      try {
-        const h = X(c);
-        o.push(h), r.push(he(v(h)).slice(2));
-      } finally {
-        c.fill(0);
-      }
-    }
-  } finally {
-    n.fill(0);
-  }
-  return { perVaultWotsKeys: e, wotsPkHashes: s, htlcSecretHexes: o, hashlocks: r };
-}
-const cn = /^0x[0-9a-f]+$/i, ln = /^[0-9a-f]+$/i, un = /^[A-Za-z0-9+/]+={0,2}$/;
-function $(n) {
-  if (typeof n != "string" || n.length === 0)
-    throw new Error("BTC wallet returned empty public key");
-  return ce(n).toLowerCase();
-}
-function hn(n) {
-  if (typeof n != "string" || n.length === 0)
-    throw new Error("BTC wallet returned empty BIP-322 signature");
-  if (n.startsWith("0x") || n.startsWith("0X")) {
-    if (!cn.test(n) || n.length < 4 || n.length % 2 !== 0)
-      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
-    return n.toLowerCase();
-  }
-  if (ln.test(n)) {
-    if (n.length % 2 !== 0)
-      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
-    return `0x${n.toLowerCase()}`;
-  }
-  if (!un.test(n) || n.length % 4 !== 0)
-    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
-  const t = J.from(n, "base64");
-  if (t.length === 0 || t.toString("base64") !== n)
-    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
-  return `0x${t.toString("hex")}`;
-}
-const Dt = 0, L = 25, rt = 9999, Q = "00".repeat(32);
-function dn(n, t) {
-  const e = {
-    bitcoin: "bc",
-    testnet: "tb",
-    signet: "tb",
-    regtest: "bcrt"
-  };
-  try {
-    const s = Ct.address.fromBech32(n);
-    return s.prefix === e[t] && s.version === 0 && s.data.length === 20;
-  } catch {
-    return !1;
-  }
-}
-function gn(n, t, e, s) {
-  const o = e == null ? void 0 : e[`${n}:${t}`];
-  return o ? Promise.resolve({
-    txid: n,
-    vout: t,
-    value: o.value,
-    scriptPubKey: o.scriptPubKey
-  }) : ye(n, t, s);
-}
-const It = 12e4;
-class Vn {
-  /**
-   * Creates a new PeginManager instance.
-   *
-   * @param config - Manager configuration including wallets and contract addresses
-   */
-  constructor(t) {
-    x(this, "config");
-    this.config = t;
-  }
-  /**
-   * Prepare a peg-in: sizing pass → vault-root derivation (one wallet
-   * popup) → per-vault WOTS / hashlock derivation → commit pass with
-   * PSBT signing (signPsbt for a single vault, one batch popup for a
-   * split). Returns broadcast-ready txs, the pubkey snapshot, and the
-   * sensitive derived material.
-   *
-   * @throws If the wallet rejects, insufficient funds, or an internal
-   *         invariant violation.
-   */
-  async preparePegin(t) {
-    if (t.amounts.length === 0)
-      throw new Error("amounts must contain at least one entry");
-    const e = await this.config.btcWallet.getPublicKeyHex(), s = $(e);
-    if (!Pt(
-      t.changeAddress,
-      e,
-      this.config.btcNetwork
-    ))
-      throw new Error(
-        `Pre-PegIn changeAddress "${t.changeAddress}" is not derived from the connected wallet's public key. Refusing to build a tx that would send change to an address the signing key doesn't control.`
-      );
-    const o = await this.prepareSizing(s, t), r = o.selectedUTXOs.map(
-      (f) => ({
-        txid: et(f.txid),
-        vout: f.vout
-      })
-    ), i = await Oe(this.config.btcWallet, {
-      depositorBtcPubkey: et(s),
-      fundingOutpoints: r
-    });
-    let a, c;
-    try {
-      const f = await ne(i);
-      try {
-        a = X(f), c = X(it(f));
-      } finally {
-        f.fill(0);
-      }
-    } catch (f) {
-      throw i.fill(0), f;
-    }
-    const h = await an(i, t.amounts.length), { perVaultWotsKeys: l, wotsPkHashes: m, htlcSecretHexes: b, hashlocks: P } = h, g = await this.preparePeginCommit({
-      depositorBtcPubkeyRaw: e,
-      depositorBtcPubkey: s,
-      hashlocks: P,
-      authAnchorHash: c,
-      sizing: o,
-      params: t
-    });
-    for (let f = 0; f < g.perVault.length; f++)
-      if (g.perVault[f].htlcVout !== f)
-        throw new Error(
-          `Internal invariant violation: htlcVout/index mismatch at vault ${f} (expected ${f}, got ${g.perVault[f].htlcVout})`
-        );
-    return de(
-      g.fundedPrePeginTxHex,
-      t.amounts.length,
-      c
-    ), {
-      transaction: {
-        ...g,
-        selectedUTXOs: o.selectedUTXOs,
-        fee: o.fee,
-        changeAmount: o.changeAmount
-      },
-      depositorBtcPubkey: s,
-      derivedSecrets: {
-        perVaultWotsKeys: l,
-        wotsPkHashes: m,
-        htlcSecretHexes: b,
-        authAnchorHex: a
-      }
-    };
-  }
-  /**
-   * Build unfunded Pre-PegIn + select UTXOs. No PSBT signing.
-   *
-   * Returns the full selection result (UTXOs, fee, changeAmount) so the
-   * commit pass funds the broadcast tx with the exact same set used to
-   * build the vault-context funding-outpoints commitment. Re-running
-   * `selectUtxosForPegin` in the commit pass would be deterministic given
-   * the same inputs, but threading the result through guarantees the
-   * domain separator structurally matches the funded tx inputs.
-   *
-   * Sizing runs before the wallet popup, so neither the real per-vault
-   * hashlocks nor the real `authAnchorHash` are known yet. Both slots
-   * are filled with a 32-byte placeholder; the commit pass swaps in the
-   * real values. Output budget is identical (32-byte push regardless of
-   * content), so UTXO selection is invariant under substitution.
-   */
-  async prepareSizing(t, e) {
-    const s = e.amounts.map(
-      () => Q
-    ), o = e.vaultKeeperBtcPubkeys.length, r = await mt({
-      vaultCoreVersion: e.vaultCoreVersion,
-      depositorPubkey: t,
-      vaultProviderPubkey: T(e.vaultProviderBtcPubkey),
-      vaultKeeperPubkeys: e.vaultKeeperBtcPubkeys.map(T),
-      universalChallengerPubkeys: e.universalChallengerBtcPubkeys.map(T),
-      hashlocks: s,
-      timelockRefund: e.timelockRefund,
-      pegInAmounts: e.amounts,
-      feeRate: e.protocolFeeRate,
-      minPeginFeeRate: e.minPeginFeeRate,
-      numLocalChallengers: o,
-      councilQuorum: e.councilQuorum,
-      councilSize: e.councilSize,
-      network: this.config.btcNetwork,
-      authAnchorHash: Q
-    }), i = fe(
-      [...e.availableUTXOs],
-      r.totalOutputValue,
-      e.mempoolFeeRate,
-      me(r.htlcValues.length, !0)
-    );
-    return {
-      selectedUTXOs: i.selectedUTXOs,
-      fee: i.fee,
-      changeAmount: i.changeAmount
-    };
-  }
-  /** Build PegIn txs and batch-sign their inputs with real hashlocks. */
-  async preparePeginCommit(t) {
-    const {
-      depositorBtcPubkeyRaw: e,
-      depositorBtcPubkey: s,
-      hashlocks: o,
-      authAnchorHash: r,
-      sizing: i,
-      params: a
-    } = t, c = Q.toLowerCase();
-    for (let u = 0; u < o.length; u++)
-      if (o[u].toLowerCase() === c)
-        throw new Error(
-          `preparePeginCommit refusing to build with sizing-pass placeholder hashlock at vault ${u} — internal substitution bug`
-        );
-    if (r.toLowerCase() === c)
-      throw new Error(
-        "preparePeginCommit refusing to build with sizing-pass placeholder auth-anchor hash — internal substitution bug"
-      );
-    const h = T(
-      a.vaultProviderBtcPubkey
-    ), l = a.vaultKeeperBtcPubkeys.map(T), m = a.universalChallengerBtcPubkeys.map(T), b = l.length, P = {
-      vaultCoreVersion: a.vaultCoreVersion,
-      depositorPubkey: s,
-      vaultProviderPubkey: h,
-      vaultKeeperPubkeys: l,
-      universalChallengerPubkeys: m,
-      hashlocks: o,
-      timelockRefund: a.timelockRefund,
-      pegInAmounts: a.amounts,
-      feeRate: a.protocolFeeRate,
-      minPeginFeeRate: a.minPeginFeeRate,
-      numLocalChallengers: b,
-      councilQuorum: a.councilQuorum,
-      councilSize: a.councilSize,
-      network: this.config.btcNetwork,
-      authAnchorHash: r
-    }, g = await mt(P), f = wt(this.config.btcNetwork), k = be({
-      unfundedTxHex: g.psbtHex,
-      selectedUTXOs: i.selectedUTXOs,
-      changeAddress: a.changeAddress,
-      changeAmount: i.changeAmount,
-      network: f
-    }), S = T(
-      q(k)
-    ), E = [], p = [], w = [];
-    for (let u = 0; u < o.length; u++) {
-      const B = await se({
-        prePeginParams: P,
-        timelockPegin: a.timelockPegin,
-        fundedPrePeginTxHex: k,
-        htlcVout: u
-      }), I = await re({
-        vaultCoreVersion: a.vaultCoreVersion,
-        peginTxHex: B.txHex,
-        fundedPrePeginTxHex: k,
-        depositorPubkey: s,
-        vaultProviderPubkey: h,
-        vaultKeeperPubkeys: l,
-        universalChallengerPubkeys: m,
-        hashlock: o[u],
-        timelockRefund: a.timelockRefund,
-        network: this.config.btcNetwork
-      });
-      E.push(B), p.push(I.psbtHex), w.push(
-        ue(e, 1)
-      );
-    }
-    const y = await ge(
-      this.config.btcWallet,
-      p,
-      w
-    ), d = [];
-    for (let u = 0; u < y.length; u++) {
-      bt({
-        requestedPsbtHex: p[u],
-        returnedPsbtHex: y[u]
-      });
-      const B = ie(
-        y[u],
-        s
-      );
-      oe({
-        requestedPsbtHex: p[u],
-        signatureHex: B,
-        signerXOnlyPubkeyHex: s,
-        inputIndex: 0
-      });
-      const I = ae(y[u]);
-      d.push({
-        htlcVout: u,
-        htlcValue: g.htlcValues[u],
-        peginTxHex: I,
-        peginTxid: E[u].txid,
-        peginInputSignature: B,
-        vaultScriptPubKey: E[u].vaultScriptPubKey
-      });
-    }
-    return {
-      fundedPrePeginTxHex: k,
-      prePeginTxid: S,
-      perVault: d
-    };
-  }
-  /**
-   * Signs and broadcasts a funded peg-in transaction to the Bitcoin network.
-   *
-   * This method:
-   * 1. Parses the funded transaction hex
-   * 2. Fetches UTXO data from mempool for each input
-   * 3. Creates a PSBT with proper witnessUtxo/tapInternalKey
-   * 4. Signs via btcWallet.signPsbt()
-   * 5. Finalizes and extracts the transaction
-   * 6. Broadcasts via mempool API
-   *
-   * @param params - Transaction hex and depositor public key
-   * @returns The broadcasted Bitcoin transaction ID
-   * @throws Error if signing or broadcasting fails
-   */
-  async signAndBroadcast(t) {
-    const { fundedPrePeginTxHex: e, depositorBtcPubkey: s } = t, o = e.startsWith("0x") ? e.slice(2) : e, r = Qt.fromHex(o);
-    if (r.ins.length === 0)
-      throw new Error("Transaction has no inputs");
-    const i = new gt();
-    i.setVersion(r.version), i.setLocktime(r.locktime);
-    const a = J.from(
-      $(s),
-      "hex"
-    ), c = this.config.mempoolApiUrl, h = r.ins.map((p) => {
-      const w = J.from(p.hash).reverse().toString("hex"), y = p.index;
-      return gn(w, y, t.localPrevouts, c).then(
-        (d) => ({ input: p, utxoData: d, txid: w, vout: y })
-      );
-    }), l = await Promise.all(h), m = l.reduce(
-      (p, w) => p + BigInt(w.utxoData.value),
-      0n
-    ), b = r.outs.reduce(
-      (p, w) => p + BigInt(w.value),
-      0n
-    );
-    if (m < b)
-      throw new Error(
-        `UTXO value mismatch: total input value (${m} sat) is less than total output value (${b} sat). This may indicate the mempool API returned manipulated UTXO data.`
-      );
-    const P = m - b;
-    if (P > yt)
-      throw new Error(
-        `Implied transaction fee (${P} sat) exceeds maximum reasonable fee (${yt} sat). This may indicate manipulated UTXO data.`
-      );
-    for (const { input: p, utxoData: w, txid: y, vout: d } of l) {
-      const u = pe(
-        {
-          value: w.value,
-          scriptPubKey: w.scriptPubKey
-        },
-        a
-      );
-      i.addInput({
-        hash: p.hash,
-        index: p.index,
-        sequence: p.sequence,
-        ...u
-      });
-    }
-    for (const p of r.outs)
-      i.addOutput({
-        script: p.script,
-        value: p.value
-      });
-    const g = i.toHex(), f = await this.config.btcWallet.signPsbt(g);
-    bt({
-      requestedPsbtHex: g,
-      returnedPsbtHex: f
-    });
-    const k = gt.fromHex(f);
-    try {
-      k.finalizeAllInputs();
-    } catch (p) {
-      if (!k.data.inputs.every(
-        (y) => y.finalScriptWitness || y.finalScriptSig
-      ))
-        throw new Error(
-          `PSBT finalization failed and wallet did not auto-finalize: ${p}`
-        );
-    }
-    const S = k.extractTransaction().toHex();
-    return await Pe(S, c);
-  }
-  /**
-   * Registers a peg-in on Ethereum by calling the BTCVaultRegistry contract.
-   *
-   * This method:
-   * 1. Re-verifies the PopSignature against the currently connected ETH
-   *    and BTC wallets — refuses to proceed if either has changed
-   * 2. Derives vault ID and checks if it already exists (pre-flight)
-   * 3. Encodes the contract call using viem
-   * 4. Estimates gas (catches contract errors early with proper revert
-   *    reasons)
-   * 5. Sends transaction with pre-estimated gas via
-   *    ethWallet.sendTransaction()
-   *
-   * The PopSignature must be obtained via
-   * {@link signProofOfPossession} before this call.
-   *
-   * @param params - Registration parameters including the PopSignature
-   *                 and the prepared Pre-PegIn / PegIn transactions
-   * @returns Result containing Ethereum transaction hash and vault ID
-   * @throws Error if the PopSignature does not match the connected wallets
-   * @throws Error if the vault already exists
-   * @throws Error if contract simulation fails (e.g., invalid signature,
-   *         unauthorized)
-   */
-  async registerPeginOnChain(t) {
-    const {
-      unsignedPrePeginTx: e,
-      depositorSignedPeginTx: s,
-      vaultProvider: o,
-      hashlock: r,
-      htlcVout: i,
-      depositorPayoutBtcAddress: a,
-      depositorWotsPkHash: c,
-      popSignature: h
-    } = t;
-    if (!this.config.ethWallet.account)
-      throw new Error("Ethereum wallet account not found");
-    const l = this.config.ethWallet.account.address;
-    if (!ft(h.depositorEthAddress, l))
-      throw new Error(
-        `Proof of possession was signed for ${h.depositorEthAddress} but the Ethereum wallet is currently connected to ${l}. Reconnect the original account or call signProofOfPossession() again.`
-      );
-    const m = await this.assertPopMatchesBtcWallet(h), b = h.btcPopSignature, P = v(
-      h.depositorBtcPubkey
-    ), g = v(e), f = v(s), k = a ?? await this.config.btcWallet.getAddress(), S = this.resolvePayoutScriptPubKey(
-      m,
-      k
-    ), E = q(f), p = await pt(
-      T(E),
-      T(l)
-    ), w = v(p);
-    if (await this.checkVaultExists(w))
-      throw new Error(
-        `Vault already exists (ID: ${w}, peginTxHash: ${E}). Vault IDs are derived from the pegin transaction hash and depositor address. To create a new vault, use different UTXOs or a different amount to generate a unique transaction.`
-      );
-    const d = this.config.publicClient;
-    let u;
-    try {
-      u = await d.readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: A,
-        functionName: "getPegInFee",
-        args: [o]
-      });
-    } catch (O) {
-      throw new Error(
-        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct.",
-        { cause: O }
-      );
-    }
-    const B = await this.resolveMaxAcceptableCommissionBps(
-      o,
-      t.quotedCommissionBps
-    ), I = tt({
-      abi: A,
-      functionName: "submitPeginRequest",
-      args: [
-        l,
-        P,
-        b,
-        g,
-        f,
-        o,
-        B,
-        r,
-        i,
-        S,
-        c
-      ]
-    });
-    let C;
-    try {
-      C = await d.estimateGas({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: I,
-        value: u,
-        account: this.config.ethWallet.account.address
-      });
-    } catch (O) {
-      H(O);
-    }
-    let D;
-    try {
-      D = await this.config.ethWallet.sendTransaction({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: I,
-        value: u,
-        account: this.config.ethWallet.account,
-        chain: this.config.ethChain,
-        gas: C
-      });
-    } catch (O) {
-      H(O);
-    }
-    const G = await xt({
-      publicClient: d,
-      walletAddress: this.config.ethWallet.account.address,
-      hash: D,
-      timeout: It
-    });
-    return G.status === "reverted" && H(
-      new Error(
-        `Transaction reverted. Hash: ${G.transactionHash}. Check the transaction on block explorer for details.`
-      )
-    ), {
-      ethTxHash: G.transactionHash,
-      vaultId: w,
-      peginTxHash: E
-    };
-  }
-  /**
-   * Register multiple pegins on Ethereum in a single transaction.
-   *
-   * Uses the contract's submitPeginRequestBatch() to submit all vault
-   * registrations atomically. All vaults must share the same vault provider.
-   * The PoP signature is signed once and included in each request.
-   *
-   * @param params - Batch registration parameters
-   * @returns Batch result with per-vault IDs and single ETH tx hash
-   */
-  async registerPeginBatchOnChain(t) {
-    const { vaultProvider: e, unsignedPrePeginTx: s, requests: o, popSignature: r } = t;
-    if (o.length === 0)
-      throw new Error("Batch pegin requires at least one request");
-    if (!this.config.ethWallet.account)
-      throw new Error("Ethereum wallet account not found");
-    const i = this.config.ethWallet.account.address;
-    if (!ft(r.depositorEthAddress, i))
-      throw new Error(
-        `Proof of possession was signed for ${r.depositorEthAddress} but the Ethereum wallet is currently connected to ${i}. Reconnect the original account or call signProofOfPossession() again.`
-      );
-    const a = await this.assertPopMatchesBtcWallet(r), c = r.btcPopSignature, h = o.map(
-      (d) => this.resolvePayoutScriptPubKey(
-        a,
-        d.depositorPayoutBtcAddress
-      )
-    ), l = [];
-    for (const d of o) {
-      const u = v(
-        d.depositorSignedPeginTx
-      ), B = q(u), I = await pt(
-        T(B),
-        T(i)
-      ), C = v(I);
-      if (await this.checkVaultExists(C))
-        throw new Error(
-          `Vault already exists (ID: ${C}, peginTxHash: ${B}). To create a new vault, use different UTXOs or a different amount.`
-        );
-      l.push({ vaultId: C, peginTxHash: B });
-    }
-    const m = this.config.publicClient;
-    let b;
-    try {
-      b = await m.readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: A,
-        functionName: "getPegInFee",
-        args: [e]
-      });
-    } catch (d) {
-      throw new Error(
-        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct.",
-        { cause: d }
-      );
-    }
-    const P = b * BigInt(o.length), g = await this.resolveMaxAcceptableCommissionBps(
-      e,
-      t.quotedCommissionBps
-    ), f = v(
-      r.depositorBtcPubkey
-    ), k = v(s), S = o.map((d, u) => ({
-      depositorBtcPubKey: f,
-      btcPopSignature: c,
-      unsignedPrePeginTx: k,
-      depositorSignedPeginTx: v(
-        d.depositorSignedPeginTx
-      ),
-      hashlock: d.hashlock,
-      htlcVout: d.htlcVout,
-      referralCode: Dt,
-      depositorPayoutBtcAddress: h[u],
-      depositorWotsPkHash: d.depositorWotsPkHash
-    })), E = tt({
-      abi: A,
-      functionName: "submitPeginRequestBatch",
-      args: [
-        i,
-        e,
-        g,
-        S
-      ]
-    });
-    let p;
-    try {
-      p = await m.estimateGas({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: E,
-        value: P,
-        account: this.config.ethWallet.account.address
-      });
-    } catch (d) {
-      H(d);
-    }
-    let w;
-    try {
-      w = await this.config.ethWallet.sendTransaction({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: E,
-        value: P,
-        account: this.config.ethWallet.account,
-        chain: this.config.ethChain,
-        gas: p
-      });
-    } catch (d) {
-      H(d);
-    }
-    const y = await xt({
-      publicClient: m,
-      walletAddress: this.config.ethWallet.account.address,
-      hash: w,
-      timeout: It
-    });
-    return y.status === "reverted" && H(
-      new Error(
-        `Batch transaction reverted. Hash: ${y.transactionHash}. Check the transaction on block explorer for details.`
-      )
-    ), {
-      ethTxHash: y.transactionHash,
-      vaults: l
-    };
-  }
-  // Anchor to quoted+headroom when supplied (refuse if chain drifted past it);
-  // otherwise fall back to chain-current+headroom — see #1691.
-  async resolveMaxAcceptableCommissionBps(t, e) {
-    let s;
-    try {
-      s = await new we(
-        this.config.publicClient,
-        this.config.vaultContracts.btcVaultRegistry
-      ).getVaultProviderCommission(t);
-    } catch (o) {
-      throw new Error(
-        "Failed to query vault provider commission from the contract. Please check your network connection and that the contract address is correct.",
-        { cause: o }
-      );
-    }
-    if (e !== void 0) {
-      if (s > e + L)
-        throw new Error(
-          `Vault provider commission changed since quote: quoted ${e} bps, chain currently reports ${s} bps (allowed drift ${L} bps). Please refresh to see the new commission and try again.`
-        );
-      return Math.min(
-        e + L,
-        rt
-      );
-    }
-    return Math.min(
-      s + L,
-      rt
-    );
-  }
-  /**
-   * Check if a vault already exists for a given vault ID.
-   *
-   * The contract returns a default struct (with `depositor === zeroAddress`)
-   * when no vault is registered, so existence is signalled in the response,
-   * not via a thrown error. RPC/network failures are propagated rather than
-   * silently treated as "vault doesn't exist", which would otherwise let
-   * downstream calls run with stale assumptions.
-   *
-   * @param vaultId - The Bitcoin transaction hash (vault ID)
-   * @returns True if vault exists, false otherwise
-   * @throws If the underlying RPC read fails
-   */
-  async checkVaultExists(t) {
-    return (await this.config.publicClient.readContract({
-      address: this.config.vaultContracts.btcVaultRegistry,
-      abi: A,
-      functionName: "getBtcVaultBasicInfo",
-      args: [t]
-    })).depositor !== Jt;
-  }
-  /**
-   * Resolve the BTC scriptPubKey to register as the depositor's payout sink.
-   *
-   * `address` is validated against the verified depositor pubkey, sourced
-   * from `assertPopMatchesBtcWallet`'s return value rather than
-   * `popSignature.depositorBtcPubkey` (which is x-only, parity stripped).
-   * For wallets that expose a compressed key this preserves y-parity end to
-   * end. For Taproot wallets that only expose an x-only key, the helper
-   * itself fails closed for P2WPKH — the parity is unknowable, so the
-   * payout sink must be a P2TR address derived from that same x.
-   *
-   * The helper does not call into the wallet so the batch path can resolve
-   * many requests without any extra adapter reads. Threat closed: a
-   * state-race or stale FE state that lets a non-wallet address reach the
-   * on-chain payout-script registration.
-   */
-  resolvePayoutScriptPubKey(t, e) {
-    if (!Pt(
-      e,
-      t,
-      this.config.btcNetwork
-    ))
-      throw T(t).length === le && dn(e, this.config.btcNetwork) ? new Error(
-        `BTC payout address "${e}" is a P2WPKH (Native SegWit) address, but the connected wallet only exposes an x-only public key. P2WPKH validation requires a compressed key with known y-parity. Use a P2TR (Taproot) payout address instead.`
-      ) : new Error(
-        `BTC payout address "${e}" is not derived from the connected wallet's public key. The payout sink must be controlled by the same key that signs the pegin; refusing to register a mismatched address.`
-      );
-    const s = wt(this.config.btcNetwork);
-    try {
-      return `0x${Ct.address.toOutputScript(e, s).toString("hex")}`;
-    } catch {
-      throw new Error(
-        `Invalid BTC payout address: "${e}". Please provide a valid Bitcoin address for the ${this.config.btcNetwork} network.`
-      );
-    }
-  }
-  /**
-   * Sign a BIP-322 BTC Proof-of-Possession binding the connected BTC
-   * wallet to the connected ETH account for this chain and vault
-   * registry. The returned {@link PopSignature} can be reused across
-   * every register call in the same session.
-   */
-  async signProofOfPossession() {
-    if (!this.config.ethWallet.account)
-      throw new Error("Ethereum wallet account not found");
-    const t = this.config.ethWallet.account.address, e = $(
-      await this.config.btcWallet.getPublicKeyHex()
-    ), s = this.config.vaultContracts.btcVaultRegistry, o = `${t.toLowerCase()}:${this.config.ethChain.id}:pegin:${s.toLowerCase()}`, r = await this.config.btcWallet.signMessage(
-      o,
-      "bip322-simple"
-    );
-    return {
-      btcPopSignature: hn(r),
-      depositorEthAddress: t,
-      depositorBtcPubkey: e
-    };
-  }
-  /**
-   * Confirm the connected BTC wallet still matches the PoP it produced, and
-   * return the wallet's *raw* pubkey hex (parity-preserving form, as the
-   * wallet adapter returns it). The raw form is required by callers that
-   * validate Native SegWit / P2WPKH addresses, since P2WPKH is derived from
-   * a parity-bearing compressed key — an x-only form would let an attacker
-   * substitute the opposite-parity P2WPKH address.
-   */
-  async assertPopMatchesBtcWallet(t) {
-    const e = await this.config.btcWallet.getPublicKeyHex(), s = $(e), o = $(t.depositorBtcPubkey);
-    if (s !== o)
-      throw new Error(
-        `Proof of possession was signed with BTC pubkey ${o} but the BTC wallet is currently connected to ${s}. Reconnect the original wallet or call signProofOfPossession() again.`
-      );
-    return e;
-  }
-  /**
-   * Gets the configured Bitcoin network.
-   *
-   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
-   */
-  getNetwork() {
-    return this.config.btcNetwork;
-  }
-  /**
-   * Gets the configured BTCVaultRegistry contract address.
-   *
-   * @returns The Ethereum address of the BTCVaultRegistry contract
-   */
-  getVaultContractAddress() {
-    return this.config.vaultContracts.btcVaultRegistry;
-  }
-}
-const fn = 80, pn = 250, mn = 300, bn = 22, Gt = "ab";
-function Pn(n, t) {
-  const e = Gt.repeat(mn), s = T(n).toLowerCase(), o = t.toString(16).padStart(8, "0"), r = `${s}${o}`, i = e.slice(r.length);
-  return `0x${r}${i}`;
-}
-function wn(n, t) {
-  const e = (s) => `0x${Gt.repeat(s)}`;
-  return {
-    depositorBtcPubKey: e(32),
-    btcPopSignature: e(fn),
-    unsignedPrePeginTx: e(pn),
-    depositorSignedPeginTx: Pn(
-      n,
-      t
-    ),
-    hashlock: e(32),
-    htlcVout: t,
-    referralCode: Dt,
-    depositorPayoutBtcAddress: e(bn),
-    depositorWotsPkHash: e(32)
-  };
-}
-async function Mn(n) {
-  const {
-    publicClient: t,
-    btcVaultRegistry: e,
-    depositorEthAddress: s,
-    vaultProvider: o,
-    batchSize: r
-  } = n;
-  if (r <= 0)
-    throw new Error(
-      `estimateSubmitPeginRequestBatchGas requires batchSize >= 1 (received ${r})`
-    );
-  const a = await t.readContract({
-    address: e,
-    abi: A,
-    functionName: "getPegInFee",
-    args: [o]
-  }) * BigInt(r), c = Array.from(
-    { length: r },
-    (l, m) => wn(s, m)
-  ), h = tt({
-    abi: A,
-    functionName: "submitPeginRequestBatch",
-    args: [
-      s,
-      o,
-      rt,
-      c
-    ]
-  });
-  return t.estimateGas({
-    to: e,
-    data: h,
-    value: a,
-    account: s
-  });
-}
-export {
-  Vn as P,
-  Ce as V,
-  Ae as a,
-  Ie as b,
-  rn as c,
-  on as d,
-  Mn as e,
-  Oe as f
-};
-//# sourceMappingURL=PeginManager-D22MLWfM.js.map