@leofcoin/chain 1.10.16 → 1.10.18

package/exports/browser/{messages-Dw86z0zq-DrPw_nlZ.js → messages-BGHaihSi-eHZVl0y9.js}

@@ -1,8 +1,8 @@
-import { F as FormatInterface } from './node-browser-DWSdi-XP.js';
-import './browser-crypto-CeE-yId5.js';
-import './connection-monitor-Cmv00mwl.js';
+import { F as FormatInterface } from './node-browser-BNe-en1l.js';
+import './browser-crypto-CH0ua22L.js';
+import './connection-monitor-D-krNiRH.js';
 import './index-CvKt4UDE.js';
-import './sha2-piimb6xL.js';
+import './sha2-BKcEJzgd.js';
 
 var proto$b = {
     data: new Uint8Array(),

package/exports/browser/{node-browser-DWSdi-XP.js → node-browser-BNe-en1l.js}

@@ -1,5 +1,5 @@
-import { F as FormatInterface$2, T as TransactionMessage, C as ContractMessage, n as createHash$1 } from './browser-crypto-CeE-yId5.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-Cmv00mwl.js';
+import { F as FormatInterface$2, T as TransactionMessage, C as ContractMessage, n as createHash$1 } from './browser-crypto-CH0ua22L.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-D-krNiRH.js';
 import './index-CvKt4UDE.js';
 
 var proto = {};
@@ -8510,7 +8510,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-dTQVgkpf-CuHJWO2l.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-dTQVgkpf-BbdshWB0.js');
             const { identity, accounts } = await importee.default(password, this.network);
             if (fresh) {
                 await globalThis.accountStore.clear();
@@ -17484,7 +17484,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-Dw86z0zq-DrPw_nlZ.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-BGHaihSi-eHZVl0y9.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -17531,7 +17531,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-CAC7RVMf-Dmz_2A_5.js');
+        const importee = await import('./client-C_pBoi1g-_pfKzCvX.js');
         /**
          * @access public
          * @type {PeernetClient}

package/exports/browser/node-browser.js

@@ -1,5 +1,5 @@
-export { N as default } from './node-browser-DWSdi-XP.js';
-import './browser-crypto-CeE-yId5.js';
-import './connection-monitor-Cmv00mwl.js';
+export { N as default } from './node-browser-BNe-en1l.js';
+import './browser-crypto-CH0ua22L.js';
+import './connection-monitor-D-krNiRH.js';
 import './index-CvKt4UDE.js';
-import './sha2-piimb6xL.js';
+import './sha2-BKcEJzgd.js';

package/exports/browser/{sha2-piimb6xL.js → sha2-BKcEJzgd.js}

@@ -73,10 +73,13 @@ function anumber(n, title = '') {
 function abytes(value, length, title = '') {
     // Success path first: this runs at the start of every update() / digestInto(), and the
     // common `abytes(data)` form must not pay for length handling it does not use.
-    if (isBytes(value) && (length === undefined))
+    if (isBytes(value) && (length === undefined || value.length === length))
         return value;
+    // Error path: recompute freely to build the exact message.
+    if (length !== undefined)
+        anumber(length, 'length');
     const bytes = isBytes(value);
-    const ofLen = '';
+    const ofLen = length !== undefined ? ` of length ${length}` : '';
     const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
     const message = atitle(title) + 'expected Uint8Array' + ofLen + ', got ' + got;
     if (!bytes)
@@ -209,6 +212,113 @@ function createView(arr) {
 function rotr(word, shift) {
     return (word << (32 - shift)) | (word >>> shift);
 }
+// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
+const hasHexBuiltin = /* @__PURE__ */ (() => 
+// @ts-ignore
+typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
+// Array where index 0xf0 (240) is mapped to string 'f0'
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+/**
+ * Convert byte array to hex string.
+ * Uses the built-in function when available and assumes it matches the tested
+ * fallback semantics.
+ * @param bytes - bytes to encode
+ * @returns Lowercase hexadecimal string.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Convert bytes to lowercase hexadecimal.
+ * ```ts
+ * bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])); // 'cafe0123'
+ * ```
+ */
+function bytesToHex(bytes) {
+    abytes(bytes);
+    // @ts-ignore
+    if (hasHexBuiltin)
+        return bytes.toHex();
+    // pre-caching improves the speed 6x
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+    }
+    return hex;
+}
+// Strict ASCII nibble parser: non-ASCII hex lookalikes are rejected as undefined.
+// ASCII codes: '0'..'9' = 48..57, 'A'..'F' = 65..70, 'a'..'f' = 97..102.
+// prettier-ignore
+function asciiToBase16(ch) {
+    return ch >= 48 && ch <= 57 ? ch - 48 // '2' => 50-48
+        : ch >= 65 && ch <= 70 ? ch - (65 - 10) // 'B' => 66-(65-10)
+            : ch >= 97 && ch <= 102 ? ch - (97 - 10) // 'b' => 98-(97-10)
+                : undefined;
+}
+/**
+ * Convert hex string to byte array. Uses built-in function, when available.
+ * @param hex - hexadecimal string to decode
+ * @returns Decoded bytes.
+ * @throws On wrong argument types. {@link TypeError}
+ * @throws On wrong argument ranges or values. {@link RangeError}
+ * @example
+ * Decode lowercase hexadecimal into bytes.
+ * ```ts
+ * hexToBytes('cafe0123'); // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ * ```
+ */
+function hexToBytes(hex) {
+    if (typeof hex !== 'string')
+        throw new TypeError('hex string expected, got ' + typeof hex);
+    if (hasHexBuiltin) {
+        try {
+            return Uint8Array.fromHex(hex);
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                throw new RangeError(error.message);
+            throw error;
+        }
+    }
+    const hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+        throw new RangeError('hex string expected, got unpadded hex of length ' + hl);
+    const array = new Uint8Array(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        const n1 = asciiToBase16(hex.charCodeAt(hi)); // parse first char, multiply it by 16
+        const n2 = asciiToBase16(hex.charCodeAt(hi + 1)); // parse second char
+        if (n1 === undefined || n2 === undefined) {
+            const char = hex[hi] + hex[hi + 1];
+            throw new RangeError('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+        }
+        array[ai] = n1 * 16 + n2; // example: 'A9' => 10*16 + 9
+    }
+    return array;
+}
+/**
+ * Copies several Uint8Arrays into one.
+ * @param arrays - arrays to concatenate
+ * @returns Concatenated byte array.
+ * @throws On wrong argument types. {@link TypeError}
+ * @example
+ * Concatenate multiple byte arrays.
+ * ```ts
+ * concatBytes(new Uint8Array([1]), new Uint8Array([2]));
+ * ```
+ */
+function concatBytes(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        abytes(a);
+        sum += a.length;
+    }
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        res.set(a, pad);
+        pad += a.length;
+    }
+    return res;
+}
 /**
  * Merges default options and passed options.
  * @param defaults - base option object
@@ -264,6 +374,37 @@ function createHasher(hashCons, info = {}) {
     Object.assign(hashC, info);
     return Object.freeze(hashC);
 }
+/**
+ * Cryptographically secure PRNG backed by `crypto.getRandomValues`.
+ * @param bytesLength - number of random bytes to generate
+ * @returns Random bytes.
+ * The platform `getRandomValues()` implementation still defines any
+ * single-call length cap, and this helper rejects oversize requests
+ * with a stable library `RangeError` instead of host-specific errors.
+ * @throws On wrong argument types. {@link TypeError}
+ * @throws On wrong argument ranges or values. {@link RangeError}
+ * @throws If the current runtime does not provide `crypto.getRandomValues`. {@link Error}
+ * @example
+ * Generate a fresh random key or nonce.
+ * ```ts
+ * const key = randomBytes(16);
+ * ```
+ */
+function randomBytes(bytesLength = 32) {
+    // Match the repo's other length-taking helpers instead of relying on Uint8Array coercion.
+    anumber(bytesLength, 'bytesLength');
+    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;
+    if (typeof cr?.getRandomValues !== 'function')
+        throw new Error('crypto.getRandomValues must be defined');
+    // Web Cryptography API Level 2 §10.1.1:
+    // if `byteLength > 65536`, throw `QuotaExceededError`.
+    // Keep the guard explicit so callers can see the quota in code
+    // instead of discovering it by reading the spec or host errors.
+    // This wrapper surfaces the same quota as a stable library RangeError.
+    if (bytesLength > 65536)
+        throw new RangeError(`"bytesLength" expected <= 65536, got ${bytesLength}`);
+    return cr.getRandomValues(new Uint8Array(bytesLength));
+}
 /**
  * Creates OID metadata for NIST hashes with prefix `06 09 60 86 48 01 65 03 04 02`.
  * @param suffix - final OID byte for the selected hash.
@@ -611,4 +752,4 @@ class _SHA256 extends SHA2_32B {
 const sha256 = /* @__PURE__ */ createHasher(() => new _SHA256(), 
 /* @__PURE__ */ oidNist(0x01));
 
-export { ahash as a, abytes as b, clean as c, aexists as d, aoutput as e, anumber as f, sha256 as s };
+export { ahash as a, anumber as b, abytes as c, clean as d, concatBytes as e, bytesToHex as f, aexists as g, hexToBytes as h, isBytes as i, aoutput as j, randomBytes as r, sha256 as s };