@babylonlabs-io/ts-sdk 0.8.1 → 0.9.0

package/dist/errors-D_DWT0CT.js

@@ -0,0 +1,2063 @@
+var ue = Object.defineProperty;
+var le = (e, t, n) => t in e ? ue(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var f = (e, t, n) => le(e, typeof t != "symbol" ? t + "" : t, n);
+import * as he from "bitcoinjs-lib";
+import { script as fe, Transaction as st, address as de, Psbt as ft } from "bitcoinjs-lib";
+import { Buffer as S } from "buffer";
+import { P as pe, x as be, D as Dt, M as Pt, B as xe, T as ye, A as dt, t as W, b as ge, z as me, a as we, d as Pe, e as Te, f as ve, r as at, p as He, w as Tt, g as vt, h as Ht } from "./challengeAssert-D50t_Qyo.js";
+import { createPublicClient as kt, http as It, encodeFunctionData as ke, zeroAddress as Ie } from "viem";
+import { c as pt } from "./signOptions-Drwr3bXB.js";
+import { SINGLE_DEPOSIT_HTLC_VOUT as Et } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+function Ee(e, t, n) {
+  if (e.length === 0)
+    throw new Error("Insufficient funds: no UTXOs available");
+  const s = e.filter((c) => {
+    const l = S.from(c.scriptPubKey, "hex");
+    return !!fe.decompile(l);
+  });
+  if (s.length === 0)
+    throw new Error(
+      "Insufficient funds: no valid UTXOs available (all have invalid scripts)"
+    );
+  const r = [...s].sort((c, l) => l.value - c.value), o = [];
+  let i = 0n, a = 0n;
+  for (const c of r) {
+    o.push(c), i += BigInt(c.value);
+    const l = o.length * pe, h = 2 * Pt, u = l + h + ye;
+    if (a = BigInt(Math.ceil(u * n)) + BigInt(be(n)), i - t - a > Dt) {
+      const p = BigInt(
+        Math.ceil(Pt * n)
+      );
+      a += p;
+    }
+    if (i >= t + a) {
+      const p = i - t - a;
+      return {
+        selectedUTXOs: o,
+        totalValue: i,
+        fee: a,
+        changeAmount: p
+      };
+    }
+  }
+  throw new Error(
+    `Insufficient funds: need ${t + a} sats (${t} pegin + ${a} fee), have ${i} sats`
+  );
+}
+function zn(e) {
+  return e > Dt;
+}
+function qn() {
+  return xe;
+}
+function St(e) {
+  const t = e.startsWith("0x") ? e.slice(2) : e;
+  return `0x${st.fromHex(t).getId()}`;
+}
+function Zn(e, t, n) {
+  if (e.length === 0)
+    throw new Error("No input UTXOs provided for split transaction");
+  if (t.length === 0)
+    throw new Error("No outputs specified for split transaction");
+  for (const c of t)
+    if (c.amount <= 0n)
+      throw new Error(
+        `Invalid output amount for ${c.address}: ${c.amount} satoshis. Amount must be greater than zero.`
+      );
+  const s = dt(n), r = new st();
+  r.version = 2;
+  for (const c of e) {
+    const l = S.from(c.txid, "hex").reverse();
+    r.addInput(l, c.vout);
+  }
+  const o = [];
+  for (let c = 0; c < t.length; c++) {
+    const l = t[c];
+    let h;
+    try {
+      h = de.toOutputScript(l.address, s);
+    } catch (u) {
+      throw new Error(
+        `Failed to decode address "${l.address}": ${u instanceof Error ? u.message : String(u)}`
+      );
+    }
+    r.addOutput(h, Number(l.amount)), o.push({
+      txid: "",
+      // Will be set after txid calculation
+      vout: c,
+      value: Number(l.amount),
+      scriptPubKey: h.toString("hex")
+    });
+  }
+  const i = r.toHex(), a = r.getId();
+  for (const c of o)
+    c.txid = a;
+  return {
+    txHex: i,
+    txid: a,
+    outputs: o
+  };
+}
+function Jn(e, t, n) {
+  const s = st.fromHex(e), r = new ft();
+  if (r.setVersion(s.version), r.setLocktime(s.locktime), !S.isBuffer(n) || n.length !== 32)
+    throw new Error(
+      `Invalid publicKeyNoCoord: expected 32-byte Buffer (x-only pubkey), got ${S.isBuffer(n) ? `${n.length}-byte Buffer` : typeof n}`
+    );
+  if (t.length !== s.ins.length)
+    throw new Error(
+      `UTXO count mismatch: transaction has ${s.ins.length} input${s.ins.length !== 1 ? "s" : ""}, but ${t.length} UTXO${t.length !== 1 ? "s were" : " was"} provided`
+    );
+  for (let o = 0; o < s.ins.length; o++) {
+    const i = s.ins[o], a = t[o];
+    if (!a)
+      throw new Error(`Missing UTXO data for input ${o}`);
+    const c = S.from(i.hash).reverse().toString("hex"), l = i.index;
+    if (a.txid !== c || a.vout !== l)
+      throw new Error(
+        `Input ${o} outpoint mismatch: transaction expects ${c}:${l}, but UTXO ${a.txid}:${a.vout} was provided. Ensure inputs array matches the order used in createSplitTransaction().`
+      );
+    const h = S.from(a.scriptPubKey, "hex");
+    if (!(h.length === 34 && h[0] === 81 && // OP_1 (witness version 1)
+    h[1] === 32))
+      throw new Error(
+        `Input ${o} must be P2TR (Taproot). createSplitTransactionPsbt() requires P2TR inputs because it uses tapInternalKey for Taproot signing. ScriptPubKey: ${a.scriptPubKey.substring(0, 20)}...`
+      );
+    const d = {
+      script: S.from(a.scriptPubKey, "hex"),
+      value: a.value
+    };
+    r.addInput({
+      hash: i.hash,
+      index: i.index,
+      sequence: i.sequence,
+      witnessUtxo: d,
+      tapInternalKey: n
+    });
+  }
+  for (const o of s.outs)
+    r.addOutput({
+      script: o.script,
+      value: o.value
+    });
+  return r.toHex();
+}
+var tt = /* @__PURE__ */ ((e) => (e.P2PKH = "P2PKH", e.P2SH = "P2SH", e.P2WPKH = "P2WPKH", e.P2WSH = "P2WSH", e.P2TR = "P2TR", e.UNKNOWN = "UNKNOWN", e))(tt || {});
+function Se(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 Ae(e, t) {
+  const n = S.from(e.scriptPubKey, "hex"), s = Se(n);
+  switch (s) {
+    case tt.P2WPKH:
+      return {
+        witnessUtxo: {
+          script: n,
+          value: e.value
+        }
+      };
+    case tt.P2WSH: {
+      if (!e.witnessScript)
+        throw new Error("Missing witnessScript for P2WSH input");
+      return {
+        witnessUtxo: {
+          script: n,
+          value: e.value
+        },
+        witnessScript: S.from(e.witnessScript, "hex")
+      };
+    }
+    case tt.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}`);
+  }
+}
+const Be = 21e6 * 1e8, Kt = 1e4;
+function Mt(e) {
+  return Number.isInteger(e) && e > 0 && e <= Be;
+}
+function Ue(e) {
+  return Number.isInteger(e) && e > 0 && e <= Kt;
+}
+function Nt(e, t) {
+  return !Number.isInteger(e) || e < 0 ? !1 : t === void 0 || e < t;
+}
+const Le = {
+  mainnet: "https://mempool.space/api",
+  testnet: "https://mempool.space/testnet/api",
+  signet: "https://mempool.space/signet/api"
+};
+async function nt(e, t) {
+  try {
+    const n = await fetch(e, t);
+    if (!n.ok) {
+      const r = await n.text();
+      throw new Error(
+        `Mempool API error (${n.status}): ${r || 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 $e(e, t) {
+  try {
+    const n = await fetch(`${t}/tx`, {
+      method: "POST",
+      body: e,
+      headers: {
+        "Content-Type": "text/plain"
+      }
+    });
+    if (!n.ok) {
+      const r = await n.text();
+      let o;
+      try {
+        o = JSON.parse(r).message;
+      } catch {
+        o = r;
+      }
+      throw new Error(
+        o || `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 Fe(e, t) {
+  return nt(`${t}/tx/${e}`);
+}
+async function Yn(e, t) {
+  try {
+    const n = await fetch(`${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 Oe(e, t, n) {
+  const s = await Fe(e, n);
+  if (!Nt(t, s.vout.length))
+    throw new Error(
+      `Invalid vout ${t} for transaction ${e} (has ${s.vout.length} outputs)`
+    );
+  const r = s.vout[t];
+  if (!Mt(r.value))
+    throw new Error(`Invalid UTXO value ${r.value} for ${e}:${t}`);
+  return {
+    txid: e,
+    vout: t,
+    value: r.value,
+    scriptPubKey: r.scriptpubkey
+  };
+}
+async function Qn(e, t) {
+  try {
+    const n = await nt(`${t}/address/${e}/utxo`), s = await nt(`${t}/v1/validate-address/${e}`);
+    if (!s.isvalid)
+      throw new Error(
+        `Invalid Bitcoin address: ${e}. Mempool API validation failed.`
+      );
+    for (const o of n) {
+      if (!Nt(o.vout))
+        throw new Error(`Invalid vout ${o.vout} for ${o.txid}`);
+      if (!Mt(o.value))
+        throw new Error(
+          `Invalid UTXO value ${o.value} for ${o.txid}:${o.vout}`
+        );
+    }
+    return n.sort((o, i) => i.value - o.value).map((o) => ({
+      txid: o.txid,
+      vout: o.vout,
+      value: o.value,
+      scriptPubKey: s.scriptPubKey,
+      confirmed: o.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 ts(e) {
+  return Le[e];
+}
+async function es(e, t) {
+  return nt(`${t}/address/${e}/txs`);
+}
+async function ns(e) {
+  const t = await fetch(`${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 r of s)
+    if (!Ue(n[r]))
+      throw new Error(
+        `Invalid fee rate ${r}=${n[r]} from mempool API: expected a positive number ≤ ${Kt}`
+      );
+  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 ct = [
+  {
+    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: "depositorLamportPkHash",
+        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: "depositorLamportPkHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "activateVaultWithSecret",
+    inputs: [
+      {
+        name: "vaultId",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "s",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    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: "proverProgramVersion", type: "uint16", internalType: "uint16" },
+          { name: "createdAt", type: "uint256", internalType: "uint256" },
+          { name: "verifiedAt", type: "uint256", internalType: "uint256" },
+          { name: "depositorLamportPkHash", type: "bytes32", internalType: "bytes32" },
+          { name: "hashlock", type: "bytes32", internalType: "bytes32" },
+          { name: "htlcVout", type: "uint8", internalType: "uint8" }
+        ]
+      }
+    ],
+    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: []
+  }
+], D = {
+  // 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 xt(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 r = 5;
+  for (; n && typeof n == "object" && s < r; ) {
+    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 ss(e) {
+  const t = xt(e);
+  if (t) {
+    const n = t.substring(0, 10);
+    return D[t] ?? D[n];
+  }
+}
+function rs(e) {
+  const t = xt(e);
+  if (t === void 0) return !1;
+  const n = t.substring(0, 10);
+  return t in D || n in D;
+}
+function At(e) {
+  console.error("[Contract Error] Raw error:", e);
+  const t = xt(e);
+  if (console.error("[Contract Error] Extracted error data:", t), t) {
+    const s = t.substring(0, 10), r = D[t] ?? D[s];
+    if (r)
+      throw console.error("[Contract Error] Known error:", r), new Error(r);
+  }
+  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)}`);
+}
+function Ce(e, t, n, s) {
+  const r = n == null ? void 0 : n[`${e}:${t}`];
+  return r ? Promise.resolve({
+    txid: e,
+    vout: t,
+    value: r.value,
+    scriptPubKey: r.scriptPubKey
+  }) : Oe(e, t, s);
+}
+class os {
+  /**
+   * Creates a new PeginManager instance.
+   *
+   * @param config - Manager configuration including wallets and contract addresses
+   */
+  constructor(t) {
+    f(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, r = W(t.vaultProviderBtcPubkey), o = t.vaultKeeperBtcPubkeys.map(W), i = t.universalChallengerBtcPubkeys.map(W);
+    if (t.hashlocks.length !== 1)
+      throw new Error(
+        "hashlocks must contain exactly one entry (batched deposits not yet supported)"
+      );
+    const a = o.length, c = {
+      depositorPubkey: s,
+      vaultProviderPubkey: r,
+      vaultKeeperPubkeys: o,
+      universalChallengerPubkeys: i,
+      hashlocks: t.hashlocks,
+      timelockRefund: t.timelockRefund,
+      pegInAmount: t.amount,
+      feeRate: t.protocolFeeRate,
+      numLocalChallengers: a,
+      councilQuorum: t.councilQuorum,
+      councilSize: t.councilSize,
+      network: this.config.btcNetwork
+    }, l = await ge(c), h = Ee(
+      [...t.availableUTXOs],
+      l.totalOutputValue,
+      t.mempoolFeeRate
+    ), u = dt(this.config.btcNetwork), d = me({
+      unfundedTxHex: l.psbtHex,
+      selectedUTXOs: h.selectedUTXOs,
+      changeAddress: t.changeAddress,
+      changeAmount: h.changeAmount,
+      network: u
+    }), p = W(St(d)), b = await we({
+      prePeginParams: c,
+      timelockPegin: t.timelockPegin,
+      fundedPrePeginTxHex: d,
+      htlcVout: Et
+    }), m = await Pe({
+      peginTxHex: b.txHex,
+      fundedPrePeginTxHex: d,
+      depositorPubkey: s,
+      vaultProviderPubkey: r,
+      vaultKeeperPubkeys: o,
+      universalChallengerPubkeys: i,
+      hashlock: t.hashlocks[0],
+      timelockRefund: t.timelockRefund,
+      network: this.config.btcNetwork
+    }), x = await this.config.btcWallet.signPsbt(
+      m.psbtHex,
+      pt(n, 1)
+    ), g = Te(
+      x,
+      s
+    ), w = ve(x);
+    return {
+      fundedPrePeginTxHex: d,
+      htlcValue: l.htlcValue,
+      signedPeginInputPsbtHex: x,
+      peginInputSignature: g,
+      vaultScriptPubKey: b.vaultScriptPubKey,
+      peginTxHex: w,
+      prePeginTxid: p,
+      peginTxid: b.txid,
+      selectedUTXOs: h.selectedUTXOs,
+      fee: h.fee,
+      changeAmount: h.changeAmount
+    };
+  }
+  /**
+   * 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, r = n.startsWith("0x") ? n.slice(2) : n, o = st.fromHex(r);
+    if (o.ins.length === 0)
+      throw new Error("Transaction has no inputs");
+    const i = new ft();
+    i.setVersion(o.version), i.setLocktime(o.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 = S.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 = o.ins.map((x) => {
+      const g = S.from(x.hash).reverse().toString("hex"), w = x.index;
+      return Ce(g, w, t.localPrevouts, l).then(
+        (y) => ({ input: x, utxoData: y, txid: g, vout: w })
+      );
+    }), u = await Promise.all(h);
+    for (const { input: x, utxoData: g, txid: w, vout: y } of u) {
+      const P = Ae(
+        {
+          value: g.value,
+          scriptPubKey: g.scriptPubKey
+        },
+        c
+      );
+      i.addInput({
+        hash: x.hash,
+        index: x.index,
+        sequence: x.sequence,
+        ...P
+      });
+    }
+    for (const x of o.outs)
+      i.addOutput({
+        script: x.script,
+        value: x.value
+      });
+    const d = await this.config.btcWallet.signPsbt(i.toHex()), p = ft.fromHex(d);
+    try {
+      p.finalizeAllInputs();
+    } catch (x) {
+      if (!p.data.inputs.every(
+        (w) => w.finalScriptWitness || w.finalScriptSig
+      ))
+        throw new Error(
+          `PSBT finalization failed and wallet did not auto-finalize: ${x}`
+        );
+    }
+    const b = p.extractTransaction().toHex();
+    return await $e(b, 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: r,
+      vaultProvider: o,
+      hashlock: i,
+      onPopSigned: a,
+      depositorPayoutBtcAddress: c,
+      depositorLamportPkHash: l,
+      preSignedBtcPopSignature: h
+    } = t;
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const u = this.config.ethWallet.account.address, d = await this.resolvePopSignature(
+      u,
+      h
+    );
+    a && await a();
+    const p = at(n), b = at(s), m = at(r), x = await this.resolvePayoutScriptPubKey(
+      c
+    ), g = St(m);
+    if (await this.checkVaultExists(g))
+      throw new Error(
+        `Vault already exists for this transaction (ID: ${g}). Vault IDs are deterministically derived from the unsigned Bitcoin transaction, so using the same UTXOs and amount will always produce the same vault. To create a new vault, please use different UTXOs or a different amount to generate a unique transaction.`
+      );
+    const y = kt({
+      chain: this.config.ethChain,
+      transport: It()
+    });
+    let P;
+    try {
+      P = await y.readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: ct,
+        functionName: "getPegInFee",
+        args: [o]
+      });
+    } 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 v = ke({
+      abi: ct,
+      functionName: "submitPeginRequest",
+      args: [
+        u,
+        p,
+        d,
+        b,
+        m,
+        o,
+        i,
+        Et,
+        x,
+        l
+      ]
+    });
+    let T;
+    try {
+      T = await y.estimateGas({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: v,
+        value: P,
+        account: this.config.ethWallet.account.address
+      });
+    } catch (k) {
+      At(k);
+    }
+    try {
+      return {
+        ethTxHash: await this.config.ethWallet.sendTransaction({
+          to: this.config.vaultContracts.btcVaultRegistry,
+          data: v,
+          value: P,
+          account: this.config.ethWallet.account,
+          chain: this.config.ethChain,
+          gas: T
+        }),
+        vaultId: g,
+        btcPopSignature: d
+      };
+    } catch (k) {
+      At(k);
+    }
+  }
+  /**
+   * 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 kt({
+        chain: this.config.ethChain,
+        transport: It()
+      }).readContract({
+        address: this.config.vaultContracts.btcVaultRegistry,
+        abi: ct,
+        functionName: "getBTCVault",
+        args: [t]
+      })).depositor !== Ie;
+    } 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 r = await this.config.btcWallet.getPublicKeyHex();
+      if (!He(
+        n,
+        r,
+        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 = dt(this.config.btcNetwork);
+    try {
+      return `0x${he.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, r = `${t.toLowerCase()}:${this.config.ethChain.id}:pegin:${s.toLowerCase()}`, o = await this.config.btcWallet.signMessage(
+      r,
+      "bip322-simple"
+    );
+    return o.startsWith("0x") ? o : `0x${S.from(o, "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 is {
+  /**
+   * Creates a new PayoutManager instance.
+   *
+   * @param config - Manager configuration including wallet
+   */
+  constructor(t) {
+    f(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) {
+    const n = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: s } = Tt(
+      n,
+      t.depositorBtcPubkey
+    ), r = await vt({
+      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
+    }), o = await this.config.btcWallet.signPsbt(
+      r.psbtHex,
+      pt(n, 1)
+    );
+    return {
+      signature: Ht(o, 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 = [], r = [], o = [];
+    for (const c of t) {
+      const { depositorPubkey: l } = Tt(
+        n,
+        c.depositorBtcPubkey
+      );
+      o.push(l);
+      const h = await vt({
+        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), r.push(pt(n, 1));
+    }
+    const i = await this.config.btcWallet.signPsbts(
+      s,
+      r
+    );
+    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 = o[c], h = Ht(
+        i[c],
+        l
+      );
+      a.push({
+        payoutSignature: h,
+        depositorBtcPubkey: l
+      });
+    }
+    return a;
+  }
+}
+function _e(e) {
+  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function C(e, t = "") {
+  if (!Number.isSafeInteger(e) || e < 0) {
+    const n = t && `"${t}" `;
+    throw new Error(`${n}expected integer >= 0, got ${e}`);
+  }
+}
+function _(e, t, n = "") {
+  const s = _e(e), r = e == null ? void 0 : e.length, o = t !== void 0;
+  if (!s || o && r !== t) {
+    const i = n && `"${n}" `, a = o ? ` of length ${t}` : "", c = s ? `length=${r}` : `type=${typeof e}`;
+    throw new Error(i + "expected Uint8Array" + a + ", got " + c);
+  }
+  return e;
+}
+function Xt(e) {
+  if (typeof e != "function" || typeof e.create != "function")
+    throw new Error("Hash must wrapped by utils.createHasher");
+  C(e.outputLen), C(e.blockLen);
+}
+function K(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 Gt(e, t) {
+  _(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 Re(e) {
+  return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
+}
+function A(...e) {
+  for (let t = 0; t < e.length; t++)
+    e[t].fill(0);
+}
+function et(e) {
+  return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function B(e, t) {
+  return e << 32 - t | e >>> t;
+}
+function j(e, t) {
+  return e << t | e >>> 32 - t >>> 0;
+}
+const Ve = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function We(e) {
+  return e << 24 & 4278190080 | e << 8 & 16711680 | e >>> 8 & 65280 | e >>> 24 & 255;
+}
+function De(e) {
+  for (let t = 0; t < e.length; t++)
+    e[t] = We(e[t]);
+  return e;
+}
+const Bt = Ve ? (e) => e : De;
+function Ke(e) {
+  if (typeof e != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(e));
+}
+function Ut(e, t = "") {
+  return typeof e == "string" ? Ke(e) : _(e, void 0, t);
+}
+function Me(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 rt(e, t = {}) {
+  const n = (r, o) => e(o).update(r).digest(), s = e(void 0);
+  return n.outputLen = s.outputLen, n.blockLen = s.blockLen, n.create = (r) => e(r), 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 zt {
+  constructor(t, n) {
+    f(this, "oHash");
+    f(this, "iHash");
+    f(this, "blockLen");
+    f(this, "outputLen");
+    f(this, "finished", !1);
+    f(this, "destroyed", !1);
+    if (Xt(t), _(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, r = new Uint8Array(s);
+    r.set(n.length > s ? t.create().update(n).digest() : n);
+    for (let o = 0; o < r.length; o++)
+      r[o] ^= 54;
+    this.iHash.update(r), this.oHash = t.create();
+    for (let o = 0; o < r.length; o++)
+      r[o] ^= 106;
+    this.oHash.update(r), A(r);
+  }
+  update(t) {
+    return K(this), this.iHash.update(t), this;
+  }
+  digestInto(t) {
+    K(this), _(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: r, destroyed: o, blockLen: i, outputLen: a } = this;
+    return t = t, t.finished = r, t.destroyed = o, 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 yt = (e, t, n) => new zt(e, t).update(n).digest();
+yt.create = (e, t) => new zt(e, t);
+function Ne(e, t, n) {
+  return e & t ^ ~e & n;
+}
+function Xe(e, t, n) {
+  return e & t ^ e & n ^ t & n;
+}
+class gt {
+  constructor(t, n, s, r) {
+    f(this, "blockLen");
+    f(this, "outputLen");
+    f(this, "padOffset");
+    f(this, "isLE");
+    // For partial updates less than block size
+    f(this, "buffer");
+    f(this, "view");
+    f(this, "finished", !1);
+    f(this, "length", 0);
+    f(this, "pos", 0);
+    f(this, "destroyed", !1);
+    this.blockLen = t, this.outputLen = n, this.padOffset = s, this.isLE = r, this.buffer = new Uint8Array(t), this.view = et(this.buffer);
+  }
+  update(t) {
+    K(this), _(t);
+    const { view: n, buffer: s, blockLen: r } = this, o = t.length;
+    for (let i = 0; i < o; ) {
+      const a = Math.min(r - this.pos, o - i);
+      if (a === r) {
+        const c = et(t);
+        for (; r <= o - i; i += r)
+          this.process(c, i);
+        continue;
+      }
+      s.set(t.subarray(i, i + a), this.pos), this.pos += a, i += a, this.pos === r && (this.process(n, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    K(this), Gt(t, this), this.finished = !0;
+    const { buffer: n, view: s, blockLen: r, isLE: o } = this;
+    let { pos: i } = this;
+    n[i++] = 128, A(this.buffer.subarray(i)), this.padOffset > r - i && (this.process(s, 0), i = 0);
+    for (let u = i; u < r; u++)
+      n[u] = 0;
+    s.setBigUint64(r - 8, BigInt(this.length * 8), o), this.process(s, 0);
+    const a = et(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], o);
+  }
+  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: r, finished: o, destroyed: i, pos: a } = this;
+    return t.destroyed = i, t.finished = o, t.length = r, t.pos = a, r % n && t.buffer.set(s), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const L = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), H = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]), Ge = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), qt = Uint8Array.from(new Array(16).fill(0).map((e, t) => t)), je = qt.map((e) => (9 * e + 5) % 16), Zt = /* @__PURE__ */ (() => {
+  const n = [[qt], [je]];
+  for (let s = 0; s < 4; s++)
+    for (let r of n)
+      r.push(r[s].map((o) => Ge[o]));
+  return n;
+})(), Jt = Zt[0], Yt = Zt[1], Qt = /* @__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)), ze = /* @__PURE__ */ Jt.map((e, t) => e.map((n) => Qt[t][n])), qe = /* @__PURE__ */ Yt.map((e, t) => e.map((n) => Qt[t][n])), Ze = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), Je = /* @__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 z = /* @__PURE__ */ new Uint32Array(16);
+class Ye extends gt {
+  constructor() {
+    super(64, 20, 8, !0);
+    f(this, "h0", 1732584193);
+    f(this, "h1", -271733879);
+    f(this, "h2", -1732584194);
+    f(this, "h3", 271733878);
+    f(this, "h4", -1009589776);
+  }
+  get() {
+    const { h0: n, h1: s, h2: r, h3: o, h4: i } = this;
+    return [n, s, r, o, i];
+  }
+  set(n, s, r, o, i) {
+    this.h0 = n | 0, this.h1 = s | 0, this.h2 = r | 0, this.h3 = o | 0, this.h4 = i | 0;
+  }
+  process(n, s) {
+    for (let b = 0; b < 16; b++, s += 4)
+      z[b] = n.getUint32(s, !0);
+    let r = this.h0 | 0, o = r, i = this.h1 | 0, a = i, c = this.h2 | 0, l = c, h = this.h3 | 0, u = h, d = this.h4 | 0, p = d;
+    for (let b = 0; b < 5; b++) {
+      const m = 4 - b, x = Ze[b], g = Je[b], w = Jt[b], y = Yt[b], P = ze[b], v = qe[b];
+      for (let T = 0; T < 16; T++) {
+        const k = j(r + Lt(b, i, c, h) + z[w[T]] + x, P[T]) + d | 0;
+        r = d, d = h, h = j(c, 10) | 0, c = i, i = k;
+      }
+      for (let T = 0; T < 16; T++) {
+        const k = j(o + Lt(m, a, l, u) + z[y[T]] + g, v[T]) + p | 0;
+        o = p, p = u, u = j(l, 10) | 0, l = a, a = k;
+      }
+    }
+    this.set(this.h1 + c + u | 0, this.h2 + h + p | 0, this.h3 + d + o | 0, this.h4 + r + a | 0, this.h0 + i + l | 0);
+  }
+  roundClean() {
+    A(z);
+  }
+  destroy() {
+    this.destroyed = !0, A(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const Qe = /* @__PURE__ */ rt(() => new Ye()), q = /* @__PURE__ */ BigInt(2 ** 32 - 1), $t = /* @__PURE__ */ BigInt(32);
+function tn(e, t = !1) {
+  return t ? { h: Number(e & q), l: Number(e >> $t & q) } : { h: Number(e >> $t & q) | 0, l: Number(e & q) | 0 };
+}
+function te(e, t = !1) {
+  const n = e.length;
+  let s = new Uint32Array(n), r = new Uint32Array(n);
+  for (let o = 0; o < n; o++) {
+    const { h: i, l: a } = tn(e[o], t);
+    [s[o], r[o]] = [i, a];
+  }
+  return [s, r];
+}
+const Ft = (e, t, n) => e >>> n, Ot = (e, t, n) => e << 32 - n | t >>> n, R = (e, t, n) => e >>> n | t << 32 - n, V = (e, t, n) => e << 32 - n | t >>> n, Z = (e, t, n) => e << 64 - n | t >>> n - 32, J = (e, t, n) => e >>> n - 32 | t << 64 - n, en = (e, t, n) => e << n | t >>> 32 - n, nn = (e, t, n) => t << n | e >>> 32 - n, sn = (e, t, n) => t << n - 32 | e >>> 64 - n, rn = (e, t, n) => e << n - 32 | t >>> 64 - n;
+function U(e, t, n, s) {
+  const r = (t >>> 0) + (s >>> 0);
+  return { h: e + n + (r / 2 ** 32 | 0) | 0, l: r | 0 };
+}
+const on = (e, t, n) => (e >>> 0) + (t >>> 0) + (n >>> 0), an = (e, t, n, s) => t + n + s + (e / 2 ** 32 | 0) | 0, cn = (e, t, n, s) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0), un = (e, t, n, s, r) => t + n + s + r + (e / 2 ** 32 | 0) | 0, ln = (e, t, n, s, r) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0) + (r >>> 0), hn = (e, t, n, s, r, o) => t + n + s + r + o + (e / 2 ** 32 | 0) | 0, fn = /* @__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
+]), $ = /* @__PURE__ */ new Uint32Array(64);
+class dn extends gt {
+  constructor(t) {
+    super(64, t, 8, !1);
+  }
+  get() {
+    const { A: t, B: n, C: s, D: r, E: o, F: i, G: a, H: c } = this;
+    return [t, n, s, r, o, i, a, c];
+  }
+  // prettier-ignore
+  set(t, n, s, r, o, i, a, c) {
+    this.A = t | 0, this.B = n | 0, this.C = s | 0, this.D = r | 0, this.E = o | 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)
+      $[u] = t.getUint32(n, !1);
+    for (let u = 16; u < 64; u++) {
+      const d = $[u - 15], p = $[u - 2], b = B(d, 7) ^ B(d, 18) ^ d >>> 3, m = B(p, 17) ^ B(p, 19) ^ p >>> 10;
+      $[u] = m + $[u - 7] + b + $[u - 16] | 0;
+    }
+    let { A: s, B: r, C: o, D: i, E: a, F: c, G: l, H: h } = this;
+    for (let u = 0; u < 64; u++) {
+      const d = B(a, 6) ^ B(a, 11) ^ B(a, 25), p = h + d + Ne(a, c, l) + fn[u] + $[u] | 0, m = (B(s, 2) ^ B(s, 13) ^ B(s, 22)) + Xe(s, r, o) | 0;
+      h = l, l = c, c = a, a = i + p | 0, i = o, o = r, r = s, s = p + m | 0;
+    }
+    s = s + this.A | 0, r = r + this.B | 0, o = o + 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, r, o, i, a, c, l, h);
+  }
+  roundClean() {
+    A($);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), A(this.buffer);
+  }
+}
+class pn extends dn {
+  constructor() {
+    super(32);
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    f(this, "A", L[0] | 0);
+    f(this, "B", L[1] | 0);
+    f(this, "C", L[2] | 0);
+    f(this, "D", L[3] | 0);
+    f(this, "E", L[4] | 0);
+    f(this, "F", L[5] | 0);
+    f(this, "G", L[6] | 0);
+    f(this, "H", L[7] | 0);
+  }
+}
+const ee = te([
+  "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))), bn = ee[0], xn = ee[1], F = /* @__PURE__ */ new Uint32Array(80), O = /* @__PURE__ */ new Uint32Array(80);
+class yn extends gt {
+  constructor(t) {
+    super(128, t, 16, !1);
+  }
+  // prettier-ignore
+  get() {
+    const { Ah: t, Al: n, Bh: s, Bl: r, Ch: o, Cl: i, Dh: a, Dl: c, Eh: l, El: h, Fh: u, Fl: d, Gh: p, Gl: b, Hh: m, Hl: x } = this;
+    return [t, n, s, r, o, i, a, c, l, h, u, d, p, b, m, x];
+  }
+  // prettier-ignore
+  set(t, n, s, r, o, i, a, c, l, h, u, d, p, b, m, x) {
+    this.Ah = t | 0, this.Al = n | 0, this.Bh = s | 0, this.Bl = r | 0, this.Ch = o | 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 = p | 0, this.Gl = b | 0, this.Hh = m | 0, this.Hl = x | 0;
+  }
+  process(t, n) {
+    for (let y = 0; y < 16; y++, n += 4)
+      F[y] = t.getUint32(n), O[y] = t.getUint32(n += 4);
+    for (let y = 16; y < 80; y++) {
+      const P = F[y - 15] | 0, v = O[y - 15] | 0, T = R(P, v, 1) ^ R(P, v, 8) ^ Ft(P, v, 7), k = V(P, v, 1) ^ V(P, v, 8) ^ Ot(P, v, 7), I = F[y - 2] | 0, E = O[y - 2] | 0, X = R(I, E, 19) ^ Z(I, E, 61) ^ Ft(I, E, 6), ot = V(I, E, 19) ^ J(I, E, 61) ^ Ot(I, E, 6), G = cn(k, ot, O[y - 7], O[y - 16]), it = un(G, T, X, F[y - 7], F[y - 16]);
+      F[y] = it | 0, O[y] = G | 0;
+    }
+    let { Ah: s, Al: r, Bh: o, Bl: i, Ch: a, Cl: c, Dh: l, Dl: h, Eh: u, El: d, Fh: p, Fl: b, Gh: m, Gl: x, Hh: g, Hl: w } = this;
+    for (let y = 0; y < 80; y++) {
+      const P = R(u, d, 14) ^ R(u, d, 18) ^ Z(u, d, 41), v = V(u, d, 14) ^ V(u, d, 18) ^ J(u, d, 41), T = u & p ^ ~u & m, k = d & b ^ ~d & x, I = ln(w, v, k, xn[y], O[y]), E = hn(I, g, P, T, bn[y], F[y]), X = I | 0, ot = R(s, r, 28) ^ Z(s, r, 34) ^ Z(s, r, 39), G = V(s, r, 28) ^ J(s, r, 34) ^ J(s, r, 39), it = s & o ^ s & a ^ o & a, ce = r & i ^ r & c ^ i & c;
+      g = m | 0, w = x | 0, m = p | 0, x = b | 0, p = u | 0, b = d | 0, { h: u, l: d } = U(l | 0, h | 0, E | 0, X | 0), l = a | 0, h = c | 0, a = o | 0, c = i | 0, o = s | 0, i = r | 0;
+      const wt = on(X, G, ce);
+      s = an(wt, E, ot, it), r = wt | 0;
+    }
+    ({ h: s, l: r } = U(this.Ah | 0, this.Al | 0, s | 0, r | 0)), { h: o, l: i } = U(this.Bh | 0, this.Bl | 0, o | 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: p, l: b } = U(this.Fh | 0, this.Fl | 0, p | 0, b | 0), { h: m, l: x } = U(this.Gh | 0, this.Gl | 0, m | 0, x | 0), { h: g, l: w } = U(this.Hh | 0, this.Hl | 0, g | 0, w | 0), this.set(s, r, o, i, a, c, l, h, u, d, p, b, m, x, g, w);
+  }
+  roundClean() {
+    A(F, O);
+  }
+  destroy() {
+    A(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+class gn extends yn {
+  constructor() {
+    super(64);
+    f(this, "Ah", H[0] | 0);
+    f(this, "Al", H[1] | 0);
+    f(this, "Bh", H[2] | 0);
+    f(this, "Bl", H[3] | 0);
+    f(this, "Ch", H[4] | 0);
+    f(this, "Cl", H[5] | 0);
+    f(this, "Dh", H[6] | 0);
+    f(this, "Dl", H[7] | 0);
+    f(this, "Eh", H[8] | 0);
+    f(this, "El", H[9] | 0);
+    f(this, "Fh", H[10] | 0);
+    f(this, "Fl", H[11] | 0);
+    f(this, "Gh", H[12] | 0);
+    f(this, "Gl", H[13] | 0);
+    f(this, "Hh", H[14] | 0);
+    f(this, "Hl", H[15] | 0);
+  }
+}
+const mn = /* @__PURE__ */ rt(
+  () => new pn(),
+  /* @__PURE__ */ jt(1)
+), ne = /* @__PURE__ */ rt(
+  () => new gn(),
+  /* @__PURE__ */ jt(3)
+), wn = BigInt(0), M = BigInt(1), Pn = BigInt(2), Tn = BigInt(7), vn = BigInt(256), Hn = BigInt(113), se = [], re = [], oe = [];
+for (let e = 0, t = M, n = 1, s = 0; e < 24; e++) {
+  [n, s] = [s, (2 * n + 3 * s) % 5], se.push(2 * (5 * s + n)), re.push((e + 1) * (e + 2) / 2 % 64);
+  let r = wn;
+  for (let o = 0; o < 7; o++)
+    t = (t << M ^ (t >> Tn) * Hn) % vn, t & Pn && (r ^= M << (M << BigInt(o)) - M);
+  oe.push(r);
+}
+const ie = te(oe, !0), kn = ie[0], In = ie[1], Ct = (e, t, n) => n > 32 ? sn(e, t, n) : en(e, t, n), _t = (e, t, n) => n > 32 ? rn(e, t, n) : nn(e, t, n);
+function En(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 = Ct(l, h, 1) ^ n[a], d = _t(l, h, 1) ^ n[a + 1];
+      for (let p = 0; p < 50; p += 10)
+        e[i + p] ^= u, e[i + p + 1] ^= d;
+    }
+    let r = e[2], o = e[3];
+    for (let i = 0; i < 24; i++) {
+      const a = re[i], c = Ct(r, o, a), l = _t(r, o, a), h = se[i];
+      r = e[h], o = 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] ^= kn[s], e[1] ^= In[s];
+  }
+  A(n);
+}
+class mt {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(t, n, s, r = !1, o = 24) {
+    f(this, "state");
+    f(this, "pos", 0);
+    f(this, "posOut", 0);
+    f(this, "finished", !1);
+    f(this, "state32");
+    f(this, "destroyed", !1);
+    f(this, "blockLen");
+    f(this, "suffix");
+    f(this, "outputLen");
+    f(this, "enableXOF", !1);
+    f(this, "rounds");
+    if (this.blockLen = t, this.suffix = n, this.outputLen = s, this.enableXOF = r, this.rounds = o, C(s, "outputLen"), !(0 < t && t < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200), this.state32 = Re(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    Bt(this.state32), En(this.state32, this.rounds), Bt(this.state32), this.posOut = 0, this.pos = 0;
+  }
+  update(t) {
+    K(this), _(t);
+    const { blockLen: n, state: s } = this, r = t.length;
+    for (let o = 0; o < r; ) {
+      const i = Math.min(n - this.pos, r - o);
+      for (let a = 0; a < i; a++)
+        s[this.pos++] ^= t[o++];
+      this.pos === n && this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = !0;
+    const { state: t, suffix: n, pos: s, blockLen: r } = this;
+    t[s] ^= n, (n & 128) !== 0 && s === r - 1 && this.keccak(), t[r - 1] ^= 128, this.keccak();
+  }
+  writeInto(t) {
+    K(this, !1), _(t), this.finish();
+    const n = this.state, { blockLen: s } = this;
+    for (let r = 0, o = t.length; r < o; ) {
+      this.posOut >= s && this.keccak();
+      const i = Math.min(s - this.posOut, o - r);
+      t.set(n.subarray(this.posOut, this.posOut + i), r), this.posOut += i, r += 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 C(t), this.xofInto(new Uint8Array(t));
+  }
+  digestInto(t) {
+    if (Gt(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, A(this.state);
+  }
+  _cloneInto(t) {
+    const { blockLen: n, suffix: s, outputLen: r, rounds: o, enableXOF: i } = this;
+    return t || (t = new mt(n, s, r, i, o)), t.state32.set(this.state32), t.pos = this.pos, t.posOut = this.posOut, t.finished = this.finished, t.rounds = o, t.suffix = s, t.outputLen = r, t.enableXOF = i, t.destroyed = this.destroyed, t;
+  }
+}
+const Sn = (e, t, n, s = {}) => rt(() => new mt(t, e, n), s), An = /* @__PURE__ */ Sn(1, 136, 32);
+function Bn(e, t, n, s) {
+  Xt(e);
+  const r = Me({ dkLen: 32, asyncTick: 10 }, s), { c: o, dkLen: i, asyncTick: a } = r;
+  if (C(o, "c"), C(i, "dkLen"), C(a, "asyncTick"), o < 1)
+    throw new Error("iterations (c) must be >= 1");
+  const c = Ut(t, "password"), l = Ut(n, "salt"), h = new Uint8Array(i), u = yt.create(e, c), d = u._cloneInto().update(l);
+  return { c: o, dkLen: i, asyncTick: a, DK: h, PRF: u, PRFSalt: d };
+}
+function Un(e, t, n, s, r) {
+  return e.destroy(), t.destroy(), s && s.destroy(), A(r), n;
+}
+function Ln(e, t, n, s) {
+  const { c: r, dkLen: o, DK: i, PRF: a, PRFSalt: c } = Bn(e, t, n, s);
+  let l;
+  const h = new Uint8Array(4), u = et(h), d = new Uint8Array(a.outputLen);
+  for (let p = 1, b = 0; b < o; p++, b += a.outputLen) {
+    const m = i.subarray(b, b + a.outputLen);
+    u.setInt32(0, p, !1), (l = c._cloneInto(l)).update(h).digestInto(d), m.set(d.subarray(0, m.length));
+    for (let x = 1; x < r; x++) {
+      a._cloneInto(l).update(d).digestInto(d);
+      for (let g = 0; g < m.length; g++)
+        m[g] ^= d[g];
+    }
+  }
+  return Un(a, c, i, l, d);
+}
+function ae(e) {
+  if (typeof e != "string")
+    throw new TypeError("invalid mnemonic type: " + typeof e);
+  return e.normalize("NFKD");
+}
+function $n(e) {
+  const t = ae(e), n = t.split(" ");
+  if (![12, 15, 18, 21, 24].includes(n.length))
+    throw new Error("Invalid mnemonic");
+  return { nfkd: t, words: n };
+}
+const Fn = (e) => ae("mnemonic" + e);
+function On(e, t = "") {
+  return Ln(ne, $n(e).nfkd, Fn(t), { c: 2048, dkLen: 64 });
+}
+const Cn = 508, Rt = 16, Y = 32, Q = 64, Vt = 5, _n = 4;
+function N(...e) {
+  const t = e.reduce((r, o) => r + o.length, 0), n = new Uint8Array(t);
+  let s = 0;
+  for (const r of e)
+    n.set(r, s), s += r.length;
+  return n;
+}
+function ut(e) {
+  return new TextEncoder().encode(e);
+}
+function lt(e) {
+  const t = new Uint8Array(_n);
+  return new DataView(t.buffer).setUint32(0, e.length, !1), N(t, e);
+}
+function ht(e, t) {
+  return yt(ne, e, t);
+}
+function Wt(e) {
+  return Qe(mn(e));
+}
+const bt = (e) => Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("");
+function Rn(e) {
+  const t = On(e);
+  return new Uint8Array(t);
+}
+async function Vn(e, t, n, s) {
+  if (e.length !== Q)
+    throw new Error(
+      `Lamport seed must be ${Q} bytes, got ${e.length}`
+    );
+  t = W(t), n = W(n);
+  const r = e.slice(Y, Q), o = e.slice(0, Y), i = [r, o];
+  try {
+    const a = N(
+      lt(ut(t)),
+      lt(ut(n)),
+      lt(ut(s))
+    ), c = N(o, a);
+    i.push(c);
+    const l = ht(r, c);
+    i.push(l);
+    const h = l.slice(0, Y), u = l.slice(Y, Q);
+    i.push(h, u);
+    const d = [], p = [], b = [], m = [];
+    let x = !1;
+    try {
+      for (let g = 0; g < Cn; g++) {
+        const w = new Uint8Array(Vt);
+        w[0] = 0, new DataView(w.buffer).setUint32(1, g, !1);
+        const y = new Uint8Array(Vt);
+        y[0] = 1, new DataView(y.buffer).setUint32(1, g, !1);
+        const P = N(h, w), v = N(h, y), T = ht(u, P), k = ht(u, v);
+        try {
+          const I = T.slice(0, Rt), E = k.slice(0, Rt);
+          d.push(I), p.push(E), b.push(Wt(I)), m.push(Wt(E));
+        } finally {
+          P.fill(0), v.fill(0), T.fill(0), k.fill(0);
+        }
+      }
+      return x = !0, { falsePreimages: d, truePreimages: p, falseHashes: b, trueHashes: m };
+    } finally {
+      if (!x) {
+        for (const g of d) g.fill(0);
+        for (const g of p) g.fill(0);
+      }
+    }
+  } finally {
+    for (const a of i)
+      a.fill(0);
+  }
+}
+function as(e) {
+  return {
+    false_list: e.falseHashes.map(bt),
+    true_list: e.trueHashes.map(bt)
+  };
+}
+function Wn(e) {
+  if (e.falseHashes.length === 0 || e.trueHashes.length === 0)
+    throw new Error(
+      "computeLamportPkHash: 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 r = 0;
+  for (const i of e.falseHashes)
+    s.set(i, r), r += t;
+  for (const i of e.trueHashes)
+    s.set(i, r), r += t;
+  const o = An(s);
+  return `0x${bt(o)}`;
+}
+async function cs(e, t, n, s) {
+  const r = Rn(e);
+  try {
+    const o = await Vn(
+      r,
+      t,
+      n,
+      s
+    );
+    try {
+      return Wn(o);
+    } finally {
+      for (const i of o.falsePreimages) i.fill(0);
+      for (const i of o.truePreimages) i.fill(0);
+    }
+  } finally {
+    r.fill(0);
+  }
+}
+function us(e) {
+  const t = (e instanceof Error ? e.message : typeof e == "string" ? e : "").toLowerCase();
+  return t.includes("lamport") && t.includes("hash") && t.includes("does not match");
+}
+export {
+  cs as A,
+  tt as B,
+  D as C,
+  us as D,
+  Le as M,
+  os as P,
+  zn as a,
+  Zn as b,
+  St as c,
+  Jn as d,
+  Se as e,
+  Ae as f,
+  qn as g,
+  is as h,
+  es as i,
+  Qn as j,
+  ts as k,
+  ns as l,
+  Yn as m,
+  Fe as n,
+  Oe as o,
+  $e as p,
+  ct as q,
+  xt as r,
+  Ee as s,
+  ss as t,
+  rs as u,
+  At as v,
+  Rn as w,
+  Vn as x,
+  as as y,
+  Wn as z
+};
+//# sourceMappingURL=errors-D_DWT0CT.js.map