@babylonlabs-io/ts-sdk 3.0.2 → 3.1.1

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

@@ -0,0 +1,718 @@
+import { getAbiItem as V, encodeFunctionData as E, isAddressEqual as R, zeroAddress as K } from "viem";
+import { B as a } from "./BTCVaultRegistry.abi-DBW0dyqH.js";
+import { B as v, h as b } from "./BTCVaultRegistryKeyEpochs.abi-BWoxwPQv.js";
+import { M as x } from "./constants-BeYquVd-.js";
+import { waitForTransactionReceiptSmartAware as N } from "./tbv/core/utils/eth/index.js";
+import { a as P, R as T, g as H, V as _, j as M, h as q, k as F, d as O } from "./registration-records-CKLAv3gw.js";
+const y = 25, L = 9999;
+function S(o) {
+  if (!Number.isInteger(o) || o < 0 || o >= x)
+    throw new Error(
+      `Quoted commissionBps must be an integer in [0, ${x}), got ${o}`
+    );
+  return Math.min(
+    o + y,
+    L
+  );
+}
+const A = 9999;
+function I(o) {
+  return {
+    depositor: o.depositor,
+    depositorBtcPubKey: o.depositorBtcPubKey,
+    amount: o.amount,
+    vaultProvider: o.vaultProvider,
+    status: o.status,
+    applicationEntryPoint: o.applicationEntryPoint,
+    createdAt: o.createdAt
+  };
+}
+function w(o) {
+  const t = Number(o.offchainParamsVersion);
+  return M(t), {
+    depositorSignedPeginTx: o.depositorSignedPeginTx,
+    universalChallengersVersion: o.universalChallengersVersion,
+    appVaultKeepersVersion: o.appVaultKeepersVersion,
+    offchainParamsVersion: t,
+    verifiedAt: o.verifiedAt,
+    depositorWotsPkHash: o.depositorWotsPkHash,
+    hashlock: o.hashlock,
+    htlcVout: o.htlcVout,
+    depositorPopSignature: o.depositorPopSignature,
+    prePeginTxHash: o.prePeginTxHash,
+    vaultProviderCommissionBps: o.vaultProviderCommissionBps,
+    vaultCoreVersion: o.vaultCoreVersion
+  };
+}
+const z = 1n << 64n, W = 0n, U = [
+  V({ abi: a, name: "PegInSubmitted" }),
+  V({ abi: a, name: "PegInSubmittedV2" })
+], D = V({
+  abi: a,
+  name: "VaultClaimableBy"
+}), X = 7200n;
+function Q(o, t) {
+  return o > t ? o : t;
+}
+function Y(o, t) {
+  return {
+    vaultId: o.vaultId.toLowerCase(),
+    depositor: o.depositor,
+    vaultProvider: o.vaultProvider,
+    amount: o.amount,
+    vaultCoreVersion: o.vaultCoreVersion,
+    universalChallengersVersion: o.universalChallengersVersion,
+    appVaultKeepersVersion: o.appVaultKeepersVersion,
+    proverCircuitVersion: o.proverCircuitVersion,
+    offchainParamsVersion: o.offchainParamsVersion,
+    peginTxHash: o.peginTxHash.toLowerCase(),
+    depositorPayoutScriptPubKey: o.depositorPayoutBtcAddress.toLowerCase(),
+    unsignedPrePeginTx: o.unsignedPrePeginTx,
+    maxAcceptableCommissionBps: o.maxAcceptableCommissionBps,
+    blockNumber: t
+  };
+}
+function C(o, t, e) {
+  if (o < 0n || o >= z)
+    throw new Error(
+      `getBtcVaultProtocolInfo returned ${t}=${o} for vault ${e}, outside the uint64 range — the registry may predate RFC-006`
+    );
+  return o;
+}
+function k(o, t) {
+  return {
+    vpKeyEpoch: C(o.vpKeyEpoch, "vpKeyEpoch", t),
+    appKeeperKeyEpoch: C(
+      o.appKeeperKeyEpoch,
+      "appKeeperKeyEpoch",
+      t
+    ),
+    ucKeyEpoch: C(o.ucKeyEpoch, "ucKeyEpoch", t)
+  };
+}
+class G {
+  constructor(t, e) {
+    this.publicClient = t, this.contractAddress = e;
+  }
+  /**
+   * 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(t, e) {
+    return this.getVaultProviderOperationBtcKeyAtEpoch(
+      t,
+      W,
+      e
+    );
+  }
+  /**
+   * 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(t, e, r) {
+    const s = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: a,
+      functionName: "getOperationBtcKeyAtEpoch",
+      args: [t, e],
+      blockNumber: r
+    });
+    return P(
+      s,
+      `getOperationBtcKeyAtEpoch (vp=${t}, epoch=${e})`
+    );
+  }
+  /**
+   * 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(t, e) {
+    return await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: a,
+      functionName: "getVaultProviderApplication",
+      args: [t],
+      blockNumber: e
+    });
+  }
+  /**
+   * 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(t) {
+    const e = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: a,
+      functionName: "getCurrentOperationBtcKey",
+      args: [t]
+    });
+    return P(
+      e,
+      `getCurrentOperationBtcKey (vp=${t})`
+    );
+  }
+  /**
+   * 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(t) {
+    const e = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: v,
+      functionName: "getBtcVaultProtocolInfo",
+      args: [t]
+    });
+    return k(e, t);
+  }
+  async getVaultKeyEpochsBatch(t) {
+    return t.length === 0 ? [] : (await this.publicClient.multicall({
+      contracts: t.map((r) => ({
+        address: this.contractAddress,
+        abi: v,
+        functionName: "getBtcVaultProtocolInfo",
+        args: [r]
+      })),
+      allowFailure: !1
+    })).map(
+      (r, s) => k(r, t[s])
+    );
+  }
+  async getVaultBasicInfo(t) {
+    const e = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: a,
+      functionName: "getBtcVaultBasicInfo",
+      args: [t]
+    });
+    return I(e);
+  }
+  async getVaultProtocolInfo(t) {
+    const e = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: a,
+      functionName: "getBtcVaultProtocolInfo",
+      args: [t]
+    });
+    return w(e);
+  }
+  async getProtocolInfoBatch(t) {
+    return t.length === 0 ? [] : (await this.publicClient.multicall({
+      contracts: t.map((r) => ({
+        address: this.contractAddress,
+        abi: a,
+        functionName: "getBtcVaultProtocolInfo",
+        args: [r]
+      })),
+      allowFailure: !1
+    })).map((r, s) => {
+      const i = r;
+      if (!i.depositorSignedPeginTx || i.depositorSignedPeginTx === "0x")
+        throw new Error(
+          `Vault ${t[s]} not found on-chain or has no pegin transaction`
+        );
+      return w(i);
+    });
+  }
+  /**
+   * Read the protocol pegin fee (in wei) for a given vault provider.
+   * Mirrors the `getPegInFee(address)` view on BTCVaultRegistry.
+   */
+  async getPegInFee(t) {
+    return await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: a,
+      functionName: "getPegInFee",
+      args: [t]
+    });
+  }
+  /**
+   * 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(t) {
+    const e = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: a,
+      functionName: "getVaultProviderCommission",
+      args: [t]
+    });
+    if (!Number.isInteger(e) || e < 0 || e > A)
+      throw new Error(
+        `getVaultProviderCommission returned ${e} bps for ${t}, outside the protocol range [0, ${A}]`
+      );
+    return e;
+  }
+  async getVaultData(t) {
+    const [e, r] = await this.publicClient.multicall({
+      contracts: [
+        {
+          address: this.contractAddress,
+          abi: a,
+          functionName: "getBtcVaultBasicInfo",
+          args: [t]
+        },
+        {
+          address: this.contractAddress,
+          abi: a,
+          functionName: "getBtcVaultProtocolInfo",
+          args: [t]
+        }
+      ],
+      allowFailure: !1
+    }), s = I(e), i = w(r);
+    if (!i.depositorSignedPeginTx || i.depositorSignedPeginTx === "0x")
+      throw new Error(
+        `Vault ${t} not found on-chain or has no pegin transaction`
+      );
+    return { basic: s, protocol: i };
+  }
+  /** @inheritdoc */
+  async getRegistrationRecordsAtBlock(t) {
+    const e = await this.publicClient.getLogs({
+      address: this.contractAddress,
+      events: U,
+      fromBlock: t,
+      toBlock: t,
+      strict: !0
+    });
+    if (e.length === 0)
+      throw new T(t);
+    const r = /* @__PURE__ */ new Map();
+    for (const s of e) {
+      if (s.eventName !== "PegInSubmittedV2") continue;
+      const i = Y(s.args, s.blockNumber);
+      if (r.has(i.vaultId))
+        throw new Error(
+          `Expected one PegInSubmittedV2 log for vault ${i.vaultId} at block ${t}, found more than one`
+        );
+      r.set(i.vaultId, i);
+    }
+    if (r.size === 0)
+      throw new T(
+        t,
+        `Block ${t} holds ${e.length} PegInSubmitted registration log(s) but no PegInSubmittedV2 log: either the node served a partial answer for block ${t} (retry, preferably another node) or the registry predates the depositor's commission ceiling (vault-contracts-aave-v4 #548) and the ceiling cannot be recovered on-chain`
+      );
+    return [...r.values()];
+  }
+  /**
+   * 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. Vault ids are matched case-insensitively.
+   *
+   * @throws As {@link getRegistrationRecordsAtBlock}, plus the same typed
+   * transient error when a vault has no registration log in its own
+   * `createdAt` block.
+   */
+  async getMaxAcceptableCommissionBpsBatch(t, e) {
+    if (t.length === 0) return [];
+    const r = await this.getRegistrationRecordsAtBlock(e);
+    return t.map(
+      (s) => H(r, s, e).maxAcceptableCommissionBps
+    );
+  }
+  /** @inheritdoc */
+  async getVaultClaimableBy(t, e, r) {
+    const i = `0x${P(
+      e,
+      `getVaultClaimableBy claimer (vault=${t})`
+    )}`, n = t.toLowerCase(), { number: c } = await this.publicClient.getBlock({
+      blockTag: "finalized"
+    });
+    if (c < r)
+      throw new Error(
+        `Finalized block ${c} is below vault ${t}'s registration block ${r}; the registration is not finalized yet, or the node is behind it`
+      );
+    let u = c;
+    for (; ; ) {
+      const l = Q(
+        r,
+        u - X + 1n
+      ), p = await this.publicClient.getLogs({
+        address: this.contractAddress,
+        event: D,
+        args: { vaultId: n, claimerPK: i },
+        fromBlock: l,
+        toBlock: u,
+        strict: !0
+      });
+      if (p.length > 1) {
+        const d = new Set(p.map((f) => f.transactionHash));
+        if (d.size > 1)
+          throw new Error(
+            `Found ${p.length} VaultClaimableBy logs for vault ${t} and claimer ${i} across ${d.size} transactions in blocks ${l}..${u}; a vault is redeemed once, so the node's answer is inconsistent`
+          );
+      }
+      if (p.length >= 1) {
+        const d = p[0];
+        return {
+          blockNumber: d.blockNumber,
+          claimerPk: P(
+            d.args.claimerPK,
+            `VaultClaimableBy.claimerPK (vault=${t})`
+          ),
+          peginTxHash: d.args.peginTxHash,
+          vaultCoreVersion: d.args.vaultCoreVersion,
+          proverCircuitVersion: d.args.proverCircuitVersion,
+          offchainParamsVersion: d.args.offchainParamsVersion,
+          universalChallengersVersion: d.args.universalChallengersVersion,
+          appVaultKeepersVersion: d.args.appVaultKeepersVersion
+        };
+      }
+      if (l === r)
+        throw new _(
+          t,
+          i,
+          r,
+          c
+        );
+      u = l - 1n;
+    }
+  }
+}
+const j = 0, Z = 255, J = 12e4;
+function m(o, t) {
+  const e = o.startsWith("0x") ? o : o.startsWith("0X") ? `0x${o.slice(2)}` : `0x${o}`;
+  if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(e))
+    throw new Error(`${t} must be non-empty, even-length hex`);
+  return e;
+}
+function B(o, t) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(o))
+    throw new Error(`${t} must be a 32-byte hex value`);
+}
+const tt = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function $(o) {
+  if (B(o, "expectedFingerprint"), o.toLowerCase() === tt)
+    throw new Error(
+      "expectedFingerprint must not be zero: the registry cannot resolve a zero fingerprint, so this submission would always revert"
+    );
+}
+function et(o) {
+  if (!Number.isInteger(o) || o < 0 || o > Z)
+    throw new Error(`htlcVout must be a uint8, got ${o}`);
+}
+class ut {
+  constructor(t) {
+    this.config = t;
+  }
+  async registerPeginOnChain(t) {
+    const e = {
+      ...t,
+      popSignature: { ...t.popSignature }
+    };
+    this.assertQuotedCommissionPresentWhenRequired(e.quotedCommissionBps), $(e.expectedFingerprint);
+    const r = this.assertPopMatchesEthAccount(e.popSignature), s = this.normalizeBtcPubkey(e.popSignature), i = m(
+      e.popSignature.btcPopSignature,
+      "btcPopSignature"
+    ), n = this.normalizeRequest(
+      e,
+      r,
+      s
+    );
+    await this.assertVaultDoesNotExist(
+      n.vaultId,
+      n.peginTxHash
+    );
+    const c = await this.readPeginFee(e.vaultProvider), u = await this.resolveMaxAcceptableCommissionBps(
+      e.vaultProvider,
+      e.quotedCommissionBps
+    ), l = E({
+      abi: a,
+      functionName: "submitPeginRequest",
+      args: [
+        r,
+        s,
+        i,
+        n.unsignedPrePeginTx,
+        n.depositorSignedPeginTx,
+        e.vaultProvider,
+        u,
+        e.hashlock,
+        e.htlcVout,
+        n.payoutScript,
+        e.depositorWotsPkHash,
+        // Appended last on the singular overload; the batch takes it at
+        // position 4 instead. Order is the selector, so do not "tidy" either.
+        e.expectedFingerprint
+      ]
+    });
+    return {
+      ethTxHash: await this.sendAndWait(
+        l,
+        c,
+        !1,
+        r
+      ),
+      vaultId: n.vaultId,
+      peginTxHash: n.peginTxHash
+    };
+  }
+  async registerPeginBatchOnChain(t) {
+    const e = {
+      ...t,
+      popSignature: { ...t.popSignature },
+      requests: t.requests.map((h) => ({ ...h }))
+    };
+    if (e.requests.length === 0)
+      throw new Error("Batch pegin requires at least one request");
+    this.assertQuotedCommissionPresentWhenRequired(e.quotedCommissionBps), $(e.expectedFingerprint);
+    const r = this.assertPopMatchesEthAccount(e.popSignature), s = m(
+      e.unsignedPrePeginTx,
+      "unsignedPrePeginTx"
+    ), i = this.normalizeBtcPubkey(e.popSignature), n = m(
+      e.popSignature.btcPopSignature,
+      "btcPopSignature"
+    ), c = [], u = [], l = /* @__PURE__ */ new Set();
+    for (const h of e.requests) {
+      const g = this.normalizeRequest(
+        {
+          ...h,
+          unsignedPrePeginTx: e.unsignedPrePeginTx,
+          vaultProvider: e.vaultProvider,
+          depositorBtcPubkeyRaw: e.depositorBtcPubkeyRaw
+        },
+        r,
+        i
+      );
+      if (l.has(g.vaultId))
+        throw new Error(`Duplicate vault in batch: ${g.vaultId}`);
+      l.add(g.vaultId), c.push({
+        vaultId: g.vaultId,
+        peginTxHash: g.peginTxHash
+      }), u.push({
+        depositorBtcPubKey: i,
+        btcPopSignature: n,
+        unsignedPrePeginTx: s,
+        depositorSignedPeginTx: g.depositorSignedPeginTx,
+        hashlock: h.hashlock,
+        htlcVout: h.htlcVout,
+        referralCode: j,
+        depositorPayoutBtcAddress: g.payoutScript,
+        depositorWotsPkHash: h.depositorWotsPkHash
+      });
+    }
+    for (const h of c)
+      await this.assertVaultDoesNotExist(h.vaultId, h.peginTxHash);
+    const p = await this.readPeginFee(e.vaultProvider), d = await this.resolveMaxAcceptableCommissionBps(
+      e.vaultProvider,
+      e.quotedCommissionBps
+    ), f = E({
+      abi: a,
+      functionName: "submitPeginRequestBatch",
+      // `expectedFingerprint` sits BEFORE `requests`, not appended. Reordering
+      // these five changes the selector and the call stops existing.
+      args: [
+        r,
+        e.vaultProvider,
+        d,
+        e.expectedFingerprint,
+        u
+      ]
+    });
+    return { ethTxHash: await this.sendAndWait(
+      f,
+      p * BigInt(e.requests.length),
+      !0,
+      r
+    ), vaults: c };
+  }
+  assertQuotedCommissionPresentWhenRequired(t) {
+    if (t === 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(t) {
+    return this.assertEthAccount(t.depositorEthAddress);
+  }
+  assertEthAccount(t) {
+    const e = this.config.ethWallet.account;
+    if (!e) throw new Error("Ethereum wallet account not found");
+    if (!R(t, e.address))
+      throw new Error(
+        `Proof of possession was signed for ${t} but the Ethereum wallet is currently connected to ${e.address}. Reconnect the original account or sign a new proof of possession.`
+      );
+    return e.address;
+  }
+  normalizeBtcPubkey(t) {
+    return `0x${P(
+      m(t.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(t, e, r) {
+    B(t.hashlock, "hashlock"), B(t.depositorWotsPkHash, "depositorWotsPkHash"), et(t.htlcVout);
+    const s = m(
+      t.unsignedPrePeginTx,
+      "unsignedPrePeginTx"
+    ), i = m(
+      t.depositorSignedPeginTx,
+      "depositorSignedPeginTx"
+    ), n = q(i);
+    return {
+      unsignedPrePeginTx: s,
+      depositorSignedPeginTx: i,
+      payoutScript: F(
+        t.depositorPayoutScriptPubKey,
+        r,
+        t.depositorBtcPubkeyRaw
+      ),
+      peginTxHash: n,
+      vaultId: m(O(n, e), "vaultId")
+    };
+  }
+  async assertVaultDoesNotExist(t, e) {
+    if ((await this.config.publicClient.readContract({
+      address: this.config.btcVaultRegistry,
+      abi: a,
+      functionName: "getBtcVaultBasicInfo",
+      args: [t]
+    })).depositor !== K)
+      throw new Error(
+        `Vault already exists (ID: ${t}, peginTxHash: ${e}). Vault IDs are derived from the pegin transaction hash and depositor address. To create a new vault, use different UTXOs or a different amount to generate a unique transaction.`
+      );
+  }
+  async readPeginFee(t) {
+    try {
+      return await this.config.publicClient.readContract({
+        address: this.config.btcVaultRegistry,
+        abi: a,
+        functionName: "getPegInFee",
+        args: [t]
+      });
+    } catch (e) {
+      throw new Error(
+        "Failed to query pegin fee from the contract. Please check your network connection and contract address.",
+        { cause: e }
+      );
+    }
+  }
+  async resolveMaxAcceptableCommissionBps(t, e) {
+    let r;
+    try {
+      r = await new G(
+        this.config.publicClient,
+        this.config.btcVaultRegistry
+      ).getVaultProviderCommission(t);
+    } 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 (e !== void 0) {
+      if (r > e + y)
+        throw new Error(
+          `Vault provider commission changed since quote: quoted ${e} bps, chain currently reports ${r} bps (allowed drift ${y} bps). Please refresh and try again.`
+        );
+      return S(e);
+    }
+    return S(r);
+  }
+  async sendAndWait(t, e, r, s) {
+    let i = this.assertEthAccount(s), n;
+    try {
+      n = await this.config.publicClient.estimateGas({
+        to: this.config.btcVaultRegistry,
+        data: t,
+        value: e,
+        account: i
+      });
+    } catch (l) {
+      b(l);
+    }
+    i = this.assertEthAccount(s);
+    let c;
+    try {
+      c = await this.config.ethWallet.sendTransaction({
+        to: this.config.btcVaultRegistry,
+        data: t,
+        value: e,
+        gas: n,
+        account: i,
+        chain: this.config.ethChain
+      });
+    } catch (l) {
+      b(l);
+    }
+    const u = await N({
+      publicClient: this.config.publicClient,
+      walletAddress: s,
+      hash: c,
+      timeout: this.config.receiptTimeoutMs ?? J
+    });
+    return u.status === "reverted" && b(
+      new Error(
+        `${r ? "Batch transaction" : "Transaction"} reverted. Hash: ${u.transactionHash}. Check a block explorer for details.`
+      )
+    ), u.transactionHash;
+  }
+}
+export {
+  y as C,
+  L as M,
+  ut as V,
+  G as a,
+  S as c
+};
+//# sourceMappingURL=pegin-registration-client-BWMwxtr8.js.map