@waku/core 0.0.28-b5e8b17.0 → 0.0.28

package/bundle/index.js

@@ -1,13 +1,9 @@
-import { v as version_0, e as encodingLength, a as encode$1, d as decode$1, M as MessagePush, F as FilterSubscribeRequest, b as FilterSubscribeResponse$1, P as PushRpc$1, c as PushResponse, H as HistoryRpc$1, f as PagingInfo, g as HistoryResponse, h as createEncoder, W as WakuMetadataResponse, i as WakuMetadataRequest } from './version_0-DiakMc1A.js';
-export { j as createDecoder } from './version_0-DiakMc1A.js';
+import { v as version_0, e as encodingLength, a as encode$1, d as decode$1, M as MessagePush, F as FilterSubscribeRequest, b as FilterSubscribeResponse$1, P as PushRpc$1, c as PushResponse, H as HistoryRpc$1, f as PagingInfo, g as HistoryResponse, h as createEncoder, W as WakuMetadataResponse, i as WakuMetadataRequest } from './version_0-C6o0DvNW.js';
+export { j as createDecoder } from './version_0-C6o0DvNW.js';
 import { g as getDefaultExportFromCjs, P as ProtocolError, a as Protocols, E as EConnectionStateEvents, T as Tags, b as EPeersByDiscoveryEvents } from './browser-DoQRY-an.js';
