@leofcoin/chain 1.10.13 → 1.10.15

package/exports/browser/hkdf-CnZvwpZ9.js

@@ -0,0 +1,222 @@
+import { a as ahash, b as abytes, c as clean, d as aexists, e as aoutput, f as anumber } from './sha2-piimb6xL.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 };

package/exports/browser/{index-Bxr5Iztg-C6xBk0rK.js → index-Bxr5Iztg-WbFIosyf.js}

@@ -1,8 +1,8 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-xlqSBOaN.js';
-import 'crypto';
-import './constants-Cv0p224A.js';
-import './proposal.proto-BcUgd885.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-BYi7D_oa.js';
+import './browser-crypto-B9N9KlL4.js';
+import './connection-monitor-GPztgSSJ.js';
 import './index-CvKt4UDE.js';
+import './sha2-piimb6xL.js';
 
 /**
  * @params {String} network

package/exports/browser/{index-CFBGfpG1.js → index-Ccn5sExe.js}

@@ -1,6 +1,5 @@
-import { F as FormatInterface, e as proto, T as TransactionMessage, C as ContractMessage, i as index$1, f as index$2, g as createRIPEMD160, h as createHMAC, k as createSHA512, l as createKeccak, m as index$3 } from './proposal.proto-BcUgd885.js';
+import { F as FormatInterface, e as proto, T as TransactionMessage, C as ContractMessage, i as index$1, f as index$2, g as createRIPEMD160, h as createHMAC, k as createSHA512, l as createKeccak, m as index$3, n as createHash$1 } from './browser-crypto-B9N9KlL4.js';
 import { t as toBase58, b as base58$1, i as index$4 } from './index-CvKt4UDE.js';
-import { createHash as createHash$1 } from 'crypto';
 
 /* Do NOT modify this file; see /src.ts/_admin/update-version.ts */
 /**

package/exports/browser/{messages-FMRAS8QX-CvlZBzy5.js → messages-DH0tgNM9-C2CtyLsf.js}

@@ -1,8 +1,8 @@
-import { F as FormatInterface } from './node-browser-xlqSBOaN.js';
-import 'crypto';
-import './constants-Cv0p224A.js';
-import './proposal.proto-BcUgd885.js';
+import { F as FormatInterface } from './node-browser-BYi7D_oa.js';
+import './browser-crypto-B9N9KlL4.js';
+import './connection-monitor-GPztgSSJ.js';
 import './index-CvKt4UDE.js';
+import './sha2-piimb6xL.js';
 
 var proto$b = {
     data: new Uint8Array(),

package/exports/browser/{node-browser-xlqSBOaN.js → node-browser-BYi7D_oa.js}

@@ -1,7 +1,6 @@
-import { createHash as createHash$1 } from 'crypto';
-import { B as BlockMessage, a as BWMessage, V as ValidatorMessage, S as StateMessage, L as LastBlockMessage, D as DEFAULT_NODE_OPTIONS } from './constants-Cv0p224A.js';
+import { F as FormatInterface$2, T as TransactionMessage, C as ContractMessage, n as createHash$1 } from './browser-crypto-B9N9KlL4.js';
+import { B as BlockMessage, a as BWMessage, V as ValidatorMessage, S as StateMessage, L as LastBlockMessage, D as DEFAULT_NODE_OPTIONS, g as guardPeerMessages } from './connection-monitor-GPztgSSJ.js';
 import './index-CvKt4UDE.js';
-import { F as FormatInterface$2, T as TransactionMessage, C as ContractMessage } from './proposal.proto-BcUgd885.js';
 
 var proto = {};
 
@@ -8391,7 +8390,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-Bxr5Iztg-C6xBk0rK.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-Bxr5Iztg-WbFIosyf.js');
             const { identity, accounts } = await importee.default(password, this.network);
             if (fresh) {
                 await globalThis.accountStore.clear();
@@ -17140,7 +17139,7 @@ class Peernet {
         await getAddress();
         this.storePrefix = options.storePrefix;
         this.root = options.root;
-        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-FMRAS8QX-CvlZBzy5.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-DH0tgNM9-C2CtyLsf.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -17187,7 +17186,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-B-jyclOB-CsNYfj4Z.js');
+        const importee = await import('./client-DDC8C510-3uaB70KL.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -17866,6 +17865,7 @@ class Node {
   async _init(config = {}, password) {
     config = { ...DEFAULT_NODE_OPTIONS, ...config };
     this.#node = globalThis.Peernet ? await new globalThis.Peernet(config, password) : await new Peernet(config, password);
+    guardPeerMessages(this.#node);
     await nodeConfig(config);
     globalThis.pubsub.subscribe("chain:ready", async () => {
       if (!this.#node.autoStart) {

package/exports/browser/node-browser.js

@@ -1,5 +1,5 @@
-export { N as default } from './node-browser-xlqSBOaN.js';
-import 'crypto';
-import './constants-Cv0p224A.js';
+export { N as default } from './node-browser-BYi7D_oa.js';
+import './browser-crypto-B9N9KlL4.js';
+import './connection-monitor-GPztgSSJ.js';
 import './index-CvKt4UDE.js';
-import './proposal.proto-BcUgd885.js';
+import './sha2-piimb6xL.js';