@waku/rln 0.1.8-e224c05.0 → 0.1.8-e800af3.0

package/bundle/node_modules/@multiformats/multiaddr/dist/src/utils.js

@@ -0,0 +1,191 @@
+import { isIPv4 } from '../../../../@chainsafe/is-ip/lib/is-ip.js';
+import { base32 } from '../../../../multiformats/dist/src/bases/base32.js';
+import { bases } from '../../../../multiformats/dist/src/basics.js';
+import { concat } from '../../../../uint8arrays/dist/src/concat.js';
+import { fromString } from '../../../../uint8arrays/dist/src/from-string.js';
+import { toString } from '../../../../uint8arrays/dist/src/to-string.js';
+import { InvalidMultiaddrError } from './errors.js';
+
+function bytesToString(base) {
+    return (buf) => {
+        return toString(buf, base);
+    };
+}
+function stringToBytes(base) {
+    return (buf) => {
+        return fromString(buf, base);
+    };
+}
+function bytes2port(buf) {
+    const view = new DataView(buf.buffer);
+    return view.getUint16(buf.byteOffset).toString();
+}
+function port2bytes(port) {
+    const buf = new ArrayBuffer(2);
+    const view = new DataView(buf);
+    view.setUint16(0, typeof port === 'string' ? parseInt(port) : port);
+    return new Uint8Array(buf);
+}
+function onion2bytes(str) {
+    const addr = str.split(':');
+    if (addr.length !== 2) {
+        throw new Error(`failed to parse onion addr: ["'${addr.join('", "')}'"]' does not contain a port number`);
+    }
+    if (addr[0].length !== 16) {
+        throw new Error(`failed to parse onion addr: ${addr[0]} not a Tor onion address.`);
+    }
+    // onion addresses do not include the multibase prefix, add it before decoding
+    const buf = fromString(addr[0], 'base32');
+    // onion port number
+    const port = parseInt(addr[1], 10);
+    if (port < 1 || port > 65536) {
+        throw new Error('Port number is not in range(1, 65536)');
+    }
+    const portBuf = port2bytes(port);
+    return concat([buf, portBuf], buf.length + portBuf.length);
+}
+function onion32bytes(str) {
+    const addr = str.split(':');
+    if (addr.length !== 2) {
+        throw new Error(`failed to parse onion addr: ["'${addr.join('", "')}'"]' does not contain a port number`);
+    }
+    if (addr[0].length !== 56) {
+        throw new Error(`failed to parse onion addr: ${addr[0]} not a Tor onion3 address.`);
+    }
+    // onion addresses do not include the multibase prefix, add it before decoding
+    const buf = base32.decode(`b${addr[0]}`);
+    // onion port number
+    const port = parseInt(addr[1], 10);
+    if (port < 1 || port > 65536) {
+        throw new Error('Port number is not in range(1, 65536)');
+    }
+    const portBuf = port2bytes(port);
+    return concat([buf, portBuf], buf.length + portBuf.length);
+}
+function bytes2onion(buf) {
+    const addrBytes = buf.subarray(0, buf.length - 2);
+    const portBytes = buf.subarray(buf.length - 2);
+    const addr = toString(addrBytes, 'base32');
+    const port = bytes2port(portBytes);
+    return `${addr}:${port}`;
+}
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L7
+// but with buf/offset args removed because we don't use them
+const ip4ToBytes = function (ip) {
+    ip = ip.toString().trim();
+    const bytes = new Uint8Array(4);
+    ip.split(/\./g).forEach((byte, index) => {
+        const value = parseInt(byte, 10);
+        if (isNaN(value) || value < 0 || value > 0xff) {
+            throw new InvalidMultiaddrError('Invalid byte value in IP address');
+        }
+        bytes[index] = value;
+    });
+    return bytes;
+};
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L7
+// but with buf/offset args removed because we don't use them
+const ip6ToBytes = function (ip) {
+    let offset = 0;
+    ip = ip.toString().trim();
+    const sections = ip.split(':', 8);
+    let i;
+    for (i = 0; i < sections.length; i++) {
+        const isv4 = isIPv4(sections[i]);
+        let v4Buffer;
+        if (isv4) {
+            v4Buffer = ip4ToBytes(sections[i]);
+            sections[i] = toString(v4Buffer.subarray(0, 2), 'base16');
+        }
+        if (v4Buffer != null && ++i < 8) {
+            sections.splice(i, 0, toString(v4Buffer.subarray(2, 4), 'base16'));
+        }
+    }
+    if (sections[0] === '') {
+        while (sections.length < 8) {
+            sections.unshift('0');
+        }
+    }
+    else if (sections[sections.length - 1] === '') {
+        while (sections.length < 8) {
+            sections.push('0');
+        }
+    }
+    else if (sections.length < 8) {
+        for (i = 0; i < sections.length && sections[i] !== ''; i++) { }
+        const argv = [i, 1];
+        for (i = 9 - sections.length; i > 0; i--) {
+            argv.push('0');
+        }
+        sections.splice.apply(sections, argv);
+    }
+    const bytes = new Uint8Array(offset + 16);
+    for (i = 0; i < sections.length; i++) {
+        if (sections[i] === '') {
+            sections[i] = '0';
+        }
+        const word = parseInt(sections[i], 16);
+        if (isNaN(word) || word < 0 || word > 0xffff) {
+            throw new InvalidMultiaddrError('Invalid byte value in IP address');
+        }
+        bytes[offset++] = (word >> 8) & 0xff;
+        bytes[offset++] = word & 0xff;
+    }
+    return bytes;
+};
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L63
+const ip4ToString = function (buf) {
+    if (buf.byteLength !== 4) {
+        throw new InvalidMultiaddrError('IPv4 address was incorrect length');
+    }
+    const result = [];
+    for (let i = 0; i < buf.byteLength; i++) {
+        result.push(buf[i]);
+    }
+    return result.join('.');
+};
+const ip6ToString = function (buf) {
+    if (buf.byteLength !== 16) {
+        throw new InvalidMultiaddrError('IPv6 address was incorrect length');
+    }
+    const result = [];
+    for (let i = 0; i < buf.byteLength; i += 2) {
+        const byte1 = buf[i];
+        const byte2 = buf[i + 1];
+        const tuple = `${byte1.toString(16).padStart(2, '0')}${byte2.toString(16).padStart(2, '0')}`;
+        result.push(tuple);
+    }
+    const ip = result.join(':');
+    try {
+        const url = new URL(`http://[${ip}]`);
+        return url.hostname.substring(1, url.hostname.length - 1);
+    }
+    catch {
+        throw new InvalidMultiaddrError(`Invalid IPv6 address "${ip}"`);
+    }
+};
+function ip6StringToValue(str) {
+    try {
+        const url = new URL(`http://[${str}]`);
+        return url.hostname.substring(1, url.hostname.length - 1);
+    }
+    catch {
+        throw new InvalidMultiaddrError(`Invalid IPv6 address "${str}"`);
+    }
+}
+const decoders = Object.values(bases).map((c) => c.decoder);
+const anybaseDecoder = (function () {
+    let acc = decoders[0].or(decoders[1]);
+    decoders.slice(2).forEach((d) => (acc = acc.or(d)));
+    return acc;
+})();
+function mb2bytes(mbstr) {
+    return anybaseDecoder.decode(mbstr);
+}
+function bytes2mb(base) {
+    return (buf) => {
+        return base.encoder.encode(buf);
+    };
+}
+
+export { bytes2mb, bytes2onion, bytes2port, bytesToString, ip4ToBytes, ip4ToString, ip6StringToValue, ip6ToBytes, ip6ToString, mb2bytes, onion2bytes, onion32bytes, port2bytes, stringToBytes };