-import { b as bytesToUtf8, u as utf8ToBytes, c as concat$1, s as sha256, a as asUint8Array, d as allocUnsafe, e as alloc, L as Logger, f as singleShardInfoToPubsubTopic, g as ensurePubsubTopicIsConfigured, D as DefaultPubsubTopic, p as pubsubTopicToSingleShardInfo, h as shardInfoToPubsubTopics } from './index-vlQahmUj.js';
-import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-BCwLeb-A.js';
-export { S as StreamManager } from './base_protocol-BCwLeb-A.js';
-
-function isDefined(value) {
-    return Boolean(value);
-}
+import { b as bytesToUtf8, u as utf8ToBytes, c as concat$1, s as sha256, a as allocUnsafe, d as alloc, L as Logger, e as singleShardInfoToPubsubTopic, f as ensurePubsubTopicIsConfigured, D as DefaultPubsubTopic, p as pubsubTopicToSingleShardInfo, g as shardInfoToPubsubTopics } from './index-BJwgMx4y.js';
+import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-D0Zdzb-v.js';
+export { S as StreamManager } from './base_protocol-D0Zdzb-v.js';
 
 function groupByContentTopic(values) {
     const groupedDecoders = new Map();
@@ -174,13 +170,18 @@ function all(source) {
     return arr;
 }
 
+/**
+ * To guarantee Uint8Array semantics, convert nodejs Buffers
+ * into vanilla Uint8Arrays
+ */
+function asUint8Array(buf) {
+    return buf;
+}
+
 /**
  * Returns a new Uint8Array created by concatenating the passed Uint8Arrays
  */
 function concat(arrays, length) {
-    if (globalThis.Buffer != null) {
-        return asUint8Array(globalThis.Buffer.concat(arrays, length));
-    }
     if (length == null) {
         length = arrays.reduce((acc, curr) => acc + curr.length, 0);
     }
@@ -1358,6 +1359,47 @@ function _pushable(getNext, options) {
     return pushable;
 }
 
+/**
+ * @packageDocumentation
+ *
+ * Merge several (async)iterables into one, yield values as they arrive.
+ *
+ * Nb. sources are iterated over in parallel so the order of emitted items is not guaranteed.
+ *
+ * @example
+ *
+ * ```javascript
+ * import merge from 'it-merge'
+ * import all from 'it-all'
+ *
+ * // This can also be an iterator, generator, etc
+ * const values1 = [0, 1, 2, 3, 4]
+ * const values2 = [5, 6, 7, 8, 9]
+ *
+ * const arr = all(merge(values1, values2))
+ *
+ * console.info(arr) // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+ * ```
+ *
+ * Async sources must be awaited:
+ *
+ * ```javascript
+ * import merge from 'it-merge'
+ * import all from 'it-all'
+ *
+ * // This can also be an iterator, async iterator, generator, etc
+ * const values1 = async function * () {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ * const values2 = async function * () {
+ *   yield * [5, 6, 7, 8, 9]
+ * }
+ *
+ * const arr = await all(merge(values1(), values2()))
+ *
+ * console.info(arr) // 0, 1, 5, 6, 2, 3, 4, 7, 8, 9  <- nb. order is not guaranteed
+ * ```
+ */
 function isAsyncIterable$1(thing) {
     return thing[Symbol.asyncIterator] != null;
 }
@@ -2128,7 +2170,7 @@ function toProtoMessage(wire) {
     return { ...EmptyMessage, ...wire };
 }
 
-const OneMillion = BigInt(1000000);
+const OneMillion = BigInt(1_000_000);
 var PageDirection;
 (function (PageDirection) {
     PageDirection["BACKWARD"] = "backward";
@@ -2201,261 +2243,80 @@ function directionToProto(pageDirection) {
 var HistoryError = HistoryResponse.HistoryError;
 const log$4 = new Logger("store");
 const StoreCodec = "/vac/waku/store/2.0.0-beta4";
-const DefaultPageSize = 10;
 /**
  * Implements the [Waku v2 Store protocol](https://rfc.vac.dev/spec/13/).
  *
  * The Waku Store protocol can be used to retrieved historical messages.
  */
-class Store extends BaseProtocol {
-    NUM_PEERS_PROTOCOL = 1;
+class StoreCore extends BaseProtocol {
     constructor(libp2p, options) {
         super(StoreCodec, libp2p.components, log$4, options.pubsubTopics, options);
     }
-    /**
-     * Processes messages based on the provided callback and options.
-     * @private
-     */
-    async processMessages(messages, callback, options) {
-        let abort = false;
-        const messagesOrUndef = await Promise.all(messages);
-        let processedMessages = messagesOrUndef.filter(isDefined);
-        if (this.shouldReverseOrder(options)) {
-            processedMessages = processedMessages.reverse();
+    async *queryPerPage(queryOpts, decoders, peer) {
+        if (queryOpts.contentTopics.toString() !==
+            Array.from(decoders.keys()).toString()) {
+            throw new Error("Internal error, the decoders should match the query's content topics");
         }
-        await Promise.all(processedMessages.map(async (msg) => {
-            if (msg && !abort) {
-                abort = Boolean(await callback(msg));
+        let currentCursor = queryOpts.cursor;
+        while (true) {
+            queryOpts.cursor = currentCursor;
+            const historyRpcQuery = HistoryRpc.createQuery(queryOpts);
+            const stream = await this.getStream(peer);
+            const res = await pipe([historyRpcQuery.encode()], encode, stream, decode, async (source) => await all(source));
+            const bytes = new Uint8ArrayList();
+            res.forEach((chunk) => {
+                bytes.append(chunk);
+            });
+            const reply = historyRpcQuery.decode(bytes);
+            if (!reply.response) {
+                log$4.warn("Stopping pagination due to store `response` field missing");
+                break;
             }
-        }));
-        return abort;
-    }
-    /**
-     * Determines whether to reverse the order of messages based on the provided options.
-     *
-     * Messages in pages are ordered from oldest (first) to most recent (last).
-     * https://github.com/vacp2p/rfc/issues/533
-     *
-     * @private
-     */
-    shouldReverseOrder(options) {
-        return (typeof options?.pageDirection === "undefined" ||
-            options?.pageDirection === PageDirection.BACKWARD);
-    }
-    /**
-     * @deprecated Use `queryWithOrderedCallback` instead
-     **/
-    queryOrderedCallback = this.queryWithOrderedCallback;
-    /**
-     * Do a query to a Waku Store to retrieve historical/missed messages.
-     *
-     * The callback function takes a `WakuMessage` in input,
-     * messages are processed in order:
-     * - oldest to latest if `options.pageDirection` == { @link PageDirection.FORWARD }
-     * - latest to oldest if `options.pageDirection` == { @link PageDirection.BACKWARD }
-     *
-     * The ordering may affect performance.
-     * The ordering depends on the behavior of the remote store node.
-     * If strong ordering is needed, you may need to handle this at application level
-     * and set your own timestamps too (the WakuMessage timestamps are not certified).
-     *
-     * @throws If not able to reach a Waku Store peer to query,
-     * or if an error is encountered when processing the reply,
-     * or if two decoders with the same content topic are passed.
-     */
-    async queryWithOrderedCallback(decoders, callback, options) {
-        for await (const promises of this.queryGenerator(decoders, options)) {
-            if (await this.processMessages(promises, callback, options))
+            const response = reply.response;
+            if (response.error && response.error !== HistoryError.NONE) {
+                throw "History response contains an Error: " + response.error;
+            }
+            if (!response.messages || !response.messages.length) {
+                log$4.warn("Stopping pagination due to store `response.messages` field missing or empty");
                 break;
-        }
-    }
-    /**
-     * Do a query to a Waku Store to retrieve historical/missed messages.
-     * The callback function takes a `Promise<WakuMessage>` in input,
-     * useful if messages need to be decrypted and performance matters.
-     *
-     * The order of the messages passed to the callback is as follows:
-     * - within a page, messages are expected to be ordered from oldest to most recent
-     * - pages direction depends on { @link QueryOptions.pageDirection }
-     *
-     * Do note that the resolution of the `Promise<WakuMessage | undefined` may
-     * break the order as it may rely on the browser decryption API, which in turn,
-     * may have a different speed depending on the type of decryption.
-     *
-     * @throws If not able to reach a Waku Store peer to query,
-     * or if an error is encountered when processing the reply,
-     * or if two decoders with the same content topic are passed.
-     */
-    async queryWithPromiseCallback(decoders, callback, options) {
-        let abort = false;
-        for await (const page of this.queryGenerator(decoders, options)) {
-            const _promises = page.map(async (msgPromise) => {
-                if (abort)
-                    return;
-                abort = Boolean(await callback(msgPromise));
+            }
+            log$4.error(`${response.messages.length} messages retrieved from store`);
+            yield response.messages.map((protoMsg) => {
+                const contentTopic = protoMsg.contentTopic;
+                if (typeof contentTopic !== "undefined") {
+                    const decoder = decoders.get(contentTopic);
+                    if (decoder) {
+                        return decoder.fromProtoObj(queryOpts.pubsubTopic, toProtoMessage(protoMsg));
+                    }
+                }
+                return Promise.resolve(undefined);
             });
-            await Promise.all(_promises);
-            if (abort)
+            const nextCursor = response.pagingInfo?.cursor;
+            if (typeof nextCursor === "undefined") {
+                // If the server does not return cursor then there is an issue,
+                // Need to abort, or we end up in an infinite loop
+                log$4.warn("Stopping pagination due to `response.pagingInfo.cursor` missing from store response");
+                break;
+            }
+            currentCursor = nextCursor;
+            const responsePageSize = response.pagingInfo?.pageSize;
+            const queryPageSize = historyRpcQuery.query?.pagingInfo?.pageSize;
+            if (
+            // Response page size smaller than query, meaning this is the last page
+            responsePageSize &&
+                queryPageSize &&
+                responsePageSize < queryPageSize) {
                 break;
-        }
-    }
-    /**
-     * Do a query to a Waku Store to retrieve historical/missed messages.
-     *
-     * This is a generator, useful if you want most control on how messages
-     * are processed.
-     *
-     * The order of the messages returned by the remote Waku node SHOULD BE
-     * as follows:
-     * - within a page, messages SHOULD be ordered from oldest to most recent
-     * - pages direction depends on { @link QueryOptions.pageDirection }
-     * @throws If not able to reach a Waku Store peer to query,
-     * or if an error is encountered when processing the reply,
-     * or if two decoders with the same content topic are passed.
-     *
-     * This API only supports querying a single pubsub topic at a time.
-     * If multiple decoders are provided, they must all have the same pubsub topic.
-     * @throws If multiple decoders with different pubsub topics are provided.
-     * @throws If no decoders are provided.
-     * @throws If no decoders are found for the provided pubsub topic.
-     */
-    async *queryGenerator(decoders, options) {
-        if (decoders.length === 0) {
-            throw new Error("No decoders provided");
-        }
-        let startTime, endTime;
-        if (options?.timeFilter) {
-            startTime = options.timeFilter.startTime;
-            endTime = options.timeFilter.endTime;
-        }
-        // convert array to set to remove duplicates
-        const uniquePubsubTopicsInQuery = Array.from(new Set(decoders.map((decoder) => decoder.pubsubTopic)));
-        // If multiple pubsub topics are provided, throw an error
-        if (uniquePubsubTopicsInQuery.length > 1) {
-            throw new Error("API does not support querying multiple pubsub topics at once");
-        }
-        // we can be certain that there is only one pubsub topic in the query
-        const pubsubTopicForQuery = uniquePubsubTopicsInQuery[0];
-        ensurePubsubTopicIsConfigured(pubsubTopicForQuery, this.pubsubTopics);
-        // check that the pubsubTopic from the Cursor and Decoder match
-        if (options?.cursor?.pubsubTopic &&
-            options.cursor.pubsubTopic !== pubsubTopicForQuery) {
-            throw new Error(`Cursor pubsub topic (${options?.cursor?.pubsubTopic}) does not match decoder pubsub topic (${pubsubTopicForQuery})`);
-        }
-        const decodersAsMap = new Map();
-        decoders.forEach((dec) => {
-            if (decodersAsMap.has(dec.contentTopic)) {
-                throw new Error("API does not support different decoder per content topic");
-            }
-            decodersAsMap.set(dec.contentTopic, dec);
-        });
-        const contentTopics = decoders
-            .filter((decoder) => decoder.pubsubTopic === pubsubTopicForQuery)
-            .map((dec) => dec.contentTopic);
-        if (contentTopics.length === 0) {
-            throw new Error("No decoders found for topic " + pubsubTopicForQuery);
-        }
-        const queryOpts = Object.assign({
-            pubsubTopic: pubsubTopicForQuery,
-            pageDirection: PageDirection.BACKWARD,
-            pageSize: DefaultPageSize
-        }, options, { contentTopics, startTime, endTime });
-        const peer = (await this.getPeers({
-            numPeers: this.NUM_PEERS_PROTOCOL,
-            maxBootstrapPeers: 1
-        }))[0];
-        for await (const messages of paginate(this.getStream.bind(this, peer), queryOpts, decodersAsMap, options?.cursor)) {
-            yield messages;
-        }
-    }
-}
-async function* paginate(streamFactory, queryOpts, decoders, cursor) {
-    if (queryOpts.contentTopics.toString() !==
-        Array.from(decoders.keys()).toString()) {
-        throw new Error("Internal error, the decoders should match the query's content topics");
-    }
-    let currentCursor = cursor;
-    while (true) {
-        queryOpts.cursor = currentCursor;
-        const historyRpcQuery = HistoryRpc.createQuery(queryOpts);
-        log$4.info("Querying store peer", `for (${queryOpts.pubsubTopic})`, queryOpts.contentTopics);
-        const stream = await streamFactory();
-        const res = await pipe([historyRpcQuery.encode()], encode, stream, decode, async (source) => await all(source));
-        const bytes = new Uint8ArrayList();
-        res.forEach((chunk) => {
-            bytes.append(chunk);
-        });
-        const reply = historyRpcQuery.decode(bytes);
-        if (!reply.response) {
-            log$4.warn("Stopping pagination due to store `response` field missing");
-            break;
-        }
-        const response = reply.response;
-        if (response.error && response.error !== HistoryError.NONE) {
-            throw "History response contains an Error: " + response.error;
-        }
-        if (!response.messages || !response.messages.length) {
-            log$4.warn("Stopping pagination due to store `response.messages` field missing or empty");
-            break;
-        }
-        log$4.error(`${response.messages.length} messages retrieved from store`);
-        yield response.messages.map((protoMsg) => {
-            const contentTopic = protoMsg.contentTopic;
-            if (typeof contentTopic !== "undefined") {
-                const decoder = decoders.get(contentTopic);
-                if (decoder) {
-                    return decoder.fromProtoObj(queryOpts.pubsubTopic, toProtoMessage(protoMsg));
-                }
             }
-            return Promise.resolve(undefined);
-        });
-        const nextCursor = response.pagingInfo?.cursor;
-        if (typeof nextCursor === "undefined") {
-            // If the server does not return cursor then there is an issue,
-            // Need to abort, or we end up in an infinite loop
-            log$4.warn("Stopping pagination due to `response.pagingInfo.cursor` missing from store response");
-            break;
-        }
-        currentCursor = nextCursor;
-        const responsePageSize = response.pagingInfo?.pageSize;
-        const queryPageSize = historyRpcQuery.query?.pagingInfo?.pageSize;
-        if (
-        // Response page size smaller than query, meaning this is the last page
-        responsePageSize &&
-            queryPageSize &&
-            responsePageSize < queryPageSize) {
-            break;
         }
     }
 }
-async function createCursor(message) {
-    if (!message ||
-        !message.timestamp ||
-        !message.payload ||
-        !message.contentTopic) {
-        throw new Error("Message is missing required fields");
-    }
-    const contentTopicBytes = utf8ToBytes(message.contentTopic);
-    const digest = sha256(concat$1([contentTopicBytes, message.payload]));
-    const messageTime = BigInt(message.timestamp.getTime()) * BigInt(1000000);
-    return {
-        digest,
-        pubsubTopic: message.pubsubTopic,
-        senderTime: messageTime,
-        receiverTime: messageTime
-    };
-}
-function wakuStore(init = {}) {
-    return (libp2p) => new Store(libp2p, init);
-}
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    DefaultPageSize: DefaultPageSize,
     get PageDirection () { return PageDirection; },
     StoreCodec: StoreCodec,
-    createCursor: createCursor,
-    wakuStore: wakuStore
+    StoreCore: StoreCore
 });
 
 class TimeoutError extends Error {
@@ -2576,8 +2437,8 @@ function pTimeout(promise, options) {
 }
 
 const normalizeEmitter = emitter => {
-	const addListener = emitter.on || emitter.addListener || emitter.addEventListener;
-	const removeListener = emitter.off || emitter.removeListener || emitter.removeEventListener;
+	const addListener = emitter.addEventListener || emitter.on || emitter.addListener;
+	const removeListener = emitter.removeEventListener || emitter.off || emitter.removeListener;
 
 	if (!addListener || !removeListener) {
 		throw new TypeError('Emitter is not compatible');
@@ -2724,7 +2585,7 @@ async function waitForRemotePeer(waku, protocols, timeoutMs) {
     if (protocols.includes(Protocols.Store)) {
         if (!waku.store)
             throw new Error("Cannot wait for Store peer: protocol not mounted");
-        promises.push(waitForConnectedPeer(waku.store, waku.libp2p.services.metadata));
+        promises.push(waitForConnectedPeer(waku.store.protocol, waku.libp2p.services.metadata));
     }
     if (protocols.includes(Protocols.LightPush)) {
         if (!waku.lightPush)
@@ -3524,4 +3385,4 @@ function wakuMetadata(shardInfo) {
     return (components) => new Metadata(shardInfo, components);
 }
 
-export { ConnectionManager, FilterCodecs, KeepAliveManager, LightPushCodec, LightPushCore, MetadataCodec, PageDirection, createCursor, createEncoder, index$3 as message, waitForRemotePeer, wakuFilter, wakuMetadata, wakuStore, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+export { ConnectionManager, FilterCodecs, KeepAliveManager, LightPushCodec, LightPushCore, MetadataCodec, PageDirection, StoreCore, createEncoder, index$3 as message, waitForRemotePeer, wakuFilter, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };

package/bundle/lib/base_protocol.js

@@ -1,3 +1,3 @@
-import '../index-vlQahmUj.js';
+import '../index-BJwgMx4y.js';
 import '../browser-DoQRY-an.js';
-export { B as BaseProtocol } from '../base_protocol-BCwLeb-A.js';
+export { B as BaseProtocol } from '../base_protocol-D0Zdzb-v.js';

package/bundle/lib/message/version_0.js

@@ -1,3 +1,3 @@
-export { D as DecodedMessage, k as Decoder, E as Encoder, V as Version, j as createDecoder, h as createEncoder, m as proto } from '../../version_0-DiakMc1A.js';
-import '../../index-vlQahmUj.js';
+export { D as DecodedMessage, k as Decoder, E as Encoder, V as Version, j as createDecoder, h as createEncoder, m as proto } from '../../version_0-C6o0DvNW.js';
+import '../../index-BJwgMx4y.js';
 import '../../browser-DoQRY-an.js';

package/bundle/lib/predefined_bootstrap_nodes.js

@@ -28,51 +28,51 @@ function shuffle(arr) {
 const DefaultWantedNumber = 1;
 var Fleet;
 (function (Fleet) {
-    Fleet["Prod"] = "prod";
+    Fleet["Sandbox"] = "sandbox";
     Fleet["Test"] = "test";
 })(Fleet || (Fleet = {}));
 /**
  * Return list of pre-defined (hardcoded) bootstrap nodes.
  *
- * Default behavior is to return nodes of the nwaku Status Prod fleet.
+ * Default behavior is to return nodes of the nwaku Status Sandbox fleet.
  *
- * @param fleet The fleet to be returned. Defaults to production fleet.
+ * @param fleet The fleet to be returned. Defaults to sandbox fleet.
  * @param wantedNumber The number of connections desired. Defaults to {@link DefaultWantedNumber}.
  *
  * @returns An array of multiaddresses.
  */
-function getPredefinedBootstrapNodes(fleet = Fleet.Prod, wantedNumber = DefaultWantedNumber) {
+function getPredefinedBootstrapNodes(fleet = Fleet.Sandbox, wantedNumber = DefaultWantedNumber) {
     if (wantedNumber <= 0) {
         return [];
     }
     let nodes;
     switch (fleet) {
-        case Fleet.Prod:
-            nodes = fleets.fleets["wakuv2.prod"]["waku-websocket"];
+        case Fleet.Sandbox:
+            nodes = fleets.fleets["waku.sandbox"]["waku-websocket"];
             break;
         case Fleet.Test:
-            nodes = fleets.fleets["wakuv2.test"]["waku-websocket"];
+            nodes = fleets.fleets["waku.test"]["waku-websocket"];
             break;
         default:
-            nodes = fleets.fleets["wakuv2.prod"]["waku-websocket"];
+            nodes = fleets.fleets["waku.sandbox"]["waku-websocket"];
     }
     nodes = Object.values(nodes);
     return getPseudoRandomSubset(nodes, wantedNumber);
 }
 const fleets = {
     fleets: {
-        "wakuv2.prod": {
+        "waku.sandbox": {
             "waku-websocket": {
-                "node-01.ac-cn-hongkong-c.wakuv2.prod": "/dns4/node-01.ac-cn-hongkong-c.wakuv2.prod.statusim.net/tcp/8000/wss/p2p/16Uiu2HAm4v86W3bmT1BiH6oSPzcsSr24iDQpSN5Qa992BCjjwgrD",
-                "node-01.do-ams3.wakuv2.prod": "/dns4/node-01.do-ams3.wakuv2.prod.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmL5okWopX7NqZWBUKVqW8iUxCEmd5GMHLVPwCgzYzQv3e",
-                "node-01.gc-us-central1-a.wakuv2.prod": "/dns4/node-01.gc-us-central1-a.wakuv2.prod.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmVkKntsECaYfefR1V2yCR79CegLATuTPE6B9TxgxBiiiA"
+                "node-01.ac-cn-hongkong-c.waku.sandbox": "/dns4/node-01.ac-cn-hongkong-c.waku.sandbox.status.im/tcp/8000/wss/p2p/16Uiu2HAmSJvSJphxRdbnigUV5bjRRZFBhTtWFTSyiKaQByCjwmpV",
+                "node-01.do-ams3.waku.sandbox": "/dns4/node-01.do-ams3.waku.sandbox.status.im/tcp/8000/wss/p2p/16Uiu2HAmQSMNExfUYUqfuXWkD5DaNZnMYnigRxFKbk3tcEFQeQeE",
+                "node-01.gc-us-central1-a.waku.sandbox": "/dns4/node-01.gc-us-central1-a.waku.sandbox.status.im/tcp/8000/wss/p2p/16Uiu2HAm6fyqE1jB5MonzvoMdU8v76bWV8ZeNpncDamY1MQXfjdB"
             }
         },
-        "wakuv2.test": {
+        "waku.test": {
             "waku-websocket": {
-                "node-01.ac-cn-hongkong-c.wakuv2.test": "/dns4/node-01.ac-cn-hongkong-c.wakuv2.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAkvWiyFsgRhuJEb9JfjYxEkoHLgnUQmr1N5mKWnYjxYRVm",
-                "node-01.do-ams3.wakuv2.test": "/dns4/node-01.do-ams3.wakuv2.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmPLe7Mzm8TsYUubgCAW1aJoeFScxrLj8ppHFivPo97bUZ",
-                "node-01.gc-us-central1-a.wakuv2.test": "/dns4/node-01.gc-us-central1-a.wakuv2.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmJb2e28qLXxT5kZxVUUoJt72EMzNGXB47Rxx5hw3q4YjS"
+                "node-01.ac-cn-hongkong-c.waku.test": "/dns4/node-01.ac-cn-hongkong-c.waku.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAkzHaTP5JsUwfR9NR8Rj9HC24puS6ocaU8wze4QrXr9iXp",
+                "node-01.do-ams3.waku.test": "/dns4/node-01.do-ams3.waku.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAkykgaECHswi3YKJ5dMLbq2kPVCo89fcyTd38UcQD6ej5W",
+                "node-01.gc-us-central1-a.waku.test": "/dns4/node-01.gc-us-central1-a.waku.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmDCp8XJ9z1ev18zuv8NHekAsjNyezAvmMfFEJkiharitG"
             }
         }
     }