@waku/message-encryption 0.0.24-678635e.0 → 0.0.24

package/bundle/index-alzPvot7.js

@@ -0,0 +1,17 @@
+import { e as ecies, g as generatePrivateKey, a as generateSymmetricKey, b as getPublicKey, c as getSubtle, k as keccak256, r as randomBytes, s as sha256, d as sign, f as symmetric } from './symmetric-CXVjdTdV.js';
+
+var index = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	ecies: ecies,
+	generatePrivateKey: generatePrivateKey,
+	generateSymmetricKey: generateSymmetricKey,
+	getPublicKey: getPublicKey,
+	getSubtle: getSubtle,
+	keccak256: keccak256,
+	randomBytes: randomBytes,
+	sha256: sha256,
+	sign: sign,
+	symmetric: symmetric
+});
+
+export { index as i };

package/bundle/index.js

@@ -1 +1,5 @@
-export { O as OneMillion, V as Version, h as ecies, g as generatePrivateKey, d as generateSymmetricKey, a as getPublicKey, s as symmetric } from './index-62691783.js';
+export { i as crypto } from './index-alzPvot7.js';
+export { e as ecies } from './ecies-R65pUoo3.js';
+export { s as symmetric } from './symmetric-7aAyizy_.js';
+export { g as generatePrivateKey, a as generateSymmetricKey, b as getPublicKey } from './symmetric-CXVjdTdV.js';
+import './encryption-zFGfcjHZ.js';

package/bundle/symmetric-7aAyizy_.js

@@ -0,0 +1,124 @@
+import { L as Logger, d as determinePubsubTopic, D as DefaultPubsubTopic, W as WakuMessage, p as preCipher, g as encryptSymmetric, a as Decoder$1, h as decryptSymmetric, c as postCipher, f as DecodedMessage } from './encryption-zFGfcjHZ.js';
+import { V as Version, O as OneMillion, a as generateSymmetricKey } from './symmetric-CXVjdTdV.js';
+
+const log = new Logger("message-encryption:symmetric");
+class Encoder {
+    pubsubTopic;
+    contentTopic;
+    symKey;
+    sigPrivKey;
+    ephemeral;
+    metaSetter;
+    constructor(pubsubTopic, contentTopic, symKey, sigPrivKey, ephemeral = false, metaSetter) {
+        this.pubsubTopic = pubsubTopic;
+        this.contentTopic = contentTopic;
+        this.symKey = symKey;
+        this.sigPrivKey = sigPrivKey;
+        this.ephemeral = ephemeral;
+        this.metaSetter = metaSetter;
+        if (!contentTopic || contentTopic === "") {
+            throw new Error("Content topic must be specified");
+        }
+    }
+    async toWire(message) {
+        const protoMessage = await this.toProtoObj(message);
+        if (!protoMessage)
+            return;
+        return WakuMessage.encode(protoMessage);
+    }
+    async toProtoObj(message) {
+        const timestamp = message.timestamp ?? new Date();
+        const preparedPayload = await preCipher(message.payload, this.sigPrivKey);
+        const payload = await encryptSymmetric(preparedPayload, this.symKey);
+        const protoMessage = {
+            payload,
+            version: Version,
+            contentTopic: this.contentTopic,
+            timestamp: BigInt(timestamp.valueOf()) * OneMillion,
+            meta: undefined,
+            rateLimitProof: message.rateLimitProof,
+            ephemeral: this.ephemeral
+        };
+        if (this.metaSetter) {
+            const meta = this.metaSetter(protoMessage);
+            return { ...protoMessage, meta };
+        }
+        return protoMessage;
+    }
+}
+/**
+ * Creates an encoder that encrypts messages using symmetric encryption for the
+ * given key, as defined in [26/WAKU2-PAYLOAD](https://rfc.vac.dev/spec/26/).
+ *
+ * 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!ISender.send } to automatically encrypt
+ * and encode outgoing messages.
+ *
+ * The payload can optionally be signed with the given private key as defined
+ * in [26/WAKU2-PAYLOAD](https://rfc.vac.dev/spec/26/).
+ */
+function createEncoder({ pubsubTopic = DefaultPubsubTopic, pubsubTopicShardInfo, contentTopic, symKey, sigPrivKey, ephemeral = false, metaSetter }) {
+    return new Encoder(determinePubsubTopic(contentTopic, pubsubTopic ?? pubsubTopicShardInfo), contentTopic, symKey, sigPrivKey, ephemeral, metaSetter);
+}
+class Decoder extends Decoder$1 {
+    symKey;
+    constructor(pubsubTopic, contentTopic, symKey) {
+        super(pubsubTopic, contentTopic);
+        this.symKey = symKey;
+    }
+    async fromProtoObj(pubsubTopic, protoMessage) {
+        const cipherPayload = protoMessage.payload;
+        if (protoMessage.version !== Version) {
+            log.error("Failed to decrypt due to incorrect version, expected:", Version, ", actual:", protoMessage.version);
+            return;
+        }
+        let payload;
+        try {
+            payload = await decryptSymmetric(cipherPayload, this.symKey);
+        }
+        catch (e) {
+            log.error(`Failed to decrypt message using asymmetric decryption for contentTopic: ${this.contentTopic}`, e);
+            return;
+        }
+        if (!payload) {
+            log.error(`Failed to decrypt payload for contentTopic ${this.contentTopic}`);
+            return;
+        }
+        const res = postCipher(payload);
+        if (!res) {
+            log.error(`Failed to decode payload for contentTopic ${this.contentTopic}`);
+            return;
+        }
+        log.info("Message decrypted", protoMessage);
+        return new DecodedMessage(pubsubTopic, protoMessage, res.payload, res.sig?.signature, res.sig?.publicKey);
+    }
+}
+/**
+ * Creates a decoder that decrypts messages using symmetric encryption, using
+ * the given key as defined in [26/WAKU2-PAYLOAD](https://rfc.vac.dev/spec/26/).
+ *
+ * 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!IReceiver.subscribe } to automatically decrypt and
+ * decode incoming messages.
+ *
+ * @param contentTopic The resulting decoder will only decode messages with this content topic.
+ * @param symKey The symmetric key used to decrypt the message.
+ */
+function createDecoder(contentTopic, symKey, pubsubTopicShardInfo = DefaultPubsubTopic) {
+    return new Decoder(determinePubsubTopic(contentTopic, pubsubTopicShardInfo), contentTopic, symKey);
+}
+
+var symmetric = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createDecoder: createDecoder,
+    createEncoder: createEncoder,
+    decryptSymmetric: decryptSymmetric,
+    encryptSymmetric: encryptSymmetric,
+    generateSymmetricKey: generateSymmetricKey,
+    postCipher: postCipher,
+    preCipher: preCipher
+});
+
+export { createDecoder as a, createEncoder as c, symmetric as s };