@waku/rln 0.1.1 → 0.1.2-3dc5908

package/src/identity.ts

@@ -0,0 +1,27 @@
+import { buildBigIntFromUint8Array } from "./utils/index.js";
+
+export class IdentityCredential {
+  constructor(
+    public readonly IDTrapdoor: Uint8Array,
+    public readonly IDNullifier: Uint8Array,
+    public readonly IDSecretHash: Uint8Array,
+    public readonly IDCommitment: Uint8Array,
+    public readonly IDCommitmentBigInt: bigint
+  ) {}
+
+  static fromBytes(memKeys: Uint8Array): IdentityCredential {
+    const idTrapdoor = memKeys.subarray(0, 32);
+    const idNullifier = memKeys.subarray(32, 64);
+    const idSecretHash = memKeys.subarray(64, 96);
+    const idCommitment = memKeys.subarray(96);
+    const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment);
+
+    return new IdentityCredential(
+      idTrapdoor,
+      idNullifier,
+      idSecretHash,
+      idCommitment,
+      idCommitmentBigInt
+    );
+  }
+}

package/src/index.ts

@@ -1,32 +1,30 @@
 import { RLNDecoder, RLNEncoder } from "./codec.js";
-import { RLN_ABI, SEPOLIA_CONTRACT } from "./constants.js";
 import {
-  IdentityCredential,
-  Proof,
-  ProofMetadata,
-  RLNInstance,
-} from "./rln.js";
-import { RLNContract } from "./rln_contract.js";
+  RLN_REGISTRY_ABI,
+  RLN_STORAGE_ABI,
+  SEPOLIA_CONTRACT
+} from "./contract/index.js";
+import { RLNContract } from "./contract/index.js";
+import { createRLN } from "./create.js";
+import { IdentityCredential } from "./identity.js";
+import { Keystore } from "./keystore/index.js";
+import { Proof } from "./proof.js";
+import { RLNInstance } from "./rln.js";
 import { MerkleRootTracker } from "./root_tracker.js";
-
-// reexport the create function, dynamically imported from rln.ts
-export async function create(): Promise<RLNInstance> {
-  // A dependency graph that contains any wasm must all be imported
-  // asynchronously. This file does the single async import, so
-  // that no one else needs to worry about it again.
-  const rlnModule = await import("./rln.js");
-  return await rlnModule.create();
-}
+import { extractMetaMaskSigner } from "./utils/index.js";
 
 export {
+  createRLN,
+  Keystore,
   RLNInstance,
   IdentityCredential,
   Proof,
-  ProofMetadata,
   RLNEncoder,
   RLNDecoder,
   MerkleRootTracker,
   RLNContract,
-  RLN_ABI,
+  RLN_STORAGE_ABI,
+  RLN_REGISTRY_ABI,
   SEPOLIA_CONTRACT,
+  extractMetaMaskSigner
 };

package/src/message.ts

@@ -1,12 +1,12 @@
 import type {
   IDecodedMessage,
   IMessage,
-  IRateLimitProof,
+  IRateLimitProof
 } from "@waku/interfaces";
 import * as utils from "@waku/utils/bytes";
 
-import { epochBytesToInt } from "./epoch.js";
 import { RLNInstance } from "./rln.js";
