@babylonlabs-io/ts-sdk 0.72.1 → 0.73.0

package/dist/PeginManager-C9RPOd0L.js

@@ -0,0 +1,1216 @@
+var Te = Object.defineProperty;
+var Se = (o, e, t) => e in o ? Te(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var P = (o, e, t) => Se(o, typeof e != "symbol" ? e + "" : e, t);
+import { c as ve, a as Y, u as _e, b as z, d as j, e as Q, f as Be, g as de, s as pe } from "./sha2-CrlWM5S8.js";
+import * as ge from "bitcoinjs-lib";
+import { Transaction as fe, Psbt as Z } from "bitcoinjs-lib";
+import { Buffer as B } from "buffer";
+import { isAddressEqual as J, encodeFunctionData as Ce } from "viem";
+import { r as Ae, e as Ie, V as He, M as $e, N as Re } from "./pegin-registration-client-BdRiR8br.js";
+import { pushTx as Oe, getUtxoInfo as Fe } from "./tbv/core/clients/mempool/index.js";
+import { B as ee } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
+import { expandWotsSeed as We, expandHashlockSecret as Me, expandAuthAnchor as Ve } from "./tbv/core/wasm/index.js";
+import { a as te, b as De, i as oe, j as Ne } from "./verifyScriptPathSchnorrSignature-Ciq_xZhw.js";
+import { d as Ue, b as Ke, e as Le, f as Xe, c as Ge } from "./verifyKeyPathSchnorrSignature-BrgUJmV0.js";
+import { p as qe, h as K, u as L, e as Ye, i as se, s as w, k as ne } from "./bitcoin-C-TuHb-v.js";
+import { c as ze, a as je } from "./signing-Cm-McVR2.js";
+import { M as ie, X as Qe } from "./validation-OSC0xTHB.js";
+import { p as Ze, d as me } from "./parseFundingOutpoints-B67CoXpF.js";
+import { c as Je, s as C, r as et, b as tt, d as ot } from "./signPsbtsWithFallback-0VBALhjS.js";
+import { s as st, h as nt } from "./psbtInputFields-B3e05Xe6.js";
+import { p as it, f as rt } from "./fundPeginTransaction-B2wyjqp0.js";
+import { M as re, B as at } from "./constants-CPzppOdq.js";
+import * as ct from "@bitcoin-js/tiny-secp256k1-asmjs";
+import { v as lt, P as ut, a as ht, b as dt } from "./bip322Verify-D6sBBUHE.js";
+const R = /* @__PURE__ */ BigInt(2 ** 32 - 1), ae = /* @__PURE__ */ BigInt(32);
+function pt(o, e = !1) {
+  return e ? { h: Number(o & R), l: Number(o >> ae & R) } : { h: Number(o >> ae & R) | 0, l: Number(o & R) | 0 };
+}
+function gt(o, e = !1) {
+  const t = o.length;
+  let s = new Uint32Array(t), r = new Uint32Array(t);
+  for (let n = 0; n < t; n++) {
+    const { h: i, l: a } = pt(o[n], e);
+    [s[n], r[n]] = [i, a];
+  }
+  return [s, r];
+}
+const ft = (o, e, t) => o << t | e >>> 32 - t, mt = (o, e, t) => e << t | o >>> 32 - t, Pt = (o, e, t) => e << t - 32 | o >>> 64 - t, bt = (o, e, t) => o << t - 32 | e >>> 64 - t, wt = 64;
+function yt(o) {
+  const e = o.prepeginTxid.toLowerCase();
+  if (!/^[0-9a-f]+$/.test(e) || e.length !== wt)
+    throw new Error(
+      `buildDepositTerms: prepeginTxid must be 64 hex chars, got "${o.prepeginTxid}"`
+    );
+  if (o.peginAmounts.length === 0)
+    throw new Error("buildDepositTerms: at least one pegin amount is required");
+  if (o.timelockPegin <= 0 || o.timelockAssert <= 0 || o.timelockRefund <= 0)
+    throw new Error("buildDepositTerms: timelocks must be positive");
+  if (!Number.isInteger(o.maxAcceptableCommissionBps) || o.maxAcceptableCommissionBps < 0 || o.maxAcceptableCommissionBps >= re)
+    throw new Error(
+      `buildDepositTerms: maxAcceptableCommissionBps must be an integer in [0, ${re}), got ${o.maxAcceptableCommissionBps}`
+    );
+  const t = BigInt(at), s = o.peginAmounts.map(
+    (r, n) => ({
+      htlcVout: n,
+      vaultProviderBtcPubkey: o.vaultProviderBtcPubkey,
+      peginAmount: r,
+      // Ceiling, not quote: floor(peginAmount * maxAcceptableBps / 10_000) —
+      // the same bound the registration calldata enforces on-chain, so any
+      // stamped commission the contract admits stays under it (firmware
+      // >= c8db53e checks the payout commission output <= this value).
+      commissionFee: r * BigInt(o.maxAcceptableCommissionBps) / t,
+      depositorClaimValue: o.depositorClaimValue,
+      peginMaxFee: o.peginMaxFee
+    })
+  );
+  return {
+    vaultCoreVersion: o.vaultCoreVersion,
+    protocolFeeRate: o.protocolFeeRate,
+    timelockPegin: o.timelockPegin,
+    timelockAssert: o.timelockAssert,
+    timelockRefund: o.timelockRefund,
+    prepeginTxid: e,
+    prepeginMaxFee: o.prepeginMaxFee,
+    vaultKeeperBtcPubkeys: [...o.vaultKeeperBtcPubkeys],
+    universalChallengerBtcPubkeys: [...o.universalChallengerBtcPubkeys],
+    vaults: s
+  };
+}
+const xt = /^0x[0-9a-f]+$/i, kt = /^[0-9a-f]+$/i, Et = /^[A-Za-z0-9+/]+={0,2}$/;
+function _(o) {
+  if (typeof o != "string" || o.length === 0)
+    throw new Error("BTC wallet returned empty public key");
+  return qe(o).toLowerCase();
+}
+function Tt(o) {
+  if (typeof o != "string" || o.length === 0)
+    throw new Error("BTC wallet returned empty BIP-322 signature");
+  if (o.startsWith("0x") || o.startsWith("0X")) {
+    if (!xt.test(o) || o.length < 4 || o.length % 2 !== 0)
+      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
+    return o.toLowerCase();
+  }
+  if (kt.test(o)) {
+    if (o.length % 2 !== 0)
+      throw new Error("BTC wallet returned malformed hex BIP-322 signature");
+    return `0x${o.toLowerCase()}`;
+  }
+  if (!Et.test(o) || o.length % 4 !== 0)
+    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
+  const e = B.from(o, "base64");
+  if (e.length === 0 || e.toString("base64") !== o)
+    throw new Error("BTC wallet returned malformed base64 BIP-322 signature");
+  return `0x${e.toString("hex")}`;
+}
+async function St(o) {
+  const { wallet: e, depositTerms: t, fundedPrePeginTxHex: s, depositorBtcPubkey: r } = o, n = typeof e.approveDepositTerms == "function" ? e.approveDepositTerms : void 0;
+  if (!n && !t)
+    return;
+  const i = s.startsWith("0x") ? s.slice(2) : s, c = fe.fromHex(i).getId();
+  if (t && t.prepeginTxid.replace(/^0x/, "").toLowerCase() !== c)
+    throw new Error(
+      `Deposit terms do not match the transaction being broadcast: terms are for prepeginTxid ${t.prepeginTxid}, but this transaction is ${c}.`
+    );
+  if (!n)
+    return;
+  if (!t)
+    throw new Error(
+      "This wallet requires approved deposit terms before signing the Pre-PegIn transaction, but none were provided. Pass PreparePeginResult.depositTerms (fresh flows) or a resume rebuild."
+    );
+  if (typeof e.deriveContextHash != "function")
+    throw new Error(
+      "A deposit-approval wallet must also implement deriveContextHash, but this one does not."
+    );
+  if (typeof e.holdsApprovedDepositTerms == "function") {
+    let f = !1;
+    try {
+      f = await e.holdsApprovedDepositTerms(t);
+    } catch {
+    }
+    if (f)
+      return;
+  }
+  typeof e.validateDepositTerms == "function" && await e.validateDepositTerms(t);
+  const u = Ze(s);
+  (await me(
+    { deriveContextHash: e.deriveContextHash.bind(e) },
+    {
+      depositorBtcPubkey: K(
+        _(r)
+      ),
+      fundingOutpoints: u
+    }
+  )).fill(0), await n.call(e, t);
+}
+const vt = BigInt(0), A = BigInt(1), _t = BigInt(2), Bt = BigInt(7), Ct = BigInt(256), At = BigInt(113), Pe = [], be = [], we = [];
+for (let o = 0, e = A, t = 1, s = 0; o < 24; o++) {
+  [t, s] = [s, (2 * t + 3 * s) % 5], Pe.push(2 * (5 * s + t)), be.push((o + 1) * (o + 2) / 2 % 64);
+  let r = vt;
+  for (let n = 0; n < 7; n++)
+    e = (e << A ^ (e >> Bt) * At) % Ct, e & _t && (r ^= A << (A << BigInt(n)) - A);
+  we.push(r);
+}
+const ye = gt(we, !0), It = ye[0], Ht = ye[1], ce = (o, e, t) => t > 32 ? Pt(o, e, t) : ft(o, e, t), le = (o, e, t) => t > 32 ? bt(o, e, t) : mt(o, e, t);
+function $t(o, e = 24) {
+  const t = new Uint32Array(10);
+  for (let s = 24 - e; s < 24; s++) {
+    for (let i = 0; i < 10; i++)
+      t[i] = o[i] ^ o[i + 10] ^ o[i + 20] ^ o[i + 30] ^ o[i + 40];
+    for (let i = 0; i < 10; i += 2) {
+      const a = (i + 8) % 10, c = (i + 2) % 10, u = t[c], d = t[c + 1], f = ce(u, d, 1) ^ t[a], x = le(u, d, 1) ^ t[a + 1];
+      for (let b = 0; b < 50; b += 10)
+        o[i + b] ^= f, o[i + b + 1] ^= x;
+    }
+    let r = o[2], n = o[3];
+    for (let i = 0; i < 24; i++) {
+      const a = be[i], c = ce(r, n, a), u = le(r, n, a), d = Pe[i];
+      r = o[d], n = o[d + 1], o[d] = c, o[d + 1] = u;
+    }
+    for (let i = 0; i < 50; i += 10) {
+      for (let a = 0; a < 10; a++)
+        t[a] = o[i + a];
+      for (let a = 0; a < 10; a++)
+        o[i + a] ^= ~t[(a + 2) % 10] & t[(a + 4) % 10];
+    }
+    o[0] ^= It[s], o[1] ^= Ht[s];
+  }
+  de(t);
+}
+class G {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(e, t, s, r = !1, n = 24) {
+    P(this, "state");
+    P(this, "pos", 0);
+    P(this, "posOut", 0);
+    P(this, "finished", !1);
+    P(this, "state32");
+    P(this, "destroyed", !1);
+    P(this, "blockLen");
+    P(this, "suffix");
+    P(this, "outputLen");
+    P(this, "enableXOF", !1);
+    P(this, "rounds");
+    if (this.blockLen = e, this.suffix = t, this.outputLen = s, this.enableXOF = r, this.rounds = n, Y(s, "outputLen"), !(0 < e && e < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200), this.state32 = _e(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    z(this.state32), $t(this.state32, this.rounds), z(this.state32), this.posOut = 0, this.pos = 0;
+  }
+  update(e) {
+    j(this), Q(e);
+    const { blockLen: t, state: s } = this, r = e.length;
+    for (let n = 0; n < r; ) {
+      const i = Math.min(t - this.pos, r - n);
+      for (let a = 0; a < i; a++)
+        s[this.pos++] ^= e[n++];
+      this.pos === t && this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = !0;
+    const { state: e, suffix: t, pos: s, blockLen: r } = this;
+    e[s] ^= t, (t & 128) !== 0 && s === r - 1 && this.keccak(), e[r - 1] ^= 128, this.keccak();
+  }
+  writeInto(e) {
+    j(this, !1), Q(e), this.finish();
+    const t = this.state, { blockLen: s } = this;
+    for (let r = 0, n = e.length; r < n; ) {
+      this.posOut >= s && this.keccak();
+      const i = Math.min(s - this.posOut, n - r);
+      e.set(t.subarray(this.posOut, this.posOut + i), r), this.posOut += i, r += 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 Y(e), this.xofInto(new Uint8Array(e));
+  }
+  digestInto(e) {
+    if (Be(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, de(this.state);
+  }
+  _cloneInto(e) {
+    const { blockLen: t, suffix: s, outputLen: r, rounds: n, enableXOF: i } = this;
+    return e || (e = new G(t, s, r, i, n)), e.state32.set(this.state32), e.pos = this.pos, e.posOut = this.posOut, e.finished = this.finished, e.rounds = n, e.suffix = s, e.outputLen = r, e.enableXOF = i, e.destroyed = this.destroyed, e;
+  }
+}
+const Rt = (o, e, t, s = {}) => ve(() => new G(e, o, t), s), Ot = /* @__PURE__ */ Rt(1, 136, 32), ue = 64, y = 20, X = 4, xe = 2, Ft = 0, Wt = 1, O = [64, 64], Mt = (o) => Array.from(o).map((e) => e.toString(16).padStart(2, "0")).join("");
+function q(o) {
+  return Ae(pe(o));
+}
+function ke(o) {
+  return (1 << o) - 1;
+}
+function Vt(o) {
+  let e = 1;
+  for (; e * e < o + 1; ) e++;
+  return Math.max(e, 2);
+}
+function Dt(o) {
+  const e = X, t = o * ke(e);
+  return { d: e, n: o, checksum_radix: Vt(t) };
+}
+function M(o, e) {
+  const t = [];
+  let s = e;
+  for (; s > 0; )
+    t.push(s & 255), s >>>= 8;
+  const r = new Uint8Array(o.length + t.length);
+  r.set(o);
+  for (let n = 0; n < t.length; n++)
+    r[o.length + n] = t[n];
+  return q(r);
+}
+function V(o, e) {
+  let t = o;
+  for (let s = 0; s < e; s++)
+    t = q(t);
+  return t;
+}
+function Nt(o, e) {
+  const t = ke(e.d), s = e.checksum_radix - 1, r = Math.floor(e.n * t / e.checksum_radix), n = [];
+  for (let d = 0; d < e.n; d++) {
+    const f = M(o, d + xe), x = V(f, t);
+    n.push(Array.from(x));
+  }
+  const i = M(
+    o,
+    Ft
+  ), a = V(
+    i,
+    s
+  ), c = M(
+    o,
+    Wt
+  ), u = V(
+    c,
+    r
+  );
+  return {
+    config: e,
+    message_terminals: n,
+    checksum_major_terminal: Array.from(u),
+    checksum_minor_terminal: Array.from(a)
+  };
+}
+async function Ut(o) {
+  try {
+    if (o.length !== ue)
+      throw new Error(
+        `WOTS seed must be exactly ${ue} bytes, got ${o.length}`
+      );
+    const e = [];
+    for (let t = 0; t < O.length; t++) {
+      const s = O[t], r = Dt(s), n = new Uint8Array(o.length + 1);
+      n.set(o), n[o.length] = t;
+      const i = q(n);
+      try {
+        const a = Nt(i, r);
+        if (a.config.d !== X)
+          throw new Error(
+            `Block ${t}: expected d=${X}, got d=${a.config.d}`
+          );
+        if (a.config.n !== s)
+          throw new Error(
+            `Block ${t}: expected n=${s}, got n=${a.config.n}`
+          );
+        if (a.message_terminals.length !== s)
+          throw new Error(
+            `Block ${t}: 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 !== y)
+            throw new Error(
+              `Block ${t} terminal ${c}: expected ${y} bytes, got ${a.message_terminals[c].length}`
+            );
+        if (a.checksum_minor_terminal.length !== y)
+          throw new Error(
+            `Block ${t} checksum_minor: expected ${y} bytes`
+          );
+        if (a.checksum_major_terminal.length !== y)
+          throw new Error(
+            `Block ${t} checksum_major: expected ${y} bytes`
+          );
+        e.push(a);
+      } finally {
+        n.fill(0), i.fill(0);
+      }
+    }
+    if (e.length !== O.length)
+      throw new Error(
+        `Expected ${O.length} blocks, got ${e.length}`
+      );
+    return e;
+  } finally {
+    o.fill(0);
+  }
+}
+function D(o, e, t) {
+  if (o.length !== y)
+    throw new Error(
+      `Block ${e} ${t}: expected ${y} bytes, got ${o.length}`
+    );
+  for (let s = 0; s < o.length; s++) {
+    const r = o[s];
+    if (!Number.isInteger(r) || r < 0 || r > 255)
+      throw new Error(
+        `Block ${e} ${t}[${s}]: invalid byte value ${r}`
+      );
+  }
+}
+function Kt(o) {
+  if (o.length === 0)
+    throw new Error("Public keys array must not be empty");
+  for (let n = 0; n < o.length; n++) {
+    const i = o[n];
+    D(i.checksum_minor_terminal, n, "checksum_minor_terminal"), D(i.checksum_major_terminal, n, "checksum_major_terminal");
+    for (let a = 0; a < i.message_terminals.length; a++)
+      D(i.message_terminals[a], n, `message_terminal[${a}]`);
+  }
+  let e = 0;
+  for (const n of o)
+    e += xe + n.message_terminals.length;
+  const t = new Uint8Array(e * y);
+  let s = 0;
+  for (const n of o) {
+    t.set(n.checksum_minor_terminal, s), s += y, t.set(n.checksum_major_terminal, s), s += y;
+    for (const i of n.message_terminals)
+      t.set(i, s), s += y;
+  }
+  const r = Ot(t);
+  return `0x${Mt(r)}`;
+}
+async function Lt(o, e) {
+  const t = [], s = [], r = [], n = [];
+  try {
+    for (let i = 0; i < e; i++) {
+      const a = await We(o, i);
+      try {
+        const u = await Ut(a);
+        t.push(u), s.push(Kt(u));
+      } finally {
+        a.fill(0);
+      }
+      const c = await Me(o, i);
+      try {
+        const u = L(c);
+        r.push(u), n.push(Je(Ye(u)).slice(2));
+      } finally {
+        c.fill(0);
+      }
+    }
+  } finally {
+    o.fill(0);
+  }
+  return { perVaultWotsKeys: t, wotsPkHashes: s, htlcSecretHexes: r, hashlocks: n };
+}
+const Xt = 1, Gt = 2, qt = 33, Yt = 2, zt = 3, jt = 1, F = 64, Qt = 0, N = 1, he = /^[0-9a-f]{64}$/i, Zt = /^(?:[0-9a-f]{2})+$/;
+function Jt(o) {
+  const e = o.slice(2);
+  if (!Zt.test(e))
+    throw new Error(
+      "proof of possession witness is not even-length lowercase hex"
+    );
+  return Ue(
+    Uint8Array.from(B.from(e, "hex")),
+    "proof of possession witness"
+  );
+}
+function eo(o, e, t) {
+  var r;
+  const s = Jt(t);
+  if (s.length === Xt) {
+    const [n] = s;
+    let i, a;
+    if (n.length === F)
+      i = n, a = Qt;
+    else if (n.length === F + 1 && n[F] === N)
+      i = n.subarray(0, F), a = N;
+    else
+      throw new Error(
+        "proof of possession witness item must be a 64-byte Schnorr signature (or 65 bytes ending in 0x01)"
+      );
+    if (!he.test(e))
+      throw new Error(
+        `depositor public key must be bare 64-char x-only hex, got "${e}"`
+      );
+    const c = Uint8Array.from(B.from(e, "hex"));
+    if (!lt(o, c, i, a))
+      throw new Error(
+        "proof of possession signature does not verify against the depositor key"
+      );
+    return { kind: "p2tr-verified" };
+  }
+  if (s.length === Gt) {
+    if (!he.test(e))
+      throw new Error(
+        `depositor public key must be bare 64-char x-only hex, got "${e}"`
+      );
+    const [n, i] = s;
+    if (i.length !== qt || i[0] !== Yt && i[0] !== zt)
+      throw new Error(
+        `proof of possession P2WPKH witness item 1 is not a compressed public key (${i.length} bytes, prefix 0x${((r = i[0]) == null ? void 0 : r.toString(16)) ?? "none"})`
+      );
+    if (!ct.isPointCompressed(i))
+      throw new Error(
+        "proof of possession P2WPKH witness pubkey is not a valid secp256k1 point"
+      );
+    const a = B.from(
+      i.subarray(jt)
+    ).toString("hex");
+    if (a !== e.toLowerCase())
+      throw new Error(
+        `proof of possession witness pubkey does not match the depositor key: witness carries ${a}, expected ${e}`
+      );
+    if (n.length < ut || n.length > ht)
+      throw new Error(
+        `proof of possession signature is ${n.length} bytes; vault ingestion accepts only 71/72-byte DER signatures with a sighash byte — try a different account or a Taproot address`
+      );
+    if (n[n.length - 1] !== N)
+      throw new Error(
+        `proof of possession P2WPKH signature must end in a SIGHASH_ALL (0x01) byte, got 0x${n[n.length - 1].toString(16)}`
+      );
+    if (!dt(o, i, n))
+      throw new Error(
+        "proof of possession signature does not verify against the depositor key"
+      );
+    return { kind: "p2wpkh-verified" };
+  }
+  throw new Error(
+    `proof of possession witness has ${s.length} items; expected 1 (P2TR) or 2 (P2WPKH)`
+  );
+}
+const U = "00".repeat(32), to = "00".repeat(32);
+function oo(o, e) {
+  const t = {
+    bitcoin: "bc",
+    testnet: "tb",
+    signet: "tb",
+    regtest: "bcrt"
+  };
+  try {
+    const s = ge.address.fromBech32(o);
+    return s.prefix === t[e] && s.version === 0 && s.data.length === 20;
+  } catch {
+    return !1;
+  }
+}
+function so(o, e, t, s) {
+  const r = t == null ? void 0 : t[`${o}:${e}`];
+  return r ? Promise.resolve({
+    txid: o,
+    vout: e,
+    value: r.value,
+    scriptPubKey: r.scriptPubKey
+  }) : Fe(o, e, s);
+}
+class Io {
+  /**
+   * Creates a new PeginManager instance.
+   *
+   * @param config - Manager configuration including wallets and contract addresses
+   */
+  constructor(e) {
+    P(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(), s = _(t);
+    if (C(this.config.btcWallet)) {
+      const l = (await et(this.config.btcWallet)).trim();
+      if (e.changeAddress.trim() !== l)
+        throw new Error(
+          `Pre-PegIn changeAddress "${e.changeAddress}" is not the approval wallet's change address ("${l}"). Refusing to build a tx the signing device would reject.`
+        );
+    } else if (!se(
+      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 r = await this.prepareSizing(s, e);
+    if (C(this.config.btcWallet)) {
+      const { validateDepositTerms: l } = this.config.btcWallet;
+      typeof l == "function" && await l.call(
+        this.config.btcWallet,
+        this.buildPeginDepositTerms({
+          params: e,
+          prepeginTxid: to,
+          prepeginMaxFee: r.fee,
+          depositorClaimValue: r.depositorClaimValue,
+          peginMaxFee: r.minPeginFee
+        })
+      );
+    }
+    const n = r.selectedUTXOs.map(
+      (l) => ({
+        txid: K(l.txid),
+        vout: l.vout
+      })
+    ), i = await me(this.config.btcWallet, {
+      depositorBtcPubkey: K(s),
+      fundingOutpoints: n
+    });
+    let a, c;
+    try {
+      const l = await Ve(i);
+      try {
+        a = L(l), c = L(pe(l));
+      } finally {
+        l.fill(0);
+      }
+    } catch (l) {
+      throw i.fill(0), l;
+    }
+    const u = await Lt(i, e.amounts.length), { perVaultWotsKeys: d, wotsPkHashes: f, htlcSecretHexes: x, hashlocks: b } = u, g = await this.preparePeginCommit({
+      depositorBtcPubkeyRaw: t,
+      depositorBtcPubkey: s,
+      hashlocks: b,
+      authAnchorHash: c,
+      sizing: r,
+      params: e
+    });
+    for (let l = 0; l < g.perVault.length; l++)
+      if (g.perVault[l].htlcVout !== l)
+        throw new Error(
+          `Internal invariant violation: htlcVout/index mismatch at vault ${l} (expected ${l}, got ${g.perVault[l].htlcVout})`
+        );
+    tt(
+      g.fundedPrePeginTxHex,
+      e.amounts.length,
+      c
+    );
+    const { depositTerms: T, ...k } = g;
+    return {
+      transaction: {
+        ...k,
+        selectedUTXOs: r.selectedUTXOs,
+        fee: r.fee,
+        changeAmount: r.changeAmount
+      },
+      depositorBtcPubkey: s,
+      derivedSecrets: {
+        perVaultWotsKeys: d,
+        wotsPkHashes: f,
+        htlcSecretHexes: x,
+        authAnchorHex: a
+      },
+      depositTerms: T
+    };
+  }
+  /**
+   * 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 s = t.amounts.map(
+      () => U
+    ), r = t.vaultKeeperBtcPubkeys.length, n = await te({
+      vaultCoreVersion: t.vaultCoreVersion,
+      depositorPubkey: e,
+      vaultProviderPubkey: w(t.vaultProviderBtcPubkey),
+      vaultKeeperPubkeys: t.vaultKeeperBtcPubkeys.map(w),
+      universalChallengerPubkeys: t.universalChallengerBtcPubkeys.map(w),
+      hashlocks: s,
+      timelockRefund: t.timelockRefund,
+      pegInAmounts: t.amounts,
+      feeRate: t.protocolFeeRate,
+      minPeginFeeRate: t.minPeginFeeRate,
+      numLocalChallengers: r,
+      councilQuorum: t.councilQuorum,
+      councilSize: t.councilSize,
+      network: this.config.btcNetwork,
+      authAnchorHash: U
+    }), i = st(
+      [...t.availableUTXOs],
+      n.totalOutputValue,
+      t.mempoolFeeRate,
+      it(n.htlcValues.length, !0)
+    );
+    return {
+      selectedUTXOs: i.selectedUTXOs,
+      fee: i.fee,
+      changeAmount: i.changeAmount,
+      depositorClaimValue: n.depositorClaimValue,
+      minPeginFee: n.minPeginFee
+    };
+  }
+  /**
+   * One projection for both the provisional (pre-derive, placeholder-txid)
+   * terms and the final approved terms, so the fields the pre-check validated
+   * cannot drift from the fields the device later displays (#2110 T4).
+   */
+  buildPeginDepositTerms(e) {
+    const { params: t } = e;
+    return yt({
+      vaultCoreVersion: t.vaultCoreVersion,
+      protocolFeeRate: t.protocolFeeRate,
+      timelockPegin: t.timelockPegin,
+      timelockAssert: t.timelockAssert,
+      timelockRefund: t.timelockRefund,
+      prepeginTxid: e.prepeginTxid,
+      prepeginMaxFee: e.prepeginMaxFee,
+      vaultProviderBtcPubkey: w(t.vaultProviderBtcPubkey),
+      vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys.map(w),
+      universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys.map(w),
+      maxAcceptableCommissionBps: Ie(
+        t.commissionBps
+      ),
+      peginAmounts: t.amounts,
+      depositorClaimValue: e.depositorClaimValue,
+      peginMaxFee: e.peginMaxFee
+    });
+  }
+  /** Build PegIn txs and batch-sign their inputs with real hashlocks. */
+  async preparePeginCommit(e) {
+    const {
+      depositorBtcPubkeyRaw: t,
+      depositorBtcPubkey: s,
+      hashlocks: r,
+      authAnchorHash: n,
+      sizing: i,
+      params: a
+    } = e, c = U.toLowerCase();
+    for (let h = 0; h < r.length; h++)
+      if (r[h].toLowerCase() === c)
+        throw new Error(
+          `preparePeginCommit refusing to build with sizing-pass placeholder hashlock at vault ${h} — internal substitution bug`
+        );
+    if (n.toLowerCase() === c)
+      throw new Error(
+        "preparePeginCommit refusing to build with sizing-pass placeholder auth-anchor hash — internal substitution bug"
+      );
+    const u = w(
+      a.vaultProviderBtcPubkey
+    ), d = a.vaultKeeperBtcPubkeys.map(w), f = a.universalChallengerBtcPubkeys.map(w), x = d.length, b = {
+      vaultCoreVersion: a.vaultCoreVersion,
+      depositorPubkey: s,
+      vaultProviderPubkey: u,
+      vaultKeeperPubkeys: d,
+      universalChallengerPubkeys: f,
+      hashlocks: r,
+      timelockRefund: a.timelockRefund,
+      pegInAmounts: a.amounts,
+      feeRate: a.protocolFeeRate,
+      minPeginFeeRate: a.minPeginFeeRate,
+      numLocalChallengers: x,
+      councilQuorum: a.councilQuorum,
+      councilSize: a.councilSize,
+      network: this.config.btcNetwork,
+      authAnchorHash: n
+    }, g = await te(b);
+    if (g.depositorClaimValue !== i.depositorClaimValue || g.minPeginFee !== i.minPeginFee)
+      throw new Error(
+        `Pre-PegIn sizing/commit divergence: depositorClaimValue ${i.depositorClaimValue} -> ${g.depositorClaimValue}, minPeginFee ${i.minPeginFee} -> ${g.minPeginFee}. The provisional deposit terms validated before derivation would not match the terms sent for approval; refusing to continue.`
+      );
+    const T = ne(this.config.btcNetwork), k = rt({
+      unfundedTxHex: g.psbtHex,
+      selectedUTXOs: i.selectedUTXOs,
+      changeAddress: a.changeAddress,
+      changeAmount: i.changeAmount,
+      network: T
+    }), l = i.selectedUTXOs.reduce((h, v) => h + BigInt(v.value), 0n) - g.totalOutputValue - i.changeAmount;
+    if (l !== i.fee)
+      throw new Error(
+        `Pre-PegIn funded fee ${l} does not match the sizing-pass fee ${i.fee}; refusing to publish a deposit-terms fee bound the funded transaction does not pay.`
+      );
+    const I = w(
+      ze(k)
+    ), H = [], p = [], m = [];
+    for (let h = 0; h < r.length; h++) {
+      const v = await De({
+        prePeginParams: b,
+        timelockPegin: a.timelockPegin,
+        fundedPrePeginTxHex: k,
+        htlcVout: h
+      }), W = await Ke({
+        vaultCoreVersion: a.vaultCoreVersion,
+        peginTxHex: v.txHex,
+        fundedPrePeginTxHex: k,
+        depositorPubkey: s,
+        vaultProviderPubkey: u,
+        vaultKeeperPubkeys: d,
+        universalChallengerPubkeys: f,
+        hashlock: r[h],
+        timelockRefund: a.timelockRefund,
+        network: this.config.btcNetwork
+      });
+      H.push(v), p.push(W.psbtHex), m.push(
+        je(t, 1)
+      );
+    }
+    const E = this.buildPeginDepositTerms({
+      params: a,
+      prepeginTxid: I,
+      prepeginMaxFee: i.fee,
+      depositorClaimValue: g.depositorClaimValue,
+      peginMaxFee: g.minPeginFee
+    });
+    C(this.config.btcWallet) && await this.config.btcWallet.approveDepositTerms(E);
+    const S = await ot(
+      this.config.btcWallet,
+      p,
+      m
+    ), $ = [];
+    for (let h = 0; h < S.length; h++) {
+      oe({
+        requestedPsbtHex: p[h],
+        returnedPsbtHex: S[h]
+      });
+      const v = Le(
+        S[h],
+        s
+      );
+      Ne({
+        requestedPsbtHex: p[h],
+        signatureHex: v,
+        signerXOnlyPubkeyHex: s,
+        inputIndex: 0
+      });
+      const W = Xe(S[h]);
+      $.push({
+        htlcVout: h,
+        htlcValue: g.htlcValues[h],
+        peginTxHex: W,
+        peginTxid: H[h].txid,
+        peginInputSignature: v,
+        vaultScriptPubKey: H[h].vaultScriptPubKey
+      });
+    }
+    return {
+      fundedPrePeginTxHex: k,
+      prePeginTxid: I,
+      perVault: $,
+      depositTerms: E
+    };
+  }
+  /**
+   * 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
+   *
+   * IMPORTANT — this method does NOT gate on Ethereum finality. Committing
+   * BTC to the HTLC while the peg-in registration is still reorg-exposed can
+   * strand the deposit: the vault record disappears from the chain while the
+   * BTC stays locked until the HTLC refund timelock. Callers must await
+   * `waitForPeginRegistrationDepth` for the registered vault(s) before calling
+   * this. The gate is not applied here because the params carry no vault ID —
+   * adding one would be a breaking signature change.
+   *
+   * @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: s } = e, r = t.startsWith("0x") ? t.slice(2) : t, n = fe.fromHex(r);
+    if (n.ins.length === 0)
+      throw new Error("Transaction has no inputs");
+    const i = new Z();
+    i.setVersion(n.version), i.setLocktime(n.locktime);
+    const a = B.from(
+      _(s),
+      "hex"
+    ), c = this.config.mempoolApiUrl, u = n.ins.map((p) => {
+      const m = B.from(p.hash).reverse().toString("hex"), E = p.index;
+      return so(m, E, e.localPrevouts, c).then(
+        (S) => ({ input: p, utxoData: S, txid: m, vout: E })
+      );
+    }), d = await Promise.all(u), f = d.reduce(
+      (p, m) => p + BigInt(m.utxoData.value),
+      0n
+    ), x = n.outs.reduce(
+      (p, m) => p + BigInt(m.value),
+      0n
+    );
+    if (f < x)
+      throw new Error(
+        `UTXO value mismatch: total input value (${f} sat) is less than total output value (${x} sat). This may indicate the mempool API returned manipulated UTXO data.`
+      );
+    const b = f - x;
+    if (b > ie)
+      throw new Error(
+        `Implied transaction fee (${b} sat) exceeds maximum reasonable fee (${ie} sat). This may indicate manipulated UTXO data.`
+      );
+    for (const { input: p, utxoData: m, txid: E, vout: S } of d) {
+      const $ = nt(
+        {
+          value: m.value,
+          scriptPubKey: m.scriptPubKey
+        },
+        a
+      );
+      i.addInput({
+        hash: p.hash,
+        index: p.index,
+        sequence: p.sequence,
+        ...$
+      });
+    }
+    for (const p of n.outs)
+      i.addOutput({
+        script: p.script,
+        value: p.value
+      });
+    await St({
+      wallet: this.config.btcWallet,
+      depositTerms: e.depositTerms,
+      fundedPrePeginTxHex: t,
+      depositorBtcPubkey: s
+    });
+    const g = i.toHex(), T = await this.config.btcWallet.signPsbt(g);
+    oe({
+      requestedPsbtHex: g,
+      returnedPsbtHex: T
+    });
+    const k = Ge({
+      requestedPsbtHex: g,
+      returnedPsbtHex: T
+    });
+    if (C(this.config.btcWallet) && k !== i.data.inputs.length)
+      throw new Error(
+        `Key-path verification covered ${k} of ${i.data.inputs.length} Pre-PegIn inputs; an approval wallet signs every input key-path, so the unverified ones must not be broadcast.`
+      );
+    const l = Z.fromHex(T);
+    try {
+      l.finalizeAllInputs();
+    } catch (p) {
+      if (!l.data.inputs.every(
+        (E) => E.finalScriptWitness || E.finalScriptSig
+      ))
+        throw new Error(
+          `PSBT finalization failed and wallet did not auto-finalize: ${p}`
+        );
+    }
+    const I = l.extractTransaction().toHex();
+    return await Oe(I, 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) {
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const t = this.config.ethWallet.account.address;
+    if (!J(
+      e.popSignature.depositorEthAddress,
+      t
+    ))
+      throw new Error(
+        `Proof of possession was signed for ${e.popSignature.depositorEthAddress} but the Ethereum wallet is currently connected to ${t}. Reconnect the original account or call signProofOfPossession() again.`
+      );
+    const s = await this.assertPopMatchesBtcWallet(
+      e.popSignature
+    ), r = e.depositorPayoutBtcAddress ?? await this.config.btcWallet.getAddress(), n = this.resolvePayoutScriptPubKey(
+      s,
+      r
+    );
+    return this.createRegistrationClient().registerPeginOnChain({
+      unsignedPrePeginTx: e.unsignedPrePeginTx,
+      depositorSignedPeginTx: e.depositorSignedPeginTx,
+      vaultProvider: e.vaultProvider,
+      hashlock: e.hashlock,
+      htlcVout: e.htlcVout,
+      depositorPayoutScriptPubKey: n,
+      depositorBtcPubkeyRaw: s,
+      depositorWotsPkHash: e.depositorWotsPkHash,
+      popSignature: e.popSignature,
+      quotedCommissionBps: e.quotedCommissionBps
+    });
+  }
+  /**
+   * 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) {
+    if (e.requests.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 t = this.config.ethWallet.account.address;
+    if (!J(
+      e.popSignature.depositorEthAddress,
+      t
+    ))
+      throw new Error(
+        `Proof of possession was signed for ${e.popSignature.depositorEthAddress} but the Ethereum wallet is currently connected to ${t}. Reconnect the original account or call signProofOfPossession() again.`
+      );
+    const s = await this.assertPopMatchesBtcWallet(
+      e.popSignature
+    ), r = e.requests.map(
+      (n) => this.resolvePayoutScriptPubKey(
+        s,
+        n.depositorPayoutBtcAddress
+      )
+    );
+    return this.createRegistrationClient().registerPeginBatchOnChain({
+      vaultProvider: e.vaultProvider,
+      unsignedPrePeginTx: e.unsignedPrePeginTx,
+      popSignature: e.popSignature,
+      depositorBtcPubkeyRaw: s,
+      quotedCommissionBps: e.quotedCommissionBps,
+      requests: e.requests.map((n, i) => ({
+        depositorSignedPeginTx: n.depositorSignedPeginTx,
+        hashlock: n.hashlock,
+        htlcVout: n.htlcVout,
+        depositorPayoutScriptPubKey: r[i],
+        depositorWotsPkHash: n.depositorWotsPkHash
+      }))
+    });
+  }
+  createRegistrationClient() {
+    return new He({
+      ethWallet: this.config.ethWallet,
+      ethChain: this.config.ethChain,
+      publicClient: this.config.publicClient,
+      btcVaultRegistry: this.config.vaultContracts.btcVaultRegistry,
+      requireQuotedCommissionBps: C(
+        this.config.btcWallet
+      )
+    });
+  }
+  /**
+   * 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 (!se(
+      t,
+      e,
+      this.config.btcNetwork
+    ))
+      throw w(e).length === Qe && oo(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 s = ne(this.config.btcNetwork);
+    let r;
+    try {
+      r = ge.address.toOutputScript(t, s).toString("hex");
+    } catch {
+      throw new Error(
+        `Invalid BTC payout address: "${t}". Please provide a valid Bitcoin address for the ${this.config.btcNetwork} network.`
+      );
+    }
+    return r;
+  }
+  /**
+   * 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.
+   *
+   * The witness is verified against the depositor key before it is
+   * returned — Schnorr for one-item (P2TR), ECDSA over the BIP-322
+   * P2WPKH virtual transaction for two-item — see {@link verifyPopWitness}.
+   *
+   * @throws If the wallet returns a malformed witness or a signature that
+   *         does not verify.
+   */
+  async signProofOfPossession() {
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const e = this.config.ethWallet.account.address, t = _(
+      await this.config.btcWallet.getPublicKeyHex()
+    ), s = this.config.vaultContracts.btcVaultRegistry, r = `${e.toLowerCase()}:${this.config.ethChain.id}:pegin:${s.toLowerCase()}`, n = await this.config.btcWallet.signMessage(
+      r,
+      "bip322-simple"
+    ), i = Tt(n);
+    return eo(
+      new TextEncoder().encode(r),
+      t,
+      i
+    ), { btcPopSignature: i, 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(), s = _(t), r = _(e.depositorBtcPubkey);
+    if (s !== r)
+      throw new Error(
+        `Proof of possession was signed with BTC pubkey ${r} but the BTC wallet is currently connected to ${s}. 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 no = 80, io = 250, ro = 300, ao = 22, Ee = "ab";
+function co(o, e) {
+  const t = Ee.repeat(ro), s = w(o).toLowerCase(), r = e.toString(16).padStart(8, "0"), n = `${s}${r}`, i = t.slice(n.length);
+  return `0x${n}${i}`;
+}
+function lo(o, e) {
+  const t = (s) => `0x${Ee.repeat(s)}`;
+  return {
+    depositorBtcPubKey: t(32),
+    btcPopSignature: t(no),
+    unsignedPrePeginTx: t(io),
+    depositorSignedPeginTx: co(
+      o,
+      e
+    ),
+    hashlock: t(32),
+    htlcVout: e,
+    referralCode: Re,
+    depositorPayoutBtcAddress: t(ao),
+    depositorWotsPkHash: t(32)
+  };
+}
+async function Ho(o) {
+  const {
+    publicClient: e,
+    btcVaultRegistry: t,
+    depositorEthAddress: s,
+    vaultProvider: r,
+    batchSize: n
+  } = o;
+  if (n <= 0)
+    throw new Error(
+      `estimateSubmitPeginRequestBatchGas requires batchSize >= 1 (received ${n})`
+    );
+  const a = await e.readContract({
+    address: t,
+    abi: ee,
+    functionName: "getPegInFee",
+    args: [r]
+  }) * BigInt(n), c = Array.from(
+    { length: n },
+    (d, f) => lo(s, f)
+  ), u = Ce({
+    abi: ee,
+    functionName: "submitPeginRequestBatch",
+    args: [
+      s,
+      r,
+      $e,
+      c
+    ]
+  });
+  return e.estimateGas({
+    to: t,
+    data: u,
+    value: a,
+    account: s
+  });
+}
+export {
+  Io as P,
+  St as a,
+  yt as b,
+  Kt as c,
+  Ut as d,
+  Ho as e,
+  Lt as f
+};
+//# sourceMappingURL=PeginManager-C9RPOd0L.js.map