package/bundle/node_modules/@multiformats/multiaddr/dist/src/validation.js

@@ -0,0 +1,30 @@
+import { ValidationError } from './errors.js';
+
+function integer(value) {
+    const int = parseInt(value);
+    if (int.toString() !== value) {
+        throw new ValidationError('Value must be an integer');
+    }
+}
+function positive(value) {
+    if (value < 0) {
+        throw new ValidationError('Value must be a positive integer, or zero');
+    }
+}
+function maxValue(max) {
+    return (value) => {
+        if (value > max) {
+            throw new ValidationError(`Value must be smaller than or equal to ${max}`);
+        }
+    };
+}
+function validate(...funcs) {
+    return (value) => {
+        for (const fn of funcs) {
+            fn(value);
+        }
+    };
+}
+const validatePort = validate(integer, positive, maxValue(65_535));
+
+export { integer, maxValue, positive, validate, validatePort };

package/bundle/node_modules/@noble/hashes/esm/hmac.js

@@ -0,0 +1,88 @@
+import { Hash, ahash, toBytes, clean, aexists, abytes } from './utils.js';
+
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @module
+ */
+class HMAC extends Hash {
+    constructor(hash, _key) {
+        super();
+        this.finished = false;
+        this.destroyed = false;
+        ahash(hash);
+        const key = toBytes(_key);
+        this.iHash = hash.create();
+        if (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 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 first block) of 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);
+        abytes(out, this.outputLen);
+        this.finished = true;
+        this.iHash.digestInto(out);
+        this.oHash.update(out);
+        this.oHash.digestInto(out);
+        this.destroy();
+    }
+    digest() {
+        const out = new Uint8Array(this.oHash.outputLen);
+        this.digestInto(out);
+        return out;
+    }
+    _cloneInto(to) {
+        // Create new instance without calling constructor since key already in state and we don't know it.
+        to || (to = Object.create(Object.getPrototypeOf(this), {}));
+        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+        to = to;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        to.blockLen = blockLen;
+        to.outputLen = outputLen;
+        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();
+    }
+}
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256
+ * @param key - message key
+ * @param message - message data
+ * @example
+ * import { hmac } from '@noble/hashes/hmac';
+ * import { sha256 } from '@noble/hashes/sha2';
+ * const mac1 = hmac(sha256, 'key', 'message');
+ */
+const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new HMAC(hash, key);
+
+export { HMAC, hmac };