+import { epochBytesToInt } from "./utils/index.js";
 
 export function toRLNSignal(contentTopic: string, msg: IMessage): Uint8Array {
   const contentTopicBytes = utils.utf8ToBytes(contentTopic ?? "");
@@ -14,7 +14,7 @@ export function toRLNSignal(contentTopic: string, msg: IMessage): Uint8Array {
 }
 
 export class RlnMessage<T extends IDecodedMessage> implements IDecodedMessage {
-  public pubSubTopic = "";
+  public pubsubTopic = "";
 
   constructor(
     public rlnInstance: RLNInstance,
@@ -24,7 +24,7 @@ export class RlnMessage<T extends IDecodedMessage> implements IDecodedMessage {
 
   public verify(roots: Uint8Array[]): boolean | undefined {
     return this.rateLimitProof
-      ? this.rlnInstance.verifyWithRoots(
+      ? this.rlnInstance.zerokit.verifyWithRoots(
           this.rateLimitProof,
           toRLNSignal(this.msg.contentTopic, this.msg),
           ...roots
@@ -34,7 +34,7 @@ export class RlnMessage<T extends IDecodedMessage> implements IDecodedMessage {
 
   public verifyNoRoot(): boolean | undefined {
     return this.rateLimitProof
-      ? this.rlnInstance.verifyWithNoRoot(
+      ? this.rlnInstance.zerokit.verifyWithNoRoot(
           this.rateLimitProof,
           toRLNSignal(this.msg.contentTopic, this.msg)
         ) // this.rlnInstance.verifyRLNProof once issue status-im/nwaku#1248 is fixed
@@ -57,6 +57,10 @@ export class RlnMessage<T extends IDecodedMessage> implements IDecodedMessage {
     return this.msg.ephemeral;
   }
 
+  get meta(): Uint8Array | undefined {
+    return this.msg.meta;
+  }
+
   get epoch(): number | undefined {
     const bytes = this.msg.rateLimitProof?.epoch;
     if (!bytes) return;

package/src/proof.ts

@@ -0,0 +1,67 @@
+import type { IRateLimitProof } from "@waku/interfaces";
+
+import { concatenate, poseidonHash } from "./utils/index.js";
+
+const proofOffset = 128;
+const rootOffset = proofOffset + 32;
+const epochOffset = rootOffset + 32;
+const shareXOffset = epochOffset + 32;
+const shareYOffset = shareXOffset + 32;
+const nullifierOffset = shareYOffset + 32;
+const rlnIdentifierOffset = nullifierOffset + 32;
+
+class ProofMetadata {
+  constructor(
+    public readonly nullifier: Uint8Array,
+    public readonly shareX: Uint8Array,
+    public readonly shareY: Uint8Array,
+    public readonly externalNullifier: Uint8Array
+  ) {}
+}
+
+export class Proof implements IRateLimitProof {
+  readonly proof: Uint8Array;
+  readonly merkleRoot: Uint8Array;
+  readonly epoch: Uint8Array;
+  readonly shareX: Uint8Array;
+  readonly shareY: Uint8Array;
+  readonly nullifier: Uint8Array;
+  readonly rlnIdentifier: Uint8Array;
+
+  constructor(proofBytes: Uint8Array) {
+    if (proofBytes.length < rlnIdentifierOffset) throw "invalid proof";
+    // parse the proof as proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32>
+    this.proof = proofBytes.subarray(0, proofOffset);
+    this.merkleRoot = proofBytes.subarray(proofOffset, rootOffset);
+    this.epoch = proofBytes.subarray(rootOffset, epochOffset);
+    this.shareX = proofBytes.subarray(epochOffset, shareXOffset);
+    this.shareY = proofBytes.subarray(shareXOffset, shareYOffset);
+    this.nullifier = proofBytes.subarray(shareYOffset, nullifierOffset);
+    this.rlnIdentifier = proofBytes.subarray(
+      nullifierOffset,
+      rlnIdentifierOffset
+    );
+  }
+
+  extractMetadata(): ProofMetadata {
+    const externalNullifier = poseidonHash(this.epoch, this.rlnIdentifier);
+    return new ProofMetadata(
+      this.nullifier,
+      this.shareX,
+      this.shareY,
+      externalNullifier
+    );
+  }
+}
+
+export function proofToBytes(p: IRateLimitProof): Uint8Array {
+  return concatenate(
+    p.proof,
+    p.merkleRoot,
+    p.epoch,
+    p.shareX,
+    p.shareY,
+    p.nullifier,
+    p.rlnIdentifier
+  );
+}