@babylonlabs-io/ts-sdk 0.16.1 → 0.17.0

package/dist/errors-Ld-2tiK3.js

@@ -1,2268 +0,0 @@
-var fe = Object.defineProperty;
-var pe = (e, t, n) => t in e ? fe(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
-var p = (e, t, n) => pe(e, typeof t != "symbol" ? t + "" : t, n);
-import * as ye from "bitcoinjs-lib";
-import { script as be, Transaction as xt, Psbt as kt } from "bitcoinjs-lib";
-import { Buffer as W } from "buffer";
-import { createPublicClient as lt, http as ht, encodeFunctionData as Ht, zeroAddress as ge } from "viem";
-import { P as xe, y as me, D as Xt, M as Et, B as we, T as Pe, u as S, b as Te, A as ve, G as It, E as ke, a as He, d as Ee, e as Ie, f as Se, s as C, H as Be, q as Ae, x as St, h as Bt, i as At, r as Ce } from "./challengeAssert-C5DQSUnp.js";
-import { deriveVaultId as Ct } from "@babylonlabs-io/babylon-tbv-rust-wasm";
-function Ue(e, t, n, s) {
-  if (!Number.isInteger(s) || s < 1)
-    throw new Error(
-      `Invalid numOutputs: expected a positive integer, got ${s}`
-    );
-  if (e.length === 0)
-    throw new Error("Insufficient funds: no UTXOs available");
-  const o = e.filter((l) => {
-    const h = W.from(l.scriptPubKey, "hex");
-    return !!be.decompile(h);
-  });
-  if (o.length === 0)
-    throw new Error(
-      "Insufficient funds: no valid UTXOs available (all have invalid scripts)"
-    );
-  const r = [...o].sort((l, h) => h.value - l.value), i = [];
-  let a = 0n, c = 0n;
-  for (const l of r) {
-    i.push(l), a += BigInt(l.value);
-    const h = i.length * xe, u = s * Et, d = h + u + Pe;
-    if (c = BigInt(Math.ceil(d * n)) + BigInt(me(n)), a - t - c > Xt) {
-      const y = BigInt(
-        Math.ceil(Et * n)
-      );
-      c += y;
-    }
-    if (a >= t + c) {
-      const y = a - t - c;
-      return {
-        selectedUTXOs: i,
-        totalValue: a,
-        fee: c,
-        changeAmount: y
-      };
-    }
-  }
-  throw new Error(
-    `Insufficient funds: need ${t + c} sats (${t} pegin + ${c} fee), have ${a} sats`
-  );
-}
-function Yn(e) {
-  return e > Xt;
-}
-function ts() {
-  return we;
-}
-function dt(e) {
-  const t = e.startsWith("0x") ? e.slice(2) : e;
-  return `0x${xt.fromHex(t).getId()}`;
-}
-var ot = /* @__PURE__ */ ((e) => (e.P2PKH = "P2PKH", e.P2SH = "P2SH", e.P2WPKH = "P2WPKH", e.P2WSH = "P2WSH", e.P2TR = "P2TR", e.UNKNOWN = "UNKNOWN", e))(ot || {});
-function Fe(e) {
-  const t = e.length;
-  return t === 25 && e[0] === 118 && // OP_DUP
-  e[1] === 169 && // OP_HASH160
-  e[2] === 20 && // Push 20 bytes
-  e[23] === 136 && // OP_EQUALVERIFY
-  e[24] === 172 ? "P2PKH" : t === 23 && e[0] === 169 && // OP_HASH160
-  e[1] === 20 && // Push 20 bytes
-  e[22] === 135 ? "P2SH" : t === 22 && e[0] === 0 && // OP_0
-  e[1] === 20 ? "P2WPKH" : t === 34 && e[0] === 0 && // OP_0
-  e[1] === 32 ? "P2WSH" : t === 34 && e[0] === 81 && // OP_1
-  e[1] === 32 ? "P2TR" : "UNKNOWN";
-}
-function $e(e, t) {
-  const n = W.from(e.scriptPubKey, "hex"), s = Fe(n);
-  switch (s) {
-    case ot.P2WPKH:
-      return {
-        witnessUtxo: {
-          script: n,
-          value: e.value
-        }
-      };
-    case ot.P2WSH: {
-      if (!e.witnessScript)
-        throw new Error("Missing witnessScript for P2WSH input");
-      return {
-        witnessUtxo: {
-          script: n,
-          value: e.value
-        },
-        witnessScript: W.from(e.witnessScript, "hex")
-      };
-    }
-    case ot.P2TR: {
-      if (t && t.length !== 32)
-        throw new Error(
-          `Invalid tapInternalKey length: expected 32 bytes, got ${t.length}`
-        );
-      return {
-        witnessUtxo: {
-          script: n,
-          value: e.value
-        },
-        // tapInternalKey is needed for Taproot signing
-        ...t && { tapInternalKey: t }
-      };
-    }
-    default:
-      throw new Error(`Unsupported script type: ${s}`);
-  }
-}
-function bt(e, t) {
-  if (!Number.isInteger(t) || t < 1)
-    throw new Error(`inputCount must be a positive integer, got ${t}`);
-  return {
-    autoFinalized: !1,
-    signInputs: Array.from({ length: t }, (n, s) => ({
-      index: s,
-      publicKey: e,
-      disableTweakSigner: !0
-    }))
-  };
-}
-const Oe = 21e6 * 1e8, Ut = 3e4;
-async function at(e, t) {
-  const n = new AbortController(), s = setTimeout(
-    () => n.abort(),
-    Ut
-  ), o = [n.signal, t == null ? void 0 : t.signal].filter(
-    Boolean
-  );
-  try {
-    return await fetch(e, {
-      ...t,
-      signal: AbortSignal.any(o)
-    });
-  } catch (r) {
-    throw clearTimeout(s), r != null && typeof r == "object" && "name" in r && r.name === "AbortError" ? new Error(
-      `Mempool API request timed out after ${Ut}ms: ${e}`
-    ) : r;
-  }
-}
-const qt = 1e4;
-function Gt(e) {
-  return Number.isInteger(e) && e > 0 && e <= Oe;
-}
-function Le(e) {
-  return Number.isInteger(e) && e > 0 && e <= qt;
-}
-function jt(e, t) {
-  return !Number.isInteger(e) || e < 0 ? !1 : t === void 0 || e < t;
-}
-const _e = {
-  mainnet: "https://mempool.space/api",
-  testnet: "https://mempool.space/testnet/api",
-  signet: "https://mempool.space/signet/api"
-};
-async function it(e, t) {
-  try {
-    const n = await at(e, t);
-    if (!n.ok) {
-      const o = await n.text();
-      throw new Error(
-        `Mempool API error (${n.status}): ${o || n.statusText}`
-      );
-    }
-    const s = n.headers.get("content-type");
-    return s != null && s.includes("application/json") ? await n.json() : await n.text();
-  } catch (n) {
-    throw n instanceof Error ? new Error(`Failed to fetch from mempool API: ${n.message}`) : new Error("Failed to fetch from mempool API: Unknown error");
-  }
-}
-async function Re(e, t) {
-  try {
-    const n = await at(`${t}/tx`, {
-      method: "POST",
-      body: e,
-      headers: {
-        "Content-Type": "text/plain"
-      }
-    });
-    if (!n.ok) {
-      const o = await n.text();
-      let r;
-      try {
-        r = JSON.parse(o).message;
-      } catch {
-        r = o;
-      }
-      throw new Error(
-        r || `Failed to broadcast transaction: ${n.statusText}`
-      );
-    }
-    return await n.text();
-  } catch (n) {
-    throw n instanceof Error ? new Error(`Failed to broadcast BTC transaction: ${n.message}`) : new Error("Failed to broadcast BTC transaction: Unknown error");
-  }
-}
-async function We(e, t) {
-  return it(`${t}/tx/${e}`);
-}
-async function es(e, t) {
-  try {
-    const n = await at(`${t}/tx/${e}/hex`);
-    if (!n.ok) {
-      const s = await n.text();
-      throw new Error(
-        `Mempool API error (${n.status}): ${s || n.statusText}`
-      );
-    }
-    return await n.text();
-  } catch (n) {
-    throw n instanceof Error ? new Error(`Failed to get transaction hex for ${e}: ${n.message}`) : new Error(`Failed to get transaction hex for ${e}: Unknown error`);
-  }
-}
-async function Ve(e, t, n) {
-  const s = await We(e, n);
-  if (!jt(t, s.vout.length))
-    throw new Error(
-      `Invalid vout ${t} for transaction ${e} (has ${s.vout.length} outputs)`
-    );
-  const o = s.vout[t];
-  if (!Gt(o.value))
-    throw new Error(`Invalid UTXO value ${o.value} for ${e}:${t}`);
-  return {
-    txid: e,
-    vout: t,
-    value: o.value,
-    scriptPubKey: o.scriptpubkey
-  };
-}
-async function ns(e, t) {
-  try {
-    const n = await it(`${t}/address/${e}/utxo`), s = await it(`${t}/v1/validate-address/${e}`);
-    if (!s.isvalid)
-      throw new Error(
-        `Invalid Bitcoin address: ${e}. Mempool API validation failed.`
-      );
-    for (const r of n) {
-      if (!jt(r.vout))
-        throw new Error(`Invalid vout ${r.vout} for ${r.txid}`);
-      if (!Gt(r.value))
-        throw new Error(
-          `Invalid UTXO value ${r.value} for ${r.txid}:${r.vout}`
-        );
-    }
-    return n.sort((r, i) => i.value - r.value).map((r) => ({
-      txid: r.txid,
-      vout: r.vout,
-      value: r.value,
-      scriptPubKey: s.scriptPubKey,
-      confirmed: r.status.confirmed
-    }));
-  } catch (n) {
-    throw n instanceof Error ? new Error(
-      `Failed to get UTXOs for address ${e}: ${n.message}`
-    ) : new Error(
-      `Failed to get UTXOs for address ${e}: Unknown error`
-    );
-  }
-}
-function ss(e) {
-  return _e[e];
-}
-async function os(e, t) {
-  return it(`${t}/address/${e}/txs`);
-}
-async function rs(e) {
-  const t = await at(`${e}/v1/fees/recommended`);
-  if (!t.ok)
-    throw new Error(
-      `Failed to fetch network fees: ${t.status} ${t.statusText}`
-    );
-  const n = await t.json(), s = [
-    "fastestFee",
-    "halfHourFee",
-    "hourFee",
-    "economyFee",
-    "minimumFee"
-  ];
-  for (const o of s)
-    if (!Le(n[o]))
-      throw new Error(
-        `Invalid fee rate ${o}=${n[o]} from mempool API: expected a positive number ≤ ${qt}`
-      );
-  if (n.minimumFee > n.economyFee || n.economyFee > n.hourFee || n.hourFee > n.halfHourFee || n.halfHourFee > n.fastestFee)
-    throw new Error(
-      `Fee rate ordering violation from mempool API: expected minimumFee (${n.minimumFee}) <= economyFee (${n.economyFee}) <= hourFee (${n.hourFee}) <= halfHourFee (${n.halfHourFee}) <= fastestFee (${n.fastestFee}).`
-    );
-  return n;
-}
-const j = [
-  {
-    type: "function",
-    name: "submitPeginRequest",
-    inputs: [
-      {
-        name: "depositor",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "depositorBtcPubKey",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "btcPopSignature",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "unsignedPrePeginTx",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "depositorSignedPeginTx",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "vaultProvider",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "hashlock",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "htlcVout",
-        type: "uint8",
-        internalType: "uint8"
-      },
-      {
-        name: "depositorPayoutBtcAddress",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "depositorWotsPkHash",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
-    ],
-    stateMutability: "payable"
-  },
-  {
-    type: "function",
-    name: "submitPeginRequest",
-    inputs: [
-      {
-        name: "depositor",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "depositorBtcPubKey",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "btcPopSignature",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "unsignedPrePeginTx",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "depositorSignedPeginTx",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "vaultProvider",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "hashlock",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "htlcVout",
-        type: "uint8",
-        internalType: "uint8"
-      },
-      {
-        name: "referralCode",
-        type: "uint32",
-        internalType: "uint32"
-      },
-      {
-        name: "depositorPayoutBtcAddress",
-        type: "bytes",
-        internalType: "bytes"
-      },
-      {
-        name: "depositorWotsPkHash",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
-    ],
-    stateMutability: "payable"
-  },
-  {
-    type: "function",
-    name: "submitPeginRequestBatch",
-    inputs: [
-      { name: "depositor", type: "address", internalType: "address" },
-      { name: "vaultProvider", type: "address", internalType: "address" },
-      {
-        name: "requests",
-        type: "tuple[]",
-        internalType: "struct IBTCVaultRegistry.BatchPeginRequest[]",
-        components: [
-          { name: "depositorBtcPubKey", type: "bytes32", internalType: "bytes32" },
-          { name: "btcPopSignature", type: "bytes", internalType: "bytes" },
-          { name: "unsignedPrePeginTx", type: "bytes", internalType: "bytes" },
-          { name: "depositorSignedPeginTx", type: "bytes", internalType: "bytes" },
-          { name: "hashlock", type: "bytes32", internalType: "bytes32" },
-          { name: "htlcVout", type: "uint8", internalType: "uint8" },
-          { name: "referralCode", type: "uint32", internalType: "uint32" },
-          { name: "depositorPayoutBtcAddress", type: "bytes", internalType: "bytes" },
-          { name: "depositorWotsPkHash", type: "bytes32", internalType: "bytes32" }
-        ]
-      }
-    ],
-    outputs: [
-      { name: "vaultIds", type: "bytes32[]", internalType: "bytes32[]" }
-    ],
-    stateMutability: "payable"
-  },
-  {
-    type: "function",
-    name: "activateVaultWithSecret",
-    inputs: [
-      {
-        name: "vaultId",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "s",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "activationMetadata",
-        type: "bytes",
-        internalType: "bytes"
-      }
-    ],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "getPegInFee",
-    inputs: [
-      {
-        name: "vaultProvider",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "totalFee",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "getBTCVault",
-    inputs: [
-      {
-        name: "vaultId",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
-    ],
-    outputs: [
-      {
-        name: "vault",
-        type: "tuple",
-        internalType: "struct IBTCVaultRegistry.BTCVault",
-        components: [
-          { name: "depositor", type: "address", internalType: "address" },
-          { name: "depositorBtcPubKey", type: "bytes32", internalType: "bytes32" },
-          { name: "depositorSignedPeginTx", type: "bytes", internalType: "bytes" },
-          { name: "amount", type: "uint256", internalType: "uint256" },
-          { name: "vaultProvider", type: "address", internalType: "address" },
-          { name: "status", type: "uint8", internalType: "enum IBTCVaultRegistry.BTCVaultStatus" },
-          { name: "applicationEntryPoint", type: "address", internalType: "address" },
-          { name: "universalChallengersVersion", type: "uint16", internalType: "uint16" },
-          { name: "appVaultKeepersVersion", type: "uint16", internalType: "uint16" },
-          { name: "offchainParamsVersion", type: "uint16", internalType: "uint16" },
-          { name: "createdAt", type: "uint256", internalType: "uint256" },
-          { name: "verifiedAt", type: "uint256", internalType: "uint256" },
-          { name: "depositorWotsPkHash", type: "bytes32", internalType: "bytes32" },
-          { name: "hashlock", type: "bytes32", internalType: "bytes32" },
-          { name: "htlcVout", type: "uint8", internalType: "uint8" },
-          { name: "depositorPopSignature", type: "bytes", internalType: "bytes" },
-          { name: "prePeginTxHash", type: "bytes32", internalType: "bytes32" }
-        ]
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "error",
-    name: "InvalidPeginFee",
-    inputs: [
-      {
-        name: "provided",
-        type: "uint256",
-        internalType: "uint256"
-      },
-      {
-        name: "required",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ]
-  },
-  {
-    type: "error",
-    name: "InvalidSecret",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "ActivationDeadlineExpired",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "InvalidHashlock",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "DuplicateHashlock",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "CapExceeded",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "InvalidOutputIndex",
-    inputs: []
-  },
-  {
-    type: "error",
-    name: "PeginSignaturesIncomplete",
-    inputs: []
-  }
-], q = {
-  // 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 mt(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 is(e) {
-  const t = mt(e);
-  if (t) {
-    const n = t.substring(0, 10);
-    return q[t] ?? q[n];
-  }
-}
-function as(e) {
-  const t = mt(e);
-  if (t === void 0) return !1;
-  const n = t.substring(0, 10);
-  return t in q || n in q;
-}
-function M(e) {
-  console.error("[Contract Error] Raw error:", e);
-  const t = mt(e);
-  if (console.error("[Contract Error] Extracted error data:", t), t) {
-    const s = t.substring(0, 10), o = q[t] ?? q[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 De = 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
-  }) : Ve(e, t, s);
-}
-const Ft = 12e4;
-class cs {
-  /**
-   * Creates a new PeginManager instance.
-   *
-   * @param config - Manager configuration including wallets and contract addresses
-   */
-  constructor(t) {
-    p(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 = S(t.vaultProviderBtcPubkey), r = t.vaultKeeperBtcPubkeys.map(S), i = t.universalChallengerBtcPubkeys.map(S);
-    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, c = {
-      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
-    }, l = await Te(c), h = Ue(
-      [...t.availableUTXOs],
-      l.totalOutputValue,
-      t.mempoolFeeRate,
-      ve(l.htlcValues.length)
-    ), u = It(this.config.btcNetwork), d = ke({
-      unfundedTxHex: l.psbtHex,
-      selectedUTXOs: h.selectedUTXOs,
-      changeAddress: t.changeAddress,
-      changeAmount: h.changeAmount,
-      network: u
-    }), g = S(dt(d)), y = [], x = [], P = [];
-    for (let f = 0; f < t.hashlocks.length; f++) {
-      const m = await He({
-        prePeginParams: c,
-        timelockPegin: t.timelockPegin,
-        fundedPrePeginTxHex: d,
-        htlcVout: f
-      }), v = await Ee({
-        peginTxHex: m.txHex,
-        fundedPrePeginTxHex: d,
-        depositorPubkey: s,
-        vaultProviderPubkey: o,
-        vaultKeeperPubkeys: r,
-        universalChallengerPubkeys: i,
-        hashlock: t.hashlocks[f],
-        timelockRefund: t.timelockRefund,
-        network: this.config.btcNetwork
-      });
-      y.push(m), x.push(v.psbtHex), P.push(
-        bt(n, 1)
-      );
-    }
-    const w = await this.signPsbtsWithFallback(
-      x,
-      P
-    ), b = [];
-    for (let f = 0; f < w.length; f++) {
-      const m = Ie(
-        w[f],
-        s
-      ), v = Se(w[f]);
-      b.push({
-        htlcVout: f,
-        htlcValue: l.htlcValues[f],
-        peginTxHex: v,
-        peginTxid: y[f].txid,
-        peginInputSignature: m,
-        vaultScriptPubKey: y[f].vaultScriptPubKey
-      });
-    }
-    return {
-      fundedPrePeginTxHex: d,
-      prePeginTxid: g,
-      unsignedPrePeginTxHex: l.psbtHex,
-      perVault: b,
-      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 = xt.fromHex(o);
-    if (r.ins.length === 0)
-      throw new Error("Transaction has no inputs");
-    const i = new kt();
-    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 c = W.from(a, "hex");
-    if (c.length !== 32)
-      throw new Error(
-        `Invalid depositorBtcPubkey length: expected 32 bytes, got ${c.length}`
-      );
-    const l = this.config.mempoolApiUrl, h = r.ins.map((b) => {
-      const f = W.from(b.hash).reverse().toString("hex"), m = b.index;
-      return Ke(f, m, t.localPrevouts, l).then(
-        (v) => ({ input: b, utxoData: v, txid: f, vout: m })
-      );
-    }), u = await Promise.all(h), d = u.reduce(
-      (b, f) => b + BigInt(f.utxoData.value),
-      0n
-    ), g = r.outs.reduce(
-      (b, f) => b + BigInt(f.value),
-      0n
-    );
-    if (d < g)
-      throw new Error(
-        `UTXO value mismatch: total input value (${d} sat) is less than total output value (${g} sat). This may indicate the mempool API returned manipulated UTXO data.`
-      );
-    for (const { input: b, utxoData: f, txid: m, vout: v } of u) {
-      const T = $e(
-        {
-          value: f.value,
-          scriptPubKey: f.scriptPubKey
-        },
-        c
-      );
-      i.addInput({
-        hash: b.hash,
-        index: b.index,
-        sequence: b.sequence,
-        ...T
-      });
-    }
-    for (const b of r.outs)
-      i.addOutput({
-        script: b.script,
-        value: b.value
-      });
-    const y = await this.config.btcWallet.signPsbt(i.toHex()), x = kt.fromHex(y);
-    try {
-      x.finalizeAllInputs();
-    } catch (b) {
-      if (!x.data.inputs.every(
-        (m) => m.finalScriptWitness || m.finalScriptSig
-      ))
-        throw new Error(
-          `PSBT finalization failed and wallet did not auto-finalize: ${b}`
-        );
-    }
-    const P = x.extractTransaction().toHex();
-    return await Re(P, l);
-  }
-  /**
-   * 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: c,
-      depositorPayoutBtcAddress: l,
-      depositorWotsPkHash: h,
-      preSignedBtcPopSignature: u
-    } = t;
-    if (!this.config.ethWallet.account)
-      throw new Error("Ethereum wallet account not found");
-    const d = this.config.ethWallet.account.address, g = await this.resolvePopSignature(
-      d,
-      u
-    );
-    c && await c();
-    const y = C(n), x = C(s), P = C(o), w = await this.resolvePayoutScriptPubKey(
-      l
-    ), b = dt(P), f = await Ct(
-      S(b),
-      S(d)
-    ), m = C(f);
-    if (await this.checkVaultExists(m))
-      throw new Error(
-        `Vault already exists (ID: ${m}, peginTxHash: ${b}). 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 T = lt({
-      chain: this.config.ethChain,
-      transport: ht()
-    });
-    let H;
-    try {
-      H = await T.readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: j,
-        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 E = Ht({
-      abi: j,
-      functionName: "submitPeginRequest",
-      args: [
-        d,
-        y,
-        g,
-        x,
-        P,
-        r,
-        i,
-        a,
-        w,
-        h
-      ]
-    });
-    let I;
-    try {
-      I = await T.estimateGas({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: E,
-        value: H,
-        account: this.config.ethWallet.account.address
-      });
-    } catch ($) {
-      M($);
-    }
-    let F;
-    try {
-      F = await this.config.ethWallet.sendTransaction({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: E,
-        value: H,
-        account: this.config.ethWallet.account,
-        chain: this.config.ethChain,
-        gas: I
-      });
-    } catch ($) {
-      M($);
-    }
-    const K = await T.waitForTransactionReceipt({
-      hash: F,
-      timeout: Ft
-    });
-    return K.status === "reverted" && M(
-      new Error(
-        `Transaction reverted. Hash: ${F}. Check the transaction on block explorer for details.`
-      )
-    ), {
-      ethTxHash: K.transactionHash,
-      vaultId: m,
-      peginTxHash: b,
-      btcPopSignature: g
-    };
-  }
-  /**
-   * 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 c = [];
-    for (const b of s)
-      c.push(
-        await this.resolvePayoutScriptPubKey(b.depositorPayoutBtcAddress)
-      );
-    const l = [];
-    for (const b of s) {
-      const f = C(
-        b.depositorSignedPeginTx
-      ), m = dt(f), v = await Ct(
-        S(m),
-        S(i)
-      ), T = C(v);
-      if (await this.checkVaultExists(T))
-        throw new Error(
-          `Vault already exists (ID: ${T}, peginTxHash: ${m}). To create a new vault, use different UTXOs or a different amount.`
-        );
-      l.push({ vaultId: T, peginTxHash: m });
-    }
-    const h = lt({
-      chain: this.config.ethChain,
-      transport: ht()
-    });
-    let u;
-    try {
-      u = await h.readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: j,
-        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 d = u * BigInt(s.length), g = s.map((b, f) => ({
-      depositorBtcPubKey: C(b.depositorBtcPubkey),
-      btcPopSignature: a,
-      unsignedPrePeginTx: C(b.unsignedPrePeginTx),
-      depositorSignedPeginTx: C(
-        b.depositorSignedPeginTx
-      ),
-      hashlock: b.hashlock,
-      htlcVout: b.htlcVout,
-      referralCode: De,
-      depositorPayoutBtcAddress: c[f],
-      depositorWotsPkHash: b.depositorWotsPkHash
-    })), y = Ht({
-      abi: j,
-      functionName: "submitPeginRequestBatch",
-      args: [i, n, g]
-    });
-    let x;
-    try {
-      x = await h.estimateGas({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: y,
-        value: d,
-        account: this.config.ethWallet.account.address
-      });
-    } catch (b) {
-      M(b);
-    }
-    let P;
-    try {
-      P = await this.config.ethWallet.sendTransaction({
-        to: this.config.vaultContracts.btcVaultRegistry,
-        data: y,
-        value: d,
-        account: this.config.ethWallet.account,
-        chain: this.config.ethChain,
-        gas: x
-      });
-    } catch (b) {
-      M(b);
-    }
-    const w = await h.waitForTransactionReceipt({
-      hash: P,
-      timeout: Ft
-    });
-    return w.status === "reverted" && M(
-      new Error(
-        `Batch transaction reverted. Hash: ${P}. Check the transaction on block explorer for details.`
-      )
-    ), {
-      ethTxHash: w.transactionHash,
-      vaults: l,
-      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 lt({
-        chain: this.config.ethChain,
-        transport: ht()
-      }).readContract({
-        address: this.config.vaultContracts.btcVaultRegistry,
-        abi: j,
-        functionName: "getBTCVault",
-        args: [t]
-      })).depositor !== ge;
-    } 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) {
-    Be();
-    let n;
-    if (t)
-      n = t;
-    else {
-      n = await this.config.btcWallet.getAddress();
-      const o = await this.config.btcWallet.getPublicKeyHex();
-      if (!Ae(
-        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 = It(this.config.btcNetwork);
-    try {
-      return `0x${ye.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${W.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 us {
-  /**
-   * Creates a new PayoutManager instance.
-   *
-   * @param config - Manager configuration including wallet
-   */
-  constructor(t) {
-    p(this, "config");
-    this.config = t;
-  }
-  /**
-   * Signs a Payout transaction and extracts the Schnorr signature.
-   *
-   * Flow:
-   * 1. Vault provider submits Claim transaction
-   * 2. Claimer submits Assert transaction to prove validity
-   * 3. Payout can be executed (references Assert tx)
-   *
-   * This method orchestrates the following steps:
-   * 1. Get wallet's public key and convert to x-only format
-   * 2. Validate wallet pubkey matches on-chain depositor pubkey (if provided)
-   * 3. Build unsigned PSBT using primitives
-   * 4. Sign PSBT via btcWallet.signPsbt()
-   * 5. Extract 64-byte Schnorr signature using primitives
-   *
-   * The returned signature can be submitted to the vault provider API.
-   *
-   * @param params - Payout signing parameters
-   * @returns Signature result with 64-byte Schnorr signature and depositor pubkey
-   * @throws Error if wallet pubkey doesn't match depositor pubkey
-   * @throws Error if wallet operations fail or signature extraction fails
-   */
-  async signPayoutTransaction(t) {
-    this.validatePayoutOutputs(
-      t.payoutTxHex,
-      t.registeredPayoutScriptPubKey
-    );
-    const n = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: s } = St(
-      n,
-      t.depositorBtcPubkey
-    ), o = await Bt({
-      payoutTxHex: t.payoutTxHex,
-      peginTxHex: t.peginTxHex,
-      assertTxHex: t.assertTxHex,
-      depositorBtcPubkey: s,
-      vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
-      vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys,
-      universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
-      timelockPegin: t.timelockPegin,
-      network: this.config.network
-    }), r = await this.config.btcWallet.signPsbt(
-      o.psbtHex,
-      bt(n, 1)
-    );
-    return {
-      signature: At(r, s),
-      depositorBtcPubkey: s
-    };
-  }
-  /**
-   * Gets the configured Bitcoin network.
-   *
-   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
-   */
-  getNetwork() {
-    return this.config.network;
-  }
-  /**
-   * Checks if the wallet supports batch signing (signPsbts).
-   *
-   * @returns true if batch signing is supported
-   */
-  supportsBatchSigning() {
-    return typeof this.config.btcWallet.signPsbts == "function";
-  }
-  /**
-   * Batch signs multiple payout transactions (1 per claimer).
-   * This allows signing all transactions with a single wallet interaction.
-   *
-   * @param transactions - Array of payout params to sign
-   * @returns Array of signature results matching input order
-   * @throws Error if wallet doesn't support batch signing
-   * @throws Error if any signing operation fails
-   */
-  async signPayoutTransactionsBatch(t) {
-    if (!this.supportsBatchSigning())
-      throw new Error(
-        "Wallet does not support batch signing (signPsbts method not available)"
-      );
-    const n = await this.config.btcWallet.getPublicKeyHex(), s = [], o = [], r = [];
-    for (const c of t) {
-      this.validatePayoutOutputs(
-        c.payoutTxHex,
-        c.registeredPayoutScriptPubKey
-      );
-      const { depositorPubkey: l } = St(
-        n,
-        c.depositorBtcPubkey
-      );
-      r.push(l);
-      const h = await Bt({
-        payoutTxHex: c.payoutTxHex,
-        peginTxHex: c.peginTxHex,
-        assertTxHex: c.assertTxHex,
-        depositorBtcPubkey: l,
-        vaultProviderBtcPubkey: c.vaultProviderBtcPubkey,
-        vaultKeeperBtcPubkeys: c.vaultKeeperBtcPubkeys,
-        universalChallengerBtcPubkeys: c.universalChallengerBtcPubkeys,
-        timelockPegin: c.timelockPegin,
-        network: this.config.network
-      });
-      s.push(h.psbtHex), o.push(bt(n, 1));
-    }
-    const i = await this.config.btcWallet.signPsbts(
-      s,
-      o
-    );
-    if (i.length !== t.length)
-      throw new Error(
-        `Expected ${t.length} signed PSBTs but received ${i.length}`
-      );
-    const a = [];
-    for (let c = 0; c < t.length; c++) {
-      const l = r[c], h = At(
-        i[c],
-        l
-      );
-      a.push({
-        payoutSignature: h,
-        depositorBtcPubkey: l
-      });
-    }
-    return a;
-  }
-  /**
-   * Validates that the payout transaction's largest output pays to the
-   * registered depositor payout address (scriptPubKey).
-   *
-   * This prevents two attack vectors from a malicious vault provider:
-   * 1. Substituting a completely different payout address
-   * 2. Including a dust output to the correct address while routing
-   *    the actual funds to an attacker-controlled address
-   *
-   * @param payoutTxHex - Raw payout transaction hex
-   * @param registeredPayoutScriptPubKey - On-chain registered scriptPubKey (hex, with or without 0x prefix)
-   * @throws Error if scriptPubKey is invalid hex
-   * @throws Error if the largest output does not pay to the registered address
-   */
-  validatePayoutOutputs(t, n) {
-    if (!Ce(n))
-      throw new Error(
-        "Invalid registeredPayoutScriptPubKey: not valid hex"
-      );
-    const s = W.from(
-      S(n),
-      "hex"
-    ), o = xt.fromHex(S(t));
-    if (o.outs.length === 0)
-      throw new Error("Payout transaction has no outputs");
-    if (!o.outs.reduce(
-      (i, a) => a.value > i.value ? a : i
-    ).script.equals(s))
-      throw new Error(
-        "Payout transaction does not pay to the registered depositor payout address"
-      );
-  }
-}
-function Me(e) {
-  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
-}
-function V(e, t = "") {
-  if (!Number.isSafeInteger(e) || e < 0) {
-    const n = t && `"${t}" `;
-    throw new Error(`${n}expected integer >= 0, got ${e}`);
-  }
-}
-function D(e, t, n = "") {
-  const s = Me(e), o = e == null ? void 0 : e.length, r = t !== void 0;
-  if (!s || r && o !== t) {
-    const i = n && `"${n}" `, a = r ? ` of length ${t}` : "", c = s ? `length=${o}` : `type=${typeof e}`;
-    throw new Error(i + "expected Uint8Array" + a + ", got " + c);
-  }
-  return e;
-}
-function zt(e) {
-  if (typeof e != "function" || typeof e.create != "function")
-    throw new Error("Hash must wrapped by utils.createHasher");
-  V(e.outputLen), V(e.blockLen);
-}
-function G(e, t = !0) {
-  if (e.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (t && e.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function Zt(e, t) {
-  D(e, void 0, "digestInto() output");
-  const n = t.outputLen;
-  if (e.length < n)
-    throw new Error('"digestInto() output" expected to be of length >=' + n);
-}
-function Ne(e) {
-  return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
-}
-function B(...e) {
-  for (let t = 0; t < e.length; t++)
-    e[t].fill(0);
-}
-function rt(e) {
-  return new DataView(e.buffer, e.byteOffset, e.byteLength);
-}
-function A(e, t) {
-  return e << 32 - t | e >>> t;
-}
-function J(e, t) {
-  return e << t | e >>> 32 - t >>> 0;
-}
-const Xe = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-function qe(e) {
-  return e << 24 & 4278190080 | e << 8 & 16711680 | e >>> 8 & 65280 | e >>> 24 & 255;
-}
-function Ge(e) {
-  for (let t = 0; t < e.length; t++)
-    e[t] = qe(e[t]);
-  return e;
-}
-const $t = Xe ? (e) => e : Ge;
-function je(e) {
-  if (typeof e != "string")
-    throw new Error("string expected");
-  return new Uint8Array(new TextEncoder().encode(e));
-}
-function Ot(e, t = "") {
-  return typeof e == "string" ? je(e) : D(e, void 0, t);
-}
-function ze(e, t) {
-  if (t !== void 0 && {}.toString.call(t) !== "[object Object]")
-    throw new Error("options must be object or undefined");
-  return Object.assign(e, t);
-}
-function ct(e, t = {}) {
-  const n = (o, r) => e(r).update(o).digest(), s = e(void 0);
-  return n.outputLen = s.outputLen, n.blockLen = s.blockLen, n.create = (o) => e(o), Object.assign(n, t), Object.freeze(n);
-}
-const Jt = (e) => ({
-  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, e])
-});
-class Qt {
-  constructor(t, n) {
-    p(this, "oHash");
-    p(this, "iHash");
-    p(this, "blockLen");
-    p(this, "outputLen");
-    p(this, "finished", !1);
-    p(this, "destroyed", !1);
-    if (zt(t), D(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), B(o);
-  }
-  update(t) {
-    return G(this), this.iHash.update(t), this;
-  }
-  digestInto(t) {
-    G(this), D(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 wt = (e, t, n) => new Qt(e, t).update(n).digest();
-wt.create = (e, t) => new Qt(e, t);
-function Ze(e, t, n) {
-  return e & t ^ ~e & n;
-}
-function Je(e, t, n) {
-  return e & t ^ e & n ^ t & n;
-}
-class Pt {
-  constructor(t, n, s, o) {
-    p(this, "blockLen");
-    p(this, "outputLen");
-    p(this, "padOffset");
-    p(this, "isLE");
-    // For partial updates less than block size
-    p(this, "buffer");
-    p(this, "view");
-    p(this, "finished", !1);
-    p(this, "length", 0);
-    p(this, "pos", 0);
-    p(this, "destroyed", !1);
-    this.blockLen = t, this.outputLen = n, this.padOffset = s, this.isLE = o, this.buffer = new Uint8Array(t), this.view = rt(this.buffer);
-  }
-  update(t) {
-    G(this), D(t);
-    const { view: n, buffer: s, blockLen: o } = this, r = t.length;
-    for (let i = 0; i < r; ) {
-      const a = Math.min(o - this.pos, r - i);
-      if (a === o) {
-        const c = rt(t);
-        for (; o <= r - i; i += o)
-          this.process(c, i);
-        continue;
-      }
-      s.set(t.subarray(i, i + a), this.pos), this.pos += a, i += a, this.pos === o && (this.process(n, 0), this.pos = 0);
-    }
-    return this.length += t.length, this.roundClean(), this;
-  }
-  digestInto(t) {
-    G(this), Zt(t, this), this.finished = !0;
-    const { buffer: n, view: s, blockLen: o, isLE: r } = this;
-    let { pos: i } = this;
-    n[i++] = 128, B(this.buffer.subarray(i)), this.padOffset > o - i && (this.process(s, 0), i = 0);
-    for (let u = i; u < o; u++)
-      n[u] = 0;
-    s.setBigUint64(o - 8, BigInt(this.length * 8), r), this.process(s, 0);
-    const a = rt(t), c = this.outputLen;
-    if (c % 4)
-      throw new Error("_sha2: outputLen must be aligned to 32bit");
-    const l = c / 4, h = this.get();
-    if (l > h.length)
-      throw new Error("_sha2: outputLen bigger than state");
-    for (let u = 0; u < l; u++)
-      a.setUint32(4 * u, h[u], r);
-  }
-  digest() {
-    const { buffer: t, outputLen: n } = this;
-    this.digestInto(t);
-    const s = t.slice(0, n);
-    return this.destroy(), s;
-  }
-  _cloneInto(t) {
-    t || (t = new this.constructor()), t.set(...this.get());
-    const { blockLen: n, buffer: s, length: o, finished: r, destroyed: i, pos: a } = this;
-    return t.destroyed = i, t.finished = r, t.length = o, t.pos = a, o % n && t.buffer.set(s), t;
-  }
-  clone() {
-    return this._cloneInto();
-  }
-}
-const O = /* @__PURE__ */ Uint32Array.from([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]), k = /* @__PURE__ */ Uint32Array.from([
-  1779033703,
-  4089235720,
-  3144134277,
-  2227873595,
-  1013904242,
-  4271175723,
-  2773480762,
-  1595750129,
-  1359893119,
-  2917565137,
-  2600822924,
-  725511199,
-  528734635,
-  4215389547,
-  1541459225,
-  327033209
-]), Qe = /* @__PURE__ */ Uint8Array.from([
-  7,
-  4,
-  13,
-  1,
-  10,
-  6,
-  15,
-  3,
-  12,
-  0,
-  9,
-  5,
-  2,
-  14,
-  11,
-  8
-]), Yt = Uint8Array.from(new Array(16).fill(0).map((e, t) => t)), Ye = Yt.map((e) => (9 * e + 5) % 16), te = /* @__PURE__ */ (() => {
-  const n = [[Yt], [Ye]];
-  for (let s = 0; s < 4; s++)
-    for (let o of n)
-      o.push(o[s].map((r) => Qe[r]));
-  return n;
-})(), ee = te[0], ne = te[1], se = /* @__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)), tn = /* @__PURE__ */ ee.map((e, t) => e.map((n) => se[t][n])), en = /* @__PURE__ */ ne.map((e, t) => e.map((n) => se[t][n])), nn = /* @__PURE__ */ Uint32Array.from([
-  0,
-  1518500249,
-  1859775393,
-  2400959708,
-  2840853838
-]), sn = /* @__PURE__ */ Uint32Array.from([
-  1352829926,
-  1548603684,
-  1836072691,
-  2053994217,
-  0
-]);
-function Lt(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 Q = /* @__PURE__ */ new Uint32Array(16);
-class on extends Pt {
-  constructor() {
-    super(64, 20, 8, !0);
-    p(this, "h0", 1732584193);
-    p(this, "h1", -271733879);
-    p(this, "h2", -1732584194);
-    p(this, "h3", 271733878);
-    p(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 y = 0; y < 16; y++, s += 4)
-      Q[y] = n.getUint32(s, !0);
-    let o = this.h0 | 0, r = o, i = this.h1 | 0, a = i, c = this.h2 | 0, l = c, h = this.h3 | 0, u = h, d = this.h4 | 0, g = d;
-    for (let y = 0; y < 5; y++) {
-      const x = 4 - y, P = nn[y], w = sn[y], b = ee[y], f = ne[y], m = tn[y], v = en[y];
-      for (let T = 0; T < 16; T++) {
-        const H = J(o + Lt(y, i, c, h) + Q[b[T]] + P, m[T]) + d | 0;
-        o = d, d = h, h = J(c, 10) | 0, c = i, i = H;
-      }
-      for (let T = 0; T < 16; T++) {
-        const H = J(r + Lt(x, a, l, u) + Q[f[T]] + w, v[T]) + g | 0;
-        r = g, g = u, u = J(l, 10) | 0, l = a, a = H;
-      }
-    }
-    this.set(this.h1 + c + u | 0, this.h2 + h + g | 0, this.h3 + d + r | 0, this.h4 + o + a | 0, this.h0 + i + l | 0);
-  }
-  roundClean() {
-    B(Q);
-  }
-  destroy() {
-    this.destroyed = !0, B(this.buffer), this.set(0, 0, 0, 0, 0);
-  }
-}
-const rn = /* @__PURE__ */ ct(() => new on()), Y = /* @__PURE__ */ BigInt(2 ** 32 - 1), _t = /* @__PURE__ */ BigInt(32);
-function an(e, t = !1) {
-  return t ? { h: Number(e & Y), l: Number(e >> _t & Y) } : { h: Number(e >> _t & Y) | 0, l: Number(e & Y) | 0 };
-}
-function oe(e, t = !1) {
-  const n = e.length;
-  let s = new Uint32Array(n), o = new Uint32Array(n);
-  for (let r = 0; r < n; r++) {
-    const { h: i, l: a } = an(e[r], t);
-    [s[r], o[r]] = [i, a];
-  }
-  return [s, o];
-}
-const Rt = (e, t, n) => e >>> n, Wt = (e, t, n) => e << 32 - n | t >>> n, N = (e, t, n) => e >>> n | t << 32 - n, X = (e, t, n) => e << 32 - n | t >>> n, tt = (e, t, n) => e << 64 - n | t >>> n - 32, et = (e, t, n) => e >>> n - 32 | t << 64 - n, cn = (e, t, n) => e << n | t >>> 32 - n, un = (e, t, n) => t << n | e >>> 32 - n, ln = (e, t, n) => t << n - 32 | e >>> 64 - n, hn = (e, t, n) => e << n - 32 | t >>> 64 - n;
-function U(e, t, n, s) {
-  const o = (t >>> 0) + (s >>> 0);
-  return { h: e + n + (o / 2 ** 32 | 0) | 0, l: o | 0 };
-}
-const dn = (e, t, n) => (e >>> 0) + (t >>> 0) + (n >>> 0), fn = (e, t, n, s) => t + n + s + (e / 2 ** 32 | 0) | 0, pn = (e, t, n, s) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0), yn = (e, t, n, s, o) => t + n + s + o + (e / 2 ** 32 | 0) | 0, bn = (e, t, n, s, o) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0) + (o >>> 0), gn = (e, t, n, s, o, r) => t + n + s + o + r + (e / 2 ** 32 | 0) | 0, xn = /* @__PURE__ */ Uint32Array.from([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]), L = /* @__PURE__ */ new Uint32Array(64);
-class mn extends Pt {
-  constructor(t) {
-    super(64, t, 8, !1);
-  }
-  get() {
-    const { A: t, B: n, C: s, D: o, E: r, F: i, G: a, H: c } = this;
-    return [t, n, s, o, r, i, a, c];
-  }
-  // prettier-ignore
-  set(t, n, s, o, r, i, a, c) {
-    this.A = t | 0, this.B = n | 0, this.C = s | 0, this.D = o | 0, this.E = r | 0, this.F = i | 0, this.G = a | 0, this.H = c | 0;
-  }
-  process(t, n) {
-    for (let u = 0; u < 16; u++, n += 4)
-      L[u] = t.getUint32(n, !1);
-    for (let u = 16; u < 64; u++) {
-      const d = L[u - 15], g = L[u - 2], y = A(d, 7) ^ A(d, 18) ^ d >>> 3, x = A(g, 17) ^ A(g, 19) ^ g >>> 10;
-      L[u] = x + L[u - 7] + y + L[u - 16] | 0;
-    }
-    let { A: s, B: o, C: r, D: i, E: a, F: c, G: l, H: h } = this;
-    for (let u = 0; u < 64; u++) {
-      const d = A(a, 6) ^ A(a, 11) ^ A(a, 25), g = h + d + Ze(a, c, l) + xn[u] + L[u] | 0, x = (A(s, 2) ^ A(s, 13) ^ A(s, 22)) + Je(s, o, r) | 0;
-      h = l, l = c, c = a, a = i + g | 0, i = r, r = o, o = s, s = g + x | 0;
-    }
-    s = s + this.A | 0, o = o + this.B | 0, r = r + this.C | 0, i = i + this.D | 0, a = a + this.E | 0, c = c + this.F | 0, l = l + this.G | 0, h = h + this.H | 0, this.set(s, o, r, i, a, c, l, h);
-  }
-  roundClean() {
-    B(L);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0), B(this.buffer);
-  }
-}
-class wn extends mn {
-  constructor() {
-    super(32);
-    // We cannot use array here since array allows indexing by variable
-    // which means optimizer/compiler cannot use registers.
-    p(this, "A", O[0] | 0);
-    p(this, "B", O[1] | 0);
-    p(this, "C", O[2] | 0);
-    p(this, "D", O[3] | 0);
-    p(this, "E", O[4] | 0);
-    p(this, "F", O[5] | 0);
-    p(this, "G", O[6] | 0);
-    p(this, "H", O[7] | 0);
-  }
-}
-const re = oe([
-  "0x428a2f98d728ae22",
-  "0x7137449123ef65cd",
-  "0xb5c0fbcfec4d3b2f",
-  "0xe9b5dba58189dbbc",
-  "0x3956c25bf348b538",
-  "0x59f111f1b605d019",
-  "0x923f82a4af194f9b",
-  "0xab1c5ed5da6d8118",
-  "0xd807aa98a3030242",
-  "0x12835b0145706fbe",
-  "0x243185be4ee4b28c",
-  "0x550c7dc3d5ffb4e2",
-  "0x72be5d74f27b896f",
-  "0x80deb1fe3b1696b1",
-  "0x9bdc06a725c71235",
-  "0xc19bf174cf692694",
-  "0xe49b69c19ef14ad2",
-  "0xefbe4786384f25e3",
-  "0x0fc19dc68b8cd5b5",
-  "0x240ca1cc77ac9c65",
-  "0x2de92c6f592b0275",
-  "0x4a7484aa6ea6e483",
-  "0x5cb0a9dcbd41fbd4",
-  "0x76f988da831153b5",
-  "0x983e5152ee66dfab",
-  "0xa831c66d2db43210",
-  "0xb00327c898fb213f",
-  "0xbf597fc7beef0ee4",
-  "0xc6e00bf33da88fc2",
-  "0xd5a79147930aa725",
-  "0x06ca6351e003826f",
-  "0x142929670a0e6e70",
-  "0x27b70a8546d22ffc",
-  "0x2e1b21385c26c926",
-  "0x4d2c6dfc5ac42aed",
-  "0x53380d139d95b3df",
-  "0x650a73548baf63de",
-  "0x766a0abb3c77b2a8",
-  "0x81c2c92e47edaee6",
-  "0x92722c851482353b",
-  "0xa2bfe8a14cf10364",
-  "0xa81a664bbc423001",
-  "0xc24b8b70d0f89791",
-  "0xc76c51a30654be30",
-  "0xd192e819d6ef5218",
-  "0xd69906245565a910",
-  "0xf40e35855771202a",
-  "0x106aa07032bbd1b8",
-  "0x19a4c116b8d2d0c8",
-  "0x1e376c085141ab53",
-  "0x2748774cdf8eeb99",
-  "0x34b0bcb5e19b48a8",
-  "0x391c0cb3c5c95a63",
-  "0x4ed8aa4ae3418acb",
-  "0x5b9cca4f7763e373",
-  "0x682e6ff3d6b2b8a3",
-  "0x748f82ee5defb2fc",
-  "0x78a5636f43172f60",
-  "0x84c87814a1f0ab72",
-  "0x8cc702081a6439ec",
-  "0x90befffa23631e28",
-  "0xa4506cebde82bde9",
-  "0xbef9a3f7b2c67915",
-  "0xc67178f2e372532b",
-  "0xca273eceea26619c",
-  "0xd186b8c721c0c207",
-  "0xeada7dd6cde0eb1e",
-  "0xf57d4f7fee6ed178",
-  "0x06f067aa72176fba",
-  "0x0a637dc5a2c898a6",
-  "0x113f9804bef90dae",
-  "0x1b710b35131c471b",
-  "0x28db77f523047d84",
-  "0x32caab7b40c72493",
-  "0x3c9ebe0a15c9bebc",
-  "0x431d67c49c100d4c",
-  "0x4cc5d4becb3e42b6",
-  "0x597f299cfc657e2a",
-  "0x5fcb6fab3ad6faec",
-  "0x6c44198c4a475817"
-].map((e) => BigInt(e))), Pn = re[0], Tn = re[1], _ = /* @__PURE__ */ new Uint32Array(80), R = /* @__PURE__ */ new Uint32Array(80);
-class vn extends Pt {
-  constructor(t) {
-    super(128, t, 16, !1);
-  }
-  // prettier-ignore
-  get() {
-    const { Ah: t, Al: n, Bh: s, Bl: o, Ch: r, Cl: i, Dh: a, Dl: c, Eh: l, El: h, Fh: u, Fl: d, Gh: g, Gl: y, Hh: x, Hl: P } = this;
-    return [t, n, s, o, r, i, a, c, l, h, u, d, g, y, x, P];
-  }
-  // prettier-ignore
-  set(t, n, s, o, r, i, a, c, l, h, u, d, g, y, x, P) {
-    this.Ah = t | 0, this.Al = n | 0, this.Bh = s | 0, this.Bl = o | 0, this.Ch = r | 0, this.Cl = i | 0, this.Dh = a | 0, this.Dl = c | 0, this.Eh = l | 0, this.El = h | 0, this.Fh = u | 0, this.Fl = d | 0, this.Gh = g | 0, this.Gl = y | 0, this.Hh = x | 0, this.Hl = P | 0;
-  }
-  process(t, n) {
-    for (let f = 0; f < 16; f++, n += 4)
-      _[f] = t.getUint32(n), R[f] = t.getUint32(n += 4);
-    for (let f = 16; f < 80; f++) {
-      const m = _[f - 15] | 0, v = R[f - 15] | 0, T = N(m, v, 1) ^ N(m, v, 8) ^ Rt(m, v, 7), H = X(m, v, 1) ^ X(m, v, 8) ^ Wt(m, v, 7), E = _[f - 2] | 0, I = R[f - 2] | 0, F = N(E, I, 19) ^ tt(E, I, 61) ^ Rt(E, I, 6), K = X(E, I, 19) ^ et(E, I, 61) ^ Wt(E, I, 6), $ = pn(H, K, R[f - 7], R[f - 16]), ut = yn($, T, F, _[f - 7], _[f - 16]);
-      _[f] = ut | 0, R[f] = $ | 0;
-    }
-    let { Ah: s, Al: o, Bh: r, Bl: i, Ch: a, Cl: c, Dh: l, Dl: h, Eh: u, El: d, Fh: g, Fl: y, Gh: x, Gl: P, Hh: w, Hl: b } = this;
-    for (let f = 0; f < 80; f++) {
-      const m = N(u, d, 14) ^ N(u, d, 18) ^ tt(u, d, 41), v = X(u, d, 14) ^ X(u, d, 18) ^ et(u, d, 41), T = u & g ^ ~u & x, H = d & y ^ ~d & P, E = bn(b, v, H, Tn[f], R[f]), I = gn(E, w, m, T, Pn[f], _[f]), F = E | 0, K = N(s, o, 28) ^ tt(s, o, 34) ^ tt(s, o, 39), $ = X(s, o, 28) ^ et(s, o, 34) ^ et(s, o, 39), ut = s & r ^ s & a ^ r & a, de = o & i ^ o & c ^ i & c;
-      w = x | 0, b = P | 0, x = g | 0, P = y | 0, g = u | 0, y = d | 0, { h: u, l: d } = U(l | 0, h | 0, I | 0, F | 0), l = a | 0, h = c | 0, a = r | 0, c = i | 0, r = s | 0, i = o | 0;
-      const vt = dn(F, $, de);
-      s = fn(vt, I, K, ut), o = vt | 0;
-    }
-    ({ h: s, l: o } = U(this.Ah | 0, this.Al | 0, s | 0, o | 0)), { h: r, l: i } = U(this.Bh | 0, this.Bl | 0, r | 0, i | 0), { h: a, l: c } = U(this.Ch | 0, this.Cl | 0, a | 0, c | 0), { h: l, l: h } = U(this.Dh | 0, this.Dl | 0, l | 0, h | 0), { h: u, l: d } = U(this.Eh | 0, this.El | 0, u | 0, d | 0), { h: g, l: y } = U(this.Fh | 0, this.Fl | 0, g | 0, y | 0), { h: x, l: P } = U(this.Gh | 0, this.Gl | 0, x | 0, P | 0), { h: w, l: b } = U(this.Hh | 0, this.Hl | 0, w | 0, b | 0), this.set(s, o, r, i, a, c, l, h, u, d, g, y, x, P, w, b);
-  }
-  roundClean() {
-    B(_, R);
-  }
-  destroy() {
-    B(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-  }
-}
-class kn extends vn {
-  constructor() {
-    super(64);
-    p(this, "Ah", k[0] | 0);
-    p(this, "Al", k[1] | 0);
-    p(this, "Bh", k[2] | 0);
-    p(this, "Bl", k[3] | 0);
-    p(this, "Ch", k[4] | 0);
-    p(this, "Cl", k[5] | 0);
-    p(this, "Dh", k[6] | 0);
-    p(this, "Dl", k[7] | 0);
-    p(this, "Eh", k[8] | 0);
-    p(this, "El", k[9] | 0);
-    p(this, "Fh", k[10] | 0);
-    p(this, "Fl", k[11] | 0);
-    p(this, "Gh", k[12] | 0);
-    p(this, "Gl", k[13] | 0);
-    p(this, "Hh", k[14] | 0);
-    p(this, "Hl", k[15] | 0);
-  }
-}
-const Hn = /* @__PURE__ */ ct(
-  () => new wn(),
-  /* @__PURE__ */ Jt(1)
-), ie = /* @__PURE__ */ ct(
-  () => new kn(),
-  /* @__PURE__ */ Jt(3)
-), En = BigInt(0), z = BigInt(1), In = BigInt(2), Sn = BigInt(7), Bn = BigInt(256), An = BigInt(113), ae = [], ce = [], ue = [];
-for (let e = 0, t = z, n = 1, s = 0; e < 24; e++) {
-  [n, s] = [s, (2 * n + 3 * s) % 5], ae.push(2 * (5 * s + n)), ce.push((e + 1) * (e + 2) / 2 % 64);
-  let o = En;
-  for (let r = 0; r < 7; r++)
-    t = (t << z ^ (t >> Sn) * An) % Bn, t & In && (o ^= z << (z << BigInt(r)) - z);
-  ue.push(o);
-}
-const le = oe(ue, !0), Cn = le[0], Un = le[1], Vt = (e, t, n) => n > 32 ? ln(e, t, n) : cn(e, t, n), Dt = (e, t, n) => n > 32 ? hn(e, t, n) : un(e, t, n);
-function Fn(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, c = (i + 2) % 10, l = n[c], h = n[c + 1], u = Vt(l, h, 1) ^ n[a], d = Dt(l, h, 1) ^ n[a + 1];
-      for (let g = 0; g < 50; g += 10)
-        e[i + g] ^= u, e[i + g + 1] ^= d;
-    }
-    let o = e[2], r = e[3];
-    for (let i = 0; i < 24; i++) {
-      const a = ce[i], c = Vt(o, r, a), l = Dt(o, r, a), h = ae[i];
-      o = e[h], r = e[h + 1], e[h] = c, e[h + 1] = l;
-    }
-    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] ^= Cn[s], e[1] ^= Un[s];
-  }
-  B(n);
-}
-class Tt {
-  // NOTE: we accept arguments in bytes instead of bits here.
-  constructor(t, n, s, o = !1, r = 24) {
-    p(this, "state");
-    p(this, "pos", 0);
-    p(this, "posOut", 0);
-    p(this, "finished", !1);
-    p(this, "state32");
-    p(this, "destroyed", !1);
-    p(this, "blockLen");
-    p(this, "suffix");
-    p(this, "outputLen");
-    p(this, "enableXOF", !1);
-    p(this, "rounds");
-    if (this.blockLen = t, this.suffix = n, this.outputLen = s, this.enableXOF = o, this.rounds = r, V(s, "outputLen"), !(0 < t && t < 200))
-      throw new Error("only keccak-f1600 function is supported");
-    this.state = new Uint8Array(200), this.state32 = Ne(this.state);
-  }
-  clone() {
-    return this._cloneInto();
-  }
-  keccak() {
-    $t(this.state32), Fn(this.state32, this.rounds), $t(this.state32), this.posOut = 0, this.pos = 0;
-  }
-  update(t) {
-    G(this), D(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) {
-    G(this, !1), D(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 V(t), this.xofInto(new Uint8Array(t));
-  }
-  digestInto(t) {
-    if (Zt(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, B(this.state);
-  }
-  _cloneInto(t) {
-    const { blockLen: n, suffix: s, outputLen: o, rounds: r, enableXOF: i } = this;
-    return t || (t = new Tt(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 $n = (e, t, n, s = {}) => ct(() => new Tt(t, e, n), s), On = /* @__PURE__ */ $n(1, 136, 32);
-function Ln(e, t, n, s) {
-  zt(e);
-  const o = ze({ dkLen: 32, asyncTick: 10 }, s), { c: r, dkLen: i, asyncTick: a } = o;
-  if (V(r, "c"), V(i, "dkLen"), V(a, "asyncTick"), r < 1)
-    throw new Error("iterations (c) must be >= 1");
-  const c = Ot(t, "password"), l = Ot(n, "salt"), h = new Uint8Array(i), u = wt.create(e, c), d = u._cloneInto().update(l);
-  return { c: r, dkLen: i, asyncTick: a, DK: h, PRF: u, PRFSalt: d };
-}
-function _n(e, t, n, s, o) {
-  return e.destroy(), t.destroy(), s && s.destroy(), B(o), n;
-}
-function Rn(e, t, n, s) {
-  const { c: o, dkLen: r, DK: i, PRF: a, PRFSalt: c } = Ln(e, t, n, s);
-  let l;
-  const h = new Uint8Array(4), u = rt(h), d = new Uint8Array(a.outputLen);
-  for (let g = 1, y = 0; y < r; g++, y += a.outputLen) {
-    const x = i.subarray(y, y + a.outputLen);
-    u.setInt32(0, g, !1), (l = c._cloneInto(l)).update(h).digestInto(d), x.set(d.subarray(0, x.length));
-    for (let P = 1; P < o; P++) {
-      a._cloneInto(l).update(d).digestInto(d);
-      for (let w = 0; w < x.length; w++)
-        x[w] ^= d[w];
-    }
-  }
-  return _n(a, c, i, l, d);
-}
-function he(e) {
-  if (typeof e != "string")
-    throw new TypeError("invalid mnemonic type: " + typeof e);
-  return e.normalize("NFKD");
-}
-function Wn(e) {
-  const t = he(e), n = t.split(" ");
-  if (![12, 15, 18, 21, 24].includes(n.length))
-    throw new Error("Invalid mnemonic");
-  return { nfkd: t, words: n };
-}
-const Vn = (e) => he("mnemonic" + e);
-function Dn(e, t = "") {
-  return Rn(ie, Wn(e).nfkd, Vn(t), { c: 2048, dkLen: 64 });
-}
-const Kn = 508, Kt = 16, nt = 32, st = 64, Mt = 5, Mn = 4;
-function Z(...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 ft(e) {
-  return new TextEncoder().encode(e);
-}
-function pt(e) {
-  const t = new Uint8Array(Mn);
-  return new DataView(t.buffer).setUint32(0, e.length, !1), Z(t, e);
-}
-function yt(e, t) {
-  return wt(ie, e, t);
-}
-function Nt(e) {
-  return rn(Hn(e));
-}
-const gt = (e) => Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("");
-function Nn(e) {
-  const t = Dn(e), n = new Uint8Array(t);
-  return t.fill(0), n;
-}
-async function Xn(e, t, n, s) {
-  if (e.length !== st)
-    throw new Error(
-      `WOTS seed must be ${st} bytes, got ${e.length}`
-    );
-  t = S(t), n = S(n);
-  const o = e.slice(nt, st), r = e.slice(0, nt), i = [o, r];
-  try {
-    const a = Z(
-      pt(ft(t)),
-      pt(ft(n)),
-      pt(ft(s))
-    ), c = Z(r, a);
-    i.push(c);
-    const l = yt(o, c);
-    i.push(l);
-    const h = l.slice(0, nt), u = l.slice(nt, st);
-    i.push(h, u);
-    const d = [], g = [], y = [], x = [];
-    let P = !1;
-    try {
-      for (let w = 0; w < Kn; w++) {
-        const b = new Uint8Array(Mt);
-        b[0] = 0, new DataView(b.buffer).setUint32(1, w, !1);
-        const f = new Uint8Array(Mt);
-        f[0] = 1, new DataView(f.buffer).setUint32(1, w, !1);
-        const m = Z(h, b), v = Z(h, f), T = yt(u, m), H = yt(u, v);
-        try {
-          const E = T.slice(0, Kt), I = H.slice(0, Kt);
-          d.push(E), g.push(I), y.push(Nt(E)), x.push(Nt(I));
-        } finally {
-          m.fill(0), v.fill(0), T.fill(0), H.fill(0);
-        }
-      }
-      return P = !0, { falsePreimages: d, truePreimages: g, falseHashes: y, trueHashes: x };
-    } finally {
-      if (!P) {
-        for (const w of d) w.fill(0);
-        for (const w of g) w.fill(0);
-      }
-    }
-  } finally {
-    for (const a of i)
-      a.fill(0);
-  }
-}
-function ls(e) {
-  return {
-    false_list: e.falseHashes.map(gt),
-    true_list: e.trueHashes.map(gt)
-  };
-}
-function qn(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 = On(s);
-  return `0x${gt(r)}`;
-}
-async function hs(e, t, n, s) {
-  const o = Nn(e);
-  try {
-    const r = await Xn(
-      o,
-      t,
-      n,
-      s
-    );
-    try {
-      return qn(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 ds(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 {
-  ds as A,
-  ot as B,
-  q as C,
-  _e as M,
-  cs as P,
-  Yn as a,
-  Fe as b,
-  dt as c,
-  $e as d,
-  bt as e,
-  us as f,
-  ts as g,
-  os as h,
-  ns as i,
-  ss as j,
-  rs as k,
-  es as l,
-  We as m,
-  Ve as n,
-  j as o,
-  Re as p,
-  mt as q,
-  is as r,
-  Ue as s,
-  as as t,
-  M as u,
-  Nn as v,
-  Xn as w,
-  ls as x,
-  qn as y,
-  hs as z
-};
-//# sourceMappingURL=errors-Ld-2tiK3.js.map