package/bundle/node_modules/@noble/hashes/esm/sha3.js

@@ -1,4 +1,4 @@
-import { split, rotlSH, rotlSL, rotlBH, rotlBL } from './_u64.js';
+import { rotlSH, rotlSL, rotlBH, rotlBL, split } from './_u64.js';
 import { createHasher, Hash, anumber, u32, swap32IfBE, aexists, toBytes, abytes, aoutput, clean } from './utils.js';
 
 /**

package/bundle/node_modules/@noble/hashes/esm/utils.js

@@ -25,6 +25,13 @@ function abytes(b, ...lengths) {
     if (lengths.length > 0 && !lengths.includes(b.length))
         throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
 }
+/** Asserts something is hash */
+function ahash(h) {
+    if (typeof h !== 'function' || typeof h.create !== 'function')
+        throw new Error('Hash should be wrapped by utils.createHasher');
+    anumber(h.outputLen);
+    anumber(h.blockLen);
+}
 /** Asserts a hash instance has not been destroyed / finished */
 function aexists(instance, checkFinished = true) {
     if (instance.destroyed)
@@ -185,4 +192,4 @@ function createHasher(hashCons) {
     return hashC;
 }
 
-export { Hash, abytes, aexists, anumber, aoutput, byteSwap, byteSwap32, bytesToHex, clean, concatBytes, createHasher, createView, hexToBytes, isBytes, isLE, rotr, swap32IfBE, toBytes, u32, utf8ToBytes };
+export { Hash, abytes, aexists, ahash, anumber, aoutput, byteSwap, byteSwap32, bytesToHex, clean, concatBytes, createHasher, createView, hexToBytes, isBytes, isLE, rotr, swap32IfBE, toBytes, u32, utf8ToBytes };