@babylonlabs-io/ts-sdk 0.15.0 → 0.15.2

package/dist/{errors-D19BQSaj.js → errors-C5aW6wrA.js}

@@ -1,12 +1,12 @@
-var ce = Object.defineProperty;
-var ue = (e, t, n) => t in e ? ce(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
-var d = (e, t, n) => ue(e, typeof t != "symbol" ? t + "" : t, n);
-import * as le from "bitcoinjs-lib";
-import { script as he, Transaction as q, address as fe, Psbt as dt } from "bitcoinjs-lib";
+var he = Object.defineProperty;
+var de = (e, t, n) => t in e ? he(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var p = (e, t, n) => de(e, typeof t != "symbol" ? t + "" : t, n);
+import * as fe from "bitcoinjs-lib";
+import { script as pe, Transaction as J, address as ge, Psbt as bt } from "bitcoinjs-lib";
 import { Buffer as S } from "buffer";
-import { P as de, y as pe, D as Vt, M as Tt, B as be, T as ge, G as pt, u as $, b as xe, A as ye, E as we, a as me, d as Pe, e as Te, f as ve, s as z, q as ke, x as vt, h as kt, i as Ht, r as He } from "./challengeAssert-CenzzhZU.js";
-import { createPublicClient as It, http as Et, encodeFunctionData as Ie, zeroAddress as Ee } from "viem";
-import { deriveVaultId as Se } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import { P as be, y as ye, D as Mt, M as Ht, B as xe, T as we, G as yt, u as B, b as me, A as Pe, E as Te, a as ve, d as ke, e as He, f as Ee, s as U, q as Ie, x as Et, h as It, i as St, r as Se } from "./challengeAssert-CenzzhZU.js";
+import { createPublicClient as lt, http as ht, encodeFunctionData as Bt, zeroAddress as Be } from "viem";
+import { deriveVaultId as At } from "@babylonlabs-io/babylon-tbv-rust-wasm";
 function Ae(e, t, n, s) {
   if (!Number.isInteger(s) || s < 1)
     throw new Error(
@@ -14,32 +14,32 @@ function Ae(e, t, n, s) {
     );
   if (e.length === 0)
     throw new Error("Insufficient funds: no UTXOs available");
-  const r = e.filter((u) => {
-    const h = S.from(u.scriptPubKey, "hex");
-    return !!he.decompile(h);
+  const o = e.filter((l) => {
+    const h = S.from(l.scriptPubKey, "hex");
+    return !!pe.decompile(h);
   });
-  if (r.length === 0)
+  if (o.length === 0)
     throw new Error(
       "Insufficient funds: no valid UTXOs available (all have invalid scripts)"
     );
-  const o = [...r].sort((u, h) => h.value - u.value), i = [];
+  const r = [...o].sort((l, h) => h.value - l.value), i = [];
   let a = 0n, c = 0n;
-  for (const u of o) {
-    i.push(u), a += BigInt(u.value);
-    const h = i.length * de, l = s * Tt, f = h + l + ge;
-    if (c = BigInt(Math.ceil(f * n)) + BigInt(pe(n)), a - t - c > Vt) {
-      const b = BigInt(
-        Math.ceil(Tt * n)
+  for (const l of r) {
+    i.push(l), a += BigInt(l.value);
+    const h = i.length * be, u = s * Ht, d = h + u + we;
+    if (c = BigInt(Math.ceil(d * n)) + BigInt(ye(n)), a - t - c > Mt) {
+      const g = BigInt(
+        Math.ceil(Ht * n)
       );
-      c += b;
+      c += g;
     }
     if (a >= t + c) {
-      const b = a - t - c;
+      const g = a - t - c;
       return {
         selectedUTXOs: i,
         totalValue: a,
         fee: c,
-        changeAmount: b
+        changeAmount: g
       };
     }
   }
@@ -47,17 +47,17 @@ function Ae(e, t, n, s) {
     `Insufficient funds: need ${t + c} sats (${t} pegin + ${c} fee), have ${a} sats`
   );
 }
-function Zn(e) {
-  return e > Vt;
+function Jn(e) {
+  return e > Mt;
 }
-function Jn() {
-  return be;
+function Yn() {
+  return xe;
 }
-function St(e) {
+function dt(e) {
   const t = e.startsWith("0x") ? e.slice(2) : e;
-  return `0x${q.fromHex(t).getId()}`;
+  return `0x${J.fromHex(t).getId()}`;
 }
-function Yn(e, t, n) {
+function Qn(e, t, n) {
   if (e.length === 0)
     throw new Error("No input UTXOs provided for split transaction");
   if (t.length === 0)
@@ -67,43 +67,43 @@ function Yn(e, t, n) {
       throw new Error(
         `Invalid output amount for ${c.address}: ${c.amount} satoshis. Amount must be greater than zero.`
       );
-  const s = pt(n), r = new q();
-  r.version = 2;
+  const s = yt(n), o = new J();
+  o.version = 2;
   for (const c of e) {
-    const u = S.from(c.txid, "hex").reverse();
-    r.addInput(u, c.vout);
+    const l = S.from(c.txid, "hex").reverse();
+    o.addInput(l, c.vout);
   }
-  const o = [];
+  const r = [];
   for (let c = 0; c < t.length; c++) {
-    const u = t[c];
+    const l = t[c];
     let h;
     try {
-      h = fe.toOutputScript(u.address, s);
-    } catch (l) {
+      h = ge.toOutputScript(l.address, s);
+    } catch (u) {
       throw new Error(
-        `Failed to decode address "${u.address}": ${l instanceof Error ? l.message : String(l)}`
+        `Failed to decode address "${l.address}": ${u instanceof Error ? u.message : String(u)}`
       );
     }
-    r.addOutput(h, Number(u.amount)), o.push({
+    o.addOutput(h, Number(l.amount)), r.push({
       txid: "",
       // Will be set after txid calculation
       vout: c,
-      value: Number(u.amount),
+      value: Number(l.amount),
       scriptPubKey: h.toString("hex")
     });
   }
-  const i = r.toHex(), a = r.getId();
-  for (const c of o)
+  const i = o.toHex(), a = o.getId();
+  for (const c of r)
     c.txid = a;
   return {
     txHex: i,
     txid: a,
-    outputs: o
+    outputs: r
   };
 }
-function Qn(e, t, n) {
-  const s = q.fromHex(e), r = new dt();
-  if (r.setVersion(s.version), r.setLocktime(s.locktime), !S.isBuffer(n) || n.length !== 32)
+function ts(e, t, n) {
+  const s = J.fromHex(e), o = new bt();
+  if (o.setVersion(s.version), o.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}`
     );
@@ -111,42 +111,42 @@ function Qn(e, t, n) {
     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];
+  for (let r = 0; r < s.ins.length; r++) {
+    const i = s.ins[r], a = t[r];
     if (!a)
-      throw new Error(`Missing UTXO data for input ${o}`);
-    const c = S.from(i.hash).reverse().toString("hex"), u = i.index;
-    if (a.txid !== c || a.vout !== u)
+      throw new Error(`Missing UTXO data for input ${r}`);
+    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}:${u}, but UTXO ${a.txid}:${a.vout} was provided. Ensure inputs array matches the order used in createSplitTransaction().`
+        `Input ${r} 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)}...`
+        `Input ${r} must be P2TR (Taproot). createSplitTransactionPsbt() requires P2TR inputs because it uses tapInternalKey for Taproot signing. ScriptPubKey: ${a.scriptPubKey.substring(0, 20)}...`
       );
-    const f = {
+    const d = {
       script: S.from(a.scriptPubKey, "hex"),
       value: a.value
     };
-    r.addInput({
+    o.addInput({
       hash: i.hash,
       index: i.index,
       sequence: i.sequence,
-      witnessUtxo: f,
+      witnessUtxo: d,
       tapInternalKey: n
     });
   }
-  for (const o of s.outs)
-    r.addOutput({
-      script: o.script,
-      value: o.value
+  for (const r of s.outs)
+    o.addOutput({
+      script: r.script,
+      value: r.value
     });
-  return r.toHex();
+  return o.toHex();
 }
-var st = /* @__PURE__ */ ((e) => (e.P2PKH = "P2PKH", e.P2SH = "P2SH", e.P2WPKH = "P2WPKH", e.P2WSH = "P2WSH", e.P2TR = "P2TR", e.UNKNOWN = "UNKNOWN", e))(st || {});
-function Be(e) {
+var rt = /* @__PURE__ */ ((e) => (e.P2PKH = "P2PKH", e.P2SH = "P2SH", e.P2WPKH = "P2WPKH", e.P2WSH = "P2WSH", e.P2TR = "P2TR", e.UNKNOWN = "UNKNOWN", e))(rt || {});
+function $e(e) {
   const t = e.length;
   return t === 25 && e[0] === 118 && // OP_DUP
   e[1] === 169 && // OP_HASH160
@@ -159,17 +159,17 @@ function Be(e) {
   e[1] === 32 ? "P2WSH" : t === 34 && e[0] === 81 && // OP_1
   e[1] === 32 ? "P2TR" : "UNKNOWN";
 }
-function $e(e, t) {
-  const n = S.from(e.scriptPubKey, "hex"), s = Be(n);
+function Ue(e, t) {
+  const n = S.from(e.scriptPubKey, "hex"), s = $e(n);
   switch (s) {
-    case st.P2WPKH:
+    case rt.P2WPKH:
       return {
         witnessUtxo: {
           script: n,
           value: e.value
         }
       };
-    case st.P2WSH: {
+    case rt.P2WSH: {
       if (!e.witnessScript)
         throw new Error("Missing witnessScript for P2WSH input");
       return {
@@ -180,7 +180,7 @@ function $e(e, t) {
         witnessScript: S.from(e.witnessScript, "hex")
       };
     }
-    case st.P2TR: {
+    case rt.P2TR: {
       if (t && t.length !== 32)
         throw new Error(
           `Invalid tapInternalKey length: expected 32 bytes, got ${t.length}`
@@ -198,7 +198,7 @@ function $e(e, t) {
       throw new Error(`Unsupported script type: ${s}`);
   }
 }
-function bt(e, t) {
+function xt(e, t) {
   if (!Number.isInteger(t) || t < 1)
     throw new Error(`inputCount must be a positive integer, got ${t}`);
   return {
@@ -210,14 +210,14 @@ function bt(e, t) {
     }))
   };
 }
-const Ue = 21e6 * 1e8, Kt = 1e4;
-function Dt(e) {
-  return Number.isInteger(e) && e > 0 && e <= Ue;
+const Fe = 21e6 * 1e8, Nt = 1e4;
+function Xt(e) {
+  return Number.isInteger(e) && e > 0 && e <= Fe;
 }
-function Fe(e) {
-  return Number.isInteger(e) && e > 0 && e <= Kt;
+function Ce(e) {
+  return Number.isInteger(e) && e > 0 && e <= Nt;
 }
-function Mt(e, t) {
+function qt(e, t) {
   return !Number.isInteger(e) || e < 0 ? !1 : t === void 0 || e < t;
 }
 const Oe = {
@@ -225,13 +225,13 @@ const Oe = {
   testnet: "https://mempool.space/testnet/api",
   signet: "https://mempool.space/signet/api"
 };
-async function ot(e, t) {
+async function at(e, t) {
   try {
     const n = await fetch(e, t);
     if (!n.ok) {
-      const r = await n.text();
+      const o = await n.text();
       throw new Error(
-        `Mempool API error (${n.status}): ${r || n.statusText}`
+        `Mempool API error (${n.status}): ${o || n.statusText}`
       );
     }
     const s = n.headers.get("content-type");
@@ -250,15 +250,15 @@ async function Le(e, t) {
       }
     });
     if (!n.ok) {
-      const r = await n.text();
-      let o;
+      const o = await n.text();
+      let r;
       try {
-        o = JSON.parse(r).message;
+        r = JSON.parse(o).message;
       } catch {
-        o = r;
+        r = o;
       }
       throw new Error(
-        o || `Failed to broadcast transaction: ${n.statusText}`
+        r || `Failed to broadcast transaction: ${n.statusText}`
       );
     }
     return await n.text();
@@ -266,10 +266,10 @@ async function Le(e, t) {
     throw n instanceof Error ? new Error(`Failed to broadcast BTC transaction: ${n.message}`) : new Error("Failed to broadcast BTC transaction: Unknown error");
   }
 }
-async function Ce(e, t) {
-  return ot(`${t}/tx/${e}`);
+async function _e(e, t) {
+  return at(`${t}/tx/${e}`);
 }
-async function ts(e, t) {
+async function es(e, t) {
   try {
     const n = await fetch(`${t}/tx/${e}/hex`);
     if (!n.ok) {
@@ -283,43 +283,43 @@ async function ts(e, t) {
     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 _e(e, t, n) {
-  const s = await Ce(e, n);
-  if (!Mt(t, s.vout.length))
+async function Re(e, t, n) {
+  const s = await _e(e, n);
+  if (!qt(t, s.vout.length))
     throw new Error(
       `Invalid vout ${t} for transaction ${e} (has ${s.vout.length} outputs)`
     );
-  const r = s.vout[t];
-  if (!Dt(r.value))
-    throw new Error(`Invalid UTXO value ${r.value} for ${e}:${t}`);
+  const o = s.vout[t];
+  if (!Xt(o.value))
+    throw new Error(`Invalid UTXO value ${o.value} for ${e}:${t}`);
   return {
     txid: e,
     vout: t,
-    value: r.value,
-    scriptPubKey: r.scriptpubkey
+    value: o.value,
+    scriptPubKey: o.scriptpubkey
   };
 }
-async function es(e, t) {
+async function ns(e, t) {
   try {
-    const n = await ot(`${t}/address/${e}/utxo`), s = await ot(`${t}/v1/validate-address/${e}`);
+    const n = await at(`${t}/address/${e}/utxo`), s = await at(`${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 (!Mt(o.vout))
-        throw new Error(`Invalid vout ${o.vout} for ${o.txid}`);
-      if (!Dt(o.value))
+    for (const r of n) {
+      if (!qt(r.vout))
+        throw new Error(`Invalid vout ${r.vout} for ${r.txid}`);
+      if (!Xt(r.value))
         throw new Error(
-          `Invalid UTXO value ${o.value} for ${o.txid}:${o.vout}`
+          `Invalid UTXO value ${r.value} for ${r.txid}:${r.vout}`
         );
     }
-    return n.sort((o, i) => i.value - o.value).map((o) => ({
-      txid: o.txid,
-      vout: o.vout,
-      value: o.value,
+    return n.sort((r, i) => i.value - r.value).map((r) => ({
+      txid: r.txid,
+      vout: r.vout,
+      value: r.value,
       scriptPubKey: s.scriptPubKey,
-      confirmed: o.status.confirmed
+      confirmed: r.status.confirmed
     }));
   } catch (n) {
     throw n instanceof Error ? new Error(
@@ -329,11 +329,11 @@ async function es(e, t) {
     );
   }
 }
-function ns(e) {
+function ss(e) {
   return Oe[e];
 }
-async function ss(e, t) {
-  return ot(`${t}/address/${e}/txs`);
+async function os(e, t) {
+  return at(`${t}/address/${e}/txs`);
 }
 async function rs(e) {
   const t = await fetch(`${e}/v1/fees/recommended`);
@@ -348,10 +348,10 @@ async function rs(e) {
     "economyFee",
     "minimumFee"
   ];
-  for (const r of s)
-    if (!Fe(n[r]))
+  for (const o of s)
+    if (!Ce(n[o]))
       throw new Error(
-        `Invalid fee rate ${r}=${n[r]} from mempool API: expected a positive number ≤ ${Kt}`
+        `Invalid fee rate ${o}=${n[o]} from mempool API: expected a positive number ≤ ${Nt}`
       );
   if (n.minimumFee > n.economyFee || n.economyFee > n.hourFee || n.hourFee > n.halfHourFee || n.halfHourFee > n.fastestFee)
     throw new Error(
@@ -359,7 +359,7 @@ async function rs(e) {
     );
   return n;
 }
-const ct = [
+const j = [
   {
     type: "function",
     name: "submitPeginRequest",
@@ -493,6 +493,34 @@ const ct = [
     ],
     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",
@@ -624,7 +652,7 @@ const ct = [
     name: "PeginSignaturesIncomplete",
     inputs: []
   }
-], N = {
+], 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
@@ -654,7 +682,7 @@ const ct = [
   // 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) {
+function mt(e) {
   if (!e || typeof e != "object") return;
   const t = e;
   if (typeof t.data == "string" && t.data.startsWith("0x"))
@@ -662,8 +690,8 @@ function xt(e) {
   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 o = 5;
+  for (; n && typeof n == "object" && s < o; ) {
     const a = n;
     if (typeof a.data == "string" && a.data.startsWith("0x"))
       return a.data;
@@ -673,26 +701,26 @@ function xt(e) {
   if (i)
     return i[1];
 }
-function os(e) {
-  const t = xt(e);
+function is(e) {
+  const t = mt(e);
   if (t) {
     const n = t.substring(0, 10);
-    return N[t] ?? N[n];
+    return q[t] ?? q[n];
   }
 }
-function is(e) {
-  const t = xt(e);
+function as(e) {
+  const t = mt(e);
   if (t === void 0) return !1;
   const n = t.substring(0, 10);
-  return t in N || n in N;
+  return t in q || n in q;
 }
-function ut(e) {
+function M(e) {
   console.error("[Contract Error] Raw error:", e);
-  const t = xt(e);
+  const t = mt(e);
   if (console.error("[Contract Error] Extracted error data:", t), t) {
-    const s = t.substring(0, 10), r = N[t] ?? N[s];
-    if (r)
-      throw console.error("[Contract Error] Known error:", r), new Error(r);
+    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")) {
@@ -708,24 +736,25 @@ function ut(e) {
   }
   throw e instanceof Error ? (console.error("[Contract Error] Unhandled error:", e.message), e) : new Error(`Contract call failed: ${String(e)}`);
 }
-function We(e, t, n, s) {
-  const r = n == null ? void 0 : n[`${e}:${t}`];
-  return r ? Promise.resolve({
+const We = 0;
+function Ve(e, t, n, s) {
+  const o = n == null ? void 0 : n[`${e}:${t}`];
+  return o ? Promise.resolve({
     txid: e,
     vout: t,
-    value: r.value,
-    scriptPubKey: r.scriptPubKey
-  }) : _e(e, t, s);
+    value: o.value,
+    scriptPubKey: o.scriptPubKey
+  }) : Re(e, t, s);
 }
-const Re = 12e4;
-class as {
+const $t = 12e4;
+class cs {
   /**
    * Creates a new PeginManager instance.
    *
    * @param config - Manager configuration including wallets and contract addresses
    */
   constructor(t) {
-    d(this, "config");
+    p(this, "config");
     this.config = t;
   }
   /**
@@ -749,17 +778,17 @@ class as {
    * @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 = $(t.vaultProviderBtcPubkey), o = t.vaultKeeperBtcPubkeys.map($), i = t.universalChallengerBtcPubkeys.map($);
+    const n = await this.config.btcWallet.getPublicKeyHex(), s = n.length === 66 ? n.slice(2) : n, o = B(t.vaultProviderBtcPubkey), r = t.vaultKeeperBtcPubkeys.map(B), i = t.universalChallengerBtcPubkeys.map(B);
     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 = o.length, c = {
+    const a = r.length, c = {
       depositorPubkey: s,
-      vaultProviderPubkey: r,
-      vaultKeeperPubkeys: o,
+      vaultProviderPubkey: o,
+      vaultKeeperPubkeys: r,
       universalChallengerPubkeys: i,
       hashlocks: t.hashlocks,
       timelockRefund: t.timelockRefund,
@@ -769,62 +798,62 @@ class as {
       councilQuorum: t.councilQuorum,
       councilSize: t.councilSize,
       network: this.config.btcNetwork
-    }, u = await xe(c), h = Ae(
+    }, l = await me(c), h = Ae(
       [...t.availableUTXOs],
-      u.totalOutputValue,
+      l.totalOutputValue,
       t.mempoolFeeRate,
-      ye(u.htlcValues.length)
-    ), l = pt(this.config.btcNetwork), f = we({
-      unfundedTxHex: u.psbtHex,
+      Pe(l.htlcValues.length)
+    ), u = yt(this.config.btcNetwork), d = Te({
+      unfundedTxHex: l.psbtHex,
       selectedUTXOs: h.selectedUTXOs,
       changeAddress: t.changeAddress,
       changeAmount: h.changeAmount,
-      network: l
-    }), g = $(St(f)), b = [], w = [], x = [];
-    for (let p = 0; p < t.hashlocks.length; p++) {
-      const P = await me({
+      network: u
+    }), y = B(dt(d)), g = [], x = [], P = [];
+    for (let f = 0; f < t.hashlocks.length; f++) {
+      const w = await ve({
         prePeginParams: c,
         timelockPegin: t.timelockPegin,
-        fundedPrePeginTxHex: f,
-        htlcVout: p
-      }), v = await Pe({
-        peginTxHex: P.txHex,
-        fundedPrePeginTxHex: f,
+        fundedPrePeginTxHex: d,
+        htlcVout: f
+      }), v = await ke({
+        peginTxHex: w.txHex,
+        fundedPrePeginTxHex: d,
         depositorPubkey: s,
-        vaultProviderPubkey: r,
-        vaultKeeperPubkeys: o,
+        vaultProviderPubkey: o,
+        vaultKeeperPubkeys: r,
         universalChallengerPubkeys: i,
-        hashlock: t.hashlocks[p],
+        hashlock: t.hashlocks[f],
         timelockRefund: t.timelockRefund,
         network: this.config.btcNetwork
       });
-      b.push(P), w.push(v.psbtHex), x.push(
-        bt(n, 1)
+      g.push(w), x.push(v.psbtHex), P.push(
+        xt(n, 1)
       );
     }
-    const y = await this.signPsbtsWithFallback(
-      w,
-      x
-    ), m = [];
-    for (let p = 0; p < y.length; p++) {
-      const P = Te(
-        y[p],
+    const m = await this.signPsbtsWithFallback(
+      x,
+      P
+    ), b = [];
+    for (let f = 0; f < m.length; f++) {
+      const w = He(
+        m[f],
         s
-      ), v = ve(y[p]);
-      m.push({
-        htlcVout: p,
-        htlcValue: u.htlcValues[p],
+      ), v = Ee(m[f]);
+      b.push({
+        htlcVout: f,
+        htlcValue: l.htlcValues[f],
         peginTxHex: v,
-        peginTxid: b[p].txid,
-        peginInputSignature: P,
-        vaultScriptPubKey: b[p].vaultScriptPubKey
+        peginTxid: g[f].txid,
+        peginInputSignature: w,
+        vaultScriptPubKey: g[f].vaultScriptPubKey
       });
     }
     return {
-      fundedPrePeginTxHex: f,
-      prePeginTxid: g,
-      unsignedPrePeginTxHex: u.psbtHex,
-      perVault: m,
+      fundedPrePeginTxHex: d,
+      prePeginTxid: y,
+      unsignedPrePeginTxHex: l.psbtHex,
+      perVault: b,
       selectedUTXOs: h.selectedUTXOs,
       fee: h.fee,
       changeAmount: h.changeAmount
@@ -839,23 +868,23 @@ class as {
    */
   async signPsbtsWithFallback(t, n) {
     if (typeof this.config.btcWallet.signPsbts == "function") {
-      const r = await this.config.btcWallet.signPsbts(
+      const o = await this.config.btcWallet.signPsbts(
         t,
         n
       );
-      if (r.length !== t.length)
+      if (o.length !== t.length)
         throw new Error(
-          `Expected ${t.length} signed PSBTs but received ${r.length}`
+          `Expected ${t.length} signed PSBTs but received ${o.length}`
         );
-      return r;
+      return o;
     }
     const s = [];
-    for (let r = 0; r < t.length; r++) {
-      const o = await this.config.btcWallet.signPsbt(
-        t[r],
-        n[r]
+    for (let o = 0; o < t.length; o++) {
+      const r = await this.config.btcWallet.signPsbt(
+        t[o],
+        n[o]
       );
-      s.push(o);
+      s.push(r);
     }
     return s;
   }
@@ -875,11 +904,11 @@ class as {
    * @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 = q.fromHex(r);
-    if (o.ins.length === 0)
+    const { fundedPrePeginTxHex: n, depositorBtcPubkey: s } = t, o = n.startsWith("0x") ? n.slice(2) : n, r = J.fromHex(o);
+    if (r.ins.length === 0)
       throw new Error("Transaction has no inputs");
-    const i = new dt();
-    i.setVersion(o.version), i.setLocktime(o.locktime);
+    const i = new bt();
+    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(
@@ -890,45 +919,55 @@ class as {
       throw new Error(
         `Invalid depositorBtcPubkey length: expected 32 bytes, got ${c.length}`
       );
-    const u = this.config.mempoolApiUrl, h = o.ins.map((x) => {
-      const y = S.from(x.hash).reverse().toString("hex"), m = x.index;
-      return We(y, m, t.localPrevouts, u).then(
-        (p) => ({ input: x, utxoData: p, txid: y, vout: m })
+    const l = this.config.mempoolApiUrl, h = r.ins.map((b) => {
+      const f = S.from(b.hash).reverse().toString("hex"), w = b.index;
+      return Ve(f, w, t.localPrevouts, l).then(
+        (v) => ({ input: b, utxoData: v, txid: f, vout: w })
+      );
+    }), u = await Promise.all(h), d = u.reduce(
+      (b, f) => b + BigInt(f.utxoData.value),
+      0n
+    ), y = r.outs.reduce(
+      (b, f) => b + BigInt(f.value),
+      0n
+    );
+    if (d < y)
+      throw new Error(
+        `UTXO value mismatch: total input value (${d} sat) is less than total output value (${y} sat). This may indicate the mempool API returned manipulated UTXO data.`
       );
-    }), l = await Promise.all(h);
-    for (const { input: x, utxoData: y, txid: m, vout: p } of l) {
-      const P = $e(
+    for (const { input: b, utxoData: f, txid: w, vout: v } of u) {
+      const T = Ue(
         {
-          value: y.value,
-          scriptPubKey: y.scriptPubKey
+          value: f.value,
+          scriptPubKey: f.scriptPubKey
         },
         c
       );
       i.addInput({
-        hash: x.hash,
-        index: x.index,
-        sequence: x.sequence,
-        ...P
+        hash: b.hash,
+        index: b.index,
+        sequence: b.sequence,
+        ...T
       });
     }
-    for (const x of o.outs)
+    for (const b of r.outs)
       i.addOutput({
-        script: x.script,
-        value: x.value
+        script: b.script,
+        value: b.value
       });
-    const f = await this.config.btcWallet.signPsbt(i.toHex()), g = dt.fromHex(f);
+    const g = await this.config.btcWallet.signPsbt(i.toHex()), x = bt.fromHex(g);
     try {
-      g.finalizeAllInputs();
-    } catch (x) {
-      if (!g.data.inputs.every(
-        (m) => m.finalScriptWitness || m.finalScriptSig
+      x.finalizeAllInputs();
+    } catch (b) {
+      if (!x.data.inputs.every(
+        (w) => w.finalScriptWitness || w.finalScriptSig
       ))
         throw new Error(
-          `PSBT finalization failed and wallet did not auto-finalize: ${x}`
+          `PSBT finalization failed and wallet did not auto-finalize: ${b}`
         );
     }
-    const b = g.extractTransaction().toHex();
-    return await Le(b, u);
+    const P = x.extractTransaction().toHex();
+    return await Le(P, l);
   }
   /**
    * Registers a peg-in on Ethereum by calling the BTCVaultRegistry contract.
@@ -951,62 +990,62 @@ class as {
     const {
       depositorBtcPubkey: n,
       unsignedPrePeginTx: s,
-      depositorSignedPeginTx: r,
-      vaultProvider: o,
+      depositorSignedPeginTx: o,
+      vaultProvider: r,
       hashlock: i,
       htlcVout: a,
       onPopSigned: c,
-      depositorPayoutBtcAddress: u,
+      depositorPayoutBtcAddress: l,
       depositorWotsPkHash: h,
-      preSignedBtcPopSignature: l
+      preSignedBtcPopSignature: u
     } = t;
     if (!this.config.ethWallet.account)
       throw new Error("Ethereum wallet account not found");
-    const f = this.config.ethWallet.account.address, g = await this.resolvePopSignature(
-      f,
-      l
+    const d = this.config.ethWallet.account.address, y = await this.resolvePopSignature(
+      d,
+      u
     );
     c && await c();
-    const b = z(n), w = z(s), x = z(r), y = await this.resolvePayoutScriptPubKey(
-      u
-    ), m = St(x), p = await Se(
-      $(m),
-      $(f)
-    ), P = z(p);
-    if (await this.checkVaultExists(P))
+    const g = U(n), x = U(s), P = U(o), m = await this.resolvePayoutScriptPubKey(
+      l
+    ), b = dt(P), f = await At(
+      B(b),
+      B(d)
+    ), w = U(f);
+    if (await this.checkVaultExists(w))
       throw new Error(
-        `Vault already exists (ID: ${P}, peginTxHash: ${m}). 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.`
+        `Vault already exists (ID: ${w}, 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 = It({
+    const T = lt({
       chain: this.config.ethChain,
-      transport: Et()
+      transport: ht()
     });
-    let E;
+    let H;
     try {
-      E = await T.readContract({
+      H = await T.readContract({
         address: this.config.vaultContracts.btcVaultRegistry,
-        abi: ct,
+        abi: j,
         functionName: "getPegInFee",
-        args: [o]
+        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 H = Ie({
-      abi: ct,
+    const E = Bt({
+      abi: j,
       functionName: "submitPeginRequest",
       args: [
-        f,
-        b,
+        d,
         g,
-        w,
+        y,
         x,
-        o,
+        P,
+        r,
         i,
         a,
-        y,
+        m,
         h
       ]
     });
@@ -1014,39 +1053,151 @@ class as {
     try {
       I = await T.estimateGas({
         to: this.config.vaultContracts.btcVaultRegistry,
-        data: H,
-        value: E,
+        data: E,
+        value: H,
         account: this.config.ethWallet.account.address
       });
     } catch (O) {
-      ut(O);
+      M(O);
     }
-    let F;
+    let C;
     try {
-      F = await this.config.ethWallet.sendTransaction({
+      C = await this.config.ethWallet.sendTransaction({
         to: this.config.vaultContracts.btcVaultRegistry,
-        data: H,
-        value: E,
+        data: E,
+        value: H,
         account: this.config.ethWallet.account,
         chain: this.config.ethChain,
         gas: I
       });
     } catch (O) {
-      ut(O);
+      M(O);
     }
-    const K = await T.waitForTransactionReceipt({
-      hash: F,
-      timeout: Re
+    const D = await T.waitForTransactionReceipt({
+      hash: C,
+      timeout: $t
     });
-    return K.status === "reverted" && ut(
+    return D.status === "reverted" && M(
       new Error(
-        `Transaction reverted. Hash: ${F}. Check the transaction on block explorer for details.`
+        `Transaction reverted. Hash: ${C}. Check the transaction on block explorer for details.`
       )
     ), {
-      ethTxHash: K.transactionHash,
-      vaultId: P,
-      peginTxHash: m,
-      btcPopSignature: g
+      ethTxHash: D.transactionHash,
+      vaultId: w,
+      peginTxHash: b,
+      btcPopSignature: y
+    };
+  }
+  /**
+   * Register multiple pegins on Ethereum in a single transaction.
+   *
+   * Uses the contract's submitPeginRequestBatch() to submit all vault
+   * registrations atomically. All vaults must share the same vault provider.
+   * The PoP signature is signed once and included in each request.
+   *
+   * @param params - Batch registration parameters
+   * @returns Batch result with per-vault IDs and single ETH tx hash
+   */
+  async registerPeginBatchOnChain(t) {
+    const { vaultProvider: n, requests: s, preSignedBtcPopSignature: o, onPopSigned: r } = t;
+    if (s.length === 0)
+      throw new Error("Batch pegin requires at least one request");
+    if (!this.config.ethWallet.account)
+      throw new Error("Ethereum wallet account not found");
+    const i = this.config.ethWallet.account.address, a = await this.resolvePopSignature(
+      i,
+      o
+    );
+    r && await r();
+    const c = [];
+    for (const b of s)
+      c.push(
+        await this.resolvePayoutScriptPubKey(b.depositorPayoutBtcAddress)
+      );
+    const l = [];
+    for (const b of s) {
+      const f = U(
+        b.depositorSignedPeginTx
+      ), w = dt(f), v = await At(
+        B(w),
+        B(i)
+      ), T = U(v);
+      if (await this.checkVaultExists(T))
+        throw new Error(
+          `Vault already exists (ID: ${T}, peginTxHash: ${w}). To create a new vault, use different UTXOs or a different amount.`
+        );
+      l.push({ vaultId: T, peginTxHash: w });
+    }
+    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), y = s.map((b, f) => ({
+      depositorBtcPubKey: U(b.depositorBtcPubkey),
+      btcPopSignature: a,
+      unsignedPrePeginTx: U(b.unsignedPrePeginTx),
+      depositorSignedPeginTx: U(
+        b.depositorSignedPeginTx
+      ),
+      hashlock: b.hashlock,
+      htlcVout: b.htlcVout,
+      referralCode: We,
+      depositorPayoutBtcAddress: c[f],
+      depositorWotsPkHash: b.depositorWotsPkHash
+    })), g = Bt({
+      abi: j,
+      functionName: "submitPeginRequestBatch",
+      args: [i, n, y]
+    });
+    let x;
+    try {
+      x = await h.estimateGas({
+        to: this.config.vaultContracts.btcVaultRegistry,
+        data: g,
+        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: g,
+        value: d,
+        account: this.config.ethWallet.account,
+        chain: this.config.ethChain,
+        gas: x
+      });
+    } catch (b) {
+      M(b);
+    }
+    const m = await h.waitForTransactionReceipt({
+      hash: P,
+      timeout: $t
+    });
+    return m.status === "reverted" && M(
+      new Error(
+        `Batch transaction reverted. Hash: ${P}. Check the transaction on block explorer for details.`
+      )
+    ), {
+      ethTxHash: m.transactionHash,
+      vaults: l,
+      btcPopSignature: a
     };
   }
   /**
@@ -1057,15 +1208,15 @@ class as {
    */
   async checkVaultExists(t) {
     try {
-      return (await It({
+      return (await lt({
         chain: this.config.ethChain,
-        transport: Et()
+        transport: ht()
       }).readContract({
         address: this.config.vaultContracts.btcVaultRegistry,
-        abi: ct,
+        abi: j,
         functionName: "getBTCVault",
         args: [t]
-      })).depositor !== Ee;
+      })).depositor !== Be;
     } catch {
       return !1;
     }
@@ -1083,19 +1234,19 @@ class as {
       n = t;
     else {
       n = await this.config.btcWallet.getAddress();
-      const r = await this.config.btcWallet.getPublicKeyHex();
-      if (!ke(
+      const o = await this.config.btcWallet.getPublicKeyHex();
+      if (!Ie(
         n,
-        r,
+        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 = pt(this.config.btcNetwork);
+    const s = yt(this.config.btcNetwork);
     try {
-      return `0x${le.address.toOutputScript(n, s).toString("hex")}`;
+      return `0x${fe.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.`
@@ -1111,11 +1262,11 @@ class as {
   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,
+    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 o.startsWith("0x") ? o : `0x${S.from(o, "base64").toString("hex")}`;
+    return r.startsWith("0x") ? r : `0x${S.from(r, "base64").toString("hex")}`;
   }
   /**
    * Gets the configured Bitcoin network.
@@ -1134,14 +1285,14 @@ class as {
     return this.config.vaultContracts.btcVaultRegistry;
   }
 }
-class cs {
+class us {
   /**
    * Creates a new PayoutManager instance.
    *
    * @param config - Manager configuration including wallet
    */
   constructor(t) {
-    d(this, "config");
+    p(this, "config");
     this.config = t;
   }
   /**
@@ -1171,10 +1322,10 @@ class cs {
       t.payoutTxHex,
       t.registeredPayoutScriptPubKey
     );
-    const n = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: s } = vt(
+    const n = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: s } = Et(
       n,
       t.depositorBtcPubkey
-    ), r = await kt({
+    ), o = await It({
       payoutTxHex: t.payoutTxHex,
       peginTxHex: t.peginTxHex,
       assertTxHex: t.assertTxHex,
@@ -1184,12 +1335,12 @@ class cs {
       universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
       timelockPegin: t.timelockPegin,
       network: this.config.network
-    }), o = await this.config.btcWallet.signPsbt(
-      r.psbtHex,
-      bt(n, 1)
+    }), r = await this.config.btcWallet.signPsbt(
+      o.psbtHex,
+      xt(n, 1)
     );
     return {
-      signature: Ht(o, s),
+      signature: St(r, s),
       depositorBtcPubkey: s
     };
   }
@@ -1223,33 +1374,33 @@ class cs {
       throw new Error(
         "Wallet does not support batch signing (signPsbts method not available)"
       );
-    const n = await this.config.btcWallet.getPublicKeyHex(), s = [], r = [], o = [];
+    const n = await this.config.btcWallet.getPublicKeyHex(), s = [], o = [], r = [];
     for (const c of t) {
       this.validatePayoutOutputs(
         c.payoutTxHex,
         c.registeredPayoutScriptPubKey
       );
-      const { depositorPubkey: u } = vt(
+      const { depositorPubkey: l } = Et(
         n,
         c.depositorBtcPubkey
       );
-      o.push(u);
-      const h = await kt({
+      r.push(l);
+      const h = await It({
         payoutTxHex: c.payoutTxHex,
         peginTxHex: c.peginTxHex,
         assertTxHex: c.assertTxHex,
-        depositorBtcPubkey: u,
+        depositorBtcPubkey: l,
         vaultProviderBtcPubkey: c.vaultProviderBtcPubkey,
         vaultKeeperBtcPubkeys: c.vaultKeeperBtcPubkeys,
         universalChallengerBtcPubkeys: c.universalChallengerBtcPubkeys,
         timelockPegin: c.timelockPegin,
         network: this.config.network
       });
-      s.push(h.psbtHex), r.push(bt(n, 1));
+      s.push(h.psbtHex), o.push(xt(n, 1));
     }
     const i = await this.config.btcWallet.signPsbts(
       s,
-      r
+      o
     );
     if (i.length !== t.length)
       throw new Error(
@@ -1257,13 +1408,13 @@ class cs {
       );
     const a = [];
     for (let c = 0; c < t.length; c++) {
-      const u = o[c], h = Ht(
+      const l = r[c], h = St(
         i[c],
-        u
+        l
       );
       a.push({
         payoutSignature: h,
-        depositorBtcPubkey: u
+        depositorBtcPubkey: l
       });
     }
     return a;
@@ -1283,17 +1434,17 @@ class cs {
    * @throws Error if the largest output does not pay to the registered address
    */
   validatePayoutOutputs(t, n) {
-    if (!He(n))
+    if (!Se(n))
       throw new Error(
         "Invalid registeredPayoutScriptPubKey: not valid hex"
       );
     const s = S.from(
-      $(n),
+      B(n),
       "hex"
-    ), r = q.fromHex($(t));
-    if (r.outs.length === 0)
+    ), o = J.fromHex(B(t));
+    if (o.outs.length === 0)
       throw new Error("Payout transaction has no outputs");
-    if (!r.outs.reduce(
+    if (!o.outs.reduce(
       (i, a) => a.value > i.value ? a : i
     ).script.equals(s))
       throw new Error(
@@ -1301,111 +1452,111 @@ class cs {
       );
   }
 }
-function Ve(e) {
+function Ke(e) {
   return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
 }
-function R(e, t = "") {
+function V(e, t = "") {
   if (!Number.isSafeInteger(e) || e < 0) {
     const n = t && `"${t}" `;
     throw new Error(`${n}expected integer >= 0, got ${e}`);
   }
 }
-function V(e, t, n = "") {
-  const s = Ve(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}`;
+function K(e, t, n = "") {
+  const s = Ke(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 Nt(e) {
+function Gt(e) {
   if (typeof e != "function" || typeof e.create != "function")
     throw new Error("Hash must wrapped by utils.createHasher");
-  R(e.outputLen), R(e.blockLen);
+  V(e.outputLen), V(e.blockLen);
 }
-function X(e, t = !0) {
+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 Xt(e, t) {
-  V(e, void 0, "digestInto() output");
+function jt(e, t) {
+  K(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 Ke(e) {
+function De(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 rt(e) {
+function it(e) {
   return new DataView(e.buffer, e.byteOffset, e.byteLength);
 }
-function B(e, t) {
+function $(e, t) {
   return e << 32 - t | e >>> t;
 }
-function Z(e, t) {
+function Y(e, t) {
   return e << t | e >>> 32 - t >>> 0;
 }
-const De = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-function Me(e) {
+const Me = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function Ne(e) {
   return e << 24 & 4278190080 | e << 8 & 16711680 | e >>> 8 & 65280 | e >>> 24 & 255;
 }
-function Ne(e) {
+function Xe(e) {
   for (let t = 0; t < e.length; t++)
-    e[t] = Me(e[t]);
+    e[t] = Ne(e[t]);
   return e;
 }
-const At = De ? (e) => e : Ne;
-function Xe(e) {
+const Ut = Me ? (e) => e : Xe;
+function qe(e) {
   if (typeof e != "string")
     throw new Error("string expected");
   return new Uint8Array(new TextEncoder().encode(e));
 }
-function Bt(e, t = "") {
-  return typeof e == "string" ? Xe(e) : V(e, void 0, t);
+function Ft(e, t = "") {
+  return typeof e == "string" ? qe(e) : K(e, void 0, t);
 }
 function Ge(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 it(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);
+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 Gt = (e) => ({
+const zt = (e) => ({
   oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, e])
 });
-class jt {
+class Zt {
   constructor(t, n) {
-    d(this, "oHash");
-    d(this, "iHash");
-    d(this, "blockLen");
-    d(this, "outputLen");
-    d(this, "finished", !1);
-    d(this, "destroyed", !1);
-    if (Nt(t), V(n, void 0, "key"), this.iHash = t.create(), typeof this.iHash.update != "function")
+    p(this, "oHash");
+    p(this, "iHash");
+    p(this, "blockLen");
+    p(this, "outputLen");
+    p(this, "finished", !1);
+    p(this, "destroyed", !1);
+    if (Gt(t), K(n, void 0, "key"), this.iHash = t.create(), typeof this.iHash.update != "function")
       throw new Error("Expected instance of class which extends utils.Hash");
     this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
-    const s = this.blockLen, 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);
+    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), A(o);
   }
   update(t) {
-    return X(this), this.iHash.update(t), this;
+    return G(this), this.iHash.update(t), this;
   }
   digestInto(t) {
-    X(this), V(t, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
+    G(this), K(t, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
   }
   digest() {
     const t = new Uint8Array(this.oHash.outputLen);
@@ -1413,8 +1564,8 @@ class jt {
   }
   _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;
+    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();
@@ -1423,60 +1574,60 @@ class jt {
     this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
   }
 }
-const yt = (e, t, n) => new jt(e, t).update(n).digest();
-yt.create = (e, t) => new jt(e, t);
+const Pt = (e, t, n) => new Zt(e, t).update(n).digest();
+Pt.create = (e, t) => new Zt(e, t);
 function je(e, t, n) {
   return e & t ^ ~e & n;
 }
-function qe(e, t, n) {
+function ze(e, t, n) {
   return e & t ^ e & n ^ t & n;
 }
-class wt {
-  constructor(t, n, s, r) {
-    d(this, "blockLen");
-    d(this, "outputLen");
-    d(this, "padOffset");
-    d(this, "isLE");
+class Tt {
+  constructor(t, n, s, o) {
+    p(this, "blockLen");
+    p(this, "outputLen");
+    p(this, "padOffset");
+    p(this, "isLE");
     // For partial updates less than block size
-    d(this, "buffer");
-    d(this, "view");
-    d(this, "finished", !1);
-    d(this, "length", 0);
-    d(this, "pos", 0);
-    d(this, "destroyed", !1);
-    this.blockLen = t, this.outputLen = n, this.padOffset = s, this.isLE = r, this.buffer = new Uint8Array(t), this.view = rt(this.buffer);
+    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 = it(this.buffer);
   }
   update(t) {
-    X(this), V(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 = rt(t);
-        for (; r <= o - i; i += r)
+    G(this), K(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 = it(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 === r && (this.process(n, 0), this.pos = 0);
+      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) {
-    X(this), Xt(t, this), this.finished = !0;
-    const { buffer: n, view: s, blockLen: r, isLE: o } = this;
+    G(this), jt(t, this), this.finished = !0;
+    const { buffer: n, view: s, blockLen: o, isLE: r } = 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 l = i; l < r; l++)
-      n[l] = 0;
-    s.setBigUint64(r - 8, BigInt(this.length * 8), o), this.process(s, 0);
-    const a = rt(t), c = this.outputLen;
+    n[i++] = 128, A(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 = it(t), c = this.outputLen;
     if (c % 4)
       throw new Error("_sha2: outputLen must be aligned to 32bit");
-    const u = c / 4, h = this.get();
-    if (u > h.length)
+    const l = c / 4, h = this.get();
+    if (l > h.length)
       throw new Error("_sha2: outputLen bigger than state");
-    for (let l = 0; l < u; l++)
-      a.setUint32(4 * l, h[l], o);
+    for (let u = 0; u < l; u++)
+      a.setUint32(4 * u, h[u], r);
   }
   digest() {
     const { buffer: t, outputLen: n } = this;
@@ -1486,8 +1637,8 @@ class wt {
   }
   _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;
+    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();
@@ -1519,7 +1670,7 @@ const L = /* @__PURE__ */ Uint32Array.from([
   4215389547,
   1541459225,
   327033209
-]), ze = /* @__PURE__ */ Uint8Array.from([
+]), Ze = /* @__PURE__ */ Uint8Array.from([
   7,
   4,
   13,
@@ -1536,94 +1687,94 @@ const L = /* @__PURE__ */ Uint32Array.from([
   14,
   11,
   8
-]), qt = Uint8Array.from(new Array(16).fill(0).map((e, t) => t)), Ze = qt.map((e) => (9 * e + 5) % 16), zt = /* @__PURE__ */ (() => {
-  const n = [[qt], [Ze]];
+]), Jt = Uint8Array.from(new Array(16).fill(0).map((e, t) => t)), Je = Jt.map((e) => (9 * e + 5) % 16), Yt = /* @__PURE__ */ (() => {
+  const n = [[Jt], [Je]];
   for (let s = 0; s < 4; s++)
-    for (let r of n)
-      r.push(r[s].map((o) => ze[o]));
+    for (let o of n)
+      o.push(o[s].map((r) => Ze[r]));
   return n;
-})(), Zt = zt[0], Jt = zt[1], Yt = /* @__PURE__ */ [
+})(), Qt = Yt[0], te = Yt[1], ee = /* @__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)), Je = /* @__PURE__ */ Zt.map((e, t) => e.map((n) => Yt[t][n])), Ye = /* @__PURE__ */ Jt.map((e, t) => e.map((n) => Yt[t][n])), Qe = /* @__PURE__ */ Uint32Array.from([
+].map((e) => Uint8Array.from(e)), Ye = /* @__PURE__ */ Qt.map((e, t) => e.map((n) => ee[t][n])), Qe = /* @__PURE__ */ te.map((e, t) => e.map((n) => ee[t][n])), tn = /* @__PURE__ */ Uint32Array.from([
   0,
   1518500249,
   1859775393,
   2400959708,
   2840853838
-]), tn = /* @__PURE__ */ Uint32Array.from([
+]), en = /* @__PURE__ */ Uint32Array.from([
   1352829926,
   1548603684,
   1836072691,
   2053994217,
   0
 ]);
-function $t(e, t, n, s) {
+function Ct(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 J = /* @__PURE__ */ new Uint32Array(16);
-class en extends wt {
+const Q = /* @__PURE__ */ new Uint32Array(16);
+class nn extends Tt {
   constructor() {
     super(64, 20, 8, !0);
-    d(this, "h0", 1732584193);
-    d(this, "h1", -271733879);
-    d(this, "h2", -1732584194);
-    d(this, "h3", 271733878);
-    d(this, "h4", -1009589776);
+    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: r, h3: o, h4: i } = this;
-    return [n, s, r, o, i];
+    const { h0: n, h1: s, h2: o, h3: r, h4: i } = this;
+    return [n, s, o, r, 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;
+  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 b = 0; b < 16; b++, s += 4)
-      J[b] = n.getUint32(s, !0);
-    let r = this.h0 | 0, o = r, i = this.h1 | 0, a = i, c = this.h2 | 0, u = c, h = this.h3 | 0, l = h, f = this.h4 | 0, g = f;
-    for (let b = 0; b < 5; b++) {
-      const w = 4 - b, x = Qe[b], y = tn[b], m = Zt[b], p = Jt[b], P = Je[b], v = Ye[b];
+    for (let g = 0; g < 16; g++, s += 4)
+      Q[g] = 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, y = d;
+    for (let g = 0; g < 5; g++) {
+      const x = 4 - g, P = tn[g], m = en[g], b = Qt[g], f = te[g], w = Ye[g], v = Qe[g];
       for (let T = 0; T < 16; T++) {
-        const E = Z(r + $t(b, i, c, h) + J[m[T]] + x, P[T]) + f | 0;
-        r = f, f = h, h = Z(c, 10) | 0, c = i, i = E;
+        const H = Y(o + Ct(g, i, c, h) + Q[b[T]] + P, w[T]) + d | 0;
+        o = d, d = h, h = Y(c, 10) | 0, c = i, i = H;
       }
       for (let T = 0; T < 16; T++) {
-        const E = Z(o + $t(w, a, u, l) + J[p[T]] + y, v[T]) + g | 0;
-        o = g, g = l, l = Z(u, 10) | 0, u = a, a = E;
+        const H = Y(r + Ct(x, a, l, u) + Q[f[T]] + m, v[T]) + y | 0;
+        r = y, y = u, u = Y(l, 10) | 0, l = a, a = H;
       }
     }
-    this.set(this.h1 + c + l | 0, this.h2 + h + g | 0, this.h3 + f + o | 0, this.h4 + r + a | 0, this.h0 + i + u | 0);
+    this.set(this.h1 + c + u | 0, this.h2 + h + y | 0, this.h3 + d + r | 0, this.h4 + o + a | 0, this.h0 + i + l | 0);
   }
   roundClean() {
-    A(J);
+    A(Q);
   }
   destroy() {
     this.destroyed = !0, A(this.buffer), this.set(0, 0, 0, 0, 0);
   }
 }
-const nn = /* @__PURE__ */ it(() => new en()), Y = /* @__PURE__ */ BigInt(2 ** 32 - 1), Ut = /* @__PURE__ */ BigInt(32);
-function sn(e, t = !1) {
-  return t ? { h: Number(e & Y), l: Number(e >> Ut & Y) } : { h: Number(e >> Ut & Y) | 0, l: Number(e & Y) | 0 };
+const sn = /* @__PURE__ */ ct(() => new nn()), tt = /* @__PURE__ */ BigInt(2 ** 32 - 1), Ot = /* @__PURE__ */ BigInt(32);
+function on(e, t = !1) {
+  return t ? { h: Number(e & tt), l: Number(e >> Ot & tt) } : { h: Number(e >> Ot & tt) | 0, l: Number(e & tt) | 0 };
 }
-function Qt(e, t = !1) {
+function ne(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 } = sn(e[o], t);
-    [s[o], r[o]] = [i, a];
+  let s = new Uint32Array(n), o = new Uint32Array(n);
+  for (let r = 0; r < n; r++) {
+    const { h: i, l: a } = on(e[r], t);
+    [s[r], o[r]] = [i, a];
   }
-  return [s, r];
+  return [s, o];
 }
-const Ft = (e, t, n) => e >>> n, Ot = (e, t, n) => e << 32 - n | t >>> n, D = (e, t, n) => e >>> n | t << 32 - n, M = (e, t, n) => e << 32 - n | t >>> n, Q = (e, t, n) => e << 64 - n | t >>> n - 32, tt = (e, t, n) => e >>> n - 32 | t << 64 - n, rn = (e, t, n) => e << n | t >>> 32 - n, on = (e, t, n) => t << n | e >>> 32 - n, an = (e, t, n) => t << n - 32 | e >>> 64 - n, cn = (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 Lt = (e, t, n) => e >>> n, _t = (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, et = (e, t, n) => e << 64 - n | t >>> n - 32, nt = (e, t, n) => e >>> n - 32 | t << 64 - n, rn = (e, t, n) => e << n | t >>> 32 - n, an = (e, t, n) => t << n | e >>> 32 - n, cn = (e, t, n) => t << n - 32 | e >>> 64 - n, un = (e, t, n) => e << n - 32 | t >>> 64 - n;
+function F(e, t, n, s) {
+  const o = (t >>> 0) + (s >>> 0);
+  return { h: e + n + (o / 2 ** 32 | 0) | 0, l: o | 0 };
 }
-const un = (e, t, n) => (e >>> 0) + (t >>> 0) + (n >>> 0), ln = (e, t, n, s) => t + n + s + (e / 2 ** 32 | 0) | 0, hn = (e, t, n, s) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0), fn = (e, t, n, s, r) => t + n + s + r + (e / 2 ** 32 | 0) | 0, dn = (e, t, n, s, r) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0) + (r >>> 0), pn = (e, t, n, s, r, o) => t + n + s + r + o + (e / 2 ** 32 | 0) | 0, bn = /* @__PURE__ */ Uint32Array.from([
+const ln = (e, t, n) => (e >>> 0) + (t >>> 0) + (n >>> 0), hn = (e, t, n, s) => t + n + s + (e / 2 ** 32 | 0) | 0, dn = (e, t, n, s) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0), fn = (e, t, n, s, o) => t + n + s + o + (e / 2 ** 32 | 0) | 0, pn = (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, bn = /* @__PURE__ */ Uint32Array.from([
   1116352408,
   1899447441,
   3049323471,
@@ -1688,56 +1839,56 @@ const un = (e, t, n) => (e >>> 0) + (t >>> 0) + (n >>> 0), ln = (e, t, n, s) =>
   2756734187,
   3204031479,
   3329325298
-]), C = /* @__PURE__ */ new Uint32Array(64);
-class gn extends wt {
+]), _ = /* @__PURE__ */ new Uint32Array(64);
+class yn extends Tt {
   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];
+    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, 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;
+  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 l = 0; l < 16; l++, n += 4)
-      C[l] = t.getUint32(n, !1);
-    for (let l = 16; l < 64; l++) {
-      const f = C[l - 15], g = C[l - 2], b = B(f, 7) ^ B(f, 18) ^ f >>> 3, w = B(g, 17) ^ B(g, 19) ^ g >>> 10;
-      C[l] = w + C[l - 7] + b + C[l - 16] | 0;
+    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], y = _[u - 2], g = $(d, 7) ^ $(d, 18) ^ d >>> 3, x = $(y, 17) ^ $(y, 19) ^ y >>> 10;
+      _[u] = x + _[u - 7] + g + _[u - 16] | 0;
     }
-    let { A: s, B: r, C: o, D: i, E: a, F: c, G: u, H: h } = this;
-    for (let l = 0; l < 64; l++) {
-      const f = B(a, 6) ^ B(a, 11) ^ B(a, 25), g = h + f + je(a, c, u) + bn[l] + C[l] | 0, w = (B(s, 2) ^ B(s, 13) ^ B(s, 22)) + qe(s, r, o) | 0;
-      h = u, u = c, c = a, a = i + g | 0, i = o, o = r, r = s, s = g + w | 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, 6) ^ $(a, 11) ^ $(a, 25), y = h + d + je(a, c, l) + bn[u] + _[u] | 0, x = ($(s, 2) ^ $(s, 13) ^ $(s, 22)) + ze(s, o, r) | 0;
+      h = l, l = c, c = a, a = i + y | 0, i = r, r = o, o = s, s = y + x | 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, u = u + this.G | 0, h = h + this.H | 0, this.set(s, r, o, i, a, c, u, h);
+    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() {
-    A(C);
+    A(_);
   }
   destroy() {
     this.set(0, 0, 0, 0, 0, 0, 0, 0), A(this.buffer);
   }
 }
-class xn extends gn {
+class xn extends yn {
   constructor() {
     super(32);
     // We cannot use array here since array allows indexing by variable
     // which means optimizer/compiler cannot use registers.
-    d(this, "A", L[0] | 0);
-    d(this, "B", L[1] | 0);
-    d(this, "C", L[2] | 0);
-    d(this, "D", L[3] | 0);
-    d(this, "E", L[4] | 0);
-    d(this, "F", L[5] | 0);
-    d(this, "G", L[6] | 0);
-    d(this, "H", L[7] | 0);
+    p(this, "A", L[0] | 0);
+    p(this, "B", L[1] | 0);
+    p(this, "C", L[2] | 0);
+    p(this, "D", L[3] | 0);
+    p(this, "E", L[4] | 0);
+    p(this, "F", L[5] | 0);
+    p(this, "G", L[6] | 0);
+    p(this, "H", L[7] | 0);
   }
 }
-const te = Qt([
+const se = ne([
   "0x428a2f98d728ae22",
   "0x7137449123ef65cd",
   "0xb5c0fbcfec4d3b2f",
@@ -1818,93 +1969,93 @@ const te = Qt([
   "0x597f299cfc657e2a",
   "0x5fcb6fab3ad6faec",
   "0x6c44198c4a475817"
-].map((e) => BigInt(e))), yn = te[0], wn = te[1], _ = /* @__PURE__ */ new Uint32Array(80), W = /* @__PURE__ */ new Uint32Array(80);
-class mn extends wt {
+].map((e) => BigInt(e))), wn = se[0], mn = se[1], R = /* @__PURE__ */ new Uint32Array(80), W = /* @__PURE__ */ new Uint32Array(80);
+class Pn extends Tt {
   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: u, El: h, Fh: l, Fl: f, Gh: g, Gl: b, Hh: w, Hl: x } = this;
-    return [t, n, s, r, o, i, a, c, u, h, l, f, g, b, w, x];
+    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: y, Gl: g, Hh: x, Hl: P } = this;
+    return [t, n, s, o, r, i, a, c, l, h, u, d, y, g, x, P];
   }
   // prettier-ignore
-  set(t, n, s, r, o, i, a, c, u, h, l, f, g, b, w, 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 = u | 0, this.El = h | 0, this.Fh = l | 0, this.Fl = f | 0, this.Gh = g | 0, this.Gl = b | 0, this.Hh = w | 0, this.Hl = x | 0;
+  set(t, n, s, o, r, i, a, c, l, h, u, d, y, g, 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 = y | 0, this.Gl = g | 0, this.Hh = x | 0, this.Hl = P | 0;
   }
   process(t, n) {
-    for (let p = 0; p < 16; p++, n += 4)
-      _[p] = t.getUint32(n), W[p] = t.getUint32(n += 4);
-    for (let p = 16; p < 80; p++) {
-      const P = _[p - 15] | 0, v = W[p - 15] | 0, T = D(P, v, 1) ^ D(P, v, 8) ^ Ft(P, v, 7), E = M(P, v, 1) ^ M(P, v, 8) ^ Ot(P, v, 7), H = _[p - 2] | 0, I = W[p - 2] | 0, F = D(H, I, 19) ^ Q(H, I, 61) ^ Ft(H, I, 6), K = M(H, I, 19) ^ tt(H, I, 61) ^ Ot(H, I, 6), O = hn(E, K, W[p - 7], W[p - 16]), at = fn(O, T, F, _[p - 7], _[p - 16]);
-      _[p] = at | 0, W[p] = O | 0;
+    for (let f = 0; f < 16; f++, n += 4)
+      R[f] = t.getUint32(n), W[f] = t.getUint32(n += 4);
+    for (let f = 16; f < 80; f++) {
+      const w = R[f - 15] | 0, v = W[f - 15] | 0, T = N(w, v, 1) ^ N(w, v, 8) ^ Lt(w, v, 7), H = X(w, v, 1) ^ X(w, v, 8) ^ _t(w, v, 7), E = R[f - 2] | 0, I = W[f - 2] | 0, C = N(E, I, 19) ^ et(E, I, 61) ^ Lt(E, I, 6), D = X(E, I, 19) ^ nt(E, I, 61) ^ _t(E, I, 6), O = dn(H, D, W[f - 7], W[f - 16]), ut = fn(O, T, C, R[f - 7], R[f - 16]);
+      R[f] = ut | 0, W[f] = O | 0;
     }
-    let { Ah: s, Al: r, Bh: o, Bl: i, Ch: a, Cl: c, Dh: u, Dl: h, Eh: l, El: f, Fh: g, Fl: b, Gh: w, Gl: x, Hh: y, Hl: m } = this;
-    for (let p = 0; p < 80; p++) {
-      const P = D(l, f, 14) ^ D(l, f, 18) ^ Q(l, f, 41), v = M(l, f, 14) ^ M(l, f, 18) ^ tt(l, f, 41), T = l & g ^ ~l & w, E = f & b ^ ~f & x, H = dn(m, v, E, wn[p], W[p]), I = pn(H, y, P, T, yn[p], _[p]), F = H | 0, K = D(s, r, 28) ^ Q(s, r, 34) ^ Q(s, r, 39), O = M(s, r, 28) ^ tt(s, r, 34) ^ tt(s, r, 39), at = s & o ^ s & a ^ o & a, ae = r & i ^ r & c ^ i & c;
-      y = w | 0, m = x | 0, w = g | 0, x = b | 0, g = l | 0, b = f | 0, { h: l, l: f } = U(u | 0, h | 0, I | 0, F | 0), u = a | 0, h = c | 0, a = o | 0, c = i | 0, o = s | 0, i = r | 0;
-      const Pt = un(F, O, ae);
-      s = ln(Pt, I, K, at), r = Pt | 0;
+    let { Ah: s, Al: o, Bh: r, Bl: i, Ch: a, Cl: c, Dh: l, Dl: h, Eh: u, El: d, Fh: y, Fl: g, Gh: x, Gl: P, Hh: m, Hl: b } = this;
+    for (let f = 0; f < 80; f++) {
+      const w = N(u, d, 14) ^ N(u, d, 18) ^ et(u, d, 41), v = X(u, d, 14) ^ X(u, d, 18) ^ nt(u, d, 41), T = u & y ^ ~u & x, H = d & g ^ ~d & P, E = pn(b, v, H, mn[f], W[f]), I = gn(E, m, w, T, wn[f], R[f]), C = E | 0, D = N(s, o, 28) ^ et(s, o, 34) ^ et(s, o, 39), O = X(s, o, 28) ^ nt(s, o, 34) ^ nt(s, o, 39), ut = s & r ^ s & a ^ r & a, le = o & i ^ o & c ^ i & c;
+      m = x | 0, b = P | 0, x = y | 0, P = g | 0, y = u | 0, g = d | 0, { h: u, l: d } = F(l | 0, h | 0, I | 0, C | 0), l = a | 0, h = c | 0, a = r | 0, c = i | 0, r = s | 0, i = o | 0;
+      const kt = ln(C, O, le);
+      s = hn(kt, I, D, ut), o = kt | 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: u, l: h } = U(this.Dh | 0, this.Dl | 0, u | 0, h | 0), { h: l, l: f } = U(this.Eh | 0, this.El | 0, l | 0, f | 0), { h: g, l: b } = U(this.Fh | 0, this.Fl | 0, g | 0, b | 0), { h: w, l: x } = U(this.Gh | 0, this.Gl | 0, w | 0, x | 0), { h: y, l: m } = U(this.Hh | 0, this.Hl | 0, y | 0, m | 0), this.set(s, r, o, i, a, c, u, h, l, f, g, b, w, x, y, m);
+    ({ h: s, l: o } = F(this.Ah | 0, this.Al | 0, s | 0, o | 0)), { h: r, l: i } = F(this.Bh | 0, this.Bl | 0, r | 0, i | 0), { h: a, l: c } = F(this.Ch | 0, this.Cl | 0, a | 0, c | 0), { h: l, l: h } = F(this.Dh | 0, this.Dl | 0, l | 0, h | 0), { h: u, l: d } = F(this.Eh | 0, this.El | 0, u | 0, d | 0), { h: y, l: g } = F(this.Fh | 0, this.Fl | 0, y | 0, g | 0), { h: x, l: P } = F(this.Gh | 0, this.Gl | 0, x | 0, P | 0), { h: m, l: b } = F(this.Hh | 0, this.Hl | 0, m | 0, b | 0), this.set(s, o, r, i, a, c, l, h, u, d, y, g, x, P, m, b);
   }
   roundClean() {
-    A(_, W);
+    A(R, W);
   }
   destroy() {
     A(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
   }
 }
-class Pn extends mn {
+class Tn extends Pn {
   constructor() {
     super(64);
-    d(this, "Ah", k[0] | 0);
-    d(this, "Al", k[1] | 0);
-    d(this, "Bh", k[2] | 0);
-    d(this, "Bl", k[3] | 0);
-    d(this, "Ch", k[4] | 0);
-    d(this, "Cl", k[5] | 0);
-    d(this, "Dh", k[6] | 0);
-    d(this, "Dl", k[7] | 0);
-    d(this, "Eh", k[8] | 0);
-    d(this, "El", k[9] | 0);
-    d(this, "Fh", k[10] | 0);
-    d(this, "Fl", k[11] | 0);
-    d(this, "Gh", k[12] | 0);
-    d(this, "Gl", k[13] | 0);
-    d(this, "Hh", k[14] | 0);
-    d(this, "Hl", k[15] | 0);
-  }
-}
-const Tn = /* @__PURE__ */ it(
+    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 vn = /* @__PURE__ */ ct(
   () => new xn(),
-  /* @__PURE__ */ Gt(1)
-), ee = /* @__PURE__ */ it(
-  () => new Pn(),
-  /* @__PURE__ */ Gt(3)
-), vn = BigInt(0), G = BigInt(1), kn = BigInt(2), Hn = BigInt(7), In = BigInt(256), En = BigInt(113), ne = [], se = [], re = [];
-for (let e = 0, t = G, n = 1, s = 0; e < 24; e++) {
-  [n, s] = [s, (2 * n + 3 * s) % 5], ne.push(2 * (5 * s + n)), se.push((e + 1) * (e + 2) / 2 % 64);
-  let r = vn;
-  for (let o = 0; o < 7; o++)
-    t = (t << G ^ (t >> Hn) * En) % In, t & kn && (r ^= G << (G << BigInt(o)) - G);
-  re.push(r);
-}
-const oe = Qt(re, !0), Sn = oe[0], An = oe[1], Lt = (e, t, n) => n > 32 ? an(e, t, n) : rn(e, t, n), Ct = (e, t, n) => n > 32 ? cn(e, t, n) : on(e, t, n);
-function Bn(e, t = 24) {
+  /* @__PURE__ */ zt(1)
+), oe = /* @__PURE__ */ ct(
+  () => new Tn(),
+  /* @__PURE__ */ zt(3)
+), kn = BigInt(0), z = BigInt(1), Hn = BigInt(2), En = BigInt(7), In = BigInt(256), Sn = BigInt(113), re = [], ie = [], ae = [];
+for (let e = 0, t = z, n = 1, s = 0; e < 24; e++) {
+  [n, s] = [s, (2 * n + 3 * s) % 5], re.push(2 * (5 * s + n)), ie.push((e + 1) * (e + 2) / 2 % 64);
+  let o = kn;
+  for (let r = 0; r < 7; r++)
+    t = (t << z ^ (t >> En) * Sn) % In, t & Hn && (o ^= z << (z << BigInt(r)) - z);
+  ae.push(o);
+}
+const ce = ne(ae, !0), Bn = ce[0], An = ce[1], Rt = (e, t, n) => n > 32 ? cn(e, t, n) : rn(e, t, n), Wt = (e, t, n) => n > 32 ? un(e, t, n) : an(e, t, n);
+function $n(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, u = n[c], h = n[c + 1], l = Lt(u, h, 1) ^ n[a], f = Ct(u, h, 1) ^ n[a + 1];
-      for (let g = 0; g < 50; g += 10)
-        e[i + g] ^= l, e[i + g + 1] ^= f;
+      const a = (i + 8) % 10, c = (i + 2) % 10, l = n[c], h = n[c + 1], u = Rt(l, h, 1) ^ n[a], d = Wt(l, h, 1) ^ n[a + 1];
+      for (let y = 0; y < 50; y += 10)
+        e[i + y] ^= u, e[i + y + 1] ^= d;
     }
-    let r = e[2], o = e[3];
+    let o = e[2], r = e[3];
     for (let i = 0; i < 24; i++) {
-      const a = se[i], c = Lt(r, o, a), u = Ct(r, o, a), h = ne[i];
-      r = e[h], o = e[h + 1], e[h] = c, e[h + 1] = u;
+      const a = ie[i], c = Rt(o, r, a), l = Wt(o, r, a), h = re[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++)
@@ -1912,41 +2063,41 @@ function Bn(e, t = 24) {
       for (let a = 0; a < 10; a++)
         e[i + a] ^= ~n[(a + 2) % 10] & n[(a + 4) % 10];
     }
-    e[0] ^= Sn[s], e[1] ^= An[s];
+    e[0] ^= Bn[s], e[1] ^= An[s];
   }
   A(n);
 }
-class mt {
+class vt {
   // NOTE: we accept arguments in bytes instead of bits here.
-  constructor(t, n, s, r = !1, o = 24) {
-    d(this, "state");
-    d(this, "pos", 0);
-    d(this, "posOut", 0);
-    d(this, "finished", !1);
-    d(this, "state32");
-    d(this, "destroyed", !1);
-    d(this, "blockLen");
-    d(this, "suffix");
-    d(this, "outputLen");
-    d(this, "enableXOF", !1);
-    d(this, "rounds");
-    if (this.blockLen = t, this.suffix = n, this.outputLen = s, this.enableXOF = r, this.rounds = o, R(s, "outputLen"), !(0 < t && t < 200))
+  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 = Ke(this.state);
+    this.state = new Uint8Array(200), this.state32 = De(this.state);
   }
   clone() {
     return this._cloneInto();
   }
   keccak() {
-    At(this.state32), Bn(this.state32, this.rounds), At(this.state32), this.posOut = 0, this.pos = 0;
+    Ut(this.state32), $n(this.state32, this.rounds), Ut(this.state32), this.posOut = 0, this.pos = 0;
   }
   update(t) {
-    X(this), V(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);
+    G(this), K(t);
+    const { blockLen: n, state: s } = this, o = t.length;
+    for (let r = 0; r < o; ) {
+      const i = Math.min(n - this.pos, o - r);
       for (let a = 0; a < i; a++)
-        s[this.pos++] ^= t[o++];
+        s[this.pos++] ^= t[r++];
       this.pos === n && this.keccak();
     }
     return this;
@@ -1955,16 +2106,16 @@ class mt {
     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();
+    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) {
-    X(this, !1), V(t), this.finish();
+    G(this, !1), K(t), this.finish();
     const n = this.state, { blockLen: s } = this;
-    for (let r = 0, o = t.length; r < o; ) {
+    for (let o = 0, r = t.length; o < r; ) {
       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;
+      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;
   }
@@ -1974,10 +2125,10 @@ class mt {
     return this.writeInto(t);
   }
   xof(t) {
-    return R(t), this.xofInto(new Uint8Array(t));
+    return V(t), this.xofInto(new Uint8Array(t));
   }
   digestInto(t) {
-    if (Xt(t, this), this.finished)
+    if (jt(t, this), this.finished)
       throw new Error("digest() was already called");
     return this.writeInto(t), this.destroy(), t;
   }
@@ -1988,117 +2139,117 @@ class mt {
     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 { blockLen: n, suffix: s, outputLen: o, rounds: r, enableXOF: i } = this;
+    return t || (t = new vt(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 = {}) => it(() => new mt(t, e, n), s), Un = /* @__PURE__ */ $n(1, 136, 32);
-function Fn(e, t, n, s) {
-  Nt(e);
-  const r = Ge({ dkLen: 32, asyncTick: 10 }, s), { c: o, dkLen: i, asyncTick: a } = r;
-  if (R(o, "c"), R(i, "dkLen"), R(a, "asyncTick"), o < 1)
+const Un = (e, t, n, s = {}) => ct(() => new vt(t, e, n), s), Fn = /* @__PURE__ */ Un(1, 136, 32);
+function Cn(e, t, n, s) {
+  Gt(e);
+  const o = Ge({ 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 = Bt(t, "password"), u = Bt(n, "salt"), h = new Uint8Array(i), l = yt.create(e, c), f = l._cloneInto().update(u);
-  return { c: o, dkLen: i, asyncTick: a, DK: h, PRF: l, PRFSalt: f };
+  const c = Ft(t, "password"), l = Ft(n, "salt"), h = new Uint8Array(i), u = Pt.create(e, c), d = u._cloneInto().update(l);
+  return { c: r, dkLen: i, asyncTick: a, DK: h, PRF: u, PRFSalt: d };
 }
-function On(e, t, n, s, r) {
-  return e.destroy(), t.destroy(), s && s.destroy(), A(r), n;
+function On(e, t, n, s, o) {
+  return e.destroy(), t.destroy(), s && s.destroy(), A(o), n;
 }
 function Ln(e, t, n, s) {
-  const { c: r, dkLen: o, DK: i, PRF: a, PRFSalt: c } = Fn(e, t, n, s);
-  let u;
-  const h = new Uint8Array(4), l = rt(h), f = new Uint8Array(a.outputLen);
-  for (let g = 1, b = 0; b < o; g++, b += a.outputLen) {
-    const w = i.subarray(b, b + a.outputLen);
-    l.setInt32(0, g, !1), (u = c._cloneInto(u)).update(h).digestInto(f), w.set(f.subarray(0, w.length));
-    for (let x = 1; x < r; x++) {
-      a._cloneInto(u).update(f).digestInto(f);
-      for (let y = 0; y < w.length; y++)
-        w[y] ^= f[y];
+  const { c: o, dkLen: r, DK: i, PRF: a, PRFSalt: c } = Cn(e, t, n, s);
+  let l;
+  const h = new Uint8Array(4), u = it(h), d = new Uint8Array(a.outputLen);
+  for (let y = 1, g = 0; g < r; y++, g += a.outputLen) {
+    const x = i.subarray(g, g + a.outputLen);
+    u.setInt32(0, y, !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 m = 0; m < x.length; m++)
+        x[m] ^= d[m];
     }
   }
-  return On(a, c, i, u, f);
+  return On(a, c, i, l, d);
 }
-function ie(e) {
+function ue(e) {
   if (typeof e != "string")
     throw new TypeError("invalid mnemonic type: " + typeof e);
   return e.normalize("NFKD");
 }
-function Cn(e) {
-  const t = ie(e), n = t.split(" ");
+function _n(e) {
+  const t = ue(e), n = t.split(" ");
   if (![12, 15, 18, 21, 24].includes(n.length))
     throw new Error("Invalid mnemonic");
   return { nfkd: t, words: n };
 }
-const _n = (e) => ie("mnemonic" + e);
+const Rn = (e) => ue("mnemonic" + e);
 function Wn(e, t = "") {
-  return Ln(ee, Cn(e).nfkd, _n(t), { c: 2048, dkLen: 64 });
+  return Ln(oe, _n(e).nfkd, Rn(t), { c: 2048, dkLen: 64 });
 }
-const Rn = 508, _t = 16, et = 32, nt = 64, Wt = 5, Vn = 4;
-function j(...e) {
-  const t = e.reduce((r, o) => r + o.length, 0), n = new Uint8Array(t);
+const Vn = 508, Vt = 16, st = 32, ot = 64, Kt = 5, Kn = 4;
+function Z(...e) {
+  const t = e.reduce((o, r) => o + r.length, 0), n = new Uint8Array(t);
   let s = 0;
-  for (const r of e)
-    n.set(r, s), s += r.length;
+  for (const o of e)
+    n.set(o, s), s += o.length;
   return n;
 }
-function lt(e) {
+function ft(e) {
   return new TextEncoder().encode(e);
 }
-function ht(e) {
-  const t = new Uint8Array(Vn);
-  return new DataView(t.buffer).setUint32(0, e.length, !1), j(t, e);
+function pt(e) {
+  const t = new Uint8Array(Kn);
+  return new DataView(t.buffer).setUint32(0, e.length, !1), Z(t, e);
 }
-function ft(e, t) {
-  return yt(ee, e, t);
+function gt(e, t) {
+  return Pt(oe, e, t);
 }
-function Rt(e) {
-  return nn(Tn(e));
+function Dt(e) {
+  return sn(vn(e));
 }
-const gt = (e) => Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("");
-function Kn(e) {
+const wt = (e) => Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("");
+function Dn(e) {
   const t = Wn(e), n = new Uint8Array(t);
   return t.fill(0), n;
 }
-async function Dn(e, t, n, s) {
-  if (e.length !== nt)
+async function Mn(e, t, n, s) {
+  if (e.length !== ot)
     throw new Error(
-      `WOTS seed must be ${nt} bytes, got ${e.length}`
+      `WOTS seed must be ${ot} bytes, got ${e.length}`
     );
-  t = $(t), n = $(n);
-  const r = e.slice(et, nt), o = e.slice(0, et), i = [r, o];
+  t = B(t), n = B(n);
+  const o = e.slice(st, ot), r = e.slice(0, st), i = [o, r];
   try {
-    const a = j(
-      ht(lt(t)),
-      ht(lt(n)),
-      ht(lt(s))
-    ), c = j(o, a);
+    const a = Z(
+      pt(ft(t)),
+      pt(ft(n)),
+      pt(ft(s))
+    ), c = Z(r, a);
     i.push(c);
-    const u = ft(r, c);
-    i.push(u);
-    const h = u.slice(0, et), l = u.slice(et, nt);
-    i.push(h, l);
-    const f = [], g = [], b = [], w = [];
-    let x = !1;
+    const l = gt(o, c);
+    i.push(l);
+    const h = l.slice(0, st), u = l.slice(st, ot);
+    i.push(h, u);
+    const d = [], y = [], g = [], x = [];
+    let P = !1;
     try {
-      for (let y = 0; y < Rn; y++) {
-        const m = new Uint8Array(Wt);
-        m[0] = 0, new DataView(m.buffer).setUint32(1, y, !1);
-        const p = new Uint8Array(Wt);
-        p[0] = 1, new DataView(p.buffer).setUint32(1, y, !1);
-        const P = j(h, m), v = j(h, p), T = ft(l, P), E = ft(l, v);
+      for (let m = 0; m < Vn; m++) {
+        const b = new Uint8Array(Kt);
+        b[0] = 0, new DataView(b.buffer).setUint32(1, m, !1);
+        const f = new Uint8Array(Kt);
+        f[0] = 1, new DataView(f.buffer).setUint32(1, m, !1);
+        const w = Z(h, b), v = Z(h, f), T = gt(u, w), H = gt(u, v);
         try {
-          const H = T.slice(0, _t), I = E.slice(0, _t);
-          f.push(H), g.push(I), b.push(Rt(H)), w.push(Rt(I));
+          const E = T.slice(0, Vt), I = H.slice(0, Vt);
+          d.push(E), y.push(I), g.push(Dt(E)), x.push(Dt(I));
         } finally {
-          P.fill(0), v.fill(0), T.fill(0), E.fill(0);
+          w.fill(0), v.fill(0), T.fill(0), H.fill(0);
         }
       }
-      return x = !0, { falsePreimages: f, truePreimages: g, falseHashes: b, trueHashes: w };
+      return P = !0, { falsePreimages: d, truePreimages: y, falseHashes: g, trueHashes: x };
     } finally {
-      if (!x) {
-        for (const y of f) y.fill(0);
-        for (const y of g) y.fill(0);
+      if (!P) {
+        for (const m of d) m.fill(0);
+        for (const m of y) m.fill(0);
       }
     }
   } finally {
@@ -2106,82 +2257,82 @@ async function Dn(e, t, n, s) {
       a.fill(0);
   }
 }
-function us(e) {
+function ls(e) {
   return {
-    false_list: e.falseHashes.map(gt),
-    true_list: e.trueHashes.map(gt)
+    false_list: e.falseHashes.map(wt),
+    true_list: e.trueHashes.map(wt)
   };
 }
-function Mn(e) {
+function Nn(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 r = 0;
+  let o = 0;
   for (const i of e.falseHashes)
-    s.set(i, r), r += t;
+    s.set(i, o), o += t;
   for (const i of e.trueHashes)
-    s.set(i, r), r += t;
-  const o = Un(s);
-  return `0x${gt(o)}`;
+    s.set(i, o), o += t;
+  const r = Fn(s);
+  return `0x${wt(r)}`;
 }
-async function ls(e, t, n, s) {
-  const r = Kn(e);
+async function hs(e, t, n, s) {
+  const o = Dn(e);
   try {
-    const o = await Dn(
-      r,
+    const r = await Mn(
+      o,
       t,
       n,
       s
     );
     try {
-      return Mn(o);
+      return Nn(r);
     } finally {
-      for (const i of o.falsePreimages) i.fill(0);
-      for (const i of o.truePreimages) i.fill(0);
+      for (const i of r.falsePreimages) i.fill(0);
+      for (const i of r.truePreimages) i.fill(0);
     }
   } finally {
-    r.fill(0);
+    o.fill(0);
   }
 }
-function hs(e) {
+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 {
-  Mn as A,
-  st as B,
-  N as C,
-  ls as D,
-  hs as E,
+  Nn as A,
+  rt as B,
+  q as C,
+  hs as D,
+  ds as E,
   Oe as M,
-  as as P,
-  Zn as a,
-  Yn as b,
-  St as c,
-  Qn as d,
-  Be as e,
-  $e as f,
-  Jn as g,
-  bt as h,
-  cs as i,
-  ss as j,
-  es as k,
-  ns as l,
+  cs as P,
+  Jn as a,
+  Qn as b,
+  dt as c,
+  ts as d,
+  $e as e,
+  Ue as f,
+  Yn as g,
+  xt as h,
+  us as i,
+  os as j,
+  ns as k,
+  ss as l,
   rs as m,
-  ts as n,
-  Ce as o,
-  _e as p,
+  es as n,
+  _e as o,
+  Re as p,
   Le as q,
-  ct as r,
+  j as r,
   Ae as s,
-  xt as t,
-  os as u,
-  is as v,
-  ut as w,
-  Kn as x,
-  Dn as y,
-  us as z
+  mt as t,
+  is as u,
+  as as v,
+  M as w,
+  Dn as x,
+  Mn as y,
+  ls as z
 };
-//# sourceMappingURL=errors-D19BQSaj.js.map
+//# sourceMappingURL=errors-C5aW6wrA.js.map