@waku/core 0.0.2 → 0.0.4

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## @waku/core [0.0.4](https://github.com/waku-org/js-waku/compare/@waku/core@0.0.3...@waku/core@0.0.4) (2022-11-09)
+
+### Changed
+
+- Bumped `libp2p` to 0.39.2.
+
 ## @waku/core [0.0.2](https://github.com/waku-org/js-waku/compare/@waku/core@0.0.1...@waku/core@0.0.2) (2022-11-04)
 
 ### Changed

package/bundle/{index-f7e049ad.js → index-8710041d.js}

@@ -1,8 +1,6 @@
 import { e as errCode } from './index-64ce43f0.js';
 
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-// We don't care about how the IP is invalid. Save time in the error case by using a single error
-const err = new Error("Invalid IP");
 class Parser {
     index = 0;
     input = "";
@@ -14,33 +12,31 @@ class Parser {
     /** Run a parser, and restore the pre-parse state if it fails. */
     readAtomically(fn) {
         const index = this.index;
-        try {
-            return fn();
-        }
-        catch (e) {
+        const result = fn();
+        if (result === undefined) {
             this.index = index;
-            throw e;
         }
+        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) {
-            throw err;
+            return undefined;
         }
         return result;
     }
     /** Peek the next character from the input */
     peekChar() {
         if (this.index >= this.input.length) {
-            throw err;
+            return undefined;
         }
         return this.input[this.index];
     }
     /** Read the next character from the input */
     readChar() {
         if (this.index >= this.input.length) {
-            throw err;
+            return undefined;
         }
         return this.input[this.index++];
     }
@@ -49,8 +45,9 @@ class Parser {
         return this.readAtomically(() => {
             const char = this.readChar();
             if (char !== target) {
-                throw err;
+                return undefined;
             }
+            return char;
         });
     }
     /**
@@ -62,7 +59,9 @@ class Parser {
     readSeparator(sep, index, inner) {
         return this.readAtomically(() => {
             if (index > 0) {
-                this.readGivenChar(sep);
+                if (this.readGivenChar(sep) === undefined) {
+                    return undefined;
+                }
             }
             return inner();
         });
@@ -76,40 +75,45 @@ class Parser {
         return this.readAtomically(() => {
             let result = 0;
             let digitCount = 0;
-            const hasLeadingZero = this.peekChar() === "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) {
-                let digit;
-                try {
-                    digit = this.readAtomically(() => {
-                        const num = Number.parseInt(this.readChar(), radix);
-                        if (Number.isNaN(num)) {
-                            throw err;
-                        }
-                        return num;
-                    });
-                }
-                catch (e) {
+                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) {
-                    throw err;
+                    return undefined;
                 }
                 digitCount += 1;
                 if (maxDigits !== undefined) {
                     if (digitCount > maxDigits) {
-                        throw err;
+                        return undefined;
                     }
                 }
             }
             if (digitCount === 0) {
-                throw err;
+                return undefined;
             }
             else if (!allowZeroPrefix && hasLeadingZero && digitCount > 1) {
-                throw err;
+                return undefined;
             }
             else {
                 return result;
@@ -121,7 +125,11 @@ class Parser {
         return this.readAtomically(() => {
             const out = new Uint8Array(4);
             for (let i = 0; i < out.length; i++) {
-                out[i] = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
+                const ix = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
+                if (ix === undefined) {
+                    return undefined;
+                }
+                out[i] = ix;
             }
             return out;
         });
@@ -140,25 +148,21 @@ class Parser {
                 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) {
-                    try {
-                        const ipv4 = this.readSeparator(":", i, () => this.readIPv4Addr());
+                    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];
-                        // eslint-disable-next-line no-empty
                     }
-                    catch (e) { }
-                }
-                try {
-                    const group = this.readSeparator(":", i, () => this.readNumber(16, 4, true, 2));
-                    groups[ix] = group >> 8;
-                    groups[ix + 1] = group & 255;
                 }
-                catch (e) {
+                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];
         };
@@ -171,12 +175,16 @@ class Parser {
             }
             // IPv4 part is not allowed before `::`
             if (headIp4) {
-                throw err;
+                return undefined;
             }
             // Read `::` if previous code parsed less than 8 groups.
             // `::` indicates one or more groups of 16 bits of zeros.
-            this.readGivenChar(":");
-            this.readGivenChar(":");
+            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);
@@ -189,12 +197,7 @@ class Parser {
     }
     /** Read an IP Address, either IPv4 or IPv6. */
     readIPAddr() {
-        try {
-            return this.readIPv4Addr();
-        }
-        catch (e) {
-            return this.readIPv6Addr();
-        }
+        return this.readIPv4Addr() ?? this.readIPv6Addr();
     }
 }
 
@@ -205,53 +208,36 @@ const parser = new Parser();
 /** Parse `input` into IPv4 bytes. */
 function parseIPv4(input) {
     if (input.length > MAX_IPV4_LENGTH) {
-        throw err;
+        return undefined;
     }
     return parser.new(input).parseWith(() => parser.readIPv4Addr());
 }
 /** Parse `input` into IPv6 bytes. */
 function parseIPv6(input) {
     if (input.length > MAX_IPV6_LENGTH) {
-        throw err;
+        return undefined;
     }
     return parser.new(input).parseWith(() => parser.readIPv6Addr());
 }
 /** Parse `input` into IPv4 or IPv6 bytes. */
 function parseIP(input) {
     if (input.length > MAX_IPV6_LENGTH) {
-        throw err;
+        return undefined;
     }
     return parser.new(input).parseWith(() => parser.readIPAddr());
 }
+
 /** Check if `input` is IPv4. */
 function isIPv4(input) {
-    try {
-        parseIPv4(input);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
+    return Boolean(parseIPv4(input));
 }
 /** Check if `input` is IPv6. */
 function isIPv6(input) {
-    try {
-        parseIPv6(input);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
+    return Boolean(parseIPv6(input));
 }
 /** Check if `input` is IPv4 or IPv6. */
 function isIP(input) {
-    try {
-        parseIP(input);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
+    return Boolean(parseIP(input));
 }
 
 // base-x encoding / decoding

package/bundle/index.js

@@ -5,7 +5,7 @@ export { proto as proto_message } from './lib/waku_message/version_0.js';
 import { T as TopicOnlyDecoder } from './topic_only_message-5ad3a869.js';
 export { t as proto_topic_only_message } from './topic_only_message-5ad3a869.js';
 import { p as peerIdFromString, a as peerIdFromKeys, b as peerIdFromBytes, E as EventEmitter, C as CustomEvent } from './events-158407bb.js';
-import { m as multiaddr } from './index-f7e049ad.js';
+import { m as multiaddr } from './index-8710041d.js';
 import { d as debug } from './browser-1e1a2f27.js';
 import { e as errCode } from './index-64ce43f0.js';
 import { r as requireAspromise, a as requireBase64, b as requireEventemitter, c as requireFloat, d as requireInquire, e as requireUtf8, f as requirePool, g as commonjsGlobal, h as getAugmentedNamespace } from './message-049c8b67.js';
@@ -21875,7 +21875,7 @@ async function unmarshalPrivateKey(buf) {
     }
 }
 
-const codes$1 = {
+const codes = {
     ERR_SIGNATURE_NOT_VALID: 'ERR_SIGNATURE_NOT_VALID'
 };
 
@@ -23788,7 +23788,7 @@ RecordEnvelope.openAndCertify = async (data, domain) => {
     const envelope = await RecordEnvelope.createFromProtobuf(data);
     const valid = await envelope.validate(domain);
     if (!valid) {
-        throw errCode(new Error('envelope signature is not valid for the given domain'), codes$1.ERR_SIGNATURE_NOT_VALID);
+        throw errCode(new Error('envelope signature is not valid for the given domain'), codes.ERR_SIGNATURE_NOT_VALID);
     }
     return envelope;
 };
@@ -23810,108 +23810,6 @@ const formatSignaturePayload = (domain, payloadType, payload) => {
     return new Uint8ArrayList(domainLength, domainUint8Array, payloadTypeLength, payloadType, payloadLength, payload);
 };
 
-const V = -1;
-const names = {};
-const codes = {};
-const table = [
-    [4, 32, 'ip4'],
-    [6, 16, 'tcp'],
-    [33, 16, 'dccp'],
-    [41, 128, 'ip6'],
-    [42, V, 'ip6zone'],
-    [53, V, 'dns', true],
-    [54, V, 'dns4', true],
-    [55, V, 'dns6', true],
-    [56, V, 'dnsaddr', true],
-    [132, 16, 'sctp'],
-    [273, 16, 'udp'],
-    [275, 0, 'p2p-webrtc-star'],
-    [276, 0, 'p2p-webrtc-direct'],
-    [277, 0, 'p2p-stardust'],
-    [280, 0, 'webrtc'],
-    [290, 0, 'p2p-circuit'],
-    [301, 0, 'udt'],
-    [302, 0, 'utp'],
-    [400, V, 'unix', false, true],
-    // `ipfs` is added before `p2p` for legacy support.
-    // All text representations will default to `p2p`, but `ipfs` will
-    // still be supported
-    [421, V, 'ipfs'],
-    // `p2p` is the preferred name for 421, and is now the default
-    [421, V, 'p2p'],
-    [443, 0, 'https'],
-    [444, 96, 'onion'],
-    [445, 296, 'onion3'],
-    [446, V, 'garlic64'],
-    [460, 0, 'quic'],
-    [465, 0, 'webtransport'],
-    [466, V, 'certhash'],
-    [477, 0, 'ws'],
-    [478, 0, 'wss'],
-    [479, 0, 'p2p-websocket-star'],
-    [480, 0, 'http'],
-    [777, V, 'memory']
-];
-// populate tables
-table.forEach(row => {
-    const proto = createProtocol(...row);
-    codes[proto.code] = proto;
-    names[proto.name] = proto;
-});
-function createProtocol(code, size, name, resolvable, path) {
-    return {
-        code,
-        size,
-        name,
-        resolvable: Boolean(resolvable),
-        path: Boolean(path)
-    };
-}
-function getProtocol(proto) {
-    if (typeof proto === 'number') {
-        if (codes[proto] != null) {
-            return codes[proto];
-        }
-        throw new Error(`no protocol with code: ${proto}`);
-    }
-    else if (typeof proto === 'string') {
-        if (names[proto] != null) {
-            return names[proto];
-        }
-        throw new Error(`no protocol with name: ${proto}`);
-    }
-    throw new Error(`invalid protocol id type: ${typeof proto}`);
-}
-
-const decoders = Object.values(bases$2).map((c) => c.decoder);
-((function () {
-    let acc = decoders[0].or(decoders[1]);
-    decoders.slice(2).forEach((d) => (acc = acc.or(d)));
-    return acc;
-}))();
-
-(undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-(undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-[
-    getProtocol('dns').code,
-    getProtocol('dns4').code,
-    getProtocol('dns6').code,
-    getProtocol('dnsaddr').code
-];
-[
-    getProtocol('p2p').code,
-    getProtocol('ipfs').code
-];
-
 /* eslint-disable import/export */
 var PeerRecord;
 (function (PeerRecord) {

package/bundle/lib/peer_discovery_static_list.js

@@ -1,5 +1,5 @@
 import { p as peerIdFromString, E as EventEmitter, C as CustomEvent } from '../events-158407bb.js';
-import { m as multiaddr } from '../index-f7e049ad.js';
+import { m as multiaddr } from '../index-8710041d.js';
 import { d as debug } from '../browser-1e1a2f27.js';
 import { g as getPseudoRandomSubset } from '../random_subset-75d1c511.js';
 import '../index-64ce43f0.js';

package/bundle/lib/predefined_bootstrap_nodes.js

@@ -1,4 +1,4 @@
-import { m as multiaddr } from '../index-f7e049ad.js';
+import { m as multiaddr } from '../index-8710041d.js';
 import { g as getPseudoRandomSubset } from '../random_subset-75d1c511.js';
 import '../index-64ce43f0.js';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waku/core",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "TypeScript implementation of the Waku v2 protocol",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
@@ -80,8 +80,7 @@
     "watch:test": "mocha --watch",
     "prepublish": "npm run build",
     "deploy": "node ci/deploy.js",
-    "reset-hard": "git clean -dfx -e .idea && git reset --hard && npm i && npm run build",
-    "release": "semantic-release"
+    "reset-hard": "git clean -dfx -e .idea && git reset --hard && npm i && npm run build"
   },
   "engines": {
     "node": ">=16"
@@ -89,24 +88,21 @@
   "dependencies": {
     "@waku/byte-utils": "*",
     "@chainsafe/libp2p-gossipsub": "^4.1.1",
-    "@chainsafe/libp2p-noise": "^8.0.1",
-    "@libp2p/interface-connection": "3.0.1",
+    "@libp2p/interface-connection": "^3.0.3",
     "@libp2p/interface-peer-discovery": "^1.0.0",
     "@libp2p/interface-peer-id": "^1.0.2",
     "@libp2p/interface-peer-info": "^1.0.1",
     "@libp2p/interface-peer-store": "^1.0.0",
     "@libp2p/interface-pubsub": "^2.0.1",
     "@libp2p/interfaces": "^3.0.2",
-    "@libp2p/mplex": "^5.1.1",
     "@libp2p/peer-id": "^1.1.10",
-    "@libp2p/websockets": "^3.0.3",
     "@multiformats/multiaddr": "^11.0.6",
     "@waku/interfaces": "*",
     "debug": "^4.3.4",
     "it-all": "^1.0.6",
     "it-length-prefixed": "^8.0.2",
     "it-pipe": "^2.0.4",
-    "libp2p": "0.38.0",
+    "libp2p": "0.39.2",
     "p-event": "^5.0.1",
     "protons-runtime": "^3.1.0",
     "uint8arraylist": "^2.3.2",