@babylonlabs-io/ts-sdk 0.18.0 → 0.19.0

package/dist/errors-aMocmFr-.js

@@ -0,0 +1,1225 @@
+var qt = Object.defineProperty;
+var zt = (e, t, n) => t in e ? qt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var x = (e, t, n) => zt(e, typeof t != "symbol" ? t + "" : t, n);
+import * as Gt from "bitcoinjs-lib";
+import { Transaction as Zt, Psbt as mt } from "bitcoinjs-lib";
+import { Buffer as q } from "buffer";
+import { createPublicClient as z, http as G, encodeFunctionData as yt, zeroAddress as Yt } from "viem";
+import { c as Jt } from "./signing-Drwr3bXB.js";
+import { p as Qt, B as $, f as te } from "./index-BvFLf3vm.js";
+import { s as E, f as ee, g as wt, e as H, i as ne } from "./constants-Q7v2O7Ps.js";
+import { deriveVaultId as bt } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import { b as se, a as oe, d as re, e as ie, f as ae } from "./challengeAssert-k5_LWUtO.js";
+import { s as ce, c as Z, d as le } from "./psbtInputFields-DO0ELwiv.js";
+import { f as he } from "./fundPeginTransaction-DpwnDslW.js";
+import { b as St, d as K, e as S, f as M, g as Bt, H as ue, r as L, h as fe, i as U, u as de, j as xt, k as ge, l as pe, m as me, n as ye, o as we, q as be, t as xe, x as Pt, y as ut, z as Ct } from "./index-BX-V3C9t.js";
+const B = {
+  // VaultAlreadyExists()
+  "0x04aabf33": "Vault already exists: This Bitcoin transaction has already been registered. Please select different UTXOs or use a different amount to create a unique transaction.",
+  // ScriptPubKeyMismatch() - taproot output doesn't match expected script
+  "0x4fec082d": "Script mismatch: The Bitcoin transaction's taproot output does not match the expected vault script. This may be caused by incorrect vault participants or key configuration.",
+  // InvalidBTCProofOfPossession()
+  "0x6cc363a5": "Invalid BTC proof of possession: The signature could not be verified. Please ensure you're signing with the correct Bitcoin wallet.",
+  // InvalidBTCPublicKey()
+  "0x6c3f2bf6": "Invalid BTC public key: The Bitcoin public key format is invalid.",
+  // InvalidAmount()
+  "0x2c5211c6": "Invalid amount: The deposit amount is invalid or below the minimum required.",
+  // ApplicationNotRegistered()
+  "0x0405f772": "Application not registered: The application controller is not registered in the system.",
+  // InvalidProviderStatus()
+  "0x24e165cc": "Invalid provider status: The vault provider is not in a valid state to accept deposits.",
+  // ZeroAddress()
+  "0xd92e233d": "Zero address: One of the required addresses is the zero address.",
+  // BtcKeyMismatch()
+  "0x65aa7007": "BTC key mismatch: The Bitcoin public key does not match the expected key.",
+  // Unauthorized()
+  "0x82b42900": "Unauthorized: You must be the depositor or vault provider to submit this transaction.",
+  // InvalidSignature() - common signature verification error
+  "0x8baa579f": "Invalid signature: The BTC proof of possession signature could not be verified.",
+  // InvalidBtcTransaction()
+  "0x2f9d01e9": "Invalid BTC transaction: The Bitcoin transaction format is invalid.",
+  // VaultProviderNotRegistered()
+  "0x5a3c6b3e": "Vault provider not registered: The selected vault provider is not registered.",
+  // InvalidPeginFee(uint256,uint256)
+  "0x979f4518": "Invalid pegin fee: The ETH fee sent does not match the required amount. This may indicate a fee rate change during the transaction."
+};
+function ft(e) {
+  if (!e || typeof e != "object") return;
+  const t = e;
+  if (typeof t.data == "string" && t.data.startsWith("0x"))
+    return t.data;
+  if (typeof t.details == "string" && t.details.startsWith("0x"))
+    return t.details;
+  let n = t.cause, s = 0;
+  const o = 5;
+  for (; n && typeof n == "object" && s < o; ) {
+    const a = n;
+    if (typeof a.data == "string" && a.data.startsWith("0x"))
+      return a.data;
+    n = a.cause, s++;
+  }
+  const i = (typeof t.message == "string" ? t.message : "").match(/\b(0x[a-fA-F0-9]{8})\b/);
+  if (i)
+    return i[1];
+}
+function yn(e) {
+  const t = ft(e);
+  if (t) {
+    const n = t.substring(0, 10);
+    return B[t] ?? B[n];
+  }
+}
+function wn(e) {
+  const t = ft(e);
+  if (t === void 0) return !1;
+  const n = t.substring(0, 10);
+  return t in B || n in B;
+}
+function _(e) {
+  console.error("[Contract Error] Raw error:", e);
+  const t = ft(e);
+  if (console.error("[Contract Error] Extracted error data:", t), t) {
+    const s = t.substring(0, 10), o = B[t] ?? B[s];
+    if (o)
+      throw console.error("[Contract Error] Known error:", o), new Error(o);
+  }
+  const n = (e == null ? void 0 : e.message) || "";
+  if (n.includes("gas limit too high") || n.includes("21000000") || n.includes("Internal JSON-RPC error")) {
+    const s = t ? ` (error code: ${t})` : "";
+    throw console.error(
+      "[Contract Error] Transaction rejected. Error code:",
+      t,
+      "Message:",
+      n
+    ), new Error(
+      `Transaction failed: The contract rejected this transaction${s}. Possible causes: (1) Vault already exists for this transaction, (2) Invalid signature, (3) Unauthorized caller. Please check your transaction parameters and try again.`
+    );
+  }
+  throw e instanceof Error ? (console.error("[Contract Error] Unhandled error:", e.message), e) : new Error(`Contract call failed: ${String(e)}`);
+}
+const Pe = 0;
+function ke(e, t, n, s) {
+  const o = n == null ? void 0 : n[`${e}:${t}`];
+  return o ? Promise.resolve({
+    txid: e,
+    vout: t,
+    value: o.value,
+    scriptPubKey: o.scriptPubKey
+  }) : te(e, t, s);
+}
+const kt = 12e4;
+class bn {
+  /**
+   * Creates a new PeginManager instance.
+   *
+   * @param config - Manager configuration including wallets and contract addresses
+   */
+  constructor(t) {
+    x(this, "config");
+    this.config = t;
+  }
+  /**
+   * Prepares a peg-in by building the Pre-PegIn HTLC transaction,
+   * funding it, constructing the PegIn transaction, and signing the PegIn input.
+   *
+   * This method orchestrates the following steps:
+   * 1. Get depositor BTC public key from wallet
+   * 2. Build unfunded Pre-PegIn transaction (HTLC output) using primitives
+   * 3. Select UTXOs to cover the HTLC value
+   * 4. Fund the Pre-PegIn transaction
+   * 5. Derive the PegIn transaction from the funded Pre-PegIn txid
+   * 6. Build PSBT for signing the PegIn input (HTLC leaf 0)
+   * 7. Sign via BTC wallet and extract depositor signature
+   *
+   * The returned `fundedPrePeginTxHex` is funded but unsigned (inputs unsigned).
+   * Use `signAndBroadcast()` AFTER registering on Ethereum to broadcast it.
+   *
+   * @param params - Pegin parameters including amount, HTLC params, UTXOs
+   * @returns Pegin result with funded Pre-PegIn tx, signed PegIn input, and signatures
+   * @throws Error if wallet operations fail or insufficient funds
+   */
+  async preparePegin(t) {
+    const n = await this.config.btcWallet.getPublicKeyHex(), s = n.length === 66 ? n.slice(2) : n, o = E(t.vaultProviderBtcPubkey), r = t.vaultKeeperBtcPubkeys.map(E), i = t.universalChallengerBtcPubkeys.map(E);
+    if (t.hashlocks.length !== t.amounts.length)
+      throw new Error(
+        `hashlocks.length (${t.hashlocks.length}) must equal amounts.length (${t.amounts.length})`
+      );
+    if (t.hashlocks.length === 0)
+      throw new Error("hashlocks must contain at least one entry");
+    const a = r.length, d = {
+      depositorPubkey: s,
+      vaultProviderPubkey: o,
+      vaultKeeperPubkeys: r,
+      universalChallengerPubkeys: i,
+      hashlocks: t.hashlocks,
+      timelockRefund: t.timelockRefund,
+      pegInAmounts: t.amounts,
+      feeRate: t.protocolFeeRate,
+      numLocalChallengers: a,
+      councilQuorum: t.councilQuorum,
+      councilSize: t.councilSize,
+      network: this.config.btcNetwork
+    }, u = await se(d), h = ce(
+      [...t.availableUTXOs],
+      u.totalOutputValue,
+      t.mempoolFeeRate,
+      ee(u.htlcValues.length)
+    ), m = wt(this.config.btcNetwork), l = he({
+      unfundedTxHex: u.psbtHex,
+      selectedUTXOs: h.selectedUTXOs,
+      changeAddress: t.changeAddress,
+      changeAmount: h.changeAmount,
+      network: m
+    }), y = E(Z(l)), p = [], w = [], P = [];
+    for (let g = 0; g < t.hashlocks.length; g++) {
+      const b = await oe({
+        prePeginParams: d,
+        timelockPegin: t.timelockPegin,
+        fundedPrePeginTxHex: l,
+        htlcVout: g
+      }), T = await re({
+        peginTxHex: b.txHex,
+        fundedPrePeginTxHex: l,
+        depositorPubkey: s,
+        vaultProviderPubkey: o,
+        vaultKeeperPubkeys: r,
+        universalChallengerPubkeys: i,
+        hashlock: t.hashlocks[g],
+        timelockRefund: t.timelockRefund,
+        network: this.config.btcNetwork
+      });
+      p.push(b), w.push(T.psbtHex), P.push(
+        Jt(n, 1)
+      );
+    }
+    const f = await this.signPsbtsWithFallback(
+      w,
+      P
+    ), c = [];
+    for (let g = 0; g < f.length; g++) {
+      const b = ie(
+        f[g],
+        s
+      ), T = ae(f[g]);
+      c.push({
+        htlcVout: g,
+        htlcValue: u.htlcValues[g],
+        peginTxHex: T,
+        peginTxid: p[g].txid,
+        peginInputSignature: b,
+        vaultScriptPubKey: p[g].vaultScriptPubKey
+      });
+    }
+    return {
+      fundedPrePeginTxHex: l,
+      prePeginTxid: y,
+      unsignedPrePeginTxHex: u.psbtHex,
+      perVault: c,
+      selectedUTXOs: h.selectedUTXOs,
+      fee: h.fee,
+      changeAmount: h.changeAmount
+    };
+  }
+  /**
+   * Signs multiple PSBTs using batch signing if available, falling back to sequential signing.
+   *
+   * Wallets that support native batch signing (e.g. UniSat) will sign all PSBTs
+   * in a single interaction. Others (e.g. Ledger, AppKit) implement signPsbts
+   * by looping signPsbt internally, so the UX depends on the wallet adapter.
+   */
+  async signPsbtsWithFallback(t, n) {
+    if (typeof this.config.btcWallet.signPsbts == "function") {
+      const o = await this.config.btcWallet.signPsbts(
+        t,
+        n
+      );
+      if (o.length !== t.length)
+        throw new Error(
+          `Expected ${t.length} signed PSBTs but received ${o.length}`
+        );
+      return o;
+    }
+    const s = [];
+    for (let o = 0; o < t.length; o++) {
+      const r = await this.config.btcWallet.signPsbt(
+        t[o],
+        n[o]
+      );
+      s.push(r);
+    }
+    return s;
+  }
+  /**
+   * Signs and broadcasts a funded peg-in transaction to the Bitcoin network.
+   *
+   * This method:
+   * 1. Parses the funded transaction hex
+   * 2. Fetches UTXO data from mempool for each input
+   * 3. Creates a PSBT with proper witnessUtxo/tapInternalKey
+   * 4. Signs via btcWallet.signPsbt()
+   * 5. Finalizes and extracts the transaction
+   * 6. Broadcasts via mempool API
+   *
+   * @param params - Transaction hex and depositor public key
+   * @returns The broadcasted Bitcoin transaction ID
+   * @throws Error if signing or broadcasting fails
+   */
+  async signAndBroadcast(t) {
+    const { fundedPrePeginTxHex: n, depositorBtcPubkey: s } = t, o = n.startsWith("0x") ? n.slice(2) : n, r = Zt.fromHex(o);
+    if (r.ins.length === 0)
+      throw new Error("Transaction has no inputs");
+    const i = new mt();
+    i.setVersion(r.version), i.setLocktime(r.locktime);
+    const a = s.startsWith("0x") ? s.slice(2) : s;
+    if (a.length !== 64 || !/^[0-9a-fA-F]+$/.test(a))
+      throw new Error(
+        "Invalid depositorBtcPubkey: expected 64 hex characters (x-only pubkey)"
+      );
+    const d = q.from(a, "hex");
+    if (d.length !== 32)
+      throw new Error(
+        `Invalid depositorBtcPubkey length: expected 32 bytes, got ${d.length}`
+      );
+    const u = this.config.mempoolApiUrl, h = r.ins.map((c) => {
+      const g = q.from(c.hash).reverse().toString("hex"), b = c.index;
+      return ke(g, b, t.localPrevouts, u).then(
+        (T) => ({ input: c, utxoData: T, txid: g, vout: b })
+      );
+    }), m = await Promise.all(h), l = m.reduce(
+      (c, g) => c + BigInt(g.utxoData.value),
+      0n
+    ), y = r.outs.reduce(
+      (c, g) => c + BigInt(g.value),
+      0n
+    );
+    if (l < y)
+      throw new Error(
+        `UTXO value mismatch: total input value (${l} sat) is less than total output value (${y} sat). This may indicate the mempool API returned manipulated UTXO data.`
+      );
+    for (const { input: c, utxoData: g, txid: b, vout: T } of m) {
+      const k = le(
+        {
+          value: g.value,
+          scriptPubKey: g.scriptPubKey
+        },
+        d
+      );
+      i.addInput({
+        hash: c.hash,
+        index: c.index,
+        sequence: c.sequence,
+        ...k
+      });
+    }
+    for (const c of r.outs)
+      i.addOutput({
+        script: c.script,
+        value: c.value
+      });
+    const p = await this.config.btcWallet.signPsbt(i.toHex()), w = mt.fromHex(p);
+    try {
+      w.finalizeAllInputs();
+    } catch (c) {
+      if (!w.data.inputs.every(
+        (b) => b.finalScriptWitness || b.finalScriptSig
+      ))
+        throw new Error(
+          `PSBT finalization failed and wallet did not auto-finalize: ${c}`
+        );
+    }
+    const P = w.extractTransaction().toHex();
+    return await Qt(P, u);
+  }
+  /**
+   * Registers a peg-in on Ethereum by calling the BTCVaultRegistry contract.
+   *
+   * This method:
+   * 1. Gets depositor ETH address from wallet
+   * 2. Creates proof of possession (BTC signature of ETH address)
+   * 3. Checks if vault already exists (pre-flight check)
+   * 4. Encodes the contract call using viem
+   * 5. Estimates gas (catches contract errors early with proper revert reasons)
+   * 6. Sends transaction with pre-estimated gas via ethWallet.sendTransaction()
+   *
+   * @param params - Registration parameters including BTC pubkey and unsigned tx
+   * @returns Result containing Ethereum transaction hash and vault ID
+   * @throws Error if signing or transaction fails
+   * @throws Error if vault already exists
+   * @throws Error if contract simulation fails (e.g., invalid signature, unauthorized)
+   */
+  async registerPeginOnChain(t) {
+    const {
+      depositorBtcPubkey: n,
+      unsignedPrePeginTx: s,
+      depositorSignedPeginTx: o,
+      vaultProvider: r,
+      hashlock: i,
+      htlcVout: a,
+      onPopSigned: d,
+      depositorPayoutBtcAddress: u,
+      depositorWotsPkHash: h,
+      preSignedBtcPopSignature: m
+    } = t;
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const l = this.config.ethWallet.account.address, y = await this.resolvePopSignature(
+      l,
+      m
+    );
+    d && await d();
+    const p = H(n), w = H(s), P = H(o), f = await this.resolvePayoutScriptPubKey(
+      u
+    ), c = Z(P), g = await bt(
+      E(c),
+      E(l)
+    ), b = H(g);
+    if (await this.checkVaultExists(b))
+      throw new Error(
+        `Vault already exists (ID: ${b}, peginTxHash: ${c}). 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.`
+      );
+    const k = z({
+      chain: this.config.ethChain,
+      transport: G()
+    });
+    let v;
+    try {
+      v = await k.readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: $,
+        functionName: "getPegInFee",
+        args: [r]
+      });
+    } catch {
+      throw new Error(
+        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct."
+      );
+    }
+    const C = yt({
+      abi: $,
+      functionName: "submitPeginRequest",
+      args: [
+        l,
+        p,
+        y,
+        w,
+        P,
+        r,
+        i,
+        a,
+        f,
+        h
+      ]
+    });
+    let A;
+    try {
+      A = await k.estimateGas({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: C,
+        value: v,
+        account: this.config.ethWallet.account.address
+      });
+    } catch (X) {
+      _(X);
+    }
+    let j;
+    try {
+      j = await this.config.ethWallet.sendTransaction({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: C,
+        value: v,
+        account: this.config.ethWallet.account,
+        chain: this.config.ethChain,
+        gas: A
+      });
+    } catch (X) {
+      _(X);
+    }
+    const pt = await k.waitForTransactionReceipt({
+      hash: j,
+      timeout: kt
+    });
+    return pt.status === "reverted" && _(
+      new Error(
+        `Transaction reverted. Hash: ${j}. Check the transaction on block explorer for details.`
+      )
+    ), {
+      ethTxHash: pt.transactionHash,
+      vaultId: b,
+      peginTxHash: c,
+      btcPopSignature: y
+    };
+  }
+  /**
+   * Register multiple pegins on Ethereum in a single transaction.
+   *
+   * Uses the contract's submitPeginRequestBatch() to submit all vault
+   * registrations atomically. All vaults must share the same vault provider.
+   * The PoP signature is signed once and included in each request.
+   *
+   * @param params - Batch registration parameters
+   * @returns Batch result with per-vault IDs and single ETH tx hash
+   */
+  async registerPeginBatchOnChain(t) {
+    const { vaultProvider: n, requests: s, preSignedBtcPopSignature: o, onPopSigned: r } = t;
+    if (s.length === 0)
+      throw new Error("Batch pegin requires at least one request");
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const i = this.config.ethWallet.account.address, a = await this.resolvePopSignature(
+      i,
+      o
+    );
+    r && await r();
+    const d = [];
+    for (const c of s)
+      d.push(
+        await this.resolvePayoutScriptPubKey(c.depositorPayoutBtcAddress)
+      );
+    const u = [];
+    for (const c of s) {
+      const g = H(
+        c.depositorSignedPeginTx
+      ), b = Z(g), T = await bt(
+        E(b),
+        E(i)
+      ), k = H(T);
+      if (await this.checkVaultExists(k))
+        throw new Error(
+          `Vault already exists (ID: ${k}, peginTxHash: ${b}). To create a new vault, use different UTXOs or a different amount.`
+        );
+      u.push({ vaultId: k, peginTxHash: b });
+    }
+    const h = z({
+      chain: this.config.ethChain,
+      transport: G()
+    });
+    let m;
+    try {
+      m = await h.readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: $,
+        functionName: "getPegInFee",
+        args: [n]
+      });
+    } catch {
+      throw new Error(
+        "Failed to query pegin fee from the contract. Please check your network connection and that the contract address is correct."
+      );
+    }
+    const l = m * BigInt(s.length), y = s.map((c, g) => ({
+      depositorBtcPubKey: H(c.depositorBtcPubkey),
+      btcPopSignature: a,
+      unsignedPrePeginTx: H(c.unsignedPrePeginTx),
+      depositorSignedPeginTx: H(
+        c.depositorSignedPeginTx
+      ),
+      hashlock: c.hashlock,
+      htlcVout: c.htlcVout,
+      referralCode: Pe,
+      depositorPayoutBtcAddress: d[g],
+      depositorWotsPkHash: c.depositorWotsPkHash
+    })), p = yt({
+      abi: $,
+      functionName: "submitPeginRequestBatch",
+      args: [i, n, y]
+    });
+    let w;
+    try {
+      w = await h.estimateGas({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: p,
+        value: l,
+        account: this.config.ethWallet.account.address
+      });
+    } catch (c) {
+      _(c);
+    }
+    let P;
+    try {
+      P = await this.config.ethWallet.sendTransaction({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: p,
+        value: l,
+        account: this.config.ethWallet.account,
+        chain: this.config.ethChain,
+        gas: w
+      });
+    } catch (c) {
+      _(c);
+    }
+    const f = await h.waitForTransactionReceipt({
+      hash: P,
+      timeout: kt
+    });
+    return f.status === "reverted" && _(
+      new Error(
+        `Batch transaction reverted. Hash: ${P}. Check the transaction on block explorer for details.`
+      )
+    ), {
+      ethTxHash: f.transactionHash,
+      vaults: u,
+      btcPopSignature: a
+    };
+  }
+  /**
+   * Check if a vault already exists for a given vault ID.
+   *
+   * @param vaultId - The Bitcoin transaction hash (vault ID)
+   * @returns True if vault exists, false otherwise
+   */
+  async checkVaultExists(t) {
+    try {
+      return (await z({
+        chain: this.config.ethChain,
+        transport: G()
+      }).readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: $,
+        functionName: "getBtcVaultBasicInfo",
+        args: [t]
+      }))[0] !== Yt;
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Resolve the BTC payout address to a scriptPubKey hex for the contract.
+   *
+   * If a payout address is provided, converts it directly.
+   * If omitted, uses the wallet's address and validates it against the
+   * wallet's public key to guard against a compromised wallet provider.
+   */
+  async resolvePayoutScriptPubKey(t) {
+    let n;
+    if (t)
+      n = t;
+    else {
+      n = await this.config.btcWallet.getAddress();
+      const o = await this.config.btcWallet.getPublicKeyHex();
+      if (!ne(
+        n,
+        o,
+        this.config.btcNetwork
+      ))
+        throw new Error(
+          "The BTC address from your wallet does not match the wallet's public key. Please ensure your wallet is using a supported address type (Taproot or Native SegWit)."
+        );
+    }
+    const s = wt(this.config.btcNetwork);
+    try {
+      return `0x${Gt.address.toOutputScript(n, s).toString("hex")}`;
+    } catch {
+      throw new Error(
+        `Invalid BTC payout address: "${n}". Please provide a valid Bitcoin address for the ${this.config.btcNetwork} network.`
+      );
+    }
+  }
+  /**
+   * Resolve or create a BTC Proof-of-Possession signature.
+   *
+   * Reuses a pre-signed signature when provided (e.g. multi-vault deposits),
+   * otherwise signs a BIP-322 message with the BTC wallet.
+   */
+  async resolvePopSignature(t, n) {
+    if (n)
+      return n;
+    const s = this.config.vaultContracts.btcVaultRegistry, o = `${t.toLowerCase()}:${this.config.ethChain.id}:pegin:${s.toLowerCase()}`, r = await this.config.btcWallet.signMessage(
+      o,
+      "bip322-simple"
+    );
+    return r.startsWith("0x") ? r : `0x${q.from(r, "base64").toString("hex")}`;
+  }
+  /**
+   * Gets the configured Bitcoin network.
+   *
+   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
+   */
+  getNetwork() {
+    return this.config.btcNetwork;
+  }
+  /**
+   * Gets the configured BTCVaultRegistry contract address.
+   *
+   * @returns The Ethereum address of the BTCVaultRegistry contract
+   */
+  getVaultContractAddress() {
+    return this.config.vaultContracts.btcVaultRegistry;
+  }
+}
+class At {
+  constructor(t, n) {
+    x(this, "oHash");
+    x(this, "iHash");
+    x(this, "blockLen");
+    x(this, "outputLen");
+    x(this, "finished", !1);
+    x(this, "destroyed", !1);
+    if (St(t), K(n, void 0, "key"), this.iHash = t.create(), typeof this.iHash.update != "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
+    const s = this.blockLen, o = new Uint8Array(s);
+    o.set(n.length > s ? t.create().update(n).digest() : n);
+    for (let r = 0; r < o.length; r++)
+      o[r] ^= 54;
+    this.iHash.update(o), this.oHash = t.create();
+    for (let r = 0; r < o.length; r++)
+      o[r] ^= 106;
+    this.oHash.update(o), S(o);
+  }
+  update(t) {
+    return M(this), this.iHash.update(t), this;
+  }
+  digestInto(t) {
+    M(this), K(t, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
+  }
+  digest() {
+    const t = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(t), t;
+  }
+  _cloneInto(t) {
+    t || (t = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: n, iHash: s, finished: o, destroyed: r, blockLen: i, outputLen: a } = this;
+    return t = t, t.finished = o, t.destroyed = r, t.blockLen = i, t.outputLen = a, t.oHash = n._cloneInto(t.oHash), t.iHash = s._cloneInto(t.iHash), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const N = (e, t, n) => new At(e, t).update(n).digest();
+N.create = (e, t) => new At(e, t);
+const Te = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), $t = Uint8Array.from(new Array(16).fill(0).map((e, t) => t)), Ie = $t.map((e) => (9 * e + 5) % 16), Ot = /* @__PURE__ */ (() => {
+  const n = [[$t], [Ie]];
+  for (let s = 0; s < 4; s++)
+    for (let o of n)
+      o.push(o[s].map((r) => Te[r]));
+  return n;
+})(), Rt = Ot[0], Ut = Ot[1], Lt = /* @__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((e) => Uint8Array.from(e)), ve = /* @__PURE__ */ Rt.map((e, t) => e.map((n) => Lt[t][n])), Ee = /* @__PURE__ */ Ut.map((e, t) => e.map((n) => Lt[t][n])), He = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), _e = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function Tt(e, t, n, s) {
+  return e === 0 ? t ^ n ^ s : e === 1 ? t & n | ~t & s : e === 2 ? (t | ~n) ^ s : e === 3 ? t & s | n & ~s : t ^ (n | ~s);
+}
+const W = /* @__PURE__ */ new Uint32Array(16);
+class Se extends ue {
+  constructor() {
+    super(64, 20, 8, !0);
+    x(this, "h0", 1732584193);
+    x(this, "h1", -271733879);
+    x(this, "h2", -1732584194);
+    x(this, "h3", 271733878);
+    x(this, "h4", -1009589776);
+  }
+  get() {
+    const { h0: n, h1: s, h2: o, h3: r, h4: i } = this;
+    return [n, s, o, r, i];
+  }
+  set(n, s, o, r, i) {
+    this.h0 = n | 0, this.h1 = s | 0, this.h2 = o | 0, this.h3 = r | 0, this.h4 = i | 0;
+  }
+  process(n, s) {
+    for (let p = 0; p < 16; p++, s += 4)
+      W[p] = n.getUint32(s, !0);
+    let o = this.h0 | 0, r = o, i = this.h1 | 0, a = i, d = this.h2 | 0, u = d, h = this.h3 | 0, m = h, l = this.h4 | 0, y = l;
+    for (let p = 0; p < 5; p++) {
+      const w = 4 - p, P = He[p], f = _e[p], c = Rt[p], g = Ut[p], b = ve[p], T = Ee[p];
+      for (let k = 0; k < 16; k++) {
+        const v = L(o + Tt(p, i, d, h) + W[c[k]] + P, b[k]) + l | 0;
+        o = l, l = h, h = L(d, 10) | 0, d = i, i = v;
+      }
+      for (let k = 0; k < 16; k++) {
+        const v = L(r + Tt(w, a, u, m) + W[g[k]] + f, T[k]) + y | 0;
+        r = y, y = m, m = L(u, 10) | 0, u = a, a = v;
+      }
+    }
+    this.set(this.h1 + d + m | 0, this.h2 + h + y | 0, this.h3 + l + r | 0, this.h4 + o + a | 0, this.h0 + i + u | 0);
+  }
+  roundClean() {
+    S(W);
+  }
+  destroy() {
+    this.destroyed = !0, S(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const Wt = /* @__PURE__ */ Bt(() => new Se()), Be = BigInt(0), O = BigInt(1), Ce = BigInt(2), Ae = BigInt(7), $e = BigInt(256), Oe = BigInt(113), Vt = [], Ft = [], Dt = [];
+for (let e = 0, t = O, n = 1, s = 0; e < 24; e++) {
+  [n, s] = [s, (2 * n + 3 * s) % 5], Vt.push(2 * (5 * s + n)), Ft.push((e + 1) * (e + 2) / 2 % 64);
+  let o = Be;
+  for (let r = 0; r < 7; r++)
+    t = (t << O ^ (t >> Ae) * Oe) % $e, t & Ce && (o ^= O << (O << BigInt(r)) - O);
+  Dt.push(o);
+}
+const Kt = fe(Dt, !0), Re = Kt[0], Ue = Kt[1], It = (e, t, n) => n > 32 ? ye(e, t, n) : pe(e, t, n), vt = (e, t, n) => n > 32 ? we(e, t, n) : me(e, t, n);
+function Le(e, t = 24) {
+  const n = new Uint32Array(10);
+  for (let s = 24 - t; s < 24; s++) {
+    for (let i = 0; i < 10; i++)
+      n[i] = e[i] ^ e[i + 10] ^ e[i + 20] ^ e[i + 30] ^ e[i + 40];
+    for (let i = 0; i < 10; i += 2) {
+      const a = (i + 8) % 10, d = (i + 2) % 10, u = n[d], h = n[d + 1], m = It(u, h, 1) ^ n[a], l = vt(u, h, 1) ^ n[a + 1];
+      for (let y = 0; y < 50; y += 10)
+        e[i + y] ^= m, e[i + y + 1] ^= l;
+    }
+    let o = e[2], r = e[3];
+    for (let i = 0; i < 24; i++) {
+      const a = Ft[i], d = It(o, r, a), u = vt(o, r, a), h = Vt[i];
+      o = e[h], r = e[h + 1], e[h] = d, e[h + 1] = u;
+    }
+    for (let i = 0; i < 50; i += 10) {
+      for (let a = 0; a < 10; a++)
+        n[a] = e[i + a];
+      for (let a = 0; a < 10; a++)
+        e[i + a] ^= ~n[(a + 2) % 10] & n[(a + 4) % 10];
+    }
+    e[0] ^= Re[s], e[1] ^= Ue[s];
+  }
+  S(n);
+}
+class dt {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(t, n, s, o = !1, r = 24) {
+    x(this, "state");
+    x(this, "pos", 0);
+    x(this, "posOut", 0);
+    x(this, "finished", !1);
+    x(this, "state32");
+    x(this, "destroyed", !1);
+    x(this, "blockLen");
+    x(this, "suffix");
+    x(this, "outputLen");
+    x(this, "enableXOF", !1);
+    x(this, "rounds");
+    if (this.blockLen = t, this.suffix = n, this.outputLen = s, this.enableXOF = o, this.rounds = r, U(s, "outputLen"), !(0 < t && t < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200), this.state32 = de(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    xt(this.state32), Le(this.state32, this.rounds), xt(this.state32), this.posOut = 0, this.pos = 0;
+  }
+  update(t) {
+    M(this), K(t);
+    const { blockLen: n, state: s } = this, o = t.length;
+    for (let r = 0; r < o; ) {
+      const i = Math.min(n - this.pos, o - r);
+      for (let a = 0; a < i; a++)
+        s[this.pos++] ^= t[r++];
+      this.pos === n && this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = !0;
+    const { state: t, suffix: n, pos: s, blockLen: o } = this;
+    t[s] ^= n, (n & 128) !== 0 && s === o - 1 && this.keccak(), t[o - 1] ^= 128, this.keccak();
+  }
+  writeInto(t) {
+    M(this, !1), K(t), this.finish();
+    const n = this.state, { blockLen: s } = this;
+    for (let o = 0, r = t.length; o < r; ) {
+      this.posOut >= s && this.keccak();
+      const i = Math.min(s - this.posOut, r - o);
+      t.set(n.subarray(this.posOut, this.posOut + i), o), this.posOut += i, o += i;
+    }
+    return t;
+  }
+  xofInto(t) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(t);
+  }
+  xof(t) {
+    return U(t), this.xofInto(new Uint8Array(t));
+  }
+  digestInto(t) {
+    if (ge(t, this), this.finished)
+      throw new Error("digest() was already called");
+    return this.writeInto(t), this.destroy(), t;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = !0, S(this.state);
+  }
+  _cloneInto(t) {
+    const { blockLen: n, suffix: s, outputLen: o, rounds: r, enableXOF: i } = this;
+    return t || (t = new dt(n, s, o, i, r)), t.state32.set(this.state32), t.pos = this.pos, t.posOut = this.posOut, t.finished = this.finished, t.rounds = r, t.suffix = s, t.outputLen = o, t.enableXOF = i, t.destroyed = this.destroyed, t;
+  }
+}
+const We = (e, t, n, s = {}) => Bt(() => new dt(t, e, n), s), Mt = /* @__PURE__ */ We(1, 136, 32);
+function Ve(e, t, n, s) {
+  St(e);
+  const o = xe({ dkLen: 32, asyncTick: 10 }, s), { c: r, dkLen: i, asyncTick: a } = o;
+  if (U(r, "c"), U(i, "dkLen"), U(a, "asyncTick"), r < 1)
+    throw new Error("iterations (c) must be >= 1");
+  const d = Pt(t, "password"), u = Pt(n, "salt"), h = new Uint8Array(i), m = N.create(e, d), l = m._cloneInto().update(u);
+  return { c: r, dkLen: i, asyncTick: a, DK: h, PRF: m, PRFSalt: l };
+}
+function Fe(e, t, n, s, o) {
+  return e.destroy(), t.destroy(), s && s.destroy(), S(o), n;
+}
+function De(e, t, n, s) {
+  const { c: o, dkLen: r, DK: i, PRF: a, PRFSalt: d } = Ve(e, t, n, s);
+  let u;
+  const h = new Uint8Array(4), m = be(h), l = new Uint8Array(a.outputLen);
+  for (let y = 1, p = 0; p < r; y++, p += a.outputLen) {
+    const w = i.subarray(p, p + a.outputLen);
+    m.setInt32(0, y, !1), (u = d._cloneInto(u)).update(h).digestInto(l), w.set(l.subarray(0, w.length));
+    for (let P = 1; P < o; P++) {
+      a._cloneInto(u).update(l).digestInto(l);
+      for (let f = 0; f < w.length; f++)
+        w[f] ^= l[f];
+    }
+  }
+  return Fe(a, d, i, u, l);
+}
+function Nt(e) {
+  if (typeof e != "string")
+    throw new TypeError("invalid mnemonic type: " + typeof e);
+  return e.normalize("NFKD");
+}
+function Ke(e) {
+  const t = Nt(e), n = t.split(" ");
+  if (![12, 15, 18, 21, 24].includes(n.length))
+    throw new Error("Invalid mnemonic");
+  return { nfkd: t, words: n };
+}
+const Me = (e) => Nt("mnemonic" + e);
+function Ne(e, t = "") {
+  return De(ut, Ke(e).nfkd, Me(t), { c: 2048, dkLen: 64 });
+}
+const je = 508, Et = 16, V = 32, F = 64, Ht = 5, Xe = 4;
+function R(...e) {
+  const t = e.reduce((o, r) => o + r.length, 0), n = new Uint8Array(t);
+  let s = 0;
+  for (const o of e)
+    n.set(o, s), s += o.length;
+  return n;
+}
+function Y(e) {
+  return new TextEncoder().encode(e);
+}
+function J(e) {
+  const t = new Uint8Array(Xe);
+  return new DataView(t.buffer).setUint32(0, e.length, !1), R(t, e);
+}
+function Q(e, t) {
+  return N(ut, e, t);
+}
+function _t(e) {
+  return Wt(Ct(e));
+}
+const ct = (e) => Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("");
+function qe(e) {
+  const t = Ne(e), n = new Uint8Array(t);
+  return t.fill(0), n;
+}
+async function ze(e, t, n, s) {
+  if (e.length !== F)
+    throw new Error(
+      `WOTS seed must be ${F} bytes, got ${e.length}`
+    );
+  t = E(t), n = E(n);
+  const o = e.slice(V, F), r = e.slice(0, V), i = [o, r];
+  try {
+    const a = R(
+      J(Y(t)),
+      J(Y(n)),
+      J(Y(s))
+    ), d = R(r, a);
+    i.push(d);
+    const u = Q(o, d);
+    i.push(u);
+    const h = u.slice(0, V), m = u.slice(V, F);
+    i.push(h, m);
+    const l = [], y = [], p = [], w = [];
+    let P = !1;
+    try {
+      for (let f = 0; f < je; f++) {
+        const c = new Uint8Array(Ht);
+        c[0] = 0, new DataView(c.buffer).setUint32(1, f, !1);
+        const g = new Uint8Array(Ht);
+        g[0] = 1, new DataView(g.buffer).setUint32(1, f, !1);
+        const b = R(h, c), T = R(h, g), k = Q(m, b), v = Q(m, T);
+        try {
+          const C = k.slice(0, Et), A = v.slice(0, Et);
+          l.push(C), y.push(A), p.push(_t(C)), w.push(_t(A));
+        } finally {
+          b.fill(0), T.fill(0), k.fill(0), v.fill(0);
+        }
+      }
+      return P = !0, { falsePreimages: l, truePreimages: y, falseHashes: p, trueHashes: w };
+    } finally {
+      if (!P) {
+        for (const f of l) f.fill(0);
+        for (const f of y) f.fill(0);
+      }
+    }
+  } finally {
+    for (const a of i)
+      a.fill(0);
+  }
+}
+function xn(e) {
+  return {
+    false_list: e.falseHashes.map(ct),
+    true_list: e.trueHashes.map(ct)
+  };
+}
+function Ge(e) {
+  if (e.falseHashes.length === 0 || e.trueHashes.length === 0)
+    throw new Error(
+      "computeWotsPkHash: keypair hash arrays must not be empty"
+    );
+  const t = e.falseHashes[0].length, n = (e.falseHashes.length + e.trueHashes.length) * t, s = new Uint8Array(n);
+  let o = 0;
+  for (const i of e.falseHashes)
+    s.set(i, o), o += t;
+  for (const i of e.trueHashes)
+    s.set(i, o), o += t;
+  const r = Mt(s);
+  return `0x${ct(r)}`;
+}
+const tt = 32, et = 64, Ze = 4, I = 20, lt = 4, jt = 2, Ye = 0, Je = 1, D = [64, 64];
+function ht(...e) {
+  const t = e.reduce((o, r) => o + r.length, 0), n = new Uint8Array(t);
+  let s = 0;
+  for (const o of e)
+    n.set(o, s), s += o.length;
+  return n;
+}
+function nt(e) {
+  return new TextEncoder().encode(e);
+}
+function st(e) {
+  const t = new Uint8Array(Ze);
+  return new DataView(t.buffer).setUint32(0, e.length, !1), ht(t, e);
+}
+function ot(e) {
+  return e.startsWith("0x") || e.startsWith("0X") ? e.slice(2) : e;
+}
+const Qe = (e) => Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("");
+function tn(e, t) {
+  return N(ut, e, t);
+}
+function gt(e) {
+  return Wt(Ct(e));
+}
+function Xt(e) {
+  return (1 << e) - 1;
+}
+function en(e) {
+  let t = 1;
+  for (; t * t < e + 1; ) t++;
+  return Math.max(t, 2);
+}
+function nn(e) {
+  const t = lt, n = Xt(t), s = e * n;
+  return { d: t, n: e, checksum_radix: en(s) };
+}
+function rt(e, t) {
+  const n = [];
+  let s = t;
+  for (; s > 0; )
+    n.push(s & 255), s >>>= 8;
+  const o = new Uint8Array(e.length + n.length);
+  o.set(e);
+  for (let r = 0; r < n.length; r++)
+    o[e.length + r] = n[r];
+  return gt(o);
+}
+function it(e, t) {
+  let n = e;
+  for (let s = 0; s < t; s++)
+    n = gt(n);
+  return n;
+}
+function sn(e, t) {
+  const n = Xt(t.d), s = t.checksum_radix - 1, o = Math.floor(t.n * n / t.checksum_radix), r = [];
+  for (let h = 0; h < t.n; h++) {
+    const m = rt(e, h + jt), l = it(m, n);
+    r.push(Array.from(l));
+  }
+  const i = rt(
+    e,
+    Ye
+  ), a = it(
+    i,
+    s
+  ), d = rt(
+    e,
+    Je
+  ), u = it(
+    d,
+    o
+  );
+  return {
+    config: t,
+    message_terminals: r,
+    checksum_major_terminal: Array.from(u),
+    checksum_minor_terminal: Array.from(a)
+  };
+}
+async function Pn(e, t, n, s) {
+  if (e.length !== et)
+    throw new Error(
+      `WOTS seed must be exactly ${et} bytes, got ${e.length}`
+    );
+  const o = ot(t), r = ot(n), i = e.slice(tt, et), a = e.slice(0, tt), d = ht(
+    a,
+    ht(
+      st(nt(o)),
+      st(nt(r)),
+      st(nt(ot(s)))
+    )
+  ), u = tn(i, d), h = u.slice(0, tt);
+  try {
+    const m = [];
+    for (let l = 0; l < D.length; l++) {
+      const y = D[l], p = nn(y), w = new Uint8Array(h.length + 1);
+      w.set(h), w[h.length] = l;
+      const P = gt(w);
+      try {
+        const f = sn(P, p);
+        if (f.config.d !== lt)
+          throw new Error(`Block ${l}: expected d=${lt}, got d=${f.config.d}`);
+        if (f.config.n !== y)
+          throw new Error(`Block ${l}: expected n=${y}, got n=${f.config.n}`);
+        if (f.message_terminals.length !== y)
+          throw new Error(`Block ${l}: expected ${y} message terminals, got ${f.message_terminals.length}`);
+        for (let c = 0; c < f.message_terminals.length; c++)
+          if (f.message_terminals[c].length !== I)
+            throw new Error(`Block ${l} terminal ${c}: expected ${I} bytes, got ${f.message_terminals[c].length}`);
+        if (f.checksum_minor_terminal.length !== I)
+          throw new Error(`Block ${l} checksum_minor: expected ${I} bytes`);
+        if (f.checksum_major_terminal.length !== I)
+          throw new Error(`Block ${l} checksum_major: expected ${I} bytes`);
+        m.push(f);
+      } finally {
+        w.fill(0), P.fill(0);
+      }
+    }
+    if (m.length !== D.length)
+      throw new Error(
+        `Expected ${D.length} blocks, got ${m.length}`
+      );
+    return m;
+  } finally {
+    d.fill(0), i.fill(0), a.fill(0), u.fill(0), h.fill(0), e.fill(0);
+  }
+}
+function at(e, t, n) {
+  if (e.length !== I)
+    throw new Error(
+      `Block ${t} ${n}: expected ${I} bytes, got ${e.length}`
+    );
+  for (let s = 0; s < e.length; s++) {
+    const o = e[s];
+    if (!Number.isInteger(o) || o < 0 || o > 255)
+      throw new Error(
+        `Block ${t} ${n}[${s}]: invalid byte value ${o}`
+      );
+  }
+}
+function kn(e) {
+  if (e.length === 0)
+    throw new Error("Public keys array must not be empty");
+  for (let r = 0; r < e.length; r++) {
+    const i = e[r];
+    at(i.checksum_minor_terminal, r, "checksum_minor_terminal"), at(i.checksum_major_terminal, r, "checksum_major_terminal");
+    for (let a = 0; a < i.message_terminals.length; a++)
+      at(i.message_terminals[a], r, `message_terminal[${a}]`);
+  }
+  let t = 0;
+  for (const r of e)
+    t += jt + r.message_terminals.length;
+  const n = new Uint8Array(t * I);
+  let s = 0;
+  for (const r of e) {
+    n.set(r.checksum_minor_terminal, s), s += I, n.set(r.checksum_major_terminal, s), s += I;
+    for (const i of r.message_terminals)
+      n.set(i, s), s += I;
+  }
+  const o = Mt(n);
+  return `0x${Qe(o)}`;
+}
+async function Tn(e, t, n, s) {
+  const o = qe(e);
+  try {
+    const r = await ze(
+      o,
+      t,
+      n,
+      s
+    );
+    try {
+      return Ge(r);
+    } finally {
+      for (const i of r.falsePreimages) i.fill(0);
+      for (const i of r.truePreimages) i.fill(0);
+    }
+  } finally {
+    o.fill(0);
+  }
+}
+function In(e) {
+  const t = (e instanceof Error ? e.message : typeof e == "string" ? e : "").toLowerCase();
+  return t.includes("wots") && t.includes("hash") && t.includes("does not match");
+}
+export {
+  B as C,
+  bn as P,
+  Pn as a,
+  kn as b,
+  Ge as c,
+  ze as d,
+  ft as e,
+  Tn as f,
+  yn as g,
+  _ as h,
+  wn as i,
+  In as j,
+  xn as k,
+  qe as m
+};
+//# sourceMappingURL=errors-aMocmFr-.js.map