@babylonlabs-io/ts-sdk 0.26.3 → 0.27.1

package/dist/sha2-ZzfZqQSw.js

@@ -0,0 +1,1123 @@
+var re = Object.defineProperty;
+var ae = (e, t, n) => t in e ? re(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var l = (e, t, n) => ae(e, typeof t != "symbol" ? t + "" : t, n);
+const Ke = [
+  {
+    type: "function",
+    name: "submitPeginRequest",
+    inputs: [
+      {
+        name: "depositor",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "depositorBtcPubKey",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "btcPopSignature",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "unsignedPrePeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorSignedPeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "vaultProvider",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "hashlock",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "htlcVout",
+        type: "uint8",
+        internalType: "uint8"
+      },
+      {
+        name: "depositorPayoutBtcAddress",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorWotsPkHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "submitPeginRequest",
+    inputs: [
+      {
+        name: "depositor",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "depositorBtcPubKey",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "btcPopSignature",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "unsignedPrePeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorSignedPeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "vaultProvider",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "hashlock",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "htlcVout",
+        type: "uint8",
+        internalType: "uint8"
+      },
+      {
+        name: "referralCode",
+        type: "uint32",
+        internalType: "uint32"
+      },
+      {
+        name: "depositorPayoutBtcAddress",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorWotsPkHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "submitPeginRequestBatch",
+    inputs: [
+      { name: "depositor", type: "address", internalType: "address" },
+      { name: "vaultProvider", type: "address", internalType: "address" },
+      {
+        name: "requests",
+        type: "tuple[]",
+        internalType: "struct IBTCVaultRegistry.BatchPeginRequest[]",
+        components: [
+          { name: "depositorBtcPubKey", type: "bytes32", internalType: "bytes32" },
+          { name: "btcPopSignature", type: "bytes", internalType: "bytes" },
+          { name: "unsignedPrePeginTx", type: "bytes", internalType: "bytes" },
+          { name: "depositorSignedPeginTx", type: "bytes", internalType: "bytes" },
+          { name: "hashlock", type: "bytes32", internalType: "bytes32" },
+          { name: "htlcVout", type: "uint8", internalType: "uint8" },
+          { name: "referralCode", type: "uint32", internalType: "uint32" },
+          { name: "depositorPayoutBtcAddress", type: "bytes", internalType: "bytes" },
+          { name: "depositorWotsPkHash", type: "bytes32", internalType: "bytes32" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "vaultIds", type: "bytes32[]", internalType: "bytes32[]" }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "activateVaultWithSecret",
+    inputs: [
+      {
+        name: "vaultId",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "s",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "activationMetadata",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getPegInFee",
+    inputs: [
+      {
+        name: "vaultProvider",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "totalFee",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getBtcVaultBasicInfo",
+    inputs: [
+      {
+        name: "vaultId",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      { name: "depositor", type: "address", internalType: "address" },
+      { name: "depositorBtcPubKey", type: "bytes32", internalType: "bytes32" },
+      { 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: "createdAt", type: "uint256", internalType: "uint256" }
+    ],
+    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: []
+  },
+  {
+    type: "function",
+    name: "getBtcVaultProtocolInfo",
+    inputs: [
+      {
+        name: "vaultId",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "depositorSignedPeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "universalChallengersVersion",
+        type: "uint16",
+        internalType: "uint16"
+      },
+      {
+        name: "appVaultKeepersVersion",
+        type: "uint16",
+        internalType: "uint16"
+      },
+      {
+        name: "offchainParamsVersion",
+        type: "uint16",
+        internalType: "uint16"
+      },
+      {
+        name: "verifiedAt",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "depositorWotsPkHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "hashlock",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "htlcVout",
+        type: "uint8",
+        internalType: "uint8"
+      },
+      {
+        name: "depositorPopSignature",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "prePeginTxHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "vaultProviderCommissionBps",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "protocolParams",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contract IProtocolParams"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "applicationRegistry",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contract IApplicationRegistry"
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+class L extends Error {
+  constructor(t, n, s = "local", i) {
+    super(n), this.code = t, this.source = s, this.data = i, this.name = "JsonRpcError";
+  }
+}
+const v = {
+  TIMEOUT: -32e3,
+  NETWORK: -32001,
+  /** VP proxy: request timed out at proxy level */
+  PROXY_TIMEOUT: -32002,
+  /** VP proxy: VP unreachable / DNS failure / response too large */
+  PROXY_UNAVAILABLE: -32003,
+  /** SDK client: response missing "result" field (malformed JSON-RPC) */
+  INVALID_RESPONSE: -32700
+}, oe = "2.0", ce = 3, le = 1e3, ue = /* @__PURE__ */ new Set([
+  408,
+  // Request Timeout
+  429,
+  // Too Many Requests
+  500,
+  // Internal Server Error
+  502,
+  // Bad Gateway
+  503,
+  // Service Unavailable
+  504
+  // Gateway Timeout
+]), de = /* @__PURE__ */ new Set([
+  "vaultProvider_getPeginStatus",
+  "vaultProvider_getPegoutStatus",
+  "vaultProvider_requestDepositorPresignTransactions"
+]);
+function be(e) {
+  return de.has(e);
+}
+const ye = "auth_expired";
+function pe(e) {
+  if (!(e instanceof L) || e.source !== "wire") return !1;
+  const t = e.data;
+  return t === null || typeof t != "object" ? !1 : t.kind === ye;
+}
+class qe {
+  constructor(t) {
+    l(this, "baseUrl");
+    l(this, "timeout");
+    l(this, "headers");
+    l(this, "requestId", 0);
+    l(this, "retries");
+    l(this, "retryDelay");
+    l(this, "retryableFor");
+    l(this, "tokenProvider");
+    this.baseUrl = t.baseUrl.replace(/\/$/, ""), this.timeout = t.timeout, this.headers = {
+      "Content-Type": "application/json",
+      ...t.headers
+    }, this.retries = t.retries ?? ce, this.retryDelay = t.retryDelay ?? le, this.retryableFor = t.retryableFor ?? be, this.tokenProvider = t.tokenProvider;
+  }
+  async buildHeaders(t) {
+    const n = { ...this.headers };
+    if (this.tokenProvider) {
+      const s = await this.tokenProvider.getToken(t);
+      s && (n.Authorization = `Bearer ${s}`);
+    }
+    return n;
+  }
+  /**
+   * Make a JSON-RPC request with optional retry for safe methods.
+   *
+   * If the request fails with a wire-origin `auth_expired` error and a
+   * `tokenProvider` is configured, the client invalidates its cached
+   * token and retries the request once with a freshly-acquired bearer.
+   *
+   * @param method - The RPC method name
+   * @param params - The method parameters
+   * @param signal - Optional AbortSignal for caller-controlled cancellation
+   * @returns The result from the RPC method
+   * @throws JsonRpcError if the RPC call fails
+   */
+  async call(t, n, s) {
+    try {
+      return await this.callOnce(t, n, s);
+    } catch (i) {
+      if (this.tokenProvider && pe(i))
+        return this.tokenProvider.invalidate(), await this.callOnce(t, n, s);
+      throw i;
+    }
+  }
+  async callOnce(t, n, s) {
+    const i = await this.fetchWithRetry(t, n, s);
+    let r;
+    try {
+      r = await i.json();
+    } catch {
+      throw new L(
+        v.INVALID_RESPONSE,
+        "Invalid JSON-RPC response: body is not valid JSON",
+        "local"
+      );
+    }
+    if (r === null || typeof r != "object" || Array.isArray(r))
+      throw new L(
+        v.INVALID_RESPONSE,
+        `Invalid JSON-RPC response: expected an object, got ${typeof r}`,
+        "local"
+      );
+    const a = r;
+    if ("error" in a && a.error != null) {
+      const c = a.error;
+      throw new L(
+        c.code ?? v.INVALID_RESPONSE,
+        c.message ?? "Unknown RPC error",
+        "wire",
+        c.data
+      );
+    }
+    if (!("result" in a))
+      throw new L(
+        v.INVALID_RESPONSE,
+        'Invalid JSON-RPC response: missing "result" field',
+        "local"
+      );
+    return a.result;
+  }
+  /**
+   * Make a JSON-RPC request returning the raw Response (unparsed body).
+   *
+   * Bearer tokens are injected identically to `call`. **Reactive refresh
+   * is NOT performed here** — the response body may be unbounded (e.g.
+   * claimer-artifact downloads), so the client refuses to parse it to
+   * detect auth errors. Callers relying on token-expired retries for
+   * large downloads must read the body themselves and re-invoke
+   * `callRaw` after `tokenProvider.invalidate()`.
+   */
+  async callRaw(t, n, s) {
+    return this.fetchWithRetry(t, n, s);
+  }
+  async fetchWithRetry(t, n, s) {
+    const i = ++this.requestId, r = this.retryableFor(t) ? this.retries : 0, c = JSON.stringify({
+      jsonrpc: oe,
+      method: t,
+      params: [n],
+      id: i
+    });
+    let u = null;
+    for (let b = 0; b <= r; b++) {
+      const h = new AbortController(), o = setTimeout(
+        () => h.abort(),
+        this.timeout
+      ), d = s ? fe(s, h.signal) : null, x = d ? d.signal : h.signal;
+      try {
+        const y = await this.buildHeaders(t), p = await fetch(this.baseUrl, {
+          method: "POST",
+          headers: y,
+          body: c,
+          signal: x
+        });
+        if (clearTimeout(o), d == null || d.cleanup(), !p.ok) {
+          if (b < r && ue.has(p.status)) {
+            const O = this.retryDelay * Math.pow(2, b);
+            await this.sleep(O, s);
+            continue;
+          }
+          throw new Error(
+            `HTTP error: ${p.status} ${p.statusText}`
+          );
+        }
+        return p;
+      } catch (y) {
+        if (clearTimeout(o), d == null || d.cleanup(), u = y instanceof Error ? y : new Error(String(y)), s != null && s.aborted)
+          throw new Error("Request aborted");
+        if (y instanceof Error && y.name === "AbortError") {
+          if (b < r) {
+            const p = this.retryDelay * Math.pow(2, b);
+            await this.sleep(p, s);
+            continue;
+          }
+          throw new L(
+            v.TIMEOUT,
+            `Request timeout after ${this.timeout}ms (${r + 1} attempts)`,
+            "local"
+          );
+        }
+        if (y instanceof TypeError) {
+          if (b < r) {
+            const p = this.retryDelay * Math.pow(2, b);
+            await this.sleep(p, s);
+            continue;
+          }
+          throw new L(
+            v.NETWORK,
+            `Network error: ${y.message} (${r + 1} attempts)`,
+            "local"
+          );
+        }
+        throw y;
+      }
+    }
+    throw u || new Error("Unknown error after retries");
+  }
+  sleep(t, n) {
+    return new Promise((s, i) => {
+      if (n != null && n.aborted) {
+        i(new Error("Request aborted"));
+        return;
+      }
+      const r = setTimeout(() => {
+        n == null || n.removeEventListener("abort", a), s();
+      }, t), a = () => {
+        clearTimeout(r), i(new Error("Request aborted"));
+      };
+      n == null || n.addEventListener("abort", a, { once: !0 });
+    });
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+}
+function fe(e, t) {
+  if (e.aborted) return { signal: e, cleanup: () => {
+  } };
+  if (t.aborted) return { signal: t, cleanup: () => {
+  } };
+  const n = new AbortController(), s = () => {
+    t.removeEventListener("abort", i), n.abort();
+  }, i = () => {
+    e.removeEventListener("abort", s), n.abort();
+  };
+  e.addEventListener("abort", s, { once: !0 }), t.addEventListener("abort", i, { once: !0 });
+  const r = () => {
+    e.removeEventListener("abort", s), t.removeEventListener("abort", i);
+  };
+  return { signal: n.signal, cleanup: r };
+}
+var he = /* @__PURE__ */ ((e) => (e.PENDING_INGESTION = "PendingIngestion", e.PENDING_DEPOSITOR_WOTS_PK = "PendingDepositorWotsPK", e.PENDING_BABE_SETUP = "PendingBabeSetup", e.PENDING_CHALLENGER_PRESIGNING = "PendingChallengerPresigning", e.PENDING_PEGIN_SIGS_AVAILABILITY = "PendingPeginSigsAvailability", e.PENDING_PRE_PEGIN_CONFIRMATIONS = "PendingPrePegInConfirmations", e.PENDING_DEPOSITOR_SIGNATURES = "PendingDepositorSignatures", e.PENDING_ACKS = "PendingACKs", e.PENDING_ACTIVATION = "PendingActivation", e.ACTIVATED = "Activated", e.EXPIRED = "Expired", e.CLAIM_POSTED = "ClaimPosted", e.PEGGED_OUT = "PeggedOut", e))(he || {});
+const $e = [
+  "PendingIngestion",
+  "PendingBabeSetup",
+  "PendingChallengerPresigning",
+  "PendingPeginSigsAvailability",
+  "PendingPrePegInConfirmations"
+  /* PENDING_PRE_PEGIN_CONFIRMATIONS */
+], xe = [
+  "PendingACKs",
+  "PendingActivation",
+  "Activated"
+  /* ACTIVATED */
+], Te = /* @__PURE__ */ new Set([
+  "PendingBabeSetup",
+  "PendingChallengerPresigning",
+  "PendingPeginSigsAvailability",
+  "PendingPrePegInConfirmations",
+  ...xe
+]), Je = /* @__PURE__ */ new Set([
+  "Expired",
+  "ClaimPosted",
+  "PeggedOut"
+  /* PEGGED_OUT */
+]), je = /* @__PURE__ */ new Set([
+  ...Te,
+  "PendingDepositorSignatures"
+  /* PENDING_DEPOSITOR_SIGNATURES */
+]);
+var Pe = /* @__PURE__ */ ((e) => (e[e.DATABASE_ERROR = -32005] = "DATABASE_ERROR", e[e.PRESIGN_ERROR = -32006] = "PRESIGN_ERROR", e[e.JSON_SERIALIZATION_ERROR = -32007] = "JSON_SERIALIZATION_ERROR", e[e.TX_GRAPH_ERROR = -32008] = "TX_GRAPH_ERROR", e[e.INVALID_GRAPH = -32009] = "INVALID_GRAPH", e[e.VALIDATION_ERROR = -32010] = "VALIDATION_ERROR", e[e.NOT_FOUND = -32011] = "NOT_FOUND", e[e.INTERNAL_ERROR = -32603] = "INTERNAL_ERROR", e))(Pe || {});
+function Ae(e) {
+  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function Y(e, t = "") {
+  if (!Number.isSafeInteger(e) || e < 0) {
+    const n = t && `"${t}" `;
+    throw new Error(`${n}expected integer >= 0, got ${e}`);
+  }
+}
+function J(e, t, n = "") {
+  const s = Ae(e), i = e == null ? void 0 : e.length, r = t !== void 0;
+  if (!s || r && i !== t) {
+    const a = n && `"${n}" `, c = r ? ` of length ${t}` : "", u = s ? `length=${i}` : `type=${typeof e}`;
+    throw new Error(a + "expected Uint8Array" + c + ", got " + u);
+  }
+  return e;
+}
+function Ye(e) {
+  if (typeof e != "function" || typeof e.create != "function")
+    throw new Error("Hash must wrapped by utils.createHasher");
+  Y(e.outputLen), Y(e.blockLen);
+}
+function X(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 me(e, t) {
+  J(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 Xe(e) {
+  return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
+}
+function U(...e) {
+  for (let t = 0; t < e.length; t++)
+    e[t].fill(0);
+}
+function $(e) {
+  return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function A(e, t) {
+  return e << 32 - t | e >>> t;
+}
+function ze(e, t) {
+  return e << t | e >>> 32 - t >>> 0;
+}
+const Ee = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function ge(e) {
+  return e << 24 & 4278190080 | e << 8 & 16711680 | e >>> 8 & 65280 | e >>> 24 & 255;
+}
+function Ie(e) {
+  for (let t = 0; t < e.length; t++)
+    e[t] = ge(e[t]);
+  return e;
+}
+const Ze = Ee ? (e) => e : Ie;
+function Se(e) {
+  if (typeof e != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(e));
+}
+function Qe(e, t = "") {
+  return typeof e == "string" ? Se(e) : J(e, void 0, t);
+}
+function et(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 ee(e, t = {}) {
+  const n = (i, r) => e(r).update(i).digest(), s = e(void 0);
+  return n.outputLen = s.outputLen, n.blockLen = s.blockLen, n.create = (i) => e(i), Object.assign(n, t), Object.freeze(n);
+}
+const te = (e) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, e])
+});
+function _e(e, t, n) {
+  return e & t ^ ~e & n;
+}
+function Re(e, t, n) {
+  return e & t ^ e & n ^ t & n;
+}
+class ne {
+  constructor(t, n, s, i) {
+    l(this, "blockLen");
+    l(this, "outputLen");
+    l(this, "padOffset");
+    l(this, "isLE");
+    // For partial updates less than block size
+    l(this, "buffer");
+    l(this, "view");
+    l(this, "finished", !1);
+    l(this, "length", 0);
+    l(this, "pos", 0);
+    l(this, "destroyed", !1);
+    this.blockLen = t, this.outputLen = n, this.padOffset = s, this.isLE = i, this.buffer = new Uint8Array(t), this.view = $(this.buffer);
+  }
+  update(t) {
+    X(this), J(t);
+    const { view: n, buffer: s, blockLen: i } = this, r = t.length;
+    for (let a = 0; a < r; ) {
+      const c = Math.min(i - this.pos, r - a);
+      if (c === i) {
+        const u = $(t);
+        for (; i <= r - a; a += i)
+          this.process(u, a);
+        continue;
+      }
+      s.set(t.subarray(a, a + c), this.pos), this.pos += c, a += c, this.pos === i && (this.process(n, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    X(this), me(t, this), this.finished = !0;
+    const { buffer: n, view: s, blockLen: i, isLE: r } = this;
+    let { pos: a } = this;
+    n[a++] = 128, U(this.buffer.subarray(a)), this.padOffset > i - a && (this.process(s, 0), a = 0);
+    for (let o = a; o < i; o++)
+      n[o] = 0;
+    s.setBigUint64(i - 8, BigInt(this.length * 8), r), this.process(s, 0);
+    const c = $(t), u = this.outputLen;
+    if (u % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const b = u / 4, h = this.get();
+    if (b > h.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let o = 0; o < b; o++)
+      c.setUint32(4 * o, h[o], r);
+  }
+  digest() {
+    const { buffer: t, outputLen: n } = this;
+    this.digestInto(t);
+    const s = t.slice(0, n);
+    return this.destroy(), s;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: n, buffer: s, length: i, finished: r, destroyed: a, pos: c } = this;
+    return t.destroyed = a, t.finished = r, t.length = i, t.pos = c, i % n && t.buffer.set(s), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const _ = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), T = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]), V = /* @__PURE__ */ BigInt(2 ** 32 - 1), z = /* @__PURE__ */ BigInt(32);
+function we(e, t = !1) {
+  return t ? { h: Number(e & V), l: Number(e >> z & V) } : { h: Number(e >> z & V) | 0, l: Number(e & V) | 0 };
+}
+function Ne(e, t = !1) {
+  const n = e.length;
+  let s = new Uint32Array(n), i = new Uint32Array(n);
+  for (let r = 0; r < n; r++) {
+    const { h: a, l: c } = we(e[r], t);
+    [s[r], i[r]] = [a, c];
+  }
+  return [s, i];
+}
+const Z = (e, t, n) => e >>> n, Q = (e, t, n) => e << 32 - n | t >>> n, B = (e, t, n) => e >>> n | t << 32 - n, H = (e, t, n) => e << 32 - n | t >>> n, k = (e, t, n) => e << 64 - n | t >>> n - 32, M = (e, t, n) => e >>> n - 32 | t << 64 - n, tt = (e, t, n) => e << n | t >>> 32 - n, nt = (e, t, n) => t << n | e >>> 32 - n, st = (e, t, n) => t << n - 32 | e >>> 64 - n, it = (e, t, n) => e << n - 32 | t >>> 64 - n;
+function g(e, t, n, s) {
+  const i = (t >>> 0) + (s >>> 0);
+  return { h: e + n + (i / 2 ** 32 | 0) | 0, l: i | 0 };
+}
+const Oe = (e, t, n) => (e >>> 0) + (t >>> 0) + (n >>> 0), Le = (e, t, n, s) => t + n + s + (e / 2 ** 32 | 0) | 0, ve = (e, t, n, s) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0), Be = (e, t, n, s, i) => t + n + s + i + (e / 2 ** 32 | 0) | 0, He = (e, t, n, s, i) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0) + (i >>> 0), De = (e, t, n, s, i, r) => t + n + s + i + r + (e / 2 ** 32 | 0) | 0, Ue = /* @__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
+]), R = /* @__PURE__ */ new Uint32Array(64);
+class Ce extends ne {
+  constructor(t) {
+    super(64, t, 8, !1);
+  }
+  get() {
+    const { A: t, B: n, C: s, D: i, E: r, F: a, G: c, H: u } = this;
+    return [t, n, s, i, r, a, c, u];
+  }
+  // prettier-ignore
+  set(t, n, s, i, r, a, c, u) {
+    this.A = t | 0, this.B = n | 0, this.C = s | 0, this.D = i | 0, this.E = r | 0, this.F = a | 0, this.G = c | 0, this.H = u | 0;
+  }
+  process(t, n) {
+    for (let o = 0; o < 16; o++, n += 4)
+      R[o] = t.getUint32(n, !1);
+    for (let o = 16; o < 64; o++) {
+      const d = R[o - 15], x = R[o - 2], y = A(d, 7) ^ A(d, 18) ^ d >>> 3, p = A(x, 17) ^ A(x, 19) ^ x >>> 10;
+      R[o] = p + R[o - 7] + y + R[o - 16] | 0;
+    }
+    let { A: s, B: i, C: r, D: a, E: c, F: u, G: b, H: h } = this;
+    for (let o = 0; o < 64; o++) {
+      const d = A(c, 6) ^ A(c, 11) ^ A(c, 25), x = h + d + _e(c, u, b) + Ue[o] + R[o] | 0, p = (A(s, 2) ^ A(s, 13) ^ A(s, 22)) + Re(s, i, r) | 0;
+      h = b, b = u, u = c, c = a + x | 0, a = r, r = i, i = s, s = x + p | 0;
+    }
+    s = s + this.A | 0, i = i + this.B | 0, r = r + this.C | 0, a = a + this.D | 0, c = c + this.E | 0, u = u + this.F | 0, b = b + this.G | 0, h = h + this.H | 0, this.set(s, i, r, a, c, u, b, h);
+  }
+  roundClean() {
+    U(R);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), U(this.buffer);
+  }
+}
+class Ge extends Ce {
+  constructor() {
+    super(32);
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    l(this, "A", _[0] | 0);
+    l(this, "B", _[1] | 0);
+    l(this, "C", _[2] | 0);
+    l(this, "D", _[3] | 0);
+    l(this, "E", _[4] | 0);
+    l(this, "F", _[5] | 0);
+    l(this, "G", _[6] | 0);
+    l(this, "H", _[7] | 0);
+  }
+}
+const se = Ne([
+  "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))), Ve = se[0], ke = se[1], w = /* @__PURE__ */ new Uint32Array(80), N = /* @__PURE__ */ new Uint32Array(80);
+class Me extends ne {
+  constructor(t) {
+    super(128, t, 16, !1);
+  }
+  // prettier-ignore
+  get() {
+    const { Ah: t, Al: n, Bh: s, Bl: i, Ch: r, Cl: a, Dh: c, Dl: u, Eh: b, El: h, Fh: o, Fl: d, Gh: x, Gl: y, Hh: p, Hl: P } = this;
+    return [t, n, s, i, r, a, c, u, b, h, o, d, x, y, p, P];
+  }
+  // prettier-ignore
+  set(t, n, s, i, r, a, c, u, b, h, o, d, x, y, p, P) {
+    this.Ah = t | 0, this.Al = n | 0, this.Bh = s | 0, this.Bl = i | 0, this.Ch = r | 0, this.Cl = a | 0, this.Dh = c | 0, this.Dl = u | 0, this.Eh = b | 0, this.El = h | 0, this.Fh = o | 0, this.Fl = d | 0, this.Gh = x | 0, this.Gl = y | 0, this.Hh = p | 0, this.Hl = P | 0;
+  }
+  process(t, n) {
+    for (let f = 0; f < 16; f++, n += 4)
+      w[f] = t.getUint32(n), N[f] = t.getUint32(n += 4);
+    for (let f = 16; f < 80; f++) {
+      const I = w[f - 15] | 0, S = N[f - 15] | 0, F = B(I, S, 1) ^ B(I, S, 8) ^ Z(I, S, 7), W = H(I, S, 1) ^ H(I, S, 8) ^ Q(I, S, 7), m = w[f - 2] | 0, E = N[f - 2] | 0, C = B(m, E, 19) ^ k(m, E, 61) ^ Z(m, E, 6), K = H(m, E, 19) ^ M(m, E, 61) ^ Q(m, E, 6), G = ve(W, K, N[f - 7], N[f - 16]), q = Be(G, F, C, w[f - 7], w[f - 16]);
+      w[f] = q | 0, N[f] = G | 0;
+    }
+    let { Ah: s, Al: i, Bh: r, Bl: a, Ch: c, Cl: u, Dh: b, Dl: h, Eh: o, El: d, Fh: x, Fl: y, Gh: p, Gl: P, Hh: O, Hl: D } = this;
+    for (let f = 0; f < 80; f++) {
+      const I = B(o, d, 14) ^ B(o, d, 18) ^ k(o, d, 41), S = H(o, d, 14) ^ H(o, d, 18) ^ M(o, d, 41), F = o & x ^ ~o & p, W = d & y ^ ~d & P, m = He(D, S, W, ke[f], N[f]), E = De(m, O, I, F, Ve[f], w[f]), C = m | 0, K = B(s, i, 28) ^ k(s, i, 34) ^ k(s, i, 39), G = H(s, i, 28) ^ M(s, i, 34) ^ M(s, i, 39), q = s & r ^ s & c ^ r & c, ie = i & a ^ i & u ^ a & u;
+      O = p | 0, D = P | 0, p = x | 0, P = y | 0, x = o | 0, y = d | 0, { h: o, l: d } = g(b | 0, h | 0, E | 0, C | 0), b = c | 0, h = u | 0, c = r | 0, u = a | 0, r = s | 0, a = i | 0;
+      const j = Oe(C, G, ie);
+      s = Le(j, E, K, q), i = j | 0;
+    }
+    ({ h: s, l: i } = g(this.Ah | 0, this.Al | 0, s | 0, i | 0)), { h: r, l: a } = g(this.Bh | 0, this.Bl | 0, r | 0, a | 0), { h: c, l: u } = g(this.Ch | 0, this.Cl | 0, c | 0, u | 0), { h: b, l: h } = g(this.Dh | 0, this.Dl | 0, b | 0, h | 0), { h: o, l: d } = g(this.Eh | 0, this.El | 0, o | 0, d | 0), { h: x, l: y } = g(this.Fh | 0, this.Fl | 0, x | 0, y | 0), { h: p, l: P } = g(this.Gh | 0, this.Gl | 0, p | 0, P | 0), { h: O, l: D } = g(this.Hh | 0, this.Hl | 0, O | 0, D | 0), this.set(s, i, r, a, c, u, b, h, o, d, x, y, p, P, O, D);
+  }
+  roundClean() {
+    U(w, N);
+  }
+  destroy() {
+    U(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+class Fe extends Me {
+  constructor() {
+    super(64);
+    l(this, "Ah", T[0] | 0);
+    l(this, "Al", T[1] | 0);
+    l(this, "Bh", T[2] | 0);
+    l(this, "Bl", T[3] | 0);
+    l(this, "Ch", T[4] | 0);
+    l(this, "Cl", T[5] | 0);
+    l(this, "Dh", T[6] | 0);
+    l(this, "Dl", T[7] | 0);
+    l(this, "Eh", T[8] | 0);
+    l(this, "El", T[9] | 0);
+    l(this, "Fh", T[10] | 0);
+    l(this, "Fl", T[11] | 0);
+    l(this, "Gh", T[12] | 0);
+    l(this, "Gl", T[13] | 0);
+    l(this, "Hh", T[14] | 0);
+    l(this, "Hl", T[15] | 0);
+  }
+}
+const rt = /* @__PURE__ */ ee(
+  () => new Ge(),
+  /* @__PURE__ */ te(1)
+), at = /* @__PURE__ */ ee(
+  () => new Fe(),
+  /* @__PURE__ */ te(3)
+);
+export {
+  Ke as B,
+  he as D,
+  ne as H,
+  qe as J,
+  $e as P,
+  Pe as R,
+  Te as V,
+  L as a,
+  v as b,
+  Je as c,
+  je as d,
+  Ye as e,
+  J as f,
+  U as g,
+  X as h,
+  ee as i,
+  Ne as j,
+  Y as k,
+  Ze as l,
+  me as m,
+  tt as n,
+  nt as o,
+  st as p,
+  it as q,
+  ze as r,
+  rt as s,
+  $ as t,
+  Xe as u,
+  et as v,
+  Qe as w,
+  at as x
+};
+//# sourceMappingURL=sha2-ZzfZqQSw.js.map