@waku/core 0.0.1 → 0.0.3

package/bundle/lib/peer_discovery_static_list.js

@@ -1,11 +1,25 @@
-import { m as multiaddrsToPeerInfo, s as symbol } from '../multiaddr_to_peer_info-fd1de516.js';
-import { E as EventEmitter, C as CustomEvent } from '../events-fcbda4dc.js';
-import { m as multiaddr } from '../index-0a4bdddc.js';
+import { p as peerIdFromString, E as EventEmitter, C as CustomEvent } from '../events-158407bb.js';
+import { m as multiaddr } from '../index-f7e049ad.js';
 import { d as debug } from '../browser-1e1a2f27.js';
 import { g as getPseudoRandomSubset } from '../random_subset-75d1c511.js';
-import '../index-2ae915be.js';
 import '../index-64ce43f0.js';
 
+const symbol = Symbol.for('@libp2p/peer-discovery');
+
+function multiaddrsToPeerInfo(mas) {
+    return mas
+        .map((ma) => {
+        const peerIdStr = ma.getPeerId();
+        const protocols = [];
+        return {
+            id: peerIdStr ? peerIdFromString(peerIdStr) : null,
+            multiaddrs: [ma.decapsulateCode(421)],
+            protocols,
+        };
+    })
+        .filter((peerInfo) => peerInfo.id !== null);
+}
+
 const log = debug("waku:peer-discovery-static-list");
 /**
  * Pass a list of multiaddr that will be used to bootstrap a node.

package/bundle/lib/predefined_bootstrap_nodes.js

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

package/bundle/lib/wait_for_remote_peer.js

@@ -1,7 +1,6 @@
-import { P as Protocols, S as StoreCodec, L as LightPushCodec, F as FilterCodec } from '../index-691c0be6.js';
+import { P as Protocols, S as StoreCodec, L as LightPushCodec, F as FilterCodec } from '../index-a67d7136.js';
 import { d as debug } from '../browser-1e1a2f27.js';
-import '../message-e2db79d7.js';
-import '../index-ba42b4fc.js';
+import '../message-049c8b67.js';
 import '../index-64ce43f0.js';
 
 class TimeoutError extends Error {

package/bundle/lib/waku_message/topic_only_message.js

@@ -1,4 +1,3 @@
 import '../../browser-1e1a2f27.js';
-export { T as TopicOnlyDecoder, a as TopicOnlyMessage } from '../../topic_only_message-34f36fa6.js';
-import '../../message-e2db79d7.js';
-import '../../index-ba42b4fc.js';
+export { T as TopicOnlyDecoder, a as TopicOnlyMessage } from '../../topic_only_message-5ad3a869.js';
+import '../../message-049c8b67.js';

package/bundle/lib/waku_message/version_0.js

@@ -1,4 +1,317 @@
-import '../../browser-1e1a2f27.js';
-export { D as DecoderV0, E as EncoderV0, M as MessageV0, V as Version } from '../../version_0-e6fe440c.js';
-import '../../message-e2db79d7.js';
-import '../../index-ba42b4fc.js';
+import { d as debug } from '../../browser-1e1a2f27.js';
+import { m as message$1, j as encodeMessage, k as decodeMessage } from '../../message-049c8b67.js';
+
+/* eslint-disable import/export */
+var RateLimitProof;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.proof != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.proof);
+                }
+                else {
+                    throw new Error('Protocol error: required field "proof" was not found in object');
+                }
+                if (obj.merkleRoot != null) {
+                    writer.uint32(18);
+                    writer.bytes(obj.merkleRoot);
+                }
+                else {
+                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
+                }
+                if (obj.epoch != null) {
+                    writer.uint32(26);
+                    writer.bytes(obj.epoch);
+                }
+                else {
+                    throw new Error('Protocol error: required field "epoch" was not found in object');
+                }
+                if (obj.shareX != null) {
+                    writer.uint32(34);
+                    writer.bytes(obj.shareX);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareX" was not found in object');
+                }
+                if (obj.shareY != null) {
+                    writer.uint32(42);
+                    writer.bytes(obj.shareY);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareY" was not found in object');
+                }
+                if (obj.nullifier != null) {
+                    writer.uint32(50);
+                    writer.bytes(obj.nullifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "nullifier" was not found in object');
+                }
+                if (obj.rlnIdentifier != null) {
+                    writer.uint32(58);
+                    writer.bytes(obj.rlnIdentifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                if (obj.proof == null) {
+                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
+                }
+                if (obj.merkleRoot == null) {
+                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
+                }
+                if (obj.epoch == null) {
+                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
+                }
+                if (obj.shareX == null) {
+                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
+                }
+                if (obj.shareY == null) {
+                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
+                }
+                if (obj.nullifier == null) {
+                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
+                }
+                if (obj.rlnIdentifier == null) {
+                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof || (RateLimitProof = {}));
+var WakuMessage;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.payload != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    writer.uint32(24);
+                    writer.uint32(obj.version);
+                }
+                if (obj.timestampDeprecated != null) {
+                    writer.uint32(33);
+                    writer.double(obj.timestampDeprecated);
+                }
+                if (obj.timestamp != null) {
+                    writer.uint32(80);
+                    writer.sint64(obj.timestamp);
+                }
+                if (obj.rateLimitProof != null) {
+                    writer.uint32(170);
+                    RateLimitProof.codec().encode(obj.rateLimitProof, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 4:
+                            obj.timestampDeprecated = reader.double();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage || (WakuMessage = {}));
+
+var message = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get RateLimitProof () { return RateLimitProof; },
+    get WakuMessage () { return WakuMessage; }
+});
+
+const log = debug("waku:message:version-0");
+const OneMillion = BigInt(1000000);
+const Version = 0;
+class MessageV0 {
+    constructor(proto) {
+        this.proto = proto;
+    }
+    get _rawPayload() {
+        if (this.proto.payload) {
+            return new Uint8Array(this.proto.payload);
+        }
+        return;
+    }
+    get payload() {
+        return this._rawPayload;
+    }
+    get contentTopic() {
+        return this.proto.contentTopic;
+    }
+    get _rawTimestamp() {
+        return this.proto.timestamp;
+    }
+    get timestamp() {
+        // In the case we receive a value that is bigger than JS's max number,
+        // we catch the error and return undefined.
+        try {
+            if (this.proto.timestamp) {
+                // nanoseconds 10^-9 to milliseconds 10^-3
+                const timestamp = this.proto.timestamp / OneMillion;
+                return new Date(Number(timestamp));
+            }
+            if (this.proto.timestampDeprecated) {
+                return new Date(this.proto.timestampDeprecated * 1000);
+            }
+        }
+        catch (e) {
+            return;
+        }
+        return;
+    }
+    get version() {
+        // https://github.com/status-im/js-waku/issues/921
+        return this.proto.version ?? 0;
+    }
+    get rateLimitProof() {
+        return this.proto.rateLimitProof;
+    }
+}
+class EncoderV0 {
+    constructor(contentTopic) {
+        this.contentTopic = contentTopic;
+    }
+    async toWire(message$1) {
+        return WakuMessage.encode(await this.toProtoObj(message$1));
+    }
+    async toProtoObj(message) {
+        const timestamp = message.timestamp ?? new Date();
+        return {
+            payload: message.payload,
+            version: Version,
+            contentTopic: this.contentTopic,
+            timestamp: BigInt(timestamp.valueOf()) * OneMillion,
+            rateLimitProof: message.rateLimitProof,
+        };
+    }
+}
+class DecoderV0 {
+    constructor(contentTopic) {
+        this.contentTopic = contentTopic;
+    }
+    fromWireToProtoObj(bytes) {
+        const protoMessage = WakuMessage.decode(bytes);
+        log("Message decoded", protoMessage);
+        return Promise.resolve({
+            payload: protoMessage.payload ?? undefined,
+            contentTopic: protoMessage.contentTopic ?? undefined,
+            version: protoMessage.version ?? undefined,
+            timestamp: protoMessage.timestamp ?? undefined,
+            rateLimitProof: protoMessage.rateLimitProof ?? undefined,
+        });
+    }
+    async fromProtoObj(proto) {
+        // https://github.com/status-im/js-waku/issues/921
+        if (proto.version === undefined) {
+            proto.version = 0;
+        }
+        if (proto.version !== Version) {
+            log("Failed to decode due to incorrect version, expected:", Version, ", actual:", proto.version);
+            return Promise.resolve(undefined);
+        }
+        return new MessageV0(proto);
+    }
+}
+
+export { DecoderV0, EncoderV0, MessageV0, Version, message as proto };