@waku/core 0.0.6 → 0.0.7

package/bundle/lib/message/topic_only_message.js

@@ -0,0 +1,33 @@
+import { d as debug, T as TopicOnlyMessage$1 } from '../../peer_exchange-53df2b11.js';
+
+const log = debug("waku:message:topic-only");
+class TopicOnlyMessage {
+    constructor(proto) {
+        this.proto = proto;
+    }
+    get contentTopic() {
+        return this.proto.contentTopic ?? "";
+    }
+}
+class TopicOnlyDecoder {
+    constructor() {
+        this.contentTopic = "";
+    }
+    fromWireToProtoObj(bytes) {
+        const protoMessage = TopicOnlyMessage$1.decode(bytes);
+        log("Message decoded", protoMessage);
+        return Promise.resolve({
+            contentTopic: protoMessage.contentTopic,
+            payload: undefined,
+            rateLimitProof: undefined,
+            timestamp: undefined,
+            version: undefined,
+            ephemeral: undefined,
+        });
+    }
+    async fromProtoObj(proto) {
+        return new TopicOnlyMessage(proto);
+    }
+}
+
+export { TopicOnlyDecoder, TopicOnlyMessage };

package/bundle/lib/message/version_0.js

@@ -0,0 +1,133 @@
+import { d as debug, W as WakuMessage } from '../../peer_exchange-53df2b11.js';
+export { m as proto } from '../../peer_exchange-53df2b11.js';
+
+const log = debug("waku:message:version-0");
+const OneMillion = BigInt(1000000);
+const Version = 0;
+class DecodedMessage {
+    constructor(proto) {
+        this.proto = proto;
+    }
+    get _rawPayload() {
+        if (this.proto.payload) {
+            return new Uint8Array(this.proto.payload);
+        }
+        return;
+    }
+    get ephemeral() {
+        return Boolean(this.proto.ephemeral);
+    }
+    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 Encoder {
+    constructor(contentTopic, ephemeral = false) {
+        this.contentTopic = contentTopic;
+        this.ephemeral = ephemeral;
+    }
+    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,
+            ephemeral: this.ephemeral,
+        };
+    }
+}
+/**
+ * Creates an encoder that encode messages without Waku level encryption or signature.
+ *
+ * An encoder is used to encode messages in the [`14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
+ * format to be sent over the Waku network. The resulting encoder can then be
+ * pass to { @link @waku/interfaces.LightPush.push } or
+ * { @link @waku/interfaces.Relay.send } to automatically encode outgoing
+ * messages.
+ *
+ * @param contentTopic The content topic to set on outgoing messages.
+ * @param ephemeral An optional flag to mark message as ephemeral, ie, not to be stored by Waku Store nodes.
+ */
+function createEncoder(contentTopic, ephemeral = false) {
+    return new Encoder(contentTopic, ephemeral);
+}
+class Decoder {
+    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,
+            ephemeral: protoMessage.ephemeral ?? false,
+        });
+    }
+    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 DecodedMessage(proto);
+    }
+}
+/**
+ * Creates an decoder that decode messages without Waku level encryption.
+ *
+ * A decoder is used to decode messages from the [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
+ * format when received from the Waku network. The resulting decoder can then be
+ * pass to { @link @waku/interfaces.Filter.subscribe } or
+ * { @link @waku/interfaces.Relay.subscribe } to automatically decode incoming
+ * messages.
+ *
+ * @param contentTopic The resulting decoder will only decode messages with this content topic.
+ */
+function createDecoder(contentTopic) {
+    return new Decoder(contentTopic);
+}
+
+export { DecodedMessage, Decoder, Encoder, Version, createDecoder, createEncoder };