@babylonlabs-io/ts-sdk 0.55.1 → 0.56.0

package/dist/PeginManager-aYBkb-Qx.js

@@ -0,0 +1,1289 @@
+var Ft = Object.defineProperty;
+var Nt = (s, e, t) => e in s ? Ft(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var y = (s, e, t) => Nt(s, typeof e != "symbol" ? e + "" : e, t);
+import { c as Tt, H as Wt, r as M, a as L, b as st, u as Lt, d as ot, e as nt, f as rt, g as Dt, s as Bt } from "./sha2-BYVxyZzX.js";
+import * as Et from "bitcoinjs-lib";
+import { Transaction as Xt, Psbt as it } from "bitcoinjs-lib";
+import { Buffer as Y } from "buffer";
+import { isAddressEqual as at, encodeFunctionData as j, zeroAddress as Kt } from "viem";
+import { B as H } from "./BTCVaultRegistry.abi-Chs4AFBj.js";
+import { h as R } from "./errors-Blc-JWnI.js";
+import { expandWotsSeed as Gt, expandHashlockSecret as qt, expandAuthAnchor as zt, deriveVaultId as ct } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import { a as lt, b as Yt, d as ut, f as jt } from "./verifyScriptPathSchnorrSignature-CgrnAjMW.js";
+import { b as Qt, e as Zt, f as Jt } from "./peginInput-BKD_b3gq.js";
+import { u as Q, e as A, p as te, i as ht, h as dt, s as v, j as gt, X as ee } from "./bitcoin-B5aNKtsk.js";
+import { c as se } from "./signing-DaLvGwQe.js";
+import { M as ft } from "./validation-CxqROCno.js";
+import { d as oe } from "./deriveVaultRoot-B_gEOTD6.js";
+import { c as ne, a as re, s as ie, b as ae } from "./PayoutManager-BVgmuKuK.js";
+import { s as ce, f as X, i as le, w as pt } from "./waitForTransactionReceiptSmartAware-lobLm0q0.js";
+import { p as ue, f as he } from "./fundPeginTransaction-B2wyjqp0.js";
+import { M as mt, B as de } from "./constants-CDQE812z.js";
+import { p as ge, V as fe, i as pe } from "./mempoolApi-P_ApODLd.js";
+const U = /* @__PURE__ */ BigInt(2 ** 32 - 1), Pt = /* @__PURE__ */ BigInt(32);
+function me(s, e = !1) {
+  return e ? { h: Number(s & U), l: Number(s >> Pt & U) } : { h: Number(s >> Pt & U) | 0, l: Number(s & U) | 0 };
+}
+function Pe(s, e = !1) {
+  const t = s.length;
+  let o = new Uint32Array(t), n = new Uint32Array(t);
+  for (let r = 0; r < t; r++) {
+    const { h: i, l: a } = me(s[r], e);
+    [o[r], n[r]] = [i, a];
+  }
+  return [o, n];
+}
+const be = (s, e, t) => s << t | e >>> 32 - t, we = (s, e, t) => e << t | s >>> 32 - t, xe = (s, e, t) => e << t - 32 | s >>> 64 - t, ye = (s, e, t) => s << t - 32 | e >>> 64 - t, ke = 64;
+function Te(s) {
+  const e = s.prepeginTxid.toLowerCase();
+  if (!/^[0-9a-f]+$/.test(e) || e.length !== ke)
+    throw new Error(`buildDepositTerms: prepeginTxid must be 64 hex chars, got "${s.prepeginTxid}"`);
+  if (s.vaultAmounts.length === 0)
+    throw new Error("buildDepositTerms: at least one vault amount is required");
+  if (s.timelockPegin <= 0 || s.timelockRefund <= 0)
+    throw new Error("buildDepositTerms: timelocks must be positive");
+  if (!Number.isInteger(s.commissionBps) || s.commissionBps < 0 || s.commissionBps >= mt)
+    throw new Error(
+      `buildDepositTerms: commissionBps must be an integer in [0, ${mt}), got ${s.commissionBps}`
+    );
+  const t = BigInt(de), o = s.vaultAmounts.map((n, r) => ({
+    htlcVout: r,
+    vaultProviderPk: s.vaultProviderPk,
+    vaultAmount: n,
+    // floor(vaultAmount * bps / 10_000) — matches the vault provider's commission math.
+    commissionFee: n * BigInt(s.commissionBps) / t,
+    depositorClaimValue: s.depositorClaimValue,
+    peginMaxFee: s.peginMaxFee
+  }));
+  return {
+    baseFeeRate: s.protocolFeeRate,
+    peginCsvTimelock: s.timelockPegin,
+    payoutTimelock: s.timelockPegin,
+    htlcRefundTimelock: s.timelockRefund,
+    prepeginTxid: e,
+    prepeginMaxFee: s.prepeginMaxFee,
+    keeperPks: [...s.keeperPks],
+    challengerPks: [...s.challengerPks],
+    vaults: o
+  };
+}
+const Be = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), vt = Uint8Array.from(new Array(16).fill(0).map((s, e) => e)), Ee = vt.map((s) => (9 * s + 5) % 16), _t = /* @__PURE__ */ (() => {
+  const t = [[vt], [Ee]];
+  for (let o = 0; o < 4; o++)
+    for (let n of t)
+      n.push(n[o].map((r) => Be[r]));
+  return t;
+})(), St = _t[0], At = _t[1], It = /* @__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((s) => Uint8Array.from(s)), ve = /* @__PURE__ */ St.map((s, e) => s.map((t) => It[e][t])), _e = /* @__PURE__ */ At.map((s, e) => s.map((t) => It[e][t])), Se = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), Ae = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function bt(s, e, t, o) {
+  return s === 0 ? e ^ t ^ o : s === 1 ? e & t | ~e & o : s === 2 ? (e | ~t) ^ o : s === 3 ? e & o | t & ~o : e ^ (t | ~o);
+}
+const F = /* @__PURE__ */ new Uint32Array(16);
+class Ie extends Wt {
+  constructor() {
+    super(64, 20, 8, !0);
+    y(this, "h0", 1732584193);
+    y(this, "h1", -271733879);
+    y(this, "h2", -1732584194);
+    y(this, "h3", 271733878);
+    y(this, "h4", -1009589776);
+  }
+  get() {
+    const { h0: t, h1: o, h2: n, h3: r, h4: i } = this;
+    return [t, o, n, r, i];
+  }
+  set(t, o, n, r, i) {
+    this.h0 = t | 0, this.h1 = o | 0, this.h2 = n | 0, this.h3 = r | 0, this.h4 = i | 0;
+  }
+  process(t, o) {
+    for (let d = 0; d < 16; d++, o += 4)
+      F[d] = t.getUint32(o, !0);
+    let n = this.h0 | 0, r = n, i = this.h1 | 0, a = i, c = this.h2 | 0, u = c, l = this.h3 | 0, m = l, b = this.h4 | 0, w = b;
+    for (let d = 0; d < 5; d++) {
+      const E = 4 - d, k = Se[d], f = Ae[d], _ = St[d], p = At[d], P = ve[d], T = _e[d];
+      for (let h = 0; h < 16; h++) {
+        const x = M(n + bt(d, i, c, l) + F[_[h]] + k, P[h]) + b | 0;
+        n = b, b = l, l = M(c, 10) | 0, c = i, i = x;
+      }
+      for (let h = 0; h < 16; h++) {
+        const x = M(r + bt(E, a, u, m) + F[p[h]] + f, T[h]) + w | 0;
+        r = w, w = m, m = M(u, 10) | 0, u = a, a = x;
+      }
+    }
+    this.set(this.h1 + c + m | 0, this.h2 + l + w | 0, this.h3 + b + r | 0, this.h4 + n + a | 0, this.h0 + i + u | 0);
+  }
+  roundClean() {
+    L(F);
+  }
+  destroy() {
+    this.destroyed = !0, L(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const Ce = /* @__PURE__ */ Tt(() => new Ie()), He = BigInt(0), $ = BigInt(1), Re = BigInt(2), Oe = BigInt(7), $e = BigInt(256), Ve = BigInt(113), Ct = [], Ht = [], Rt = [];
+for (let s = 0, e = $, t = 1, o = 0; s < 24; s++) {
+  [t, o] = [o, (2 * t + 3 * o) % 5], Ct.push(2 * (5 * o + t)), Ht.push((s + 1) * (s + 2) / 2 % 64);
+  let n = He;
+  for (let r = 0; r < 7; r++)
+    e = (e << $ ^ (e >> Oe) * Ve) % $e, e & Re && (n ^= $ << ($ << BigInt(r)) - $);
+  Rt.push(n);
+}
+const Ot = Pe(Rt, !0), Me = Ot[0], Ue = Ot[1], wt = (s, e, t) => t > 32 ? xe(s, e, t) : be(s, e, t), xt = (s, e, t) => t > 32 ? ye(s, e, t) : we(s, e, t);
+function Fe(s, e = 24) {
+  const t = new Uint32Array(10);
+  for (let o = 24 - e; o < 24; o++) {
+    for (let i = 0; i < 10; i++)
+      t[i] = s[i] ^ s[i + 10] ^ s[i + 20] ^ s[i + 30] ^ s[i + 40];
+    for (let i = 0; i < 10; i += 2) {
+      const a = (i + 8) % 10, c = (i + 2) % 10, u = t[c], l = t[c + 1], m = wt(u, l, 1) ^ t[a], b = xt(u, l, 1) ^ t[a + 1];
+      for (let w = 0; w < 50; w += 10)
+        s[i + w] ^= m, s[i + w + 1] ^= b;
+    }
+    let n = s[2], r = s[3];
+    for (let i = 0; i < 24; i++) {
+      const a = Ht[i], c = wt(n, r, a), u = xt(n, r, a), l = Ct[i];
+      n = s[l], r = s[l + 1], s[l] = c, s[l + 1] = u;
+    }
+    for (let i = 0; i < 50; i += 10) {
+      for (let a = 0; a < 10; a++)
+        t[a] = s[i + a];
+      for (let a = 0; a < 10; a++)
+        s[i + a] ^= ~t[(a + 2) % 10] & t[(a + 4) % 10];
+    }
+    s[0] ^= Me[o], s[1] ^= Ue[o];
+  }
+  L(t);
+}
+class tt {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(e, t, o, n = !1, r = 24) {
+    y(this, "state");
+    y(this, "pos", 0);
+    y(this, "posOut", 0);
+    y(this, "finished", !1);
+    y(this, "state32");
+    y(this, "destroyed", !1);
+    y(this, "blockLen");
+    y(this, "suffix");
+    y(this, "outputLen");
+    y(this, "enableXOF", !1);
+    y(this, "rounds");
+    if (this.blockLen = e, this.suffix = t, this.outputLen = o, this.enableXOF = n, this.rounds = r, st(o, "outputLen"), !(0 < e && e < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200), this.state32 = Lt(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    ot(this.state32), Fe(this.state32, this.rounds), ot(this.state32), this.posOut = 0, this.pos = 0;
+  }
+  update(e) {
+    nt(this), rt(e);
+    const { blockLen: t, state: o } = this, n = e.length;
+    for (let r = 0; r < n; ) {
+      const i = Math.min(t - this.pos, n - r);
+      for (let a = 0; a < i; a++)
+        o[this.pos++] ^= e[r++];
+      this.pos === t && this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = !0;
+    const { state: e, suffix: t, pos: o, blockLen: n } = this;
+    e[o] ^= t, (t & 128) !== 0 && o === n - 1 && this.keccak(), e[n - 1] ^= 128, this.keccak();
+  }
+  writeInto(e) {
+    nt(this, !1), rt(e), this.finish();
+    const t = this.state, { blockLen: o } = this;
+    for (let n = 0, r = e.length; n < r; ) {
+      this.posOut >= o && this.keccak();
+      const i = Math.min(o - this.posOut, r - n);
+      e.set(t.subarray(this.posOut, this.posOut + i), n), this.posOut += i, n += i;
+    }
+    return e;
+  }
+  xofInto(e) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(e);
+  }
+  xof(e) {
+    return st(e), this.xofInto(new Uint8Array(e));
+  }
+  digestInto(e) {
+    if (Dt(e, this), this.finished)
+      throw new Error("digest() was already called");
+    return this.writeInto(e), this.destroy(), e;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = !0, L(this.state);
+  }
+  _cloneInto(e) {
+    const { blockLen: t, suffix: o, outputLen: n, rounds: r, enableXOF: i } = this;
+    return e || (e = new tt(t, o, n, i, r)), e.state32.set(this.state32), e.pos = this.pos, e.posOut = this.posOut, e.finished = this.finished, e.rounds = r, e.suffix = o, e.outputLen = n, e.enableXOF = i, e.destroyed = this.destroyed, e;
+  }
+}
+const Ne = (s, e, t, o = {}) => Tt(() => new tt(e, s, t), o), We = /* @__PURE__ */ Ne(1, 136, 32), yt = 64, S = 20, Z = 4, $t = 2, Le = 0, De = 1, N = [64, 64], Xe = (s) => Array.from(s).map((e) => e.toString(16).padStart(2, "0")).join("");
+function et(s) {
+  return Ce(Bt(s));
+}
+function Vt(s) {
+  return (1 << s) - 1;
+}
+function Ke(s) {
+  let e = 1;
+  for (; e * e < s + 1; ) e++;
+  return Math.max(e, 2);
+}
+function Ge(s) {
+  const e = Z, t = s * Vt(e);
+  return { d: e, n: s, checksum_radix: Ke(t) };
+}
+function K(s, e) {
+  const t = [];
+  let o = e;
+  for (; o > 0; )
+    t.push(o & 255), o >>>= 8;
+  const n = new Uint8Array(s.length + t.length);
+  n.set(s);
+  for (let r = 0; r < t.length; r++)
+    n[s.length + r] = t[r];
+  return et(n);
+}
+function G(s, e) {
+  let t = s;
+  for (let o = 0; o < e; o++)
+    t = et(t);
+  return t;
+}
+function qe(s, e) {
+  const t = Vt(e.d), o = e.checksum_radix - 1, n = Math.floor(e.n * t / e.checksum_radix), r = [];
+  for (let l = 0; l < e.n; l++) {
+    const m = K(s, l + $t), b = G(m, t);
+    r.push(Array.from(b));
+  }
+  const i = K(
+    s,
+    Le
+  ), a = G(
+    i,
+    o
+  ), c = K(
+    s,
+    De
+  ), u = G(
+    c,
+    n
+  );
+  return {
+    config: e,
+    message_terminals: r,
+    checksum_major_terminal: Array.from(u),
+    checksum_minor_terminal: Array.from(a)
+  };
+}
+async function ze(s) {
+  try {
+    if (s.length !== yt)
+      throw new Error(
+        `WOTS seed must be exactly ${yt} bytes, got ${s.length}`
+      );
+    const e = [];
+    for (let t = 0; t < N.length; t++) {
+      const o = N[t], n = Ge(o), r = new Uint8Array(s.length + 1);
+      r.set(s), r[s.length] = t;
+      const i = et(r);
+      try {
+        const a = qe(i, n);
+        if (a.config.d !== Z)
+          throw new Error(
+            `Block ${t}: expected d=${Z}, got d=${a.config.d}`
+          );
+        if (a.config.n !== o)
+          throw new Error(
+            `Block ${t}: expected n=${o}, got n=${a.config.n}`
+          );
+        if (a.message_terminals.length !== o)
+          throw new Error(
+            `Block ${t}: expected ${o} message terminals, got ${a.message_terminals.length}`
+          );
+        for (let c = 0; c < a.message_terminals.length; c++)
+          if (a.message_terminals[c].length !== S)
+            throw new Error(
+              `Block ${t} terminal ${c}: expected ${S} bytes, got ${a.message_terminals[c].length}`
+            );
+        if (a.checksum_minor_terminal.length !== S)
+          throw new Error(
+            `Block ${t} checksum_minor: expected ${S} bytes`
+          );
+        if (a.checksum_major_terminal.length !== S)
+          throw new Error(
+            `Block ${t} checksum_major: expected ${S} bytes`
+          );
+        e.push(a);
+      } finally {
+        r.fill(0), i.fill(0);
+      }
+    }
+    if (e.length !== N.length)
+      throw new Error(
+        `Expected ${N.length} blocks, got ${e.length}`
+      );
+    return e;
+  } finally {
+    s.fill(0);
+  }
+}
+function q(s, e, t) {
+  if (s.length !== S)
+    throw new Error(
+      `Block ${e} ${t}: expected ${S} bytes, got ${s.length}`
+    );
+  for (let o = 0; o < s.length; o++) {
+    const n = s[o];
+    if (!Number.isInteger(n) || n < 0 || n > 255)
+      throw new Error(
+        `Block ${e} ${t}[${o}]: invalid byte value ${n}`
+      );
+  }
+}
+function Ye(s) {
+  if (s.length === 0)
+    throw new Error("Public keys array must not be empty");
+  for (let r = 0; r < s.length; r++) {
+    const i = s[r];
+    q(i.checksum_minor_terminal, r, "checksum_minor_terminal"), q(i.checksum_major_terminal, r, "checksum_major_terminal");
+    for (let a = 0; a < i.message_terminals.length; a++)
+      q(i.message_terminals[a], r, `message_terminal[${a}]`);
+  }
+  let e = 0;
+  for (const r of s)
+    e += $t + r.message_terminals.length;
+  const t = new Uint8Array(e * S);
+  let o = 0;
+  for (const r of s) {
+    t.set(r.checksum_minor_terminal, o), o += S, t.set(r.checksum_major_terminal, o), o += S;
+    for (const i of r.message_terminals)
+      t.set(i, o), o += S;
+  }
+  const n = We(t);
+  return `0x${Xe(n)}`;
+}
+async function je(s, e) {
+  const t = [], o = [], n = [], r = [];
+  try {
+    for (let i = 0; i < e; i++) {
+      const a = await Gt(s, i);
+      try {
+        const u = await ze(a);
+        t.push(u), o.push(Ye(u));
+      } finally {
+        a.fill(0);
+      }
+      const c = await qt(s, i);
+      try {
+        const u = Q(c);
+        n.push(u), r.push(ne(A(u)).slice(2));
+      } finally {
+        c.fill(0);
+      }
+    }
+  } finally {
+    s.fill(0);
+  }
+  return { perVaultWotsKeys: t, wotsPkHashes: o, htlcSecretHexes: n, hashlocks: r };
+}
+const Qe = /^0x[0-9a-f]+$/i, Ze = /^[0-9a-f]+$/i, Je = /^[A-Za-z0-9+/]+={0,2}$/;
+function V(s) {
+  if (typeof s != "string" || s.length === 0)
+    throw new Error("BTC wallet returned empty public key");
+  return te(s).toLowerCase();
+}
+function ts(s) {
+  if (typeof s != "string" || s.length === 0)
+    throw new Error("BTC wallet returned empty BIP-322 signature");
+  if (s.startsWith("0x") || s.startsWith("0X")) {
+    if (!Qe.test(s) || s.length < 4 || s.length % 2 !== 0)
+      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
+    return s.toLowerCase();
+  }
+  if (Ze.test(s)) {
+    if (s.length % 2 !== 0)
+      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
+    return `0x${s.toLowerCase()}`;
+  }
+  if (!Je.test(s) || s.length % 4 !== 0)
+    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
+  const e = Y.from(s, "base64");
+  if (e.length === 0 || e.toString("base64") !== s)
+    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
+  return `0x${e.toString("hex")}`;
+}
+const Mt = 0, W = 25, J = 9999, z = "00".repeat(32);
+function es(s, e) {
+  const t = {
+    bitcoin: "bc",
+    testnet: "tb",
+    signet: "tb",
+    regtest: "bcrt"
+  };
+  try {
+    const o = Et.address.fromBech32(s);
+    return o.prefix === t[e] && o.version === 0 && o.data.length === 20;
+  } catch {
+    return !1;
+  }
+}
+function ss(s, e, t, o) {
+  const n = t == null ? void 0 : t[`${s}:${e}`];
+  return n ? Promise.resolve({
+    txid: s,
+    vout: e,
+    value: n.value,
+    scriptPubKey: n.scriptPubKey
+  }) : pe(s, e, o);
+}
+const kt = 12e4;
+class Ss {
+  /**
+   * Creates a new PeginManager instance.
+   *
+   * @param config - Manager configuration including wallets and contract addresses
+   */
+  constructor(e) {
+    y(this, "config");
+    this.config = e;
+  }
+  /**
+   * 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(e) {
+    if (e.amounts.length === 0)
+      throw new Error("amounts must contain at least one entry");
+    const t = await this.config.btcWallet.getPublicKeyHex(), o = V(t);
+    if (!ht(
+      e.changeAddress,
+      t,
+      this.config.btcNetwork
+    ))
+      throw new Error(
+        `Pre-PegIn changeAddress "${e.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 n = await this.prepareSizing(o, e), r = n.selectedUTXOs.map(
+      (f) => ({
+        txid: dt(f.txid),
+        vout: f.vout
+      })
+    ), i = await oe(this.config.btcWallet, {
+      depositorBtcPubkey: dt(o),
+      fundingOutpoints: r
+    });
+    let a, c;
+    try {
+      const f = await zt(i);
+      try {
+        a = Q(f), c = Q(Bt(f));
+      } finally {
+        f.fill(0);
+      }
+    } catch (f) {
+      throw i.fill(0), f;
+    }
+    const u = await je(i, e.amounts.length), { perVaultWotsKeys: l, wotsPkHashes: m, htlcSecretHexes: b, hashlocks: w } = u, d = await this.preparePeginCommit({
+      depositorBtcPubkeyRaw: t,
+      depositorBtcPubkey: o,
+      hashlocks: w,
+      authAnchorHash: c,
+      sizing: n,
+      params: e
+    });
+    for (let f = 0; f < d.perVault.length; f++)
+      if (d.perVault[f].htlcVout !== f)
+        throw new Error(
+          `Internal invariant violation: htlcVout/index mismatch at vault ${f} (expected ${f}, got ${d.perVault[f].htlcVout})`
+        );
+    re(
+      d.fundedPrePeginTxHex,
+      e.amounts.length,
+      c
+    );
+    const { depositTerms: E, ...k } = d;
+    return {
+      transaction: {
+        ...k,
+        selectedUTXOs: n.selectedUTXOs,
+        fee: n.fee,
+        changeAmount: n.changeAmount
+      },
+      depositorBtcPubkey: o,
+      derivedSecrets: {
+        perVaultWotsKeys: l,
+        wotsPkHashes: m,
+        htlcSecretHexes: b,
+        authAnchorHex: a
+      },
+      depositTerms: E
+    };
+  }
+  /**
+   * 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(e, t) {
+    const o = t.amounts.map(
+      () => z
+    ), n = t.vaultKeeperBtcPubkeys.length, r = await lt({
+      vaultCoreVersion: t.vaultCoreVersion,
+      depositorPubkey: e,
+      vaultProviderPubkey: v(t.vaultProviderBtcPubkey),
+      vaultKeeperPubkeys: t.vaultKeeperBtcPubkeys.map(v),
+      universalChallengerPubkeys: t.universalChallengerBtcPubkeys.map(v),
+      hashlocks: o,
+      timelockRefund: t.timelockRefund,
+      pegInAmounts: t.amounts,
+      feeRate: t.protocolFeeRate,
+      minPeginFeeRate: t.minPeginFeeRate,
+      numLocalChallengers: n,
+      councilQuorum: t.councilQuorum,
+      councilSize: t.councilSize,
+      network: this.config.btcNetwork,
+      authAnchorHash: z
+    }), i = ce(
+      [...t.availableUTXOs],
+      r.totalOutputValue,
+      t.mempoolFeeRate,
+      ue(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(e) {
+    const {
+      depositorBtcPubkeyRaw: t,
+      depositorBtcPubkey: o,
+      hashlocks: n,
+      authAnchorHash: r,
+      sizing: i,
+      params: a
+    } = e, c = z.toLowerCase();
+    for (let g = 0; g < n.length; g++)
+      if (n[g].toLowerCase() === c)
+        throw new Error(
+          `preparePeginCommit refusing to build with sizing-pass placeholder hashlock at vault ${g} — 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 u = v(
+      a.vaultProviderBtcPubkey
+    ), l = a.vaultKeeperBtcPubkeys.map(v), m = a.universalChallengerBtcPubkeys.map(v), b = l.length, w = {
+      vaultCoreVersion: a.vaultCoreVersion,
+      depositorPubkey: o,
+      vaultProviderPubkey: u,
+      vaultKeeperPubkeys: l,
+      universalChallengerPubkeys: m,
+      hashlocks: n,
+      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
+    }, d = await lt(w), E = gt(this.config.btcNetwork), k = he({
+      unfundedTxHex: d.psbtHex,
+      selectedUTXOs: i.selectedUTXOs,
+      changeAddress: a.changeAddress,
+      changeAmount: i.changeAmount,
+      network: E
+    }), f = i.selectedUTXOs.reduce((g, B) => g + BigInt(B.value), 0n) - d.totalOutputValue - i.changeAmount;
+    if (f !== i.fee)
+      throw new Error(
+        `Pre-PegIn funded fee ${f} does not match the sizing-pass fee ${i.fee}; refusing to publish a deposit-terms fee bound the funded transaction does not pay.`
+      );
+    const _ = v(
+      X(k)
+    ), p = [], P = [], T = [];
+    for (let g = 0; g < n.length; g++) {
+      const B = await Yt({
+        prePeginParams: w,
+        timelockPegin: a.timelockPegin,
+        fundedPrePeginTxHex: k,
+        htlcVout: g
+      }), C = await Qt({
+        vaultCoreVersion: a.vaultCoreVersion,
+        peginTxHex: B.txHex,
+        fundedPrePeginTxHex: k,
+        depositorPubkey: o,
+        vaultProviderPubkey: u,
+        vaultKeeperPubkeys: l,
+        universalChallengerPubkeys: m,
+        hashlock: n[g],
+        timelockRefund: a.timelockRefund,
+        network: this.config.btcNetwork
+      });
+      p.push(B), P.push(C.psbtHex), T.push(
+        se(t, 1)
+      );
+    }
+    const h = Te({
+      protocolFeeRate: a.protocolFeeRate,
+      timelockPegin: a.timelockPegin,
+      timelockRefund: a.timelockRefund,
+      prepeginTxid: _,
+      prepeginMaxFee: i.fee,
+      vaultProviderPk: u,
+      keeperPks: l,
+      challengerPks: m,
+      commissionBps: a.commissionBps,
+      vaultAmounts: a.amounts,
+      depositorClaimValue: d.depositorClaimValue,
+      peginMaxFee: d.minPeginFee
+    });
+    ie(this.config.btcWallet) && await this.config.btcWallet.approveDepositTerms(h);
+    const x = await ae(
+      this.config.btcWallet,
+      P,
+      T
+    ), I = [];
+    for (let g = 0; g < x.length; g++) {
+      ut({
+        requestedPsbtHex: P[g],
+        returnedPsbtHex: x[g]
+      });
+      const B = Zt(
+        x[g],
+        o
+      );
+      jt({
+        requestedPsbtHex: P[g],
+        signatureHex: B,
+        signerXOnlyPubkeyHex: o,
+        inputIndex: 0
+      });
+      const C = Jt(x[g]);
+      I.push({
+        htlcVout: g,
+        htlcValue: d.htlcValues[g],
+        peginTxHex: C,
+        peginTxid: p[g].txid,
+        peginInputSignature: B,
+        vaultScriptPubKey: p[g].vaultScriptPubKey
+      });
+    }
+    return {
+      fundedPrePeginTxHex: k,
+      prePeginTxid: _,
+      perVault: I,
+      depositTerms: h
+    };
+  }
+  /**
+   * 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(e) {
+    const { fundedPrePeginTxHex: t, depositorBtcPubkey: o } = e, n = t.startsWith("0x") ? t.slice(2) : t, r = Xt.fromHex(n);
+    if (r.ins.length === 0)
+      throw new Error("Transaction has no inputs");
+    const i = new it();
+    i.setVersion(r.version), i.setLocktime(r.locktime);
+    const a = Y.from(
+      V(o),
+      "hex"
+    ), c = this.config.mempoolApiUrl, u = r.ins.map((p) => {
+      const P = Y.from(p.hash).reverse().toString("hex"), T = p.index;
+      return ss(P, T, e.localPrevouts, c).then(
+        (h) => ({ input: p, utxoData: h, txid: P, vout: T })
+      );
+    }), l = await Promise.all(u), m = l.reduce(
+      (p, P) => p + BigInt(P.utxoData.value),
+      0n
+    ), b = r.outs.reduce(
+      (p, P) => p + BigInt(P.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 w = m - b;
+    if (w > ft)
+      throw new Error(
+        `Implied transaction fee (${w} sat) exceeds maximum reasonable fee (${ft} sat). This may indicate manipulated UTXO data.`
+      );
+    for (const { input: p, utxoData: P, txid: T, vout: h } of l) {
+      const x = le(
+        {
+          value: P.value,
+          scriptPubKey: P.scriptPubKey
+        },
+        a
+      );
+      i.addInput({
+        hash: p.hash,
+        index: p.index,
+        sequence: p.sequence,
+        ...x
+      });
+    }
+    for (const p of r.outs)
+      i.addOutput({
+        script: p.script,
+        value: p.value
+      });
+    const d = i.toHex(), E = await this.config.btcWallet.signPsbt(d);
+    ut({
+      requestedPsbtHex: d,
+      returnedPsbtHex: E
+    });
+    const k = it.fromHex(E);
+    try {
+      k.finalizeAllInputs();
+    } catch (p) {
+      if (!k.data.inputs.every(
+        (T) => T.finalScriptWitness || T.finalScriptSig
+      ))
+        throw new Error(
+          `PSBT finalization failed and wallet did not auto-finalize: ${p}`
+        );
+    }
+    const f = k.extractTransaction().toHex();
+    return await ge(f, 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(e) {
+    const {
+      unsignedPrePeginTx: t,
+      depositorSignedPeginTx: o,
+      vaultProvider: n,
+      hashlock: r,
+      htlcVout: i,
+      depositorPayoutBtcAddress: a,
+      depositorWotsPkHash: c,
+      popSignature: u
+    } = e;
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const l = this.config.ethWallet.account.address;
+    if (!at(u.depositorEthAddress, l))
+      throw new Error(
+        `Proof of possession was signed for ${u.depositorEthAddress} but the Ethereum wallet is currently connected to ${l}. Reconnect the original account or call signProofOfPossession() again.`
+      );
+    const m = await this.assertPopMatchesBtcWallet(u), b = u.btcPopSignature, w = A(
+      u.depositorBtcPubkey
+    ), d = A(t), E = A(o), k = a ?? await this.config.btcWallet.getAddress(), f = this.resolvePayoutScriptPubKey(
+      m,
+      k
+    ), _ = X(E), p = await ct(
+      v(_),
+      v(l)
+    ), P = A(p);
+    if (await this.checkVaultExists(P))
+      throw new Error(
+        `Vault already exists (ID: ${P}, peginTxHash: ${_}). 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 h = this.config.publicClient;
+    let x;
+    try {
+      x = await h.readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: H,
+        functionName: "getPegInFee",
+        args: [n]
+      });
+    } 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 I = await this.resolveMaxAcceptableCommissionBps(
+      n,
+      e.quotedCommissionBps
+    ), g = j({
+      abi: H,
+      functionName: "submitPeginRequest",
+      args: [
+        l,
+        w,
+        b,
+        d,
+        E,
+        n,
+        I,
+        r,
+        i,
+        f,
+        c
+      ]
+    });
+    let B;
+    try {
+      B = await h.estimateGas({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: g,
+        value: x,
+        account: this.config.ethWallet.account.address
+      });
+    } catch (O) {
+      R(O);
+    }
+    let C;
+    try {
+      C = await this.config.ethWallet.sendTransaction({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: g,
+        value: x,
+        account: this.config.ethWallet.account,
+        chain: this.config.ethChain,
+        gas: B
+      });
+    } catch (O) {
+      R(O);
+    }
+    const D = await pt({
+      publicClient: h,
+      walletAddress: this.config.ethWallet.account.address,
+      hash: C,
+      timeout: kt
+    });
+    return D.status === "reverted" && R(
+      new Error(
+        `Transaction reverted. Hash: ${D.transactionHash}. Check the transaction on block explorer for details.`
+      )
+    ), {
+      ethTxHash: D.transactionHash,
+      vaultId: P,
+      peginTxHash: _
+    };
+  }
+  /**
+   * 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(e) {
+    const { vaultProvider: t, unsignedPrePeginTx: o, requests: n, popSignature: r } = e;
+    if (n.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 (!at(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, u = n.map(
+      (h) => this.resolvePayoutScriptPubKey(
+        a,
+        h.depositorPayoutBtcAddress
+      )
+    ), l = [];
+    for (const h of n) {
+      const x = A(
+        h.depositorSignedPeginTx
+      ), I = X(x), g = await ct(
+        v(I),
+        v(i)
+      ), B = A(g);
+      if (await this.checkVaultExists(B))
+        throw new Error(
+          `Vault already exists (ID: ${B}, peginTxHash: ${I}). To create a new vault, use different UTXOs or a different amount.`
+        );
+      l.push({ vaultId: B, peginTxHash: I });
+    }
+    const m = this.config.publicClient;
+    let b;
+    try {
+      b = await m.readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: H,
+        functionName: "getPegInFee",
+        args: [t]
+      });
+    } catch (h) {
+      throw new Error(
+        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct.",
+        { cause: h }
+      );
+    }
+    const w = b * BigInt(n.length), d = await this.resolveMaxAcceptableCommissionBps(
+      t,
+      e.quotedCommissionBps
+    ), E = A(
+      r.depositorBtcPubkey
+    ), k = A(o), f = n.map((h, x) => ({
+      depositorBtcPubKey: E,
+      btcPopSignature: c,
+      unsignedPrePeginTx: k,
+      depositorSignedPeginTx: A(
+        h.depositorSignedPeginTx
+      ),
+      hashlock: h.hashlock,
+      htlcVout: h.htlcVout,
+      referralCode: Mt,
+      depositorPayoutBtcAddress: u[x],
+      depositorWotsPkHash: h.depositorWotsPkHash
+    })), _ = j({
+      abi: H,
+      functionName: "submitPeginRequestBatch",
+      args: [
+        i,
+        t,
+        d,
+        f
+      ]
+    });
+    let p;
+    try {
+      p = await m.estimateGas({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: _,
+        value: w,
+        account: this.config.ethWallet.account.address
+      });
+    } catch (h) {
+      R(h);
+    }
+    let P;
+    try {
+      P = await this.config.ethWallet.sendTransaction({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: _,
+        value: w,
+        account: this.config.ethWallet.account,
+        chain: this.config.ethChain,
+        gas: p
+      });
+    } catch (h) {
+      R(h);
+    }
+    const T = await pt({
+      publicClient: m,
+      walletAddress: this.config.ethWallet.account.address,
+      hash: P,
+      timeout: kt
+    });
+    return T.status === "reverted" && R(
+      new Error(
+        `Batch transaction reverted. Hash: ${T.transactionHash}. Check the transaction on block explorer for details.`
+      )
+    ), {
+      ethTxHash: T.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(e, t) {
+    let o;
+    try {
+      o = await new fe(
+        this.config.publicClient,
+        this.config.vaultContracts.btcVaultRegistry
+      ).getVaultProviderCommission(e);
+    } catch (n) {
+      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: n }
+      );
+    }
+    if (t !== void 0) {
+      if (o > t + W)
+        throw new Error(
+          `Vault provider commission changed since quote: quoted ${t} bps, chain currently reports ${o} bps (allowed drift ${W} bps). Please refresh to see the new commission and try again.`
+        );
+      return Math.min(
+        t + W,
+        J
+      );
+    }
+    return Math.min(
+      o + W,
+      J
+    );
+  }
+  /**
+   * 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(e) {
+    return (await this.config.publicClient.readContract({
+      address: this.config.vaultContracts.btcVaultRegistry,
+      abi: H,
+      functionName: "getBtcVaultBasicInfo",
+      args: [e]
+    })).depositor !== Kt;
+  }
+  /**
+   * 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(e, t) {
+    if (!ht(
+      t,
+      e,
+      this.config.btcNetwork
+    ))
+      throw v(e).length === ee && es(t, this.config.btcNetwork) ? new Error(
+        `BTC payout address "${t}" 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 "${t}" 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 o = gt(this.config.btcNetwork);
+    try {
+      return `0x${Et.address.toOutputScript(t, o).toString("hex")}`;
+    } catch {
+      throw new Error(
+        `Invalid BTC payout address: "${t}". 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 e = this.config.ethWallet.account.address, t = V(
+      await this.config.btcWallet.getPublicKeyHex()
+    ), o = this.config.vaultContracts.btcVaultRegistry, n = `${e.toLowerCase()}:${this.config.ethChain.id}:pegin:${o.toLowerCase()}`, r = await this.config.btcWallet.signMessage(
+      n,
+      "bip322-simple"
+    );
+    return {
+      btcPopSignature: ts(r),
+      depositorEthAddress: e,
+      depositorBtcPubkey: t
+    };
+  }
+  /**
+   * 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(e) {
+    const t = await this.config.btcWallet.getPublicKeyHex(), o = V(t), n = V(e.depositorBtcPubkey);
+    if (o !== n)
+      throw new Error(
+        `Proof of possession was signed with BTC pubkey ${n} but the BTC wallet is currently connected to ${o}. Reconnect the original wallet or call signProofOfPossession() again.`
+      );
+    return t;
+  }
+  /**
+   * 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 os = 80, ns = 250, rs = 300, is = 22, Ut = "ab";
+function as(s, e) {
+  const t = Ut.repeat(rs), o = v(s).toLowerCase(), n = e.toString(16).padStart(8, "0"), r = `${o}${n}`, i = t.slice(r.length);
+  return `0x${r}${i}`;
+}
+function cs(s, e) {
+  const t = (o) => `0x${Ut.repeat(o)}`;
+  return {
+    depositorBtcPubKey: t(32),
+    btcPopSignature: t(os),
+    unsignedPrePeginTx: t(ns),
+    depositorSignedPeginTx: as(
+      s,
+      e
+    ),
+    hashlock: t(32),
+    htlcVout: e,
+    referralCode: Mt,
+    depositorPayoutBtcAddress: t(is),
+    depositorWotsPkHash: t(32)
+  };
+}
+async function As(s) {
+  const {
+    publicClient: e,
+    btcVaultRegistry: t,
+    depositorEthAddress: o,
+    vaultProvider: n,
+    batchSize: r
+  } = s;
+  if (r <= 0)
+    throw new Error(
+      `estimateSubmitPeginRequestBatchGas requires batchSize >= 1 (received ${r})`
+    );
+  const a = await e.readContract({
+    address: t,
+    abi: H,
+    functionName: "getPegInFee",
+    args: [n]
+  }) * BigInt(r), c = Array.from(
+    { length: r },
+    (l, m) => cs(o, m)
+  ), u = j({
+    abi: H,
+    functionName: "submitPeginRequestBatch",
+    args: [
+      o,
+      n,
+      J,
+      c
+    ]
+  });
+  return e.estimateGas({
+    to: t,
+    data: u,
+    value: a,
+    account: o
+  });
+}
+export {
+  Ss as P,
+  Te as b,
+  Ye as c,
+  ze as d,
+  As as e
+};
+//# sourceMappingURL=PeginManager-aYBkb-Qx.js.map