@babylonlabs-io/ts-sdk 6.0.1 → 6.1.0

package/dist/{pegin-registration-client-BlrXyZpF.js → pegin-registration-client-Yc-Qs5kq.js}

@@ -1,22 +1,22 @@
-import { getAbiItem as R, encodeFunctionData as E, isAddressEqual as $, zeroAddress as K } from "viem";
-import { B as a } from "./BTCVaultRegistry.abi-DnP4UkB5.js";
-import { B as v, h as b } from "./BTCVaultRegistryKeyEpochs.abi-Btg0nBz1.js";
-import { M as x } from "./constants-CmDDuM3L.js";
-import { waitForTransactionReceiptSmartAware as N } from "./tbv/core/utils/eth/index.js";
-import { a as P, R as _, g as H, V as M, j as O, h as F, k as q, d as L } from "./registration-records-D39ApuHS.js";
-const V = 25, U = 9999;
-function T(o) {
-  if (!Number.isInteger(o) || o < 0 || o >= x)
+import { getAbiItem as O, encodeFunctionData as I, isAddressEqual as R, zeroAddress as q, InsufficientFundsError as L, isAddress as U } from "viem";
+import { B as u } from "./BTCVaultRegistry.abi-DnP4UkB5.js";
+import { B as k, h as B } from "./BTCVaultRegistryKeyEpochs.abi-Btg0nBz1.js";
+import { M as $ } from "./constants-CmDDuM3L.js";
+import { waitForTransactionReceiptSmartAware as W } from "./tbv/core/utils/eth/index.js";
+import { a as b, R as z, g as D, V as G, j as X, h as Q, k as Y, d as j } from "./registration-records-D39ApuHS.js";
+const T = 25, Z = 9999;
+function N(o) {
+  if (!Number.isInteger(o) || o < 0 || o >= $)
     throw new Error(
-      `Quoted commissionBps must be an integer in [0, ${x}), got ${o}`
+      `Quoted commissionBps must be an integer in [0, ${$}), got ${o}`
     );
   return Math.min(
-    o + V,
-    U
+    o + T,
+    Z
   );
 }
-const A = 9999;
-function S(o) {
+const K = 9999;
+function _(o) {
   return {
     depositor: o.depositor,
     depositorBtcPubKey: o.depositorBtcPubKey,
@@ -27,9 +27,9 @@ function S(o) {
     createdAt: o.createdAt
   };
 }
-function C(o) {
+function x(o) {
   const t = Number(o.offchainParamsVersion);
-  return O(t), {
+  return X(t), {
     depositorSignedPeginTx: o.depositorSignedPeginTx,
     universalChallengersVersion: o.universalChallengersVersion,
     appVaultKeepersVersion: o.appVaultKeepersVersion,
@@ -45,17 +45,17 @@ function C(o) {
     vaultCoreVersion: o.vaultCoreVersion
   };
 }
-const z = 1n << 64n, W = 0n, D = R({
-  abi: a,
+const J = 1n << 64n, tt = 0n, et = O({
+  abi: u,
   name: "PegInSubmitted"
-}), X = R({
-  abi: a,
+}), ot = O({
+  abi: u,
   name: "VaultClaimableBy"
-}), Q = 7200n;
-function G(o, t) {
+}), rt = 7200n;
+function it(o, t) {
   return o > t ? o : t;
 }
-function Y(o, t) {
+function st(o, t) {
   return {
     vaultId: o.vaultId.toLowerCase(),
     depositor: o.depositor,
@@ -73,30 +73,30 @@ function Y(o, t) {
     blockNumber: t
   };
 }
-function w(o, t, e) {
-  if (o < 0n || o >= z)
+function v(o, t, e) {
+  if (o < 0n || o >= J)
     throw new Error(
       `getBtcVaultProtocolInfo returned ${t}=${o} for vault ${e}, outside the uint64 range — the registry may predate RFC-006`
     );
   return o;
 }
-const j = "not found on-chain or has no pegin transaction";
-function y(o, t) {
+const nt = "not found on-chain or has no pegin transaction";
+function A(o, t) {
   if (!o.depositorSignedPeginTx || o.depositorSignedPeginTx === "0x")
-    throw new Error(`Vault ${t} ${j}`);
+    throw new Error(`Vault ${t} ${nt}`);
 }
-function I(o, t) {
-  return y(o, t), {
-    vpKeyEpoch: w(o.vpKeyEpoch, "vpKeyEpoch", t),
-    appKeeperKeyEpoch: w(
+function F(o, t) {
+  return A(o, t), {
+    vpKeyEpoch: v(o.vpKeyEpoch, "vpKeyEpoch", t),
+    appKeeperKeyEpoch: v(
       o.appKeeperKeyEpoch,
       "appKeeperKeyEpoch",
       t
     ),
-    ucKeyEpoch: w(o.ucKeyEpoch, "ucKeyEpoch", t)
+    ucKeyEpoch: v(o.ucKeyEpoch, "ucKeyEpoch", t)
   };
 }
-class Z {
+class at {
   constructor(t, e) {
     this.publicClient = t, this.contractAddress = e;
   }
@@ -126,7 +126,7 @@ class Z {
   async getVaultProviderGenesisBtcPubKey(t, e) {
     return this.getVaultProviderOperationBtcKeyAtEpoch(
       t,
-      W,
+      tt,
       e
     );
   }
@@ -139,15 +139,15 @@ class Z {
    * JSON-RPC bootstrap is signed by the provider's live key.
    */
   async getVaultProviderOperationBtcKeyAtEpoch(t, e, r) {
-    const s = await this.publicClient.readContract({
+    const i = await this.publicClient.readContract({
       address: this.contractAddress,
-      abi: a,
+      abi: u,
       functionName: "getOperationBtcKeyAtEpoch",
       args: [t, e],
       blockNumber: r
     });
-    return P(
-      s,
+    return b(
+      i,
       `getOperationBtcKeyAtEpoch (vp=${t}, epoch=${e})`
     );
   }
@@ -165,7 +165,7 @@ class Z {
   async getVaultProviderApplication(t, e) {
     return await this.publicClient.readContract({
       address: this.contractAddress,
-      abi: a,
+      abi: u,
       functionName: "getVaultProviderApplication",
       args: [t],
       blockNumber: e
@@ -185,11 +185,11 @@ class Z {
   async getCurrentVaultProviderOperationBtcKey(t) {
     const e = await this.publicClient.readContract({
       address: this.contractAddress,
-      abi: a,
+      abi: u,
       functionName: "getCurrentOperationBtcKey",
       args: [t]
     });
-    return P(
+    return b(
       e,
       `getCurrentOperationBtcKey (vp=${t})`
     );
@@ -213,55 +213,55 @@ class Z {
   async getVaultKeyEpochs(t) {
     const e = await this.publicClient.readContract({
       address: this.contractAddress,
-      abi: v,
+      abi: k,
       functionName: "getBtcVaultProtocolInfo",
       args: [t]
     });
-    return I(e, t);
+    return F(e, t);
   }
   async getVaultKeyEpochsBatch(t) {
     return t.length === 0 ? [] : (await this.publicClient.multicall({
       contracts: t.map((r) => ({
         address: this.contractAddress,
-        abi: v,
+        abi: k,
         functionName: "getBtcVaultProtocolInfo",
         args: [r]
       })),
       allowFailure: !1
     })).map(
-      (r, s) => I(r, t[s])
+      (r, i) => F(r, t[i])
     );
   }
   async getVaultBasicInfo(t) {
     const e = await this.publicClient.readContract({
       address: this.contractAddress,
-      abi: a,
+      abi: u,
       functionName: "getBtcVaultBasicInfo",
       args: [t]
     });
-    return S(e);
+    return _(e);
   }
   async getVaultProtocolInfo(t) {
     const e = await this.publicClient.readContract({
       address: this.contractAddress,
-      abi: a,
+      abi: u,
       functionName: "getBtcVaultProtocolInfo",
       args: [t]
     });
-    return C(e);
+    return x(e);
   }
   async getProtocolInfoBatch(t) {
     return t.length === 0 ? [] : (await this.publicClient.multicall({
       contracts: t.map((r) => ({
         address: this.contractAddress,
-        abi: a,
+        abi: u,
         functionName: "getBtcVaultProtocolInfo",
         args: [r]
       })),
       allowFailure: !1
-    })).map((r, s) => {
-      const i = r;
-      return y(i, t[s]), C(i);
+    })).map((r, i) => {
+      const s = r;
+      return A(s, t[i]), x(s);
     });
   }
   /**
@@ -271,7 +271,7 @@ class Z {
   async getPegInFee(t) {
     return await this.publicClient.readContract({
       address: this.contractAddress,
-      abi: a,
+      abi: u,
       functionName: "getPegInFee",
       args: [t]
     });
@@ -286,13 +286,13 @@ class Z {
   async getVaultProviderCommission(t) {
     const e = await this.publicClient.readContract({
       address: this.contractAddress,
-      abi: a,
+      abi: u,
       functionName: "getVaultProviderCommission",
       args: [t]
     });
-    if (!Number.isInteger(e) || e < 0 || e > A)
+    if (!Number.isInteger(e) || e < 0 || e > K)
       throw new Error(
-        `getVaultProviderCommission returned ${e} bps for ${t}, outside the protocol range [0, ${A}]`
+        `getVaultProviderCommission returned ${e} bps for ${t}, outside the protocol range [0, ${K}]`
       );
     return e;
   }
@@ -301,40 +301,40 @@ class Z {
       contracts: [
         {
           address: this.contractAddress,
-          abi: a,
+          abi: u,
           functionName: "getBtcVaultBasicInfo",
           args: [t]
         },
         {
           address: this.contractAddress,
-          abi: a,
+          abi: u,
           functionName: "getBtcVaultProtocolInfo",
           args: [t]
         }
       ],
       allowFailure: !1
-    }), s = S(e), i = C(r);
-    return y(i, t), { basic: s, protocol: i };
+    }), i = _(e), s = x(r);
+    return A(s, t), { basic: i, protocol: s };
   }
   /** @inheritdoc */
   async getRegistrationRecordsAtBlock(t) {
     const e = await this.publicClient.getLogs({
       address: this.contractAddress,
-      event: D,
+      event: et,
       fromBlock: t,
       toBlock: t,
       strict: !0
     });
     if (e.length === 0)
-      throw new _(t);
+      throw new z(t);
     const r = /* @__PURE__ */ new Map();
-    for (const s of e) {
-      const i = Y(s.args, s.blockNumber);
-      if (r.has(i.vaultId))
+    for (const i of e) {
+      const s = st(i.args, i.blockNumber);
+      if (r.has(s.vaultId))
         throw new Error(
-          `Expected one PegInSubmitted log for vault ${i.vaultId} at block ${t}, found more than one`
+          `Expected one PegInSubmitted log for vault ${s.vaultId} at block ${t}, found more than one`
         );
-      r.set(i.vaultId, i);
+      r.set(s.vaultId, s);
     }
     return [...r.values()];
   }
@@ -355,91 +355,91 @@ class Z {
     if (t.length === 0) return [];
     const r = await this.getRegistrationRecordsAtBlock(e);
     return t.map(
-      (s) => H(r, s, e).maxAcceptableCommissionBps
+      (i) => D(r, i, e).maxAcceptableCommissionBps
     );
   }
   /** @inheritdoc */
   async getVaultClaimableBy(t, e, r) {
-    const i = `0x${P(
+    const s = `0x${b(
       e,
       `getVaultClaimableBy claimer (vault=${t})`
-    )}`, n = t.toLowerCase(), { number: c } = await this.publicClient.getBlock({
+    )}`, a = t.toLowerCase(), { number: l } = await this.publicClient.getBlock({
       blockTag: "finalized"
     });
-    if (c < r)
+    if (l < 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`
+        `Finalized block ${l} is below vault ${t}'s registration block ${r}; the registration is not finalized yet, or the node is behind it`
       );
-    let u = c;
+    let d = l;
     for (; ; ) {
-      const l = G(
+      const h = it(
         r,
-        u - Q + 1n
+        d - rt + 1n
       ), p = await this.publicClient.getLogs({
         address: this.contractAddress,
-        event: X,
-        args: { vaultId: n, claimerPK: i },
-        fromBlock: l,
-        toBlock: u,
+        event: ot,
+        args: { vaultId: a, claimerPK: s },
+        fromBlock: h,
+        toBlock: d,
         strict: !0
       });
       if (p.length > 1) {
-        const d = new Set(p.map((f) => f.transactionHash));
-        if (d.size > 1)
+        const c = new Set(p.map((m) => m.transactionHash));
+        if (c.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`
+            `Found ${p.length} VaultClaimableBy logs for vault ${t} and claimer ${s} across ${c.size} transactions in blocks ${h}..${d}; a vault is redeemed once, so the node's answer is inconsistent`
           );
       }
       if (p.length >= 1) {
-        const d = p[0];
+        const c = p[0];
         return {
-          blockNumber: d.blockNumber,
-          claimerPk: P(
-            d.args.claimerPK,
+          blockNumber: c.blockNumber,
+          claimerPk: b(
+            c.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
+          peginTxHash: c.args.peginTxHash,
+          vaultCoreVersion: c.args.vaultCoreVersion,
+          proverCircuitVersion: c.args.proverCircuitVersion,
+          offchainParamsVersion: c.args.offchainParamsVersion,
+          universalChallengersVersion: c.args.universalChallengersVersion,
+          appVaultKeepersVersion: c.args.appVaultKeepersVersion
         };
       }
-      if (l === r)
-        throw new M(
+      if (h === r)
+        throw new G(
           t,
-          i,
+          s,
           r,
-          c
+          l
         );
-      u = l - 1n;
+      d = h - 1n;
     }
   }
 }
-const J = 0, tt = 255, et = 12e4;
-function m(o, t) {
+const ct = 0, ut = 255, lt = 12e4, dt = /^0xef0100[0-9a-f]{40}$/i;
+function f(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) {
+function S(o, t) {
   if (!/^0x[0-9a-fA-F]{64}$/.test(o))
     throw new Error(`${t} must be a 32-byte hex value`);
 }
-const ot = "0x0000000000000000000000000000000000000000000000000000000000000000";
-function k(o) {
-  if (B(o, "expectedFingerprint"), o.toLowerCase() === ot)
+const ht = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function H(o) {
+  if (S(o, "expectedFingerprint"), o.toLowerCase() === ht)
     throw new Error(
       "expectedFingerprint must not be zero: the registry cannot resolve a zero fingerprint, so this submission would always revert"
     );
 }
-function rt(o) {
-  if (!Number.isInteger(o) || o < 0 || o > tt)
+function pt(o) {
+  if (!Number.isInteger(o) || o < 0 || o > ut)
     throw new Error(`htlcVout must be a uint8, got ${o}`);
 }
-class dt {
+class wt {
   constructor(t) {
     this.config = t;
   }
@@ -448,36 +448,36 @@ class dt {
       ...t,
       popSignature: { ...t.popSignature }
     };
-    this.assertQuotedCommissionPresentWhenRequired(e.quotedCommissionBps), k(e.expectedFingerprint);
-    const r = this.assertPopMatchesEthAccount(e.popSignature), s = this.normalizeBtcPubkey(e.popSignature), i = m(
+    this.assertQuotedCommissionPresentWhenRequired(e.quotedCommissionBps), H(e.expectedFingerprint);
+    const r = this.assertPopMatchesEthAccount(e.popSignature), i = this.normalizeBtcPubkey(e.popSignature), s = f(
       e.popSignature.btcPopSignature,
       "btcPopSignature"
-    ), n = this.normalizeRequest(
+    ), a = this.normalizeRequest(
       e,
       r,
-      s
+      i
     );
     await this.assertVaultDoesNotExist(
-      n.vaultId,
-      n.peginTxHash
+      a.vaultId,
+      a.peginTxHash
     );
-    const c = await this.readPeginFee(e.vaultProvider), u = await this.resolveMaxAcceptableCommissionBps(
+    const l = await this.readPeginFee(e.vaultProvider), d = await this.resolveMaxAcceptableCommissionBps(
       e.vaultProvider,
       e.quotedCommissionBps
-    ), l = E({
-      abi: a,
+    ), h = I({
+      abi: u,
       functionName: "submitPeginRequest",
       args: [
         r,
-        s,
         i,
-        n.unsignedPrePeginTx,
-        n.depositorSignedPeginTx,
+        s,
+        a.unsignedPrePeginTx,
+        a.depositorSignedPeginTx,
         e.vaultProvider,
-        u,
+        d,
         e.hashlock,
         e.htlcVout,
-        n.payoutScript,
+        a.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.
@@ -486,83 +486,83 @@ class dt {
     });
     return {
       ethTxHash: await this.sendAndWait(
+        h,
         l,
-        c,
         !1,
         r
       ),
-      vaultId: n.vaultId,
-      peginTxHash: n.peginTxHash
+      vaultId: a.vaultId,
+      peginTxHash: a.peginTxHash
     };
   }
   async registerPeginBatchOnChain(t) {
     const e = {
       ...t,
       popSignature: { ...t.popSignature },
-      requests: t.requests.map((h) => ({ ...h }))
+      requests: t.requests.map((n) => ({ ...n }))
     };
     if (e.requests.length === 0)
       throw new Error("Batch pegin requires at least one request");
-    this.assertQuotedCommissionPresentWhenRequired(e.quotedCommissionBps), k(e.expectedFingerprint);
-    const r = this.assertPopMatchesEthAccount(e.popSignature), s = m(
+    this.assertQuotedCommissionPresentWhenRequired(e.quotedCommissionBps), H(e.expectedFingerprint);
+    const r = this.assertPopMatchesEthAccount(e.popSignature), i = f(
       e.unsignedPrePeginTx,
       "unsignedPrePeginTx"
-    ), i = this.normalizeBtcPubkey(e.popSignature), n = m(
+    ), s = this.normalizeBtcPubkey(e.popSignature), a = f(
       e.popSignature.btcPopSignature,
       "btcPopSignature"
-    ), c = [], u = [], l = /* @__PURE__ */ new Set();
-    for (const h of e.requests) {
+    ), l = [], d = [], h = /* @__PURE__ */ new Set();
+    for (const n of e.requests) {
       const g = this.normalizeRequest(
         {
-          ...h,
+          ...n,
           unsignedPrePeginTx: e.unsignedPrePeginTx,
           vaultProvider: e.vaultProvider,
           depositorBtcPubkeyRaw: e.depositorBtcPubkeyRaw
         },
         r,
-        i
+        s
       );
-      if (l.has(g.vaultId))
+      if (h.has(g.vaultId))
         throw new Error(`Duplicate vault in batch: ${g.vaultId}`);
-      l.add(g.vaultId), c.push({
+      h.add(g.vaultId), l.push({
         vaultId: g.vaultId,
         peginTxHash: g.peginTxHash
-      }), u.push({
-        depositorBtcPubKey: i,
-        btcPopSignature: n,
-        unsignedPrePeginTx: s,
+      }), d.push({
+        depositorBtcPubKey: s,
+        btcPopSignature: a,
+        unsignedPrePeginTx: i,
         depositorSignedPeginTx: g.depositorSignedPeginTx,
-        hashlock: h.hashlock,
-        htlcVout: h.htlcVout,
-        referralCode: J,
+        hashlock: n.hashlock,
+        htlcVout: n.htlcVout,
+        referralCode: ct,
         depositorPayoutBtcAddress: g.payoutScript,
-        depositorWotsPkHash: h.depositorWotsPkHash
+        depositorWotsPkHash: n.depositorWotsPkHash
       });
     }
-    for (const h of c)
-      await this.assertVaultDoesNotExist(h.vaultId, h.peginTxHash);
-    const p = await this.readPeginFee(e.vaultProvider), d = await this.resolveMaxAcceptableCommissionBps(
+    for (const n of l)
+      await this.assertVaultDoesNotExist(n.vaultId, n.peginTxHash);
+    const p = await this.readPeginFee(e.vaultProvider), c = await this.resolveMaxAcceptableCommissionBps(
       e.vaultProvider,
       e.quotedCommissionBps
-    ), f = E({
-      abi: a,
+    ), m = I({
+      abi: u,
       functionName: "submitPeginRequestBatch",
       // `expectedFingerprint` sits BEFORE `requests`, not appended. Reordering
       // these five changes the selector and the call stops existing.
       args: [
         r,
         e.vaultProvider,
-        d,
+        c,
         e.expectedFingerprint,
-        u
+        d
       ]
     });
     return { ethTxHash: await this.sendAndWait(
-      f,
+      m,
       p * BigInt(e.requests.length),
       !0,
       r
-    ), vaults: c };
+    ), vaults: l };
   }
   assertQuotedCommissionPresentWhenRequired(t) {
     if (t === void 0 && this.config.requireQuotedCommissionBps)
@@ -576,15 +576,15 @@ class dt {
   assertEthAccount(t) {
     const e = this.config.ethWallet.account;
     if (!e) throw new Error("Ethereum wallet account not found");
-    if (!$(t, e.address))
+    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"),
+    return `0x${b(
+      f(t.depositorBtcPubkey, "Proof of possession BTC pubkey"),
       "Proof of possession BTC pubkey"
     )}`;
   }
@@ -593,33 +593,33 @@ class dt {
   // 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"), rt(t.htlcVout);
-    const s = m(
+    S(t.hashlock, "hashlock"), S(t.depositorWotsPkHash, "depositorWotsPkHash"), pt(t.htlcVout);
+    const i = f(
       t.unsignedPrePeginTx,
       "unsignedPrePeginTx"
-    ), i = m(
+    ), s = f(
       t.depositorSignedPeginTx,
       "depositorSignedPeginTx"
-    ), n = F(i);
+    ), a = Q(s);
     return {
-      unsignedPrePeginTx: s,
-      depositorSignedPeginTx: i,
-      payoutScript: q(
+      unsignedPrePeginTx: i,
+      depositorSignedPeginTx: s,
+      payoutScript: Y(
         t.depositorPayoutScriptPubKey,
         r,
         t.depositorBtcPubkeyRaw
       ),
-      peginTxHash: n,
-      vaultId: m(L(n, e), "vaultId")
+      peginTxHash: a,
+      vaultId: f(j(a, e), "vaultId")
     };
   }
   async assertVaultDoesNotExist(t, e) {
     if ((await this.config.publicClient.readContract({
       address: this.config.btcVaultRegistry,
-      abi: a,
+      abi: u,
       functionName: "getBtcVaultBasicInfo",
       args: [t]
-    })).depositor !== K)
+    })).depositor !== q)
       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.`
       );
@@ -628,7 +628,7 @@ class dt {
     try {
       return await this.config.publicClient.readContract({
         address: this.config.btcVaultRegistry,
-        abi: a,
+        abi: u,
         functionName: "getPegInFee",
         args: [t]
       });
@@ -642,69 +642,96 @@ class dt {
   async resolveMaxAcceptableCommissionBps(t, e) {
     let r;
     try {
-      r = await new Z(
+      r = await new at(
         this.config.publicClient,
         this.config.btcVaultRegistry
       ).getVaultProviderCommission(t);
-    } catch (s) {
+    } catch (i) {
       throw new Error(
         "Failed to query vault provider commission from the contract. Please check your network connection and contract address.",
-        { cause: s }
+        { cause: i }
       );
     }
     if (e !== void 0) {
-      if (r > e + V)
+      if (r > e + T)
         throw new Error(
-          `Vault provider commission changed since quote: quoted ${e} bps, chain currently reports ${r} bps (allowed drift ${V} bps). Please refresh and try again.`
+          `Vault provider commission changed since quote: quoted ${e} bps, chain currently reports ${r} bps (allowed drift ${T} bps). Please refresh and try again.`
         );
-      return T(e);
+      return N(e);
     }
-    return T(r);
+    return N(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);
+  async sendAndWait(t, e, r, i) {
+    let s = this.assertEthAccount(i);
+    const a = await this.config.publicClient.getCode({ address: s }), l = a !== void 0 && a !== "0x" && !dt.test(a);
+    let d, h = e;
+    if (!l) {
+      let n;
+      try {
+        n = await this.config.publicClient.prepareTransactionRequest({
+          to: this.config.btcVaultRegistry,
+          data: t,
+          value: e,
+          account: s,
+          chain: this.config.ethChain,
+          parameters: ["gas", "fees", "type"]
+        });
+      } catch (M) {
+        B(M);
+      }
+      const { gas: g, type: w, gasPrice: V, maxFeePerGas: E, maxPriorityFeePerGas: C } = n, P = w === "eip1559" && typeof E == "bigint" && typeof C == "bigint" && C >= 0n && E >= C ? { type: w, maxFeePerGas: E, maxPriorityFeePerGas: C } : w === "legacy" && typeof V == "bigint" && V >= 0n ? { type: w, gasPrice: V } : void 0;
+      if (typeof g != "bigint" || g <= 0n || !P)
+        throw new Error(
+          "Failed to prepare registration gas and fees. Try again."
+        );
+      d = { gas: g, ...P }, h += g * (P.type === "eip1559" ? P.maxFeePerGas : P.gasPrice);
     }
-    i = this.assertEthAccount(s);
-    let c;
+    const p = await this.config.publicClient.getBalance({
+      address: this.assertEthAccount(i)
+    });
+    if (typeof p != "bigint" || p < 0n)
+      throw new Error("Failed to read the Ethereum balance. Try again.");
+    if (p < h)
+      throw new L();
+    const c = await this.config.ethWallet.getAddresses();
+    if (!Array.isArray(c) || !c.every(
+      (n) => typeof n == "string" && U(n)
+    ) || !c.some((n) => R(n, i)))
+      throw new Error(
+        "The Ethereum wallet account is no longer available. Reconnect it and try again."
+      );
+    s = this.assertEthAccount(i);
+    let m;
     try {
-      c = await this.config.ethWallet.sendTransaction({
+      m = await this.config.ethWallet.sendTransaction({
         to: this.config.btcVaultRegistry,
         data: t,
         value: e,
-        gas: n,
-        account: i,
+        ...d,
+        account: s,
         chain: this.config.ethChain
       });
-    } catch (l) {
-      b(l);
+    } catch (n) {
+      B(n);
     }
-    const u = await N({
+    const y = await W({
       publicClient: this.config.publicClient,
-      walletAddress: s,
-      hash: c,
-      timeout: this.config.receiptTimeoutMs ?? et
+      walletAddress: i,
+      hash: m,
+      timeout: this.config.receiptTimeoutMs ?? lt
     });
-    return u.status === "reverted" && b(
+    return y.status === "reverted" && B(
       new Error(
-        `${r ? "Batch transaction" : "Transaction"} reverted. Hash: ${u.transactionHash}. Check a block explorer for details.`
+        `${r ? "Batch transaction" : "Transaction"} reverted. Hash: ${y.transactionHash}. Check a block explorer for details.`
       )
-    ), u.transactionHash;
+    ), y.transactionHash;
   }
 }
 export {
-  V as C,
-  U as M,
-  dt as V,
-  Z as a,
-  T as c
+  T as C,
+  Z as M,
+  wt as V,
+  at as a,
+  N as c
 };
-//# sourceMappingURL=pegin-registration-client-BlrXyZpF.js.map
+//# sourceMappingURL=pegin-registration-client-Yc-Qs5kq.js.map