@babylonlabs-io/ts-sdk 0.74.0 → 0.75.0

package/dist/pegin-registration-client-CXK3B_D1.js

@@ -0,0 +1,882 @@
+var ut = Object.defineProperty;
+var ht = (t, e, o) => e in t ? ut(t, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : t[e] = o;
+var w = (t, e, o) => ht(t, typeof e != "symbol" ? e + "" : e, o);
+import { isAddress as lt, keccak256 as dt, encodeAbiParameters as pt, encodeFunctionData as N, isAddressEqual as ft, zeroAddress as gt } from "viem";
+import { B as f } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
+import { B as H, h as T } from "./BTCVaultRegistryKeyEpochs.abi-D8cIbMtH.js";
+import { M as K, b as O } from "./constants-D5vORbQE.js";
+import { waitForTransactionReceiptSmartAware as mt } from "./tbv/core/utils/eth/index.js";
+import { a as x } from "./onChainBtcPubkey-C-6UWpD8.js";
+import { s as Y, b as C, a as Pt } from "./secp256k1-D-H9jmd7.js";
+import { c as bt, H as yt, r as E, a as F, h as j, b as _, s as S } from "./sha2-CLpQd0Rd.js";
+const k = 25, wt = 9999;
+function M(t) {
+  if (!Number.isInteger(t) || t < 0 || t >= K)
+    throw new Error(
+      `Quoted commissionBps must be an integer in [0, ${K}), got ${t}`
+    );
+  return Math.min(
+    t + k,
+    wt
+  );
+}
+const Ct = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), J = Uint8Array.from(new Array(16).fill(0).map((t, e) => e)), xt = J.map((t) => (9 * t + 5) % 16), Z = /* @__PURE__ */ (() => {
+  const o = [[J], [xt]];
+  for (let n = 0; n < 4; n++)
+    for (let s of o)
+      s.push(s[n].map((a) => Ct[a]));
+  return o;
+})(), tt = Z[0], et = Z[1], ot = /* @__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((t) => Uint8Array.from(t)), Et = /* @__PURE__ */ tt.map((t, e) => t.map((o) => ot[e][o])), It = /* @__PURE__ */ et.map((t, e) => t.map((o) => ot[e][o])), Bt = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), $t = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function q(t, e, o, n) {
+  return t === 0 ? e ^ o ^ n : t === 1 ? e & o | ~e & n : t === 2 ? (e | ~o) ^ n : t === 3 ? e & n | o & ~n : e ^ (o | ~n);
+}
+const I = /* @__PURE__ */ new Uint32Array(16);
+class Tt extends yt {
+  constructor() {
+    super(64, 20, 8, !0);
+    w(this, "h0", 1732584193);
+    w(this, "h1", -271733879);
+    w(this, "h2", -1732584194);
+    w(this, "h3", 271733878);
+    w(this, "h4", -1009589776);
+  }
+  get() {
+    const { h0: o, h1: n, h2: s, h3: a, h4: c } = this;
+    return [o, n, s, a, c];
+  }
+  set(o, n, s, a, c) {
+    this.h0 = o | 0, this.h1 = n | 0, this.h2 = s | 0, this.h3 = a | 0, this.h4 = c | 0;
+  }
+  process(o, n) {
+    for (let r = 0; r < 16; r++, n += 4)
+      I[r] = o.getUint32(n, !0);
+    let s = this.h0 | 0, a = s, c = this.h1 | 0, l = c, d = this.h2 | 0, p = d, g = this.h3 | 0, P = g, i = this.h4 | 0, h = i;
+    for (let r = 0; r < 5; r++) {
+      const u = 4 - r, b = Bt[r], st = $t[r], it = tt[r], rt = et[r], at = Et[r], ct = It[r];
+      for (let m = 0; m < 16; m++) {
+        const $ = E(s + q(r, c, d, g) + I[it[m]] + b, at[m]) + i | 0;
+        s = i, i = g, g = E(d, 10) | 0, d = c, c = $;
+      }
+      for (let m = 0; m < 16; m++) {
+        const $ = E(a + q(u, l, p, P) + I[rt[m]] + st, ct[m]) + h | 0;
+        a = h, h = P, P = E(p, 10) | 0, p = l, l = $;
+      }
+    }
+    this.set(this.h1 + d + P | 0, this.h2 + g + h | 0, this.h3 + i + a | 0, this.h4 + s + l | 0, this.h0 + c + p | 0);
+  }
+  roundClean() {
+    F(I);
+  }
+  destroy() {
+    this.destroyed = !0, F(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const vt = /* @__PURE__ */ bt(() => new Tt()), At = "5120", R = "0014", Vt = 20, W = 33, St = 65, kt = 2, Rt = 3, _t = 4;
+function nt(t, e) {
+  const o = t.startsWith("0x") || t.startsWith("0X") ? t.slice(2) : t;
+  if (!/^(?:[0-9a-fA-F]{2})+$/.test(o))
+    throw new Error(`${e} must be non-empty, even-length hex`);
+  return `0x${o.toLowerCase()}`;
+}
+function Nt(t) {
+  const e = j(t), o = C.utils.lift_x(BigInt(`0x${t}`)), n = C.utils.bytesToNumberBE(
+    C.utils.taggedHash("TapTweak", e)
+  );
+  if (n >= Y.CURVE.n)
+    throw new Error("Proof of possession BTC pubkey has an invalid TapTweak");
+  const s = n === 0n ? o : o.add(C.Point.BASE.multiply(n));
+  return `0x${At}${_(
+    C.utils.pointToBytes(s)
+  )}`;
+}
+function Ht(t) {
+  const e = nt(t, "depositorBtcPubkeyRaw"), o = j(e.slice(2));
+  if (o.length === 32)
+    return {
+      xOnlyPubkey: x(e, "Payout BTC pubkey")
+    };
+  const n = o.length === W && (o[0] === kt || o[0] === Rt), s = o.length === St && o[0] === _t;
+  if (!n && !s)
+    throw new Error(
+      "depositorBtcPubkeyRaw must be x-only, compressed, or uncompressed"
+    );
+  try {
+    Y.Point.fromBytes(o);
+  } catch {
+    throw new Error("depositorBtcPubkeyRaw is not a valid BTC pubkey");
+  }
+  return {
+    xOnlyPubkey: _(o.subarray(1, W)),
+    compressedPubkey: n ? o : void 0
+  };
+}
+function Kt(t) {
+  return `0x${R}${_(vt(S(t)))}`;
+}
+function Ot(t, e, o) {
+  const n = nt(
+    t,
+    "depositorPayoutScriptPubKey"
+  );
+  if ((n.length - 2) / 2 > O)
+    throw new Error(
+      `depositorPayoutScriptPubKey exceeds ${O} bytes`
+    );
+  const s = e.startsWith("0x") || e.startsWith("0X") ? e.slice(2) : e, a = x(
+    `0x${s}`,
+    "Proof of possession BTC pubkey"
+  ), c = Ht(o);
+  if (c.xOnlyPubkey !== a)
+    throw new Error(
+      "depositorBtcPubkeyRaw does not match the proof of possession BTC pubkey"
+    );
+  if (n === Nt(a))
+    return n;
+  if (n.startsWith(`0x${R}`) && n.length === 2 + R.length + Vt * 2) {
+    if (!c.compressedPubkey)
+      throw new Error("A P2WPKH payout requires a compressed BTC pubkey");
+    if (n === Kt(c.compressedPubkey))
+      return n;
+  }
+  throw new Error(
+    "depositorPayoutScriptPubKey does not match the proof of possession BTC pubkey"
+  );
+}
+function Ft(t, e) {
+  const o = t.startsWith("0x") ? t.slice(2) : t;
+  if (o.length === 0 || o.length % 2 !== 0)
+    throw new Error(`${e} must be non-empty, even-length hex`);
+  if (!/^[0-9a-fA-F]+$/.test(o))
+    throw new Error(`${e} contains non-hex characters`);
+  const n = new Uint8Array(o.length / 2);
+  for (let s = 0; s < n.length; s++)
+    n[s] = Number.parseInt(o.slice(s * 2, s * 2 + 2), 16);
+  return n;
+}
+function Mt(t) {
+  return Array.from(t, (e) => e.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function qt(t) {
+  const e = new Uint8Array(
+    t.reduce((n, s) => n + s.length, 0)
+  );
+  let o = 0;
+  for (const n of t)
+    e.set(n, o), o += n.length;
+  return e;
+}
+function Wt(t) {
+  let e = 0;
+  const o = (i, h) => {
+    if (!Number.isSafeInteger(i) || i < 0)
+      throw new Error(`Invalid ${h} length ${i}`);
+    if (e + i > t.length)
+      throw new Error(`Truncated Bitcoin transaction while reading ${h}`);
+    const r = t.slice(e, e + i);
+    return e += i, r;
+  }, n = (i, h) => {
+    const r = o(i, h);
+    let u = 0n;
+    for (let b = r.length - 1; b >= 0; b--)
+      u = u << 8n | BigInt(r[b]);
+    return u;
+  }, s = (i) => {
+    const h = e, r = o(1, i)[0];
+    let u;
+    if (r < 253)
+      u = BigInt(r);
+    else if (r === 253) {
+      if (u = n(2, i), u < 0xfdn) throw new Error(`Non-canonical ${i}`);
+    } else if (r === 254) {
+      if (u = n(4, i), u <= 0xffffn) throw new Error(`Non-canonical ${i}`);
+    } else if (u = n(8, i), u <= 0xffffffffn) throw new Error(`Non-canonical ${i}`);
+    if (u > BigInt(Number.MAX_SAFE_INTEGER))
+      throw new Error(`${i} exceeds JavaScript's safe integer range`);
+    return {
+      encoded: t.slice(h, e),
+      value: Number(u)
+    };
+  }, a = o(4, "version"), c = t[e] === 0 && t[e + 1] === 1;
+  c && (e += 2);
+  const l = s("input count"), d = [];
+  for (let i = 0; i < l.value; i++) {
+    const h = e;
+    o(32, `input ${i} previous transaction hash`), o(4, `input ${i} previous output index`);
+    const r = s(`input ${i} script length`);
+    o(r.value, `input ${i} script`), o(4, `input ${i} sequence`), d.push(t.slice(h, e));
+  }
+  const p = s("output count"), g = [];
+  for (let i = 0; i < p.value; i++) {
+    const h = e;
+    o(8, `output ${i} value`);
+    const r = s(`output ${i} script length`);
+    o(r.value, `output ${i} script`), g.push(t.slice(h, e));
+  }
+  if (c) {
+    let i = !1;
+    for (let h = 0; h < l.value; h++) {
+      const r = s(`input ${h} witness item count`);
+      i || (i = r.value > 0);
+      for (let u = 0; u < r.value; u++) {
+        const b = s(
+          `input ${h} witness item ${u} length`
+        );
+        o(b.value, `input ${h} witness item ${u}`);
+      }
+    }
+    if (!i)
+      throw new Error("Bitcoin transaction has superfluous witness marker");
+  }
+  const P = o(4, "locktime");
+  if (e !== t.length)
+    throw new Error(
+      `Bitcoin transaction has ${t.length - e} trailing byte(s)`
+    );
+  return qt([
+    a,
+    l.encoded,
+    ...d,
+    p.encoded,
+    ...g,
+    P
+  ]);
+}
+function Ut(t) {
+  const e = Wt(
+    Ft(t, "transactionHex")
+  ), o = S(S(e));
+  return o.reverse(), `0x${Mt(o)}`;
+}
+function Dt(t, e) {
+  const o = t.startsWith("0x") ? t : `0x${t}`;
+  if (!/^0x[0-9a-fA-F]{64}$/.test(o))
+    throw new Error("peginTxHash must be a 32-byte hex value");
+  const n = e.startsWith("0x") ? e : `0x${e}`;
+  if (!lt(n, { strict: !0 }))
+    throw new Error(`Invalid depositor Ethereum address: ${e}`);
+  return dt(
+    pt(
+      [{ type: "bytes32" }, { type: "address" }],
+      [o, n]
+    )
+  ).slice(2);
+}
+const v = 65535, U = 1e4, B = 4294967295, D = 255;
+function Xt(t) {
+  if (!Number.isInteger(t) || t < 0 || t > B)
+    throw new Error(
+      `Invalid offchainParamsVersion from contract: must be a uint32, got ${t}`
+    );
+}
+function zt(t) {
+  const e = [];
+  if (t.timelockAssert <= 0n && e.push(
+    `timelockAssert must be positive, got ${t.timelockAssert}`
+  ), t.timelockAssert > BigInt(v) && e.push(
+    `timelockAssert ${t.timelockAssert} exceeds uint16 max (${v})`
+  ), t.timelockChallengeAssert <= 0n && e.push(
+    `timelockChallengeAssert must be positive, got ${t.timelockChallengeAssert}`
+  ), t.tRefund <= 0 && e.push(`tRefund must be positive, got ${t.tRefund}`), t.tStale <= 0 && e.push(`tStale must be positive, got ${t.tStale}`), t.securityCouncilKeys.length === 0 && e.push("securityCouncilKeys must not be empty"), t.councilQuorum <= 0 && e.push(`councilQuorum must be positive, got ${t.councilQuorum}`), t.councilQuorum > t.securityCouncilKeys.length && e.push(
+    `councilQuorum (${t.councilQuorum}) exceeds securityCouncilKeys count (${t.securityCouncilKeys.length})`
+  ), t.feeRate <= 0n && e.push(`feeRate must be positive, got ${t.feeRate}`), t.minPeginFeeRate <= 0n && e.push(
+    `minPeginFeeRate must be positive, got ${t.minPeginFeeRate}`
+  ), (!Number.isInteger(t.proverCircuitVersion) || t.proverCircuitVersion < 0 || t.proverCircuitVersion > v) && e.push(
+    `proverCircuitVersion must be a uint16, got ${t.proverCircuitVersion}`
+  ), (!Number.isInteger(t.minPrepeginDepth) || t.minPrepeginDepth <= 0 || t.minPrepeginDepth > B) && e.push(
+    `minPrepeginDepth must be a uint32 in [1, ${B}], got ${t.minPrepeginDepth}`
+  ), t.babeTotalInstances <= 0 && e.push(
+    `babeTotalInstances must be positive, got ${t.babeTotalInstances}`
+  ), t.babeInstancesToFinalize <= 0 && e.push(
+    `babeInstancesToFinalize must be positive, got ${t.babeInstancesToFinalize}`
+  ), t.babeInstancesToFinalize > t.babeTotalInstances && e.push(
+    `babeInstancesToFinalize (${t.babeInstancesToFinalize}) exceeds babeTotalInstances (${t.babeTotalInstances})`
+  ), (t.minVpCommissionBps < 0 || t.minVpCommissionBps > U) && e.push(
+    `minVpCommissionBps must be in [0, ${U}], got ${t.minVpCommissionBps}`
+  ), e.length > 0)
+    throw new Error(
+      `Invalid offchain protocol parameters: ${e.join("; ")}`
+    );
+}
+function Lt(t) {
+  const e = [];
+  if (t.minimumPegInAmount <= 0n && e.push(
+    `minimumPegInAmount must be positive, got ${t.minimumPegInAmount}`
+  ), t.maxPegInAmount < t.minimumPegInAmount && e.push(
+    `maxPegInAmount (${t.maxPegInAmount}) must be >= minimumPegInAmount (${t.minimumPegInAmount})`
+  ), t.pegInAckTimeout <= 0n && e.push(
+    `pegInAckTimeout must be positive, got ${t.pegInAckTimeout}`
+  ), t.pegInActivationTimeout <= 0n && e.push(
+    `pegInActivationTimeout must be positive, got ${t.pegInActivationTimeout}`
+  ), (!Number.isInteger(t.maxHtlcOutputCount) || t.maxHtlcOutputCount <= 0 || t.maxHtlcOutputCount > D) && e.push(
+    `maxHtlcOutputCount must be an integer in [1, ${D}], got ${t.maxHtlcOutputCount}`
+  ), (typeof t.expiredPegInGraceBlocks != "bigint" || t.expiredPegInGraceBlocks <= 0n) && e.push(
+    `expiredPegInGraceBlocks must be a positive bigint, got ${t.expiredPegInGraceBlocks}`
+  ), e.length > 0)
+    throw new Error(`Invalid TBV protocol parameters: ${e.join("; ")}`);
+}
+function ue(t) {
+  if (Lt(t), zt(t.offchainParams), !Number.isInteger(t.offchainParamsVersion) || t.offchainParamsVersion < 0 || t.offchainParamsVersion > B)
+    throw new Error(
+      `Invalid peg-in configuration: offchainParamsVersion must be a uint32, got ${t.offchainParamsVersion}`
+    );
+  Pt(
+    t.activeVaultCoreVersion,
+    "ProtocolParams.activeVaultCoreVersion()"
+  );
+}
+const X = 9999;
+function z(t) {
+  return {
+    depositor: t.depositor,
+    depositorBtcPubKey: t.depositorBtcPubKey,
+    amount: t.amount,
+    vaultProvider: t.vaultProvider,
+    status: t.status,
+    applicationEntryPoint: t.applicationEntryPoint,
+    createdAt: t.createdAt
+  };
+}
+function A(t) {
+  const e = Number(t.offchainParamsVersion);
+  return Xt(e), {
+    depositorSignedPeginTx: t.depositorSignedPeginTx,
+    universalChallengersVersion: t.universalChallengersVersion,
+    appVaultKeepersVersion: t.appVaultKeepersVersion,
+    offchainParamsVersion: e,
+    verifiedAt: t.verifiedAt,
+    depositorWotsPkHash: t.depositorWotsPkHash,
+    hashlock: t.hashlock,
+    htlcVout: t.htlcVout,
+    depositorPopSignature: t.depositorPopSignature,
+    prePeginTxHash: t.prePeginTxHash,
+    vaultProviderCommissionBps: t.vaultProviderCommissionBps,
+    vaultCoreVersion: t.vaultCoreVersion
+  };
+}
+const Qt = 1n << 64n, L = 0n;
+function V(t, e, o) {
+  if (t < 0n || t >= Qt)
+    throw new Error(
+      `getBtcVaultProtocolInfo returned ${e}=${t} for vault ${o}, outside the uint64 range — the registry may predate RFC-006`
+    );
+  return t;
+}
+function Q(t, e) {
+  return {
+    vpKeyEpoch: V(t.vpKeyEpoch, "vpKeyEpoch", e),
+    appKeeperKeyEpoch: V(
+      t.appKeeperKeyEpoch,
+      "appKeeperKeyEpoch",
+      e
+    ),
+    ucKeyEpoch: V(t.ucKeyEpoch, "ucKeyEpoch", e)
+  };
+}
+class Gt {
+  constructor(e, o) {
+    this.publicClient = e, this.contractAddress = o;
+  }
+  /**
+   * Read the VP's **genesis** (registration) x-only BTC pubkey — the key bonded
+   * at version 0, which never moves when the operator rotates.
+   *
+   * Resolved as "the operation key at epoch 0" rather than through the
+   * dedicated `getVaultProviderBTCKey` getter, which
+   * https://github.com/babylonlabs-io/vault-contracts-aave-v4/pull/539 removes.
+   * Epoch 0 predates any rotation — appended versions are stamped at epoch 1 or
+   * later — so it resolves to the registration key, and the contracts team has
+   * confirmed that is a property we can rely on rather than an implementation
+   * detail. The devnet comparison behind that claim — both getters returning the
+   * identical key for a provider that *has* rotated, while
+   * `getCurrentOperationBtcKey` differed — is recorded in
+   * https://github.com/babylonlabs-io/babylon-toolkit/issues/2188.
+   *
+   * This makes the read RFC-006-only, where the removed getter also existed on a
+   * legacy registry. That costs nothing: every caller of this method already
+   * resolves participant keys through `OperationKeyReader`, so all of them
+   * require an RFC-006 registry regardless.
+   *
+   * Validates length, hex form, and secp256k1 curve membership before minting
+   * the brand. Returns 64-char lowercase hex without the `0x` prefix.
+   */
+  async getVaultProviderGenesisBtcPubKey(e, o) {
+    const n = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: f,
+      functionName: "getOperationBtcKeyAtEpoch",
+      args: [e, L],
+      blockNumber: o
+    });
+    return x(
+      n,
+      `getOperationBtcKeyAtEpoch (vp=${e}, epoch=${L})`
+    );
+  }
+  /**
+   * Read a vault provider's *current* RFC-006 operation BTC key.
+   *
+   * Falls back on-chain to the registration key when the provider has never
+   * rotated, so this returns the same value as
+   * `getVaultProviderGenesisBtcPubKey` until the first rotation.
+   *
+   * This is the key the VP's server signs its BIP-322 auth tokens with — a
+   * live per-operator identity, not a per-vault binding, so the auth pin uses
+   * the current key rather than any vault's frozen epoch.
+   */
+  async getCurrentVaultProviderOperationBtcKey(e) {
+    const o = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: f,
+      functionName: "getCurrentOperationBtcKey",
+      args: [e]
+    });
+    return x(
+      o,
+      `getCurrentOperationBtcKey (vp=${e})`
+    );
+  }
+  /**
+   * Read a vault's frozen RFC-006 operation-key epochs.
+   *
+   * Reads `getBtcVaultProtocolInfo` through the **extended** ABI, which is only
+   * valid against an RFC-006 registry: against one whose `BTCVaultProtocolInfo`
+   * struct is not extended this call does not fail for a populated vault, it
+   * silently returns three words of tail data as epochs. Nothing here can detect
+   * that, so the guarantee is a deployment one — every network this ships to has
+   * the RFC-006 getters, and mainnet is a fresh RFC-006 deploy.
+   *
+   * A registry missing the operation-key getters entirely is the *safer* of the
+   * two cases: `resolveParticipantKeysAtEpochs` reverts downstream and these
+   * epochs never reach key resolution. See {@link UINT64_EXCLUSIVE_UPPER_BOUND}
+   * for which state the range check actually guards, and
+   * `BTCVaultRegistryKeyEpochs.abi.ts` for the decode hazard.
+   */
+  async getVaultKeyEpochs(e) {
+    const o = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: H,
+      functionName: "getBtcVaultProtocolInfo",
+      args: [e]
+    });
+    return Q(o, e);
+  }
+  async getVaultKeyEpochsBatch(e) {
+    return e.length === 0 ? [] : (await this.publicClient.multicall({
+      contracts: e.map((n) => ({
+        address: this.contractAddress,
+        abi: H,
+        functionName: "getBtcVaultProtocolInfo",
+        args: [n]
+      })),
+      allowFailure: !1
+    })).map(
+      (n, s) => Q(n, e[s])
+    );
+  }
+  async getVaultBasicInfo(e) {
+    const o = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: f,
+      functionName: "getBtcVaultBasicInfo",
+      args: [e]
+    });
+    return z(o);
+  }
+  async getVaultProtocolInfo(e) {
+    const o = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: f,
+      functionName: "getBtcVaultProtocolInfo",
+      args: [e]
+    });
+    return A(o);
+  }
+  async getProtocolInfoBatch(e) {
+    return e.length === 0 ? [] : (await this.publicClient.multicall({
+      contracts: e.map((n) => ({
+        address: this.contractAddress,
+        abi: f,
+        functionName: "getBtcVaultProtocolInfo",
+        args: [n]
+      })),
+      allowFailure: !1
+    })).map((n, s) => {
+      const a = n;
+      if (!a.depositorSignedPeginTx || a.depositorSignedPeginTx === "0x")
+        throw new Error(
+          `Vault ${e[s]} not found on-chain or has no pegin transaction`
+        );
+      return A(a);
+    });
+  }
+  /**
+   * Read the protocol pegin fee (in wei) for a given vault provider.
+   * Mirrors the `getPegInFee(address)` view on BTCVaultRegistry.
+   */
+  async getPegInFee(e) {
+    return await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: f,
+      functionName: "getPegInFee",
+      args: [e]
+    });
+  }
+  /**
+   * Read a vault provider's current commission in basis points from
+   * BTCVaultRegistry. The contract enforces `commissionBps < 10000`, so the
+   * legitimate range is `[0, 9999]`; anything outside indicates a wrong
+   * contract address or ABI drift and is surfaced as an error rather than
+   * trusted.
+   */
+  async getVaultProviderCommission(e) {
+    const o = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: f,
+      functionName: "getVaultProviderCommission",
+      args: [e]
+    });
+    if (!Number.isInteger(o) || o < 0 || o > X)
+      throw new Error(
+        `getVaultProviderCommission returned ${o} bps for ${e}, outside the protocol range [0, ${X}]`
+      );
+    return o;
+  }
+  async getVaultData(e) {
+    const [o, n] = await this.publicClient.multicall({
+      contracts: [
+        {
+          address: this.contractAddress,
+          abi: f,
+          functionName: "getBtcVaultBasicInfo",
+          args: [e]
+        },
+        {
+          address: this.contractAddress,
+          abi: f,
+          functionName: "getBtcVaultProtocolInfo",
+          args: [e]
+        }
+      ],
+      allowFailure: !1
+    }), s = z(o), a = A(n);
+    if (!a.depositorSignedPeginTx || a.depositorSignedPeginTx === "0x")
+      throw new Error(
+        `Vault ${e} not found on-chain or has no pegin transaction`
+      );
+    return { basic: s, protocol: a };
+  }
+}
+const Yt = 0, jt = 255, Jt = 12e4;
+function y(t, e) {
+  const o = t.startsWith("0x") ? t : t.startsWith("0X") ? `0x${t.slice(2)}` : `0x${t}`;
+  if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(o))
+    throw new Error(`${e} must be non-empty, even-length hex`);
+  return o;
+}
+function G(t, e) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(t))
+    throw new Error(`${e} must be a 32-byte hex value`);
+}
+function Zt(t) {
+  if (!Number.isInteger(t) || t < 0 || t > jt)
+    throw new Error(`htlcVout must be a uint8, got ${t}`);
+}
+class he {
+  constructor(e) {
+    this.config = e;
+  }
+  async registerPeginOnChain(e) {
+    const o = {
+      ...e,
+      popSignature: { ...e.popSignature }
+    };
+    this.assertQuotedCommissionPresentWhenRequired(o.quotedCommissionBps);
+    const n = this.assertPopMatchesEthAccount(o.popSignature), s = this.normalizeBtcPubkey(o.popSignature), a = y(
+      o.popSignature.btcPopSignature,
+      "btcPopSignature"
+    ), c = this.normalizeRequest(
+      o,
+      n,
+      s
+    );
+    await this.assertVaultDoesNotExist(
+      c.vaultId,
+      c.peginTxHash
+    );
+    const l = await this.readPeginFee(o.vaultProvider), d = await this.resolveMaxAcceptableCommissionBps(
+      o.vaultProvider,
+      o.quotedCommissionBps
+    ), p = N({
+      abi: f,
+      functionName: "submitPeginRequest",
+      args: [
+        n,
+        s,
+        a,
+        c.unsignedPrePeginTx,
+        c.depositorSignedPeginTx,
+        o.vaultProvider,
+        d,
+        o.hashlock,
+        o.htlcVout,
+        c.payoutScript,
+        o.depositorWotsPkHash
+      ]
+    });
+    return {
+      ethTxHash: await this.sendAndWait(
+        p,
+        l,
+        !1,
+        n
+      ),
+      vaultId: c.vaultId,
+      peginTxHash: c.peginTxHash
+    };
+  }
+  async registerPeginBatchOnChain(e) {
+    const o = {
+      ...e,
+      popSignature: { ...e.popSignature },
+      requests: e.requests.map((r) => ({ ...r }))
+    };
+    if (o.requests.length === 0)
+      throw new Error("Batch pegin requires at least one request");
+    this.assertQuotedCommissionPresentWhenRequired(o.quotedCommissionBps);
+    const n = this.assertPopMatchesEthAccount(o.popSignature), s = y(
+      o.unsignedPrePeginTx,
+      "unsignedPrePeginTx"
+    ), a = this.normalizeBtcPubkey(o.popSignature), c = y(
+      o.popSignature.btcPopSignature,
+      "btcPopSignature"
+    ), l = [], d = [], p = /* @__PURE__ */ new Set();
+    for (const r of o.requests) {
+      const u = this.normalizeRequest(
+        {
+          ...r,
+          unsignedPrePeginTx: o.unsignedPrePeginTx,
+          vaultProvider: o.vaultProvider,
+          depositorBtcPubkeyRaw: o.depositorBtcPubkeyRaw
+        },
+        n,
+        a
+      );
+      if (p.has(u.vaultId))
+        throw new Error(`Duplicate vault in batch: ${u.vaultId}`);
+      p.add(u.vaultId), l.push({
+        vaultId: u.vaultId,
+        peginTxHash: u.peginTxHash
+      }), d.push({
+        depositorBtcPubKey: a,
+        btcPopSignature: c,
+        unsignedPrePeginTx: s,
+        depositorSignedPeginTx: u.depositorSignedPeginTx,
+        hashlock: r.hashlock,
+        htlcVout: r.htlcVout,
+        referralCode: Yt,
+        depositorPayoutBtcAddress: u.payoutScript,
+        depositorWotsPkHash: r.depositorWotsPkHash
+      });
+    }
+    for (const r of l)
+      await this.assertVaultDoesNotExist(r.vaultId, r.peginTxHash);
+    const g = await this.readPeginFee(o.vaultProvider), P = await this.resolveMaxAcceptableCommissionBps(
+      o.vaultProvider,
+      o.quotedCommissionBps
+    ), i = N({
+      abi: f,
+      functionName: "submitPeginRequestBatch",
+      args: [n, o.vaultProvider, P, d]
+    });
+    return { ethTxHash: await this.sendAndWait(
+      i,
+      g * BigInt(o.requests.length),
+      !0,
+      n
+    ), vaults: l };
+  }
+  assertQuotedCommissionPresentWhenRequired(e) {
+    if (e === void 0 && this.config.requireQuotedCommissionBps)
+      throw new Error(
+        "quotedCommissionBps is required when the wallet approved deposit terms: the registration ceiling must anchor to the approved quote."
+      );
+  }
+  assertPopMatchesEthAccount(e) {
+    return this.assertEthAccount(e.depositorEthAddress);
+  }
+  assertEthAccount(e) {
+    const o = this.config.ethWallet.account;
+    if (!o) throw new Error("Ethereum wallet account not found");
+    if (!ft(e, o.address))
+      throw new Error(
+        `Proof of possession was signed for ${e} but the Ethereum wallet is currently connected to ${o.address}. Reconnect the original account or sign a new proof of possession.`
+      );
+    return o.address;
+  }
+  normalizeBtcPubkey(e) {
+    return `0x${x(
+      y(e.depositorBtcPubkey, "Proof of possession BTC pubkey"),
+      "Proof of possession BTC pubkey"
+    )}`;
+  }
+  normalizeRequest(e, o, n) {
+    G(e.hashlock, "hashlock"), G(e.depositorWotsPkHash, "depositorWotsPkHash"), Zt(e.htlcVout);
+    const s = y(
+      e.unsignedPrePeginTx,
+      "unsignedPrePeginTx"
+    ), a = y(
+      e.depositorSignedPeginTx,
+      "depositorSignedPeginTx"
+    ), c = Ut(a);
+    return {
+      unsignedPrePeginTx: s,
+      depositorSignedPeginTx: a,
+      payoutScript: Ot(
+        e.depositorPayoutScriptPubKey,
+        n,
+        e.depositorBtcPubkeyRaw
+      ),
+      peginTxHash: c,
+      vaultId: y(Dt(c, o), "vaultId")
+    };
+  }
+  async assertVaultDoesNotExist(e, o) {
+    if ((await this.config.publicClient.readContract({
+      address: this.config.btcVaultRegistry,
+      abi: f,
+      functionName: "getBtcVaultBasicInfo",
+      args: [e]
+    })).depositor !== gt)
+      throw new Error(
+        `Vault already exists (ID: ${e}, peginTxHash: ${o}). 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.`
+      );
+  }
+  async readPeginFee(e) {
+    try {
+      return await this.config.publicClient.readContract({
+        address: this.config.btcVaultRegistry,
+        abi: f,
+        functionName: "getPegInFee",
+        args: [e]
+      });
+    } catch (o) {
+      throw new Error(
+        "Failed to query pegin fee from the contract. Please check your network connection and contract address.",
+        { cause: o }
+      );
+    }
+  }
+  async resolveMaxAcceptableCommissionBps(e, o) {
+    let n;
+    try {
+      n = await new Gt(
+        this.config.publicClient,
+        this.config.btcVaultRegistry
+      ).getVaultProviderCommission(e);
+    } catch (s) {
+      throw new Error(
+        "Failed to query vault provider commission from the contract. Please check your network connection and contract address.",
+        { cause: s }
+      );
+    }
+    if (o !== void 0) {
+      if (n > o + k)
+        throw new Error(
+          `Vault provider commission changed since quote: quoted ${o} bps, chain currently reports ${n} bps (allowed drift ${k} bps). Please refresh and try again.`
+        );
+      return M(o);
+    }
+    return M(n);
+  }
+  async sendAndWait(e, o, n, s) {
+    let a = this.assertEthAccount(s), c;
+    try {
+      c = await this.config.publicClient.estimateGas({
+        to: this.config.btcVaultRegistry,
+        data: e,
+        value: o,
+        account: a
+      });
+    } catch (p) {
+      T(p);
+    }
+    a = this.assertEthAccount(s);
+    let l;
+    try {
+      l = await this.config.ethWallet.sendTransaction({
+        to: this.config.btcVaultRegistry,
+        data: e,
+        value: o,
+        gas: c,
+        account: a,
+        chain: this.config.ethChain
+      });
+    } catch (p) {
+      T(p);
+    }
+    const d = await mt({
+      publicClient: this.config.publicClient,
+      walletAddress: s,
+      hash: l,
+      timeout: this.config.receiptTimeoutMs ?? Jt
+    });
+    return d.status === "reverted" && T(
+      new Error(
+        `${n ? "Batch transaction" : "Transaction"} reverted. Hash: ${d.transactionHash}. Check a block explorer for details.`
+      )
+    ), d.transactionHash;
+  }
+}
+export {
+  k as C,
+  wt as M,
+  Yt as N,
+  he as V,
+  ue as a,
+  Lt as b,
+  Gt as c,
+  Dt as d,
+  M as e,
+  Ut as f,
+  Xt as g,
+  vt as r,
+  zt as v
+};
+//# sourceMappingURL=pegin-registration-client-CXK3B_D1.js.map