@waku/rln 0.0.8-b5f0cbb → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waku/rln",
-  "version": "0.0.8-b5f0cbb",
+  "version": "0.0.9",
   "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": "^0.29.0-7714812",
+    "js-waku": "^0.29.0-29436ea",
     "jsdom": "^19.0.0",
     "jsdom-global": "^3.0.2",
     "karma": "^6.3.12",
@@ -125,6 +125,6 @@
     ]
   },
   "dependencies": {
-    "@waku/zerokit-rln-wasm": "^0.0.2"
+    "@waku/zerokit-rln-wasm": "^0.0.3"
   }
 }

package/src/codec.ts

@@ -1,13 +1,13 @@
 import debug from "debug";
-import { proto_message, utils } from "js-waku";
 import {
   Decoder,
   Encoder,
   Message,
   ProtoMessage,
+  RateLimitProof,
 } from "js-waku/lib/interfaces";
 
-import { RlnMessage } from "./message.js";
+import { RlnMessage, toRLNSignal } from "./message.js";
 import { MembershipKey, RLNInstance } from "./rln.js";
 
 const log = debug("waku:message:rln-encoder");
@@ -27,30 +27,39 @@ export class RLNEncoder implements Encoder {
     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);
+  async toWire(message: Partial<Message>): Promise<Uint8Array | undefined> {
+    message.contentTopic = this.contentTopic;
+    message.rateLimitProof = await this.generateProof(message);
+
+    return this.encoder.toWire(message);
   }
 
-  async encodeProto(message: Message): Promise<ProtoMessage | undefined> {
-    const protoMessage = await this.encoder.encodeProto(message);
+  async toProtoObj(
+    message: Partial<Message>
+  ): Promise<ProtoMessage | undefined> {
+    message.contentTopic = this.contentTopic;
+    const protoMessage = await this.encoder.toProtoObj(message);
     if (!protoMessage) return;
 
+    protoMessage.rateLimitProof = await this.generateProof(message);
+
+    return protoMessage;
+  }
+
+  private async generateProof(
+    message: Partial<Message>
+  ): Promise<RateLimitProof> {
     const signal = toRLNSignal(message);
 
     console.time("proof_gen_timer");
-    const proof = await this.rlnInstance.generateProof(
+    const proof = await this.rlnInstance.generateRLNProof(
       signal,
       this.index,
       message.timestamp,
       this.idKey
     );
     console.timeEnd("proof_gen_timer");
-
-    protoMessage.rateLimitProof = proof;
-
-    return protoMessage;
+    return proof;
   }
 }
 
@@ -61,20 +70,15 @@ export class RLNDecoder<T extends Message> implements Decoder<RlnMessage<T>> {
     return this.decoder.contentTopic;
   }
 
-  decodeProto(bytes: Uint8Array): Promise<ProtoMessage | undefined> {
-    const protoMessage = proto_message.WakuMessage.decode(bytes);
+  fromWireToProtoObj(bytes: Uint8Array): Promise<ProtoMessage | undefined> {
+    const protoMessage = this.decoder.fromWireToProtoObj(bytes);
     log("Message decoded", protoMessage);
     return Promise.resolve(protoMessage);
   }
 
-  async decode(proto: ProtoMessage): Promise<RlnMessage<T> | undefined> {
-    const msg: T | undefined = await this.decoder.decode(proto);
+  async fromProtoObj(proto: ProtoMessage): Promise<RlnMessage<T> | undefined> {
+    const msg: T | undefined = await this.decoder.fromProtoObj(proto);
     if (!msg) return;
     return new RlnMessage(this.rlnInstance, msg, proto.rateLimitProof);
   }
 }
-
-function toRLNSignal(msg: Message): Uint8Array {
-  const contentTopicBytes = utils.utf8ToBytes(msg.contentTopic ?? "");
-  return new Uint8Array([...(msg.payload ?? []), ...contentTopicBytes]);
-}

package/src/message.ts

@@ -1,18 +1,24 @@
+import { utils } from "js-waku";
 import { Message, RateLimitProof } from "js-waku/lib/interfaces";
 
 import { epochBytesToInt } from "./epoch.js";
 import { RLNInstance } from "./rln.js";
 
+export function toRLNSignal(msg: Partial<Message>): Uint8Array {
+  const contentTopicBytes = utils.utf8ToBytes(msg.contentTopic ?? "");
+  return new Uint8Array([...(msg.payload ?? []), ...contentTopicBytes]);
+}
+
 export class RlnMessage<T extends Message> implements Message {
   constructor(
     public rlnInstance: RLNInstance,
     public msg: T,
-    public rateLimitProof?: RateLimitProof
+    public rateLimitProof: RateLimitProof | undefined
   ) {}
 
   public verify(): boolean | undefined {
     return this.rateLimitProof
-      ? this.rlnInstance.verifyProof(this.rateLimitProof)
+      ? this.rlnInstance.verifyRLNProof(this.rateLimitProof, toRLNSignal(this))
       : undefined;
   }
 

package/src/rln.ts

@@ -102,7 +102,7 @@ export class Proof implements RateLimitProof {
   }
 }
 
-function proofToBytes(p: RateLimitProof): Uint8Array {
+export function proofToBytes(p: RateLimitProof): Uint8Array {
   return concatenate(
     p.proof,
     p.merkleRoot,
@@ -145,7 +145,7 @@ export class RLNInstance {
     return concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg);
   }
 
-  async generateProof(
+  async generateRLNProof(
     msg: Uint8Array,
     index: number,
     epoch: Uint8Array | Date | undefined,
@@ -181,13 +181,20 @@ export class RLNInstance {
     return new Proof(proofBytes);
   }
 
-  verifyProof(proof: RateLimitProof | Uint8Array): boolean {
+  verifyRLNProof(proof: RateLimitProof | Uint8Array, msg: Uint8Array): boolean {
     let pBytes: Uint8Array;
     if (proof instanceof Uint8Array) {
       pBytes = proof;
     } else {
       pBytes = proofToBytes(proof);
     }
-    return zerokitRLN.verifyProof(this.zkRLN, pBytes);
+
+    // calculate message length
+    const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+
+    return zerokitRLN.verifyRLNProof(
+      this.zkRLN,
+      concatenate(pBytes, msgLen, msg)
+    );
   }
 }