@leofcoin/chain 1.10.14 → 1.10.15

package/exports/browser/connection-monitor-pdopeM1I.js

@@ -1,453 +0,0 @@
-import { F as FormatInterface, o as proto$2, q as proto$3, i as index, f as index$1, r as proto$4 } from './browser-crypto-CTP3Yk4M.js';
-
-class ValidatorMessage extends FormatInterface {
-  get messageName() {
-    return "ValidatorMessage";
-  }
-  constructor(buffer) {
-    if (buffer instanceof ValidatorMessage)
-      return buffer;
-    const name = "validator-message";
-    super(buffer, proto$2, { name });
-  }
-}
-
-class BlockMessage extends FormatInterface {
-  get messageName() {
-    return "BlockMessage";
-  }
-  constructor(buffer) {
-    if (buffer instanceof BlockMessage)
-      return buffer;
-    const name = "block-message";
-    super(buffer, proto$3, { name });
-  }
-  encode(decoded) {
-    decoded = decoded || this.decoded;
-    const validators = [];
-    for (const validator of decoded.validators) {
-      if (validator instanceof ValidatorMessage)
-        validators.push(validator.encode());
-      else
-        validators.push(new ValidatorMessage(validator).encode());
-    }
-    return super.encode({
-      ...decoded,
-      validators: index(validators)
-    });
-  }
-  decode(encoded) {
-    encoded = encoded || this.encoded;
-    super.decode(encoded);
-    this.decoded.validators = index$1(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
-    return this.decoded;
-  }
-}
-
-var proto$1 = {
-  up: Number(),
-  down: Number()
-};
-
-class BWMessage extends FormatInterface {
-  get messageName() {
-    return "BWMessage";
-  }
-  constructor(buffer) {
-    if (buffer instanceof BWMessage)
-      return buffer;
-    const name = "bw-message";
-    super(buffer, proto$1, { name });
-  }
-}
-
-class LastBlockMessage extends FormatInterface {
-  get messageName() {
-    return "LastBlockMessage";
-  }
-  constructor(buffer) {
-    if (buffer instanceof LastBlockMessage)
-      return buffer;
-    const name = "last-block-message";
-    super(buffer, proto$4, { name });
-  }
-}
-
-var proto = {
-  lastblock: Object(),
-  values: Object()
-};
-
-class StateMessage extends FormatInterface {
-  get messageName() {
-    return "StateMessage";
-  }
-  constructor(buffer) {
-    if (buffer instanceof StateMessage)
-      return buffer;
-    const name = "state-message";
-    super(buffer, proto, { name });
-  }
-}
-
-var networks = {
-  leofcoin: {
-    mainnet: {
-      // ports don't really matter since it is favorable to have it begind a ngninx proxy but if we change something to the proto it's easier maybe?
-      port: 44444,
-      // todo a versionhash would be nice to have as a double check?
-      versionHash: "0",
-      // a short description identifying the version
-      description: "Main net current version",
-      stars: ["wss://star.leofcoin.org"]
-      // todo webrtc and bittorent stars
-    },
-    peach: {
-      port: 44444,
-      description: "Main testnet: latest step before merging into main",
-      versionHash: "1",
-      stars: ["wss://star.leofcoin.org"]
-      // todo webrtc and bittorent stars
-    }
-  }
-};
-
-var networks$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    default: networks
-});
-
-const PROTOCOL_VERSION = "0.3.0";
-const REACHED_ONE_ZERO_ZERO = false;
-const DEFAULT_NODE_OPTIONS = {
-  autoStart: false,
-  network: "leofcoin:peach",
-  networkVersion: "peach",
-  version: PROTOCOL_VERSION,
-  stars: networks.leofcoin.peach.stars
-};
-
-const INITIAL_RECONNECT_DELAY = 5e3;
-const MAX_RECONNECT_DELAY = 3e4;
-const isSendablePeer = (peer) => {
-  if (!peer || typeof peer !== "object") return false;
-  const candidate = peer;
-  if (typeof candidate.send !== "function") return false;
-  if (candidate.connected === true) return true;
-  return typeof candidate.once === "function" && typeof candidate.removeListener === "function";
-};
-const guardPeerMessages = (peernet) => {
-  const sendMessage = peernet.sendMessage.bind(peernet);
-  peernet.sendMessage = (peer, ...args) => {
-    if (isSendablePeer(peer)) return sendMessage(peer, ...args);
-    for (const [peerId, connection] of Object.entries(peernet.connections || {})) {
-      if (connection === peer) delete peernet.connections[peerId];
-    }
-    return Promise.resolve(void 0);
-  };
-};
-class ConnectionMonitor {
-  #isMonitoring = false;
-  #checkInterval = null;
-  #reconnectDelay = INITIAL_RECONNECT_DELAY;
-  #reconnectTimer = null;
-  #healthCheckInterval = 6e4;
-  #version;
-  #lastHealthCheckAt = 0;
-  #reconnecting = false;
-  // event handlers to remove later
-  #onOnline = null;
-  #onVisibilityChange = null;
-  #onSigcont = null;
-  #onPeerConnected = null;
-  get isMonitoring() {
-    return this.#isMonitoring;
-  }
-  get connectedPeers() {
-    return Object.values(globalThis.peernet?.connections || {}).filter((peer) => peer.connected);
-  }
-  get compatiblePeers() {
-    return this.connectedPeers.filter((peer) => {
-      if (!peer.version || !this.#version) return false;
-      const [peerMajor, peerMinor] = peer.version.split(".");
-      const [localMajor, localMinor] = this.#version.split(".");
-      return peerMajor === localMajor && peerMinor === localMinor;
-    });
-  }
-  get disconnectedPeers() {
-    return Object.values(globalThis.peernet?.connections || {}).filter((peer) => !peer.connected);
-  }
-  #pruneInvalidConnections() {
-    const connections = globalThis.peernet?.connections;
-    if (!connections) return;
-    for (const [peerId, peer] of Object.entries(connections)) {
-      if (!isSendablePeer(peer)) {
-        delete connections[peerId];
-        console.warn(`Removed invalid peer connection: ${peerId}`);
-      }
-    }
-  }
-  start(version) {
-    this.#version = version;
-    console.log(`\u{1F517} Connection Monitor initialized for version: ${this.#version}`);
-    if (this.#isMonitoring) return;
-    this.#isMonitoring = true;
-    console.log("\u{1F504} Starting connection monitor...");
-    if (typeof window !== "undefined" && typeof document !== "undefined") {
-      this.#onOnline = () => {
-        console.log("\u{1F310} Network online \u2014 attempting restore");
-        void this.#restoreNetwork();
-      };
-      window.addEventListener("online", this.#onOnline);
-      this.#onVisibilityChange = () => {
-        if (document.visibilityState === "visible") {
-          console.log("\u{1F4A1} Visibility regained");
-          if (this.connectedPeers.length === 0) {
-            console.log("\u{1F4A1} Visibility regained \u2014 attempting restore");
-            void this.#restoreNetwork();
-          }
-        }
-      };
-      document.addEventListener("visibilitychange", this.#onVisibilityChange);
-    }
-    if (typeof process !== "undefined" && typeof process.on === "function") {
-      this.#onSigcont = () => {
-        console.log("\u{1F514} Process resumed (SIGCONT) \u2014 attempting restore");
-        void this.#restoreNetwork();
-      };
-      try {
-        process.on("SIGCONT", this.#onSigcont);
-      } catch (e) {
-      }
-    }
-    this.#lastHealthCheckAt = Date.now();
-    this.#checkInterval = setInterval(() => {
-      this.#healthCheck();
-    }, this.#healthCheckInterval);
-    this.#onPeerConnected = () => {
-      if (this.#reconnectTimer) {
-        clearTimeout(this.#reconnectTimer);
-        this.#reconnectTimer = null;
-      }
-      this.#reconnecting = false;
-      this.#reconnectDelay = INITIAL_RECONNECT_DELAY;
-    };
-    globalThis.pubsub?.subscribe("peer:connected", this.#onPeerConnected);
-  }
-  stop() {
-    if (!this.#isMonitoring) return;
-    this.#isMonitoring = false;
-    if (this.#checkInterval) {
-      clearInterval(this.#checkInterval);
-      this.#checkInterval = null;
-    }
-    if (typeof window !== "undefined") {
-      if (this.#onOnline) {
-        window.removeEventListener("online", this.#onOnline);
-        this.#onOnline = null;
-      }
-      if (this.#onVisibilityChange) {
-        document.removeEventListener("visibilitychange", this.#onVisibilityChange);
-        this.#onVisibilityChange = null;
-      }
-    }
-    if (typeof process !== "undefined" && typeof process.removeListener === "function" && this.#onSigcont) {
-      try {
-        process.removeListener("SIGCONT", this.#onSigcont);
-      } catch (e) {
-      }
-      this.#onSigcont = null;
-    }
-    if (this.#onPeerConnected) {
-      globalThis.pubsub?.unsubscribe("peer:connected", this.#onPeerConnected);
-      this.#onPeerConnected = null;
-    }
-    if (this.#reconnectTimer) {
-      clearTimeout(this.#reconnectTimer);
-      this.#reconnectTimer = null;
-    }
-    console.log("\u23F9\uFE0F Connection monitor stopped");
-  }
-  async #healthCheck() {
-    this.#pruneInvalidConnections();
-    const now = Date.now();
-    const expectedNext = this.#lastHealthCheckAt + this.#healthCheckInterval;
-    const drift = now - expectedNext;
-    this.#lastHealthCheckAt = now;
-    if (drift > 5e3) {
-      console.log(`\u23F0 Detected timer drift of ${drift}ms (likely system sleep) \u2014 attempting restore`);
-      void this.#restoreNetwork();
-    }
-    const connectedPeers = this.connectedPeers;
-    const compatiblePeers = this.compatiblePeers;
-    const disconnectedPeers = this.disconnectedPeers;
-    console.log(
-      `\u{1F50D} Health check: ${connectedPeers.length} connected, ${compatiblePeers.length} compatible, ${disconnectedPeers.length} negotiating`
-    );
-    if (connectedPeers.length === 0 && disconnectedPeers.length === 0 && !this.#reconnectTimer) {
-      console.warn("\u26A0\uFE0F No peer connections detected \u2014 attempting reconnection");
-      await this.#attemptReconnection();
-    } else if (compatiblePeers.length === 0 && connectedPeers.length > 0 && !this.#reconnectTimer) {
-      console.warn("\u26A0\uFE0F No compatible peers found \u2014 attempting reconnection");
-      await this.#attemptReconnection();
-    }
-    globalThis.pubsub?.publish("connection-status", {
-      connected: connectedPeers.length,
-      compatible: compatiblePeers.length,
-      healthy: compatiblePeers.length > 0
-    });
-  }
-  // lightweight TCP probe to detect internet connectivity in Node.js
-  async #isOnLine(timeout = 1500) {
-    if (navigator?.onLine !== void 0) {
-      return navigator.onLine;
-    }
-    return new Promise(async (resolve) => {
-      try {
-        const net = await import('net');
-        const socket = new net.Socket();
-        let finished = false;
-        const finish = (val) => {
-          if (finished) return;
-          finished = true;
-          try {
-            socket.destroy();
-          } catch (e) {
-          }
-          resolve(val);
-        };
-        socket.setTimeout(timeout);
-        socket.once("connect", () => finish(true));
-        socket.once("error", () => finish(false));
-        socket.once("timeout", () => finish(false));
-        socket.connect(53, "1.1.1.1");
-      } catch (e) {
-        resolve(false);
-      }
-    });
-  }
-  // Called on visibility/online/resume events
-  async #restoreNetwork() {
-    if (this.#reconnecting) {
-      console.log("\u{1F501} Reconnection already in progress, skipping");
-      return;
-    }
-    this.#reconnecting = true;
-    if (this.connectedPeers.length > 0) {
-      console.log("\u2705 Already connected to peers, skipping restoration");
-      this.#reconnecting = false;
-      return;
-    }
-    console.log("\u{1F501} Restoring network");
-    try {
-      const online = await this.#isOnLine(1500);
-      if (!online) {
-        console.warn("\u26A0\uFE0F No internet detected, skipping restore");
-        this.#reconnecting = false;
-        return;
-      }
-    } catch (e) {
-      console.warn("\u26A0\uFE0F Online probe failed, proceeding with restore", e?.message || e);
-    }
-    try {
-      console.log("\u{1F504} Attempting network restoration...");
-      if (globalThis.peernet?.client?.reinit) {
-        console.log("  \u2192 Trying client.reinit()");
-        try {
-          await globalThis.peernet.client.reinit();
-          console.log("  \u2705 client.reinit() succeeded");
-        } catch (e) {
-          console.warn("  \u26A0\uFE0F client.reinit() failed:", e?.message || e);
-        }
-      }
-      if (globalThis.peernet?.start) {
-        console.log("  \u2192 Trying peernet.start()");
-        try {
-          await globalThis.peernet.start();
-          console.log("  \u2705 peernet.start() succeeded");
-        } catch (e) {
-          console.warn("  \u26A0\uFE0F peernet.start() failed:", e?.message || e);
-        }
-      }
-      try {
-        const networkName = globalThis.peernet?.network;
-        if (networkName && typeof networkName === "string") {
-          const { default: networks } = await Promise.resolve().then(function () { return networks$1; });
-          const [mainKey, subKey] = networkName.split(":");
-          const networkConfig = networks?.[mainKey]?.[subKey];
-          if (networkConfig?.stars && Array.isArray(networkConfig.stars)) {
-            console.log("  \u2192 Attempting to dial star servers:", networkConfig.stars.join(", "));
-            for (const star of networkConfig.stars) {
-              try {
-                if (globalThis.peernet?.client && "dial" in globalThis.peernet.client) {
-                  await globalThis.peernet.client.dial(star);
-                  console.log(`  \u2705 Connected to star server: ${star}`);
-                }
-              } catch (e) {
-                console.warn(`  \u26A0\uFE0F Failed to dial ${star}:`, e?.message || e);
-              }
-            }
-          }
-        }
-      } catch (e) {
-        console.warn("  \u26A0\uFE0F Could not load or dial star servers:", e?.message || e);
-      }
-      await new Promise((resolve) => setTimeout(resolve, 2e3));
-      this.#pruneInvalidConnections();
-      const connectedAfter = this.connectedPeers.length;
-      console.log(`\u{1F504} Restoration complete. Connected peers: ${connectedAfter}`);
-    } catch (error) {
-      console.error("\u274C Network restoration failed:", error?.message || error);
-    } finally {
-      this.#reconnecting = false;
-    }
-  }
-  async waitForPeers(timeoutMs = 3e4) {
-    return new Promise((resolve) => {
-      const startTime = Date.now();
-      const checkPeers = () => {
-        if (this.compatiblePeers.length > 0) {
-          resolve(true);
-          return;
-        }
-        if (Date.now() - startTime >= timeoutMs) {
-          resolve(false);
-          return;
-        }
-        setTimeout(checkPeers, 1e3);
-      };
-      checkPeers();
-    });
-  }
-  async #attemptReconnection() {
-    try {
-      await this.#restoreNetwork();
-      const hasConnections = this.connectedPeers.length > 0 || this.disconnectedPeers.length > 0;
-      if (hasConnections) {
-        console.log("\u2705 Reconnection successful, resetting backoff delay");
-        this.#reconnectDelay = INITIAL_RECONNECT_DELAY;
-      } else {
-        console.warn("\u26A0\uFE0F Reconnection attempt completed but no peers connected");
-        this.#scheduleReconnect();
-      }
-    } catch (error) {
-      console.error("\u274C Reconnection failed:", error?.message || error);
-      this.#scheduleReconnect();
-    }
-  }
-  #scheduleReconnect() {
-    if (!this.#isMonitoring || this.#reconnectTimer) return;
-    if (this.#reconnectDelay >= MAX_RECONNECT_DELAY) {
-      console.warn("\u26A0\uFE0F No peers available; automatic retries paused until the next health check or network event");
-      return;
-    }
-    this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, MAX_RECONNECT_DELAY);
-    console.warn(`\u26A0\uFE0F Increasing reconnection delay to ${this.#reconnectDelay} ms`);
-    this.#reconnectTimer = setTimeout(() => {
-      this.#reconnectTimer = null;
-      void this.#attemptReconnection();
-    }, this.#reconnectDelay);
-  }
-}
-
-export { BlockMessage as B, ConnectionMonitor as C, DEFAULT_NODE_OPTIONS as D, LastBlockMessage as L, PROTOCOL_VERSION as P, REACHED_ONE_ZERO_ZERO as R, StateMessage as S, ValidatorMessage as V, BWMessage as a, guardPeerMessages as g };

package/exports/browser/hkdf-B9AXp_7K.js

@@ -1,222 +0,0 @@
-import { a as ahash, b as abytes, c as clean, d as aexists, e as aoutput, f as anumber } from './sha2-Dkoic3vb.js';
-
-/**
- * HMAC: RFC2104 message authentication code.
- * @module
- */
-/**
- * Internal class for HMAC.
- * Accepts any byte key, although RFC 2104 §3 recommends keys at least
- * `HashLen` bytes long.
- */
-class _HMAC {
-    oHash;
-    iHash;
-    blockLen;
-    outputLen;
-    canXOF = false;
-    finished = false;
-    destroyed = false;
-    constructor(hash, key) {
-        ahash(hash);
-        abytes(key, undefined, 'key');
-        this.iHash = hash.create();
-        if (typeof this.iHash.update !== 'function')
-            throw new Error('expected Hash instance');
-        this.blockLen = this.iHash.blockLen;
-        this.outputLen = this.iHash.outputLen;
-        const blockLen = this.blockLen;
-        const pad = new Uint8Array(blockLen);
-        // blockLen can be bigger than outputLen
-        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
-        for (let i = 0; i < pad.length; i++)
-            pad[i] ^= 0x36;
-        this.iHash.update(pad);
-        // By doing update (processing of the first block) of the outer hash here,
-        // we can re-use it between multiple calls via clone.
-        this.oHash = hash.create();
-        // Undo internal XOR && apply outer XOR
-        for (let i = 0; i < pad.length; i++)
-            pad[i] ^= 0x36 ^ 0x5c;
-        this.oHash.update(pad);
-        clean(pad);
-    }
-    update(buf) {
-        aexists(this);
-        this.iHash.update(buf);
-        return this;
-    }
-    digestInto(out) {
-        aexists(this);
-        aoutput(out, this);
-        this.finished = true;
-        const buf = out.subarray(0, this.outputLen);
-        // Reuse the first outputLen bytes for the inner digest; the outer hash consumes them before
-        // overwriting that same prefix with the final tag, leaving any oversized tail untouched.
-        this.iHash.digestInto(buf);
-        this.oHash.update(buf);
-        this.oHash.digestInto(buf);
-        this.destroy();
-    }
-    digest() {
-        const out = new Uint8Array(this.oHash.outputLen);
-        this.digestInto(out);
-        return out;
-    }
-    _cloneInto(to) {
-        // Create new instance without calling constructor since the key
-        // is already in state and we don't know it.
-        to ||= Object.create(Object.getPrototypeOf(this), {});
-        const { oHash, iHash, finished, destroyed, blockLen, outputLen, canXOF } = this;
-        to = to;
-        to.finished = finished;
-        to.destroyed = destroyed;
-        to.blockLen = blockLen;
-        to.outputLen = outputLen;
-        to.canXOF = canXOF;
-        to.oHash = oHash._cloneInto(to.oHash);
-        to.iHash = iHash._cloneInto(to.iHash);
-        return to;
-    }
-    clone() {
-        return this._cloneInto();
-    }
-    destroy() {
-        this.destroyed = true;
-        this.oHash.destroy();
-        this.iHash.destroy();
-    }
-}
-const hmac = /* @__PURE__ */ (() => {
-    const hmac_ = ((hash, key, message) => new _HMAC(hash, key).update(message).digest());
-    hmac_.create = (hash, key) => new _HMAC(hash, key);
-    return hmac_;
-})();
-
-/**
- * HKDF (RFC 5869): extract + expand in one step.
- * See {@link https://soatok.blog/2021/11/17/understanding-hkdf/}.
- * @module
- */
-// Shared mutable scratch byte for the RFC 5869 block counter `N`.
-// Safe to reuse because `expand()` is synchronous and resets it with `clean(...)` before returning.
-const HKDF_COUNTER = /* @__PURE__ */ Uint8Array.of(0);
-// Shared RFC 5869 empty string for both `info === undefined` and the first-block `T(0)` input.
-const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
-/**
- * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
- * @param hash - hash function that would be used (e.g. sha256)
- * @param prk - a pseudorandom key of at least HashLen octets
- *   (usually, the output from the extract step)
- * @param info - optional context and application specific information (can be a zero-length string)
- * @param length - length of output keying material in bytes.
- *   RFC 5869 §2.3 allows `0..255*HashLen`, so `0` returns an empty OKM.
- * @param _recycled - Internal destroyed extract hashes owned by the combined `hkdf()` call.
- * @returns Output keying material with the requested length.
- * @throws If the requested output length exceeds the HKDF limit
- *   for the selected hash. {@link Error}
- * @example
- * Run the HKDF expand step.
- * ```ts
- * import { expand } from '@noble/hashes/hkdf.js';
- * import { sha256 } from '@noble/hashes/sha2.js';
- * expand(sha256, new Uint8Array(32), new Uint8Array([1, 2, 3]), 16);
- * ```
- */
-function expand(hash, prk, info, length = 32, _recycled) {
-    ahash(hash);
-    anumber(length, 'length');
-    abytes(prk, undefined, 'prk');
-    const olen = hash.outputLen;
-    // RFC 5869 §2.3: PRK is "a pseudorandom key of at least HashLen octets".
-    if (prk.length < olen)
-        throw new Error('"prk" must be at least HashLen octets');
-    // RFC 5869 §2.3 only bounds `L` by `<= 255*HashLen`; `L=0` is valid and yields empty OKM.
-    if (length > 255 * olen)
-        throw new Error('Length must be <= 255*HashLen');
-    const blocks = Math.ceil(length / olen);
-    if (info === undefined)
-        info = EMPTY_BUFFER;
-    else
-        abytes(info, undefined, 'info');
-    if (!blocks) {
-        if (_recycled)
-            clean(prk); // Full hkdf() owns this intermediate PRK.
-        return new Uint8Array();
-    }
-    // first L(ength) octets of T
-    // The private PRK can become both T and a one-block result after HMAC consumes the key.
-    const okm = _recycled && blocks === 1 ? prk : new Uint8Array(blocks * olen);
-    const { iHash, oHash } = hmac.create(hash, prk);
-    // Driving them directly also skips `_HMAC.digestInto`'s per-digest destroy.
-    const T = _recycled ? prk : new Uint8Array(olen);
-    // Full hkdf() donates one destroyed extract hash; standalone creates one alternating worker.
-    const worker = blocks > 1 ? _recycled?.iHash || hash.create() : undefined;
-    for (let counter = 0; counter < blocks - 1; counter++) {
-        HKDF_COUNTER[0] = counter + 1;
-        const iWork = iHash._cloneInto(worker);
-        // T(0) = empty string (zero length)
-        // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)
-        if (counter)
-            iWork.update(T);
-        iWork.update(info).update(HKDF_COUNTER).digestInto(T);
-        oHash._cloneInto(worker).update(T).digestInto(T);
-        okm.set(T, olen * counter);
-    }
-    // Midstates are key-equivalent: they allow computing HMAC(prk, ...) for any message.
-    HKDF_COUNTER[0] = blocks; // Final block consumes them; retain worker for cleanup.
-    if (blocks > 1)
-        iHash.update(T);
-    iHash.update(info).update(HKDF_COUNTER).digestInto(T);
-    oHash.update(T).digestInto(T);
-    okm.set(T, olen * (blocks - 1));
-    iHash.destroy(); // Raw digests may leave key-derived base/worker state; wipe all explicitly.
-    oHash.destroy();
-    worker?.destroy();
-    if (T !== okm)
-        clean(T); // Wipe private T/PRK; standalone preserves caller-owned PRK.
-    clean(HKDF_COUNTER);
-    // Exact fit: return without the extra copy.
-    if (length === okm.length)
-        return okm;
-    // Copy the requested prefix, then wipe the full buffer: its tail holds
-    // up to HashLen-1 bytes of derived key material past `length`.
-    const res = okm.slice(0, length);
-    clean(okm);
-    return res;
-}
-/**
- * HKDF (RFC 5869): derive keys from an initial input.
- * Combines hkdf_extract + hkdf_expand in one step
- * @param hash - hash function that would be used (e.g. sha256)
- * @param ikm - input keying material, the initial key
- * @param salt - optional salt value (a non-secret random value)
- * @param info - optional context and application specific information bytes
- * @param length - length of output keying material in bytes.
- *   RFC 5869 §2.3 allows `0..255*HashLen`, so `0` returns an empty OKM.
- * @returns Output keying material derived from the input key.
- * @throws If the requested output length exceeds the HKDF limit
- *   for the selected hash. {@link Error}
- * @example
- * HKDF (RFC 5869): derive keys from an initial input.
- * ```ts
- * import { hkdf } from '@noble/hashes/hkdf.js';
- * import { sha256 } from '@noble/hashes/sha2.js';
- * import { randomBytes, utf8ToBytes } from '@noble/hashes/utils.js';
- * const inputKey = randomBytes(32);
- * const salt = randomBytes(32);
- * const info = utf8ToBytes('application-key');
- * const okm = hkdf(sha256, inputKey, salt, info, 32);
- * ```
- */
-const hkdf = (hash, ikm, salt, info, length) => {
-    ahash(hash);
-    if (salt === undefined)
-        salt = new Uint8Array(hash.outputLen);
-    const HMAC = hmac.create(hash, salt).update(ikm);
-    // The intermediate PRK is secret key material; wipe it instead of
-    // leaving it for GC.
-    return expand(hash, HMAC.digest(), info, length, HMAC); // expand() owns and consumes it.
-};
-
-export { hkdf as h };