@babylonlabs-io/ts-sdk 3.0.2 → 3.1.1

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

@@ -1,878 +0,0 @@
-var lt = Object.defineProperty;
-var dt = (t, e, o) => e in t ? lt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : t[e] = o;
-var m = (t, e, o) => dt(t, typeof e != "symbol" ? e + "" : e, o);
-import { getAbiItem as _, encodeFunctionData as N, isAddressEqual as pt, zeroAddress as gt } from "viem";
-import { B as h } from "./BTCVaultRegistry.abi-B0x9_Bza.js";
-import { B as K, h as T } from "./BTCVaultRegistryKeyEpochs.abi-BWoxwPQv.js";
-import { M as O, b as H } from "./constants-D5vORbQE.js";
-import { waitForTransactionReceiptSmartAware as ft } from "./tbv/core/utils/eth/index.js";
-import { a as C, c as mt, d as Pt } from "./onChainBtcPubkey-CCTdl53s.js";
-import { s as Q, b as w, a as bt } from "./secp256k1-D-H9jmd7.js";
-import { c as yt, H as wt, r as E, a as F, h as Y, b as R, s as Ct } from "./sha2-YqVHJiFj.js";
-const v = 25, Et = 9999;
-function M(t) {
-  if (!Number.isInteger(t) || t < 0 || t >= O)
-    throw new Error(
-      `Quoted commissionBps must be an integer in [0, ${O}), got ${t}`
-    );
-  return Math.min(
-    t + v,
-    Et
-  );
-}
-const xt = /* @__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)), Bt = j.map((t) => (9 * t + 5) % 16), Z = /* @__PURE__ */ (() => {
-  const o = [[j], [Bt]];
-  for (let n = 0; n < 4; n++)
-    for (let i of o)
-      i.push(i[n].map((s) => xt[s]));
-  return o;
-})(), J = Z[0], tt = Z[1], et = /* @__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)), It = /* @__PURE__ */ J.map((t, e) => t.map((o) => et[e][o])), Tt = /* @__PURE__ */ tt.map((t, e) => t.map((o) => et[e][o])), Vt = /* @__PURE__ */ Uint32Array.from([
-  0,
-  1518500249,
-  1859775393,
-  2400959708,
-  2840853838
-]), At = /* @__PURE__ */ Uint32Array.from([
-  1352829926,
-  1548603684,
-  1836072691,
-  2053994217,
-  0
-]);
-function U(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 x = /* @__PURE__ */ new Uint32Array(16);
-class St extends wt {
-  constructor() {
-    super(64, 20, 8, !0);
-    m(this, "h0", 1732584193);
-    m(this, "h1", -271733879);
-    m(this, "h2", -1732584194);
-    m(this, "h3", 271733878);
-    m(this, "h4", -1009589776);
-  }
-  get() {
-    const { h0: o, h1: n, h2: i, h3: s, h4: r } = this;
-    return [o, n, i, s, r];
-  }
-  set(o, n, i, s, r) {
-    this.h0 = o | 0, this.h1 = n | 0, this.h2 = i | 0, this.h3 = s | 0, this.h4 = r | 0;
-  }
-  process(o, n) {
-    for (let a = 0; a < 16; a++, n += 4)
-      x[a] = o.getUint32(n, !0);
-    let i = this.h0 | 0, s = i, r = this.h1 | 0, c = r, u = this.h2 | 0, l = u, g = this.h3 | 0, b = g, f = this.h4 | 0, y = f;
-    for (let a = 0; a < 5; a++) {
-      const d = 4 - a, st = Vt[a], rt = At[a], at = J[a], ct = tt[a], ut = It[a], ht = Tt[a];
-      for (let p = 0; p < 16; p++) {
-        const I = E(i + U(a, r, u, g) + x[at[p]] + st, ut[p]) + f | 0;
-        i = f, f = g, g = E(u, 10) | 0, u = r, r = I;
-      }
-      for (let p = 0; p < 16; p++) {
-        const I = E(s + U(d, c, l, b) + x[ct[p]] + rt, ht[p]) + y | 0;
-        s = y, y = b, b = E(l, 10) | 0, l = c, c = I;
-      }
-    }
-    this.set(this.h1 + u + b | 0, this.h2 + g + y | 0, this.h3 + f + s | 0, this.h4 + i + c | 0, this.h0 + r + l | 0);
-  }
-  roundClean() {
-    F(x);
-  }
-  destroy() {
-    this.destroyed = !0, F(this.buffer), this.set(0, 0, 0, 0, 0);
-  }
-}
-const vt = /* @__PURE__ */ yt(() => new St()), $t = "5120", $ = "0014", kt = 20, q = 33, Rt = 65, _t = 2, Nt = 3, Kt = 4;
-function ot(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 Ot(t) {
-  const e = Y(t), o = w.utils.lift_x(BigInt(`0x${t}`)), n = w.utils.bytesToNumberBE(
-    w.utils.taggedHash("TapTweak", e)
-  );
-  if (n >= Q.CURVE.n)
-    throw new Error("Proof of possession BTC pubkey has an invalid TapTweak");
-  const i = n === 0n ? o : o.add(w.Point.BASE.multiply(n));
-  return `0x${$t}${R(
-    w.utils.pointToBytes(i)
-  )}`;
-}
-function Ht(t) {
-  const e = ot(t, "depositorBtcPubkeyRaw"), o = Y(e.slice(2));
-  if (o.length === 32)
-    return {
-      xOnlyPubkey: C(e, "Payout BTC pubkey")
-    };
-  const n = o.length === q && (o[0] === _t || o[0] === Nt), i = o.length === Rt && o[0] === Kt;
-  if (!n && !i)
-    throw new Error(
-      "depositorBtcPubkeyRaw must be x-only, compressed, or uncompressed"
-    );
-  try {
-    Q.Point.fromBytes(o);
-  } catch {
-    throw new Error("depositorBtcPubkeyRaw is not a valid BTC pubkey");
-  }
-  return {
-    xOnlyPubkey: R(o.subarray(1, q)),
-    compressedPubkey: n ? o : void 0
-  };
-}
-function Ft(t) {
-  return `0x${$}${R(vt(Ct(t)))}`;
-}
-function Mt(t, e, o) {
-  const n = ot(
-    t,
-    "depositorPayoutScriptPubKey"
-  );
-  if ((n.length - 2) / 2 > H)
-    throw new Error(
-      `depositorPayoutScriptPubKey exceeds ${H} bytes`
-    );
-  const i = e.startsWith("0x") || e.startsWith("0X") ? e.slice(2) : e, s = C(
-    `0x${i}`,
-    "Proof of possession BTC pubkey"
-  ), r = Ht(o);
-  if (r.xOnlyPubkey !== s)
-    throw new Error(
-      "depositorBtcPubkeyRaw does not match the proof of possession BTC pubkey"
-    );
-  if (n === Ot(s))
-    return n;
-  if (n.startsWith(`0x${$}`) && n.length === 2 + $.length + kt * 2) {
-    if (!r.compressedPubkey)
-      throw new Error("A P2WPKH payout requires a compressed BTC pubkey");
-    if (n === Ft(r.compressedPubkey))
-      return n;
-  }
-  throw new Error(
-    "depositorPayoutScriptPubKey does not match the proof of possession BTC pubkey"
-  );
-}
-const V = 65535, D = 1e4, B = 4294967295, W = 255;
-function Ut(t) {
-  if (!Number.isInteger(t) || t < 0 || t > B)
-    throw new Error(
-      `Invalid offchainParamsVersion from contract: must be a uint32, got ${t}`
-    );
-}
-function qt(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 > D) && e.push(
-    `minVpCommissionBps must be in [0, ${D}], got ${t.minVpCommissionBps}`
-  ), e.length > 0)
-    throw new Error(
-      `Invalid offchain protocol parameters: ${e.join("; ")}`
-    );
-}
-function Dt(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 > W) && e.push(
-    `maxHtlcOutputCount must be an integer in [1, ${W}], 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 ce(t) {
-  if (Dt(t), qt(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}`
-    );
-  bt(
-    t.activeVaultCoreVersion,
-    "ProtocolParams.activeVaultCoreVersion()"
-  );
-}
-const nt = "RegistrationLogsUnavailableError";
-class it extends Error {
-  constructor(o) {
-    super(
-      `The Ethereum node returned no registration logs for block ${o}, which holds a vault registration; the node may not have indexed that block yet. Try again.`
-    );
-    m(this, "blockNumber");
-    this.name = nt, this.blockNumber = o;
-  }
-}
-function ue(t) {
-  return t instanceof it ? !0 : typeof t != "object" || t === null ? !1 : t.name === nt;
-}
-const L = 9999;
-function X(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 Ut(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 Wt = 1n << 64n, Lt = 0n, Xt = [
-  _({ abi: h, name: "PegInSubmitted" }),
-  _({ abi: h, name: "PegInSubmittedV2" })
-];
-function S(t, e, o) {
-  if (t < 0n || t >= Wt)
-    throw new Error(
-      `getBtcVaultProtocolInfo returned ${e}=${t} for vault ${o}, outside the uint64 range — the registry may predate RFC-006`
-    );
-  return t;
-}
-function z(t, e) {
-  return {
-    vpKeyEpoch: S(t.vpKeyEpoch, "vpKeyEpoch", e),
-    appKeeperKeyEpoch: S(
-      t.appKeeperKeyEpoch,
-      "appKeeperKeyEpoch",
-      e
-    ),
-    ucKeyEpoch: S(t.ucKeyEpoch, "ucKeyEpoch", e)
-  };
-}
-class zt {
-  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) {
-    return this.getVaultProviderOperationBtcKeyAtEpoch(
-      e,
-      Lt,
-      o
-    );
-  }
-  /**
-   * Read the VP operation key selected by `epoch`.
-   *
-   * This is public rather than hidden inside `OperationKeyReader` because
-   * subject-specific VP authentication needs exactly one participant: the
-   * gRPC bootstrap is signed by the key frozen into the vault, while the
-   * JSON-RPC bootstrap is signed by the provider's live key.
-   */
-  async getVaultProviderOperationBtcKeyAtEpoch(e, o, n) {
-    const i = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: h,
-      functionName: "getOperationBtcKeyAtEpoch",
-      args: [e, o],
-      blockNumber: n
-    });
-    return C(
-      i,
-      `getOperationBtcKeyAtEpoch (vp=${e}, epoch=${o})`
-    );
-  }
-  /**
-   * Read the application entry point a vault provider is registered for.
-   *
-   * This is the registry's own `vaultProviders[vp].applicationEntryPoint`, and
-   * it is the value the peg-in submit path resolves internally — it selects
-   * which application's vault-keeper roster, roster version and keeper key
-   * epoch a deposit is bonded to. The dApp separately carries an entry point
-   * from its own configuration; the two agree today, but they are different
-   * sources of truth, so the build path reads this one and asserts the
-   * configured value matches it rather than trusting either alone.
-   */
-  async getVaultProviderApplication(e, o) {
-    return await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: h,
-      functionName: "getVaultProviderApplication",
-      args: [e],
-      blockNumber: o
-    });
-  }
-  /**
-   * 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 uses for JSON-RPC-subject authentication.
-   * The gRPC-subject bootstrap is instead bound to the existing vault's frozen
-   * epoch and resolves through `getVaultProviderOperationBtcKeyAtEpoch`.
-   */
-  async getCurrentVaultProviderOperationBtcKey(e) {
-    const o = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: h,
-      functionName: "getCurrentOperationBtcKey",
-      args: [e]
-    });
-    return C(
-      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: K,
-      functionName: "getBtcVaultProtocolInfo",
-      args: [e]
-    });
-    return z(o, e);
-  }
-  async getVaultKeyEpochsBatch(e) {
-    return e.length === 0 ? [] : (await this.publicClient.multicall({
-      contracts: e.map((n) => ({
-        address: this.contractAddress,
-        abi: K,
-        functionName: "getBtcVaultProtocolInfo",
-        args: [n]
-      })),
-      allowFailure: !1
-    })).map(
-      (n, i) => z(n, e[i])
-    );
-  }
-  async getVaultBasicInfo(e) {
-    const o = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: h,
-      functionName: "getBtcVaultBasicInfo",
-      args: [e]
-    });
-    return X(o);
-  }
-  async getVaultProtocolInfo(e) {
-    const o = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: h,
-      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: h,
-        functionName: "getBtcVaultProtocolInfo",
-        args: [n]
-      })),
-      allowFailure: !1
-    })).map((n, i) => {
-      const s = n;
-      if (!s.depositorSignedPeginTx || s.depositorSignedPeginTx === "0x")
-        throw new Error(
-          `Vault ${e[i]} not found on-chain or has no pegin transaction`
-        );
-      return A(s);
-    });
-  }
-  /**
-   * 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: h,
-      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: h,
-      functionName: "getVaultProviderCommission",
-      args: [e]
-    });
-    if (!Number.isInteger(o) || o < 0 || o > L)
-      throw new Error(
-        `getVaultProviderCommission returned ${o} bps for ${e}, outside the protocol range [0, ${L}]`
-      );
-    return o;
-  }
-  async getVaultData(e) {
-    const [o, n] = await this.publicClient.multicall({
-      contracts: [
-        {
-          address: this.contractAddress,
-          abi: h,
-          functionName: "getBtcVaultBasicInfo",
-          args: [e]
-        },
-        {
-          address: this.contractAddress,
-          abi: h,
-          functionName: "getBtcVaultProtocolInfo",
-          args: [e]
-        }
-      ],
-      allowFailure: !1
-    }), i = X(o), s = A(n);
-    if (!s.depositorSignedPeginTx || s.depositorSignedPeginTx === "0x")
-      throw new Error(
-        `Vault ${e} not found on-chain or has no pegin transaction`
-      );
-    return { basic: i, protocol: s };
-  }
-  /**
-   * Read the depositor's commission ceiling (`maxAcceptableCommissionBps`)
-   * for vaults registered in the same block, from their `PegInSubmittedV2`
-   * logs. Returned in `vaultIds` order.
-   *
-   * The contract bound-checks the ceiling and discards it (PeginLogic.sol,
-   * `VaultProviderCommissionExceeded`), so the registration log is its only
-   * on-chain source. One query at exactly `createdAt` — the `block.number`
-   * stamped at registration — so no block-range scan is needed and public-RPC
-   * range caps do not apply. Vault ids are matched case-insensitively.
-   *
-   * @throws {RegistrationLogsUnavailableError} (transient, retry) when the
-   * node answers with no registration logs for the block at all.
-   * @throws when a vault has only its `PegInSubmitted` log — registrations
-   * that predate the V2 event (vault-contracts-aave-v4 #548) never emitted
-   * the ceiling — no registration log in its own `createdAt` block, or more
-   * than one V2 log.
-   */
-  async getMaxAcceptableCommissionBpsBatch(e, o) {
-    if (e.length === 0) return [];
-    const n = await this.publicClient.getLogs({
-      address: this.contractAddress,
-      events: Xt,
-      fromBlock: o,
-      toBlock: o,
-      strict: !0
-    });
-    if (n.length === 0)
-      throw new it(o);
-    return e.map((i) => {
-      const s = i.toLowerCase();
-      let r = !1;
-      const c = [];
-      for (const u of n)
-        u.args.vaultId.toLowerCase() === s && (r = !0, u.eventName === "PegInSubmittedV2" && c.push(u.args.maxAcceptableCommissionBps));
-      if (c.length === 1) return c[0];
-      throw c.length > 1 ? new Error(
-        `Expected one PegInSubmittedV2 log for vault ${i} at block ${o}, found ${c.length} PegInSubmittedV2 logs`
-      ) : r ? new Error(
-        `Vault ${i} was registered before the registry emitted the depositor's commission ceiling (no PegInSubmittedV2 log at block ${o}), so the ceiling cannot be recovered on-chain`
-      ) : new Error(
-        `Vault ${i} has no registration log at its on-chain registration block ${o}`
-      );
-    });
-  }
-}
-const Gt = 0, Qt = 255, Yt = 12e4;
-function P(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 k(t, e) {
-  if (!/^0x[0-9a-fA-F]{64}$/.test(t))
-    throw new Error(`${e} must be a 32-byte hex value`);
-}
-const jt = "0x0000000000000000000000000000000000000000000000000000000000000000";
-function G(t) {
-  if (k(t, "expectedFingerprint"), t.toLowerCase() === jt)
-    throw new Error(
-      "expectedFingerprint must not be zero: the registry cannot resolve a zero fingerprint, so this submission would always revert"
-    );
-}
-function Zt(t) {
-  if (!Number.isInteger(t) || t < 0 || t > Qt)
-    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), G(o.expectedFingerprint);
-    const n = this.assertPopMatchesEthAccount(o.popSignature), i = this.normalizeBtcPubkey(o.popSignature), s = P(
-      o.popSignature.btcPopSignature,
-      "btcPopSignature"
-    ), r = this.normalizeRequest(
-      o,
-      n,
-      i
-    );
-    await this.assertVaultDoesNotExist(
-      r.vaultId,
-      r.peginTxHash
-    );
-    const c = await this.readPeginFee(o.vaultProvider), u = await this.resolveMaxAcceptableCommissionBps(
-      o.vaultProvider,
-      o.quotedCommissionBps
-    ), l = N({
-      abi: h,
-      functionName: "submitPeginRequest",
-      args: [
-        n,
-        i,
-        s,
-        r.unsignedPrePeginTx,
-        r.depositorSignedPeginTx,
-        o.vaultProvider,
-        u,
-        o.hashlock,
-        o.htlcVout,
-        r.payoutScript,
-        o.depositorWotsPkHash,
-        // Appended last on the singular overload; the batch takes it at
-        // position 4 instead. Order is the selector, so do not "tidy" either.
-        o.expectedFingerprint
-      ]
-    });
-    return {
-      ethTxHash: await this.sendAndWait(
-        l,
-        c,
-        !1,
-        n
-      ),
-      vaultId: r.vaultId,
-      peginTxHash: r.peginTxHash
-    };
-  }
-  async registerPeginBatchOnChain(e) {
-    const o = {
-      ...e,
-      popSignature: { ...e.popSignature },
-      requests: e.requests.map((a) => ({ ...a }))
-    };
-    if (o.requests.length === 0)
-      throw new Error("Batch pegin requires at least one request");
-    this.assertQuotedCommissionPresentWhenRequired(o.quotedCommissionBps), G(o.expectedFingerprint);
-    const n = this.assertPopMatchesEthAccount(o.popSignature), i = P(
-      o.unsignedPrePeginTx,
-      "unsignedPrePeginTx"
-    ), s = this.normalizeBtcPubkey(o.popSignature), r = P(
-      o.popSignature.btcPopSignature,
-      "btcPopSignature"
-    ), c = [], u = [], l = /* @__PURE__ */ new Set();
-    for (const a of o.requests) {
-      const d = this.normalizeRequest(
-        {
-          ...a,
-          unsignedPrePeginTx: o.unsignedPrePeginTx,
-          vaultProvider: o.vaultProvider,
-          depositorBtcPubkeyRaw: o.depositorBtcPubkeyRaw
-        },
-        n,
-        s
-      );
-      if (l.has(d.vaultId))
-        throw new Error(`Duplicate vault in batch: ${d.vaultId}`);
-      l.add(d.vaultId), c.push({
-        vaultId: d.vaultId,
-        peginTxHash: d.peginTxHash
-      }), u.push({
-        depositorBtcPubKey: s,
-        btcPopSignature: r,
-        unsignedPrePeginTx: i,
-        depositorSignedPeginTx: d.depositorSignedPeginTx,
-        hashlock: a.hashlock,
-        htlcVout: a.htlcVout,
-        referralCode: Gt,
-        depositorPayoutBtcAddress: d.payoutScript,
-        depositorWotsPkHash: a.depositorWotsPkHash
-      });
-    }
-    for (const a of c)
-      await this.assertVaultDoesNotExist(a.vaultId, a.peginTxHash);
-    const g = await this.readPeginFee(o.vaultProvider), b = await this.resolveMaxAcceptableCommissionBps(
-      o.vaultProvider,
-      o.quotedCommissionBps
-    ), f = N({
-      abi: h,
-      functionName: "submitPeginRequestBatch",
-      // `expectedFingerprint` sits BEFORE `requests`, not appended. Reordering
-      // these five changes the selector and the call stops existing.
-      args: [
-        n,
-        o.vaultProvider,
-        b,
-        o.expectedFingerprint,
-        u
-      ]
-    });
-    return { ethTxHash: await this.sendAndWait(
-      f,
-      g * BigInt(o.requests.length),
-      !0,
-      n
-    ), vaults: c };
-  }
-  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 (!pt(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${C(
-      P(e.depositorBtcPubkey, "Proof of possession BTC pubkey"),
-      "Proof of possession BTC pubkey"
-    )}`;
-  }
-  // `expectedFingerprint` is omitted rather than accepted and ignored: nothing
-  // here normalizes it, and requiring it would force the batch loop to thread a
-  // value through a per-request helper that has no use for it. It is validated
-  // once per call, at the top of each public method.
-  normalizeRequest(e, o, n) {
-    k(e.hashlock, "hashlock"), k(e.depositorWotsPkHash, "depositorWotsPkHash"), Zt(e.htlcVout);
-    const i = P(
-      e.unsignedPrePeginTx,
-      "unsignedPrePeginTx"
-    ), s = P(
-      e.depositorSignedPeginTx,
-      "depositorSignedPeginTx"
-    ), r = mt(s);
-    return {
-      unsignedPrePeginTx: i,
-      depositorSignedPeginTx: s,
-      payoutScript: Mt(
-        e.depositorPayoutScriptPubKey,
-        n,
-        e.depositorBtcPubkeyRaw
-      ),
-      peginTxHash: r,
-      vaultId: P(Pt(r, o), "vaultId")
-    };
-  }
-  async assertVaultDoesNotExist(e, o) {
-    if ((await this.config.publicClient.readContract({
-      address: this.config.btcVaultRegistry,
-      abi: h,
-      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: h,
-        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 zt(
-        this.config.publicClient,
-        this.config.btcVaultRegistry
-      ).getVaultProviderCommission(e);
-    } catch (i) {
-      throw new Error(
-        "Failed to query vault provider commission from the contract. Please check your network connection and contract address.",
-        { cause: i }
-      );
-    }
-    if (o !== void 0) {
-      if (n > o + v)
-        throw new Error(
-          `Vault provider commission changed since quote: quoted ${o} bps, chain currently reports ${n} bps (allowed drift ${v} bps). Please refresh and try again.`
-        );
-      return M(o);
-    }
-    return M(n);
-  }
-  async sendAndWait(e, o, n, i) {
-    let s = this.assertEthAccount(i), r;
-    try {
-      r = await this.config.publicClient.estimateGas({
-        to: this.config.btcVaultRegistry,
-        data: e,
-        value: o,
-        account: s
-      });
-    } catch (l) {
-      T(l);
-    }
-    s = this.assertEthAccount(i);
-    let c;
-    try {
-      c = await this.config.ethWallet.sendTransaction({
-        to: this.config.btcVaultRegistry,
-        data: e,
-        value: o,
-        gas: r,
-        account: s,
-        chain: this.config.ethChain
-      });
-    } catch (l) {
-      T(l);
-    }
-    const u = await ft({
-      publicClient: this.config.publicClient,
-      walletAddress: i,
-      hash: c,
-      timeout: this.config.receiptTimeoutMs ?? Yt
-    });
-    return u.status === "reverted" && T(
-      new Error(
-        `${n ? "Batch transaction" : "Transaction"} reverted. Hash: ${u.transactionHash}. Check a block explorer for details.`
-      )
-    ), u.transactionHash;
-  }
-}
-export {
-  v as C,
-  Et as M,
-  it as R,
-  he as V,
-  ce as a,
-  Dt as b,
-  zt as c,
-  M as d,
-  Ut as e,
-  ue as i,
-  vt as r,
-  qt as v
-};
-//# sourceMappingURL=pegin-registration-client-ilkV1mLP.js.map