@waku/rln 0.1.6-f911bf8.0 → 0.1.7-7a9850d.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [0.1.6](https://github.com/waku-org/js-waku/compare/rln-v0.1.5...rln-v0.1.6) (2025-06-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* upgrade libp2p, nodejs and typescript ([#2401](https://github.com/waku-org/js-waku/issues/2401))
+* re-work messaging parts and sharding  ([#2399](https://github.com/waku-org/js-waku/issues/2399))
+
+### Features
+
+* Re-work messaging parts and sharding  ([#2399](https://github.com/waku-org/js-waku/issues/2399)) ([1905558](https://github.com/waku-org/js-waku/commit/1905558753a7bf61c3dd27d6892d0f561d4c57c6))
+* Refine work with membership info and other meta information ([#2341](https://github.com/waku-org/js-waku/issues/2341)) ([3b23bce](https://github.com/waku-org/js-waku/commit/3b23bceb9de5a0c250788ffb824367eabafe3728))
+
+
+### Miscellaneous Chores
+
+* Upgrade libp2p, nodejs and typescript ([#2401](https://github.com/waku-org/js-waku/issues/2401)) ([fcc6496](https://github.com/waku-org/js-waku/commit/fcc6496fef914c56f6a4d2d17c494c8b94caea3c))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @waku/core bumped from ^0.0.35 to ^0.0.36
+    * @waku/utils bumped from ^0.0.23 to ^0.0.24
+  * devDependencies
+    * @waku/interfaces bumped from 0.0.30 to 0.0.31
+    * @waku/message-encryption bumped from ^0.0.33 to ^0.0.34
+
 ## [0.1.5](https://github.com/waku-org/js-waku/compare/rln-v0.1.4...rln-v0.1.5) (2025-04-23)
 
 

package/bundle/node_modules/@chainsafe/is-ip/lib/is-ip.js

@@ -0,0 +1,12 @@
+import { parseIPv4, parseIPv6 } from './parse.js';
+
+/** Check if `input` is IPv4. */
+function isIPv4(input) {
+    return Boolean(parseIPv4(input));
+}
+/** Check if `input` is IPv6. */
+function isIPv6(input) {
+    return Boolean(parseIPv6(input));
+}
+
+export { isIPv4, isIPv6 };

package/bundle/node_modules/@chainsafe/is-ip/lib/parse.js

@@ -0,0 +1,26 @@
+import { Parser } from './parser.js';
+
+// See https://stackoverflow.com/questions/166132/maximum-length-of-the-textual-representation-of-an-ipv6-address
+const MAX_IPV6_LENGTH = 45;
+const MAX_IPV4_LENGTH = 15;
+const parser = new Parser();
+/** Parse `input` into IPv4 bytes. */
+function parseIPv4(input) {
+    if (input.length > MAX_IPV4_LENGTH) {
+        return undefined;
+    }
+    return parser.new(input).parseWith(() => parser.readIPv4Addr());
+}
+/** Parse `input` into IPv6 bytes. */
+function parseIPv6(input) {
+    // strip zone index if it is present
+    if (input.includes("%")) {
+        input = input.split("%")[0];
+    }
+    if (input.length > MAX_IPV6_LENGTH) {
+        return undefined;
+    }
+    return parser.new(input).parseWith(() => parser.readIPv6Addr());
+}
+
+export { parseIPv4, parseIPv6 };

package/bundle/node_modules/@chainsafe/is-ip/lib/parser.js

@@ -0,0 +1,202 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+class Parser {
+    index = 0;
+    input = "";
+    new(input) {
+        this.index = 0;
+        this.input = input;
+        return this;
+    }
+    /** Run a parser, and restore the pre-parse state if it fails. */
+    readAtomically(fn) {
+        const index = this.index;
+        const result = fn();
+        if (result === undefined) {
+            this.index = index;
+        }
+        return result;
+    }
+    /** Run a parser, but fail if the entire input wasn't consumed. Doesn't run atomically. */
+    parseWith(fn) {
+        const result = fn();
+        if (this.index !== this.input.length) {
+            return undefined;
+        }
+        return result;
+    }
+    /** Peek the next character from the input */
+    peekChar() {
+        if (this.index >= this.input.length) {
+            return undefined;
+        }
+        return this.input[this.index];
+    }
+    /** Read the next character from the input */
+    readChar() {
+        if (this.index >= this.input.length) {
+            return undefined;
+        }
+        return this.input[this.index++];
+    }
+    /** Read the next character from the input if it matches the target. */
+    readGivenChar(target) {
+        return this.readAtomically(() => {
+            const char = this.readChar();
+            if (char !== target) {
+                return undefined;
+            }
+            return char;
+        });
+    }
+    /**
+     * Helper for reading separators in an indexed loop. Reads the separator
+     * character iff index > 0, then runs the parser. When used in a loop,
+     * the separator character will only be read on index > 0 (see
+     * readIPv4Addr for an example)
+     */
+    readSeparator(sep, index, inner) {
+        return this.readAtomically(() => {
+            if (index > 0) {
+                if (this.readGivenChar(sep) === undefined) {
+                    return undefined;
+                }
+            }
+            return inner();
+        });
+    }
+    /**
+     * Read a number off the front of the input in the given radix, stopping
+     * at the first non-digit character or eof. Fails if the number has more
+     * digits than max_digits or if there is no number.
+     */
+    readNumber(radix, maxDigits, allowZeroPrefix, maxBytes) {
+        return this.readAtomically(() => {
+            let result = 0;
+            let digitCount = 0;
+            const leadingChar = this.peekChar();
+            if (leadingChar === undefined) {
+                return undefined;
+            }
+            const hasLeadingZero = leadingChar === "0";
+            const maxValue = 2 ** (8 * maxBytes) - 1;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const digit = this.readAtomically(() => {
+                    const char = this.readChar();
+                    if (char === undefined) {
+                        return undefined;
+                    }
+                    const num = Number.parseInt(char, radix);
+                    if (Number.isNaN(num)) {
+                        return undefined;
+                    }
+                    return num;
+                });
+                if (digit === undefined) {
+                    break;
+                }
+                result *= radix;
+                result += digit;
+                if (result > maxValue) {
+                    return undefined;
+                }
+                digitCount += 1;
+                if (maxDigits !== undefined) {
+                    if (digitCount > maxDigits) {
+                        return undefined;
+                    }
+                }
+            }
+            if (digitCount === 0) {
+                return undefined;
+            }
+            else if (!allowZeroPrefix && hasLeadingZero && digitCount > 1) {
+                return undefined;
+            }
+            else {
+                return result;
+            }
+        });
+    }
+    /** Read an IPv4 address. */
+    readIPv4Addr() {
+        return this.readAtomically(() => {
+            const out = new Uint8Array(4);
+            for (let i = 0; i < out.length; i++) {
+                const ix = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
+                if (ix === undefined) {
+                    return undefined;
+                }
+                out[i] = ix;
+            }
+            return out;
+        });
+    }
+    /** Read an IPv6 Address. */
+    readIPv6Addr() {
+        /**
+         * Read a chunk of an IPv6 address into `groups`. Returns the number
+         * of groups read, along with a bool indicating if an embedded
+         * trailing IPv4 address was read. Specifically, read a series of
+         * colon-separated IPv6 groups (0x0000 - 0xFFFF), with an optional
+         * trailing embedded IPv4 address.
+         */
+        const readGroups = (groups) => {
+            for (let i = 0; i < groups.length / 2; i++) {
+                const ix = i * 2;
+                // Try to read a trailing embedded IPv4 address. There must be at least 4 groups left.
+                if (i < groups.length - 3) {
+                    const ipv4 = this.readSeparator(":", i, () => this.readIPv4Addr());
+                    if (ipv4 !== undefined) {
+                        groups[ix] = ipv4[0];
+                        groups[ix + 1] = ipv4[1];
+                        groups[ix + 2] = ipv4[2];
+                        groups[ix + 3] = ipv4[3];
+                        return [ix + 4, true];
+                    }
+                }
+                const group = this.readSeparator(":", i, () => this.readNumber(16, 4, true, 2));
+                if (group === undefined) {
+                    return [ix, false];
+                }
+                groups[ix] = group >> 8;
+                groups[ix + 1] = group & 255;
+            }
+            return [groups.length, false];
+        };
+        return this.readAtomically(() => {
+            // Read the front part of the address; either the whole thing, or up to the first ::
+            const head = new Uint8Array(16);
+            const [headSize, headIp4] = readGroups(head);
+            if (headSize === 16) {
+                return head;
+            }
+            // IPv4 part is not allowed before `::`
+            if (headIp4) {
+                return undefined;
+            }
+            // Read `::` if previous code parsed less than 8 groups.
+            // `::` indicates one or more groups of 16 bits of zeros.
+            if (this.readGivenChar(":") === undefined) {
+                return undefined;
+            }
+            if (this.readGivenChar(":") === undefined) {
+                return undefined;
+            }
+            // Read the back part of the address. The :: must contain at least one
+            // set of zeroes, so our max length is 7.
+            const tail = new Uint8Array(14);
+            const limit = 16 - (headSize + 2);
+            const [tailSize] = readGroups(tail.subarray(0, limit));
+            // Concat the head and tail of the IP address
+            head.set(tail.subarray(0, tailSize), 16 - tailSize);
+            return head;
+        });
+    }
+    /** Read an IP Address, either IPv4 or IPv6. */
+    readIPAddr() {
+        return this.readIPv4Addr() ?? this.readIPv6Addr();
+    }
+}
+
+export { Parser };

package/bundle/node_modules/@ethersproject/bignumber/lib.esm/bignumber.js

@@ -181,7 +181,7 @@ class BigNumber {
             if (value % 1) {
                 throwFault("underflow", "BigNumber.from", value);
             }
-            if (value >= MAX_SAFE || value <= -9007199254740991) {
+            if (value >= MAX_SAFE || value <= -MAX_SAFE) {
                 throwFault("overflow", "BigNumber.from", value);
             }
             return BigNumber.from(String(value));

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

@@ -0,0 +1,43 @@
+// the values here come from https://github.com/multiformats/multiaddr/blob/master/protocols.csv
+const CODE_IP4 = 4;
+const CODE_TCP = 6;
+const CODE_UDP = 273;
+const CODE_DCCP = 33;
+const CODE_IP6 = 41;
+const CODE_IP6ZONE = 42;
+const CODE_IPCIDR = 43;
+const CODE_DNS = 53;
+const CODE_DNS4 = 54;
+const CODE_DNS6 = 55;
+const CODE_DNSADDR = 56;
+const CODE_SCTP = 132;
+const CODE_UDT = 301;
+const CODE_UTP = 302;
+const CODE_UNIX = 400;
+const CODE_P2P = 421; // also IPFS
+const CODE_ONION = 444;
+const CODE_ONION3 = 445;
+const CODE_GARLIC64 = 446;
+const CODE_GARLIC32 = 447;
+const CODE_TLS = 448;
+const CODE_SNI = 449;
+const CODE_NOISE = 454;
+const CODE_QUIC = 460;
+const CODE_QUIC_V1 = 461;
+const CODE_WEBTRANSPORT = 465;
+const CODE_CERTHASH = 466;
+const CODE_HTTP = 480;
+const CODE_HTTP_PATH = 481;
+const CODE_HTTPS = 443;
+const CODE_WS = 477;
+const CODE_WSS = 478;
+const CODE_P2P_WEBSOCKET_STAR = 479;
+const CODE_P2P_STARDUST = 277;
+const CODE_P2P_WEBRTC_STAR = 275;
+const CODE_P2P_WEBRTC_DIRECT = 276;
+const CODE_WEBRTC_DIRECT = 280;
+const CODE_WEBRTC = 281;
+const CODE_P2P_CIRCUIT = 290;
+const CODE_MEMORY = 777;
+
+export { CODE_CERTHASH, CODE_DCCP, CODE_DNS, CODE_DNS4, CODE_DNS6, CODE_DNSADDR, CODE_GARLIC32, CODE_GARLIC64, CODE_HTTP, CODE_HTTPS, CODE_HTTP_PATH, CODE_IP4, CODE_IP6, CODE_IP6ZONE, CODE_IPCIDR, CODE_MEMORY, CODE_NOISE, CODE_ONION, CODE_ONION3, CODE_P2P, CODE_P2P_CIRCUIT, CODE_P2P_STARDUST, CODE_P2P_WEBRTC_DIRECT, CODE_P2P_WEBRTC_STAR, CODE_P2P_WEBSOCKET_STAR, CODE_QUIC, CODE_QUIC_V1, CODE_SCTP, CODE_SNI, CODE_TCP, CODE_TLS, CODE_UDP, CODE_UDT, CODE_UNIX, CODE_UTP, CODE_WEBRTC, CODE_WEBRTC_DIRECT, CODE_WEBTRANSPORT, CODE_WS, CODE_WSS };

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

@@ -0,0 +1,17 @@
+/**
+ * Thrown when an invalid multiaddr is encountered
+ */
+class InvalidMultiaddrError extends Error {
+    static name = 'InvalidMultiaddrError';
+    name = 'InvalidMultiaddrError';
+}
+class ValidationError extends Error {
+    static name = 'ValidationError';
+    name = 'ValidationError';
+}
+class UnknownProtocolError extends Error {
+    static name = 'UnknownProtocolError';
+    name = 'UnknownProtocolError';
+}
+
+export { InvalidMultiaddrError, UnknownProtocolError, ValidationError };

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

@@ -0,0 +1,245 @@
+import { isIPv4, isIPv6 } from '../../../../@chainsafe/is-ip/lib/is-ip.js';
+import { CID } from '../../../../multiformats/dist/src/cid.js';
+import { base64url } from '../../../../multiformats/dist/src/bases/base64.js';
+import { CODE_IP4, CODE_TCP, CODE_UDP, CODE_DCCP, CODE_IP6, CODE_IP6ZONE, CODE_IPCIDR, CODE_DNS, CODE_DNS4, CODE_DNS6, CODE_DNSADDR, CODE_SCTP, CODE_UDT, CODE_UTP, CODE_UNIX, CODE_P2P, CODE_ONION, CODE_ONION3, CODE_GARLIC64, CODE_GARLIC32, CODE_TLS, CODE_SNI, CODE_NOISE, CODE_QUIC, CODE_QUIC_V1, CODE_WEBTRANSPORT, CODE_CERTHASH, CODE_HTTP, CODE_HTTP_PATH, CODE_HTTPS, CODE_WS, CODE_WSS, CODE_P2P_WEBSOCKET_STAR, CODE_P2P_STARDUST, CODE_P2P_WEBRTC_STAR, CODE_P2P_WEBRTC_DIRECT, CODE_WEBRTC_DIRECT, CODE_WEBRTC, CODE_P2P_CIRCUIT, CODE_MEMORY } from './constants.js';
+import { ValidationError, UnknownProtocolError } from './errors.js';
+import { ip4ToString, ip4ToBytes, bytes2port, port2bytes, ip6StringToValue, ip6ToString, ip6ToBytes, stringToBytes, bytesToString, onion2bytes, bytes2onion, onion32bytes, mb2bytes, bytes2mb } from './utils.js';
+import { validatePort } from './validation.js';
+
+const V = -1;
+class Registry {
+    protocolsByCode = new Map();
+    protocolsByName = new Map();
+    getProtocol(key) {
+        let codec;
+        if (typeof key === 'string') {
+            codec = this.protocolsByName.get(key);
+        }
+        else {
+            codec = this.protocolsByCode.get(key);
+        }
+        if (codec == null) {
+            throw new UnknownProtocolError(`Protocol ${key} was unknown`);
+        }
+        return codec;
+    }
+    addProtocol(codec) {
+        this.protocolsByCode.set(codec.code, codec);
+        this.protocolsByName.set(codec.name, codec);
+        codec.aliases?.forEach(alias => {
+            this.protocolsByName.set(alias, codec);
+        });
+    }
+    removeProtocol(code) {
+        const codec = this.protocolsByCode.get(code);
+        if (codec == null) {
+            return;
+        }
+        this.protocolsByCode.delete(codec.code);
+        this.protocolsByName.delete(codec.name);
+        codec.aliases?.forEach(alias => {
+            this.protocolsByName.delete(alias);
+        });
+    }
+}
+const registry = new Registry();
+const codecs = [{
+        code: CODE_IP4,
+        name: 'ip4',
+        size: 32,
+        valueToBytes: ip4ToBytes,
+        bytesToValue: ip4ToString,
+        validate: (value) => {
+            if (!isIPv4(value)) {
+                throw new ValidationError(`Invalid IPv4 address "${value}"`);
+            }
+        }
+    }, {
+        code: CODE_TCP,
+        name: 'tcp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_UDP,
+        name: 'udp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_DCCP,
+        name: 'dccp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_IP6,
+        name: 'ip6',
+        size: 128,
+        valueToBytes: ip6ToBytes,
+        bytesToValue: ip6ToString,
+        stringToValue: ip6StringToValue,
+        validate: (value) => {
+            if (!isIPv6(value)) {
+                throw new ValidationError(`Invalid IPv6 address "${value}"`);
+            }
+        }
+    }, {
+        code: CODE_IP6ZONE,
+        name: 'ip6zone',
+        size: V
+    }, {
+        code: CODE_IPCIDR,
+        name: 'ipcidr',
+        size: 8,
+        bytesToValue: bytesToString('base10'),
+        valueToBytes: stringToBytes('base10')
+    }, {
+        code: CODE_DNS,
+        name: 'dns',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_DNS4,
+        name: 'dns4',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_DNS6,
+        name: 'dns6',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_DNSADDR,
+        name: 'dnsaddr',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_SCTP,
+        name: 'sctp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_UDT,
+        name: 'udt'
+    }, {
+        code: CODE_UTP,
+        name: 'utp'
+    }, {
+        code: CODE_UNIX,
+        name: 'unix',
+        size: V,
+        path: true,
+        stringToValue: (str) => decodeURIComponent(str),
+        valueToString: (val) => encodeURIComponent(val)
+    }, {
+        code: CODE_P2P,
+        name: 'p2p',
+        aliases: ['ipfs'],
+        size: V,
+        bytesToValue: bytesToString('base58btc'),
+        valueToBytes: (val) => {
+            if (val.startsWith('Q') || val.startsWith('1')) {
+                return stringToBytes('base58btc')(val);
+            }
+            return CID.parse(val).multihash.bytes;
+        }
+    }, {
+        code: CODE_ONION,
+        name: 'onion',
+        size: 96,
+        bytesToValue: bytes2onion,
+        valueToBytes: onion2bytes
+    }, {
+        code: CODE_ONION3,
+        name: 'onion3',
+        size: 296,
+        bytesToValue: bytes2onion,
+        valueToBytes: onion32bytes
+    }, {
+        code: CODE_GARLIC64,
+        name: 'garlic64',
+        size: V
+    }, {
+        code: CODE_GARLIC32,
+        name: 'garlic32',
+        size: V
+    }, {
+        code: CODE_TLS,
+        name: 'tls'
+    }, {
+        code: CODE_SNI,
+        name: 'sni',
+        size: V
+    }, {
+        code: CODE_NOISE,
+        name: 'noise'
+    }, {
+        code: CODE_QUIC,
+        name: 'quic'
+    }, {
+        code: CODE_QUIC_V1,
+        name: 'quic-v1'
+    }, {
+        code: CODE_WEBTRANSPORT,
+        name: 'webtransport'
+    }, {
+        code: CODE_CERTHASH,
+        name: 'certhash',
+        size: V,
+        bytesToValue: bytes2mb(base64url),
+        valueToBytes: mb2bytes
+    }, {
+        code: CODE_HTTP,
+        name: 'http'
+    }, {
+        code: CODE_HTTP_PATH,
+        name: 'http-path',
+        size: V,
+        stringToValue: (str) => `/${decodeURIComponent(str)}`,
+        valueToString: (val) => encodeURIComponent(val.substring(1))
+    }, {
+        code: CODE_HTTPS,
+        name: 'https'
+    }, {
+        code: CODE_WS,
+        name: 'ws'
+    }, {
+        code: CODE_WSS,
+        name: 'wss'
+    }, {
+        code: CODE_P2P_WEBSOCKET_STAR,
+        name: 'p2p-websocket-star'
+    }, {
+        code: CODE_P2P_STARDUST,
+        name: 'p2p-stardust'
+    }, {
+        code: CODE_P2P_WEBRTC_STAR,
+        name: 'p2p-webrtc-star'
+    }, {
+        code: CODE_P2P_WEBRTC_DIRECT,
+        name: 'p2p-webrtc-direct'
+    }, {
+        code: CODE_WEBRTC_DIRECT,
+        name: 'webrtc-direct'
+    }, {
+        code: CODE_WEBRTC,
+        name: 'webrtc'
+    }, {
+        code: CODE_P2P_CIRCUIT,
+        name: 'p2p-circuit'
+    }, {
+        code: CODE_MEMORY,
+        name: 'memory',
+        size: V
+    }];
+codecs.forEach(codec => {
+    registry.addProtocol(codec);
+});
+
+export { V, registry };