feat: add spec and decoder

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waku/rln",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Rate Limit Nullifier for js-waku",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
@@ -81,7 +81,7 @@
     "husky": "^7.0.4",
     "ignore-loader": "^0.1.2",
     "isomorphic-fetch": "^3.0.0",
-    "js-waku": "file:../js-waku/",
+    "js-waku": "^0.29.0-5bab85f",
     "jsdom": "^19.0.0",
     "jsdom-global": "^3.0.2",
     "karma": "^6.3.12",

src/encoder.spec.ts

@@ -1,7 +1,37 @@
-import { RLNEncoder } from "./encoder.js";
+import { expect } from "chai";
+
+import {DecoderV0, EncoderV0, MessageV0} from "js-waku/lib/waku_message/version_0";
+
+import { RLNDecoder, RLNEncoder } from "./encoder.js";
+import * as rln from "./index";
+
+const TestContentTopic = "/test/1/waku-message/utf8";
 
 describe("js-rln: encoder", () => {
   it("should attach a proof to a waku message", async function () {
-    console.log(RLNEncoder);
+    const rlnInstance = await rln.create();
+    const memKeys = rlnInstance.generateMembershipKey();
+    const index = 0;
+    const payload = new Uint8Array([1, 2, 3, 4, 5]);
+
+    rlnInstance.insertMember(memKeys.IDCommitment);
+
+    const rlnEncoder = new RLNEncoder(
+      new EncoderV0(TestContentTopic),
+      rlnInstance,
+      index,
+      memKeys
+    );
+    const rlnDecoder = new RLNDecoder(new DecoderV0(TestContentTopic));
+
+    const bytes = await rlnEncoder.encode({ payload });
+    const protoResult = await rlnDecoder.decodeProto(bytes!);
+
+    const result = (await rlnDecoder.decode(protoResult!)) as MessageV0;
+
+    expect(result.contentTopic).to.eq(TestContentTopic);
+    expect(result.version).to.eq(0);
+    expect(result.payload).to.deep.eq(payload);
+    expect(result.timestamp).to.not.be.undefined;
   });
 });

src/encoder.ts

@@ -1,24 +1,35 @@
-import { Encoder, Message, ProtoMessage } from "js-waku/lib/interfaces";
+import debug from "debug";
 import { proto_message } from "js-waku";
+import {
+  Decoder,
+  Encoder,
+  Message,
+  ProtoMessage,
+} from "js-waku/lib/interfaces";
 
-import { RLNInstance } from "./rln.js";
+import { MembershipKey, RLNInstance } from "./rln.js";
+
+const log = debug("waku:message:rln-encoder");
 
 export class RLNEncoder implements Encoder {
+  public contentTopic: string;
+
+  private idKey: Uint8Array;
+
   constructor(
-    public contentTopic: string,
     private encoder: Encoder,
     private rlnInstance: RLNInstance,
     private index: number,
-    private idKey: Uint8Array
+    membershipKey: MembershipKey
   ) {
-    if (idKey.length != 32) throw "invalid id key"; // TODO: use proper err message
     if (index < 0) throw "invalid membership index";
+    this.idKey = membershipKey.IDKey;
+    this.contentTopic = encoder.contentTopic;
   }
 
   async encode(message: Message): Promise<Uint8Array | undefined> {
     const protoMessage = await this.encodeProto(message);
     if (!protoMessage) return;
-
     return proto_message.WakuMessage.encode(protoMessage);
   }
 
@@ -50,3 +61,26 @@ export class RLNEncoder implements Encoder {
     return protoMessage;
   }
 }
+
+export class RLNDecoder implements Decoder<Message> {
+  public contentTopic: string;
+
+  constructor(private decoder: Decoder<Message>) {
+    this.contentTopic = decoder.contentTopic;
+  }
+
+  decodeProto(bytes: Uint8Array): Promise<ProtoMessage | undefined> {
+    const protoMessage = proto_message.WakuMessage.decode(bytes);
+    log("Message decoded", protoMessage);
+    return Promise.resolve(protoMessage);
+  }
+
+  async decode(proto: ProtoMessage): Promise<Message | undefined> {
+    // https://github.com/status-im/js-waku/issues/921
+    if (proto.version === undefined) {
+      proto.version = 0;
+    }
+
+    return this.decoder.decode(proto);
+  }
+}

src/index.spec.ts

@@ -51,7 +51,9 @@ describe("js-rln", () => {
     try {
       // Modifying the proof so it's invalid
       const proofBytes = proof.toBytes();
-      proofBytes[7] = Math.floor(Math.random() * 256) % 255;
+      proofBytes[7] = 1;
+      proofBytes[8] = 2;
+      proofBytes[9] = 3;
 
       // verify the proof
       const verifResult = rlnInstance.verifyProof(proofBytes);