@waku/rln 0.0.1 → 0.0.2-00f2e75.0

package/src/utils/bytes.ts

@@ -0,0 +1,84 @@
+/**
+ * Concatenate Uint8Arrays
+ * @param input
+ * @returns concatenation of all Uint8Array received as input
+ */
+export function concatenate(...input: Uint8Array[]): Uint8Array {
+  let totalLength = 0;
+  for (const arr of input) {
+    totalLength += arr.length;
+  }
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of input) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+
+// Adapted from https://github.com/feross/buffer
+function checkInt(
+  buf: Uint8Array,
+  value: number,
+  offset: number,
+  ext: number,
+  max: number,
+  min: number
+): void {
+  if (value > max || value < min)
+    throw new RangeError('"value" argument is out of bounds');
+  if (offset + ext > buf.length) throw new RangeError("Index out of range");
+}
+
+export function writeUIntLE(
+  buf: Uint8Array,
+  value: number,
+  offset: number,
+  byteLength: number,
+  noAssert?: boolean
+): Uint8Array {
+  value = +value;
+  offset = offset >>> 0;
+  byteLength = byteLength >>> 0;
+  if (!noAssert) {
+    const maxBytes = Math.pow(2, 8 * byteLength) - 1;
+    checkInt(buf, value, offset, byteLength, maxBytes, 0);
+  }
+
+  let mul = 1;
+  let i = 0;
+  buf[offset] = value & 0xff;
+  while (++i < byteLength && (mul *= 0x100)) {
+    buf[offset + i] = (value / mul) & 0xff;
+  }
+
+  return buf;
+}
+
+/**
+ * Transforms Uint8Array into BigInt
+ * @param array: Uint8Array
+ * @returns BigInt
+ */
+export function buildBigIntFromUint8Array(
+  array: Uint8Array,
+  byteOffset: number = 0
+): bigint {
+  const dataView = new DataView(array.buffer);
+  return dataView.getBigUint64(byteOffset, true);
+}
+
+/**
+ * Fills with zeros to set length
+ * @param array little endian Uint8Array
+ * @param length amount to pad
+ * @returns little endian Uint8Array padded with zeros to set length
+ */
+export function zeroPadLE(array: Uint8Array, length: number): Uint8Array {
+  const result = new Uint8Array(length);
+  for (let i = 0; i < length; i++) {
+    result[i] = array[i] || 0;
+  }
+  return result;
+}

package/src/utils/epoch.ts

@@ -0,0 +1,30 @@
+import { Logger } from "@waku/utils";
+
+const DefaultEpochUnitSeconds = 10; // the rln-relay epoch length in seconds
+
+const log = new Logger("waku:rln:epoch");
+
+export function dateToEpoch(
+  timestamp: Date,
+  epochUnitSeconds: number = DefaultEpochUnitSeconds
+): number {
+  const time = timestamp.getTime();
+  const epoch = Math.floor(time / 1000 / epochUnitSeconds);
+  log.info("generated epoch", epoch);
+  return epoch;
+}
+
+export function epochIntToBytes(epoch: number): Uint8Array {
+  const bytes = new Uint8Array(32);
+  const db = new DataView(bytes.buffer);
+  db.setUint32(0, epoch, true);
+  log.info("encoded epoch", epoch, bytes);
+  return bytes;
+}
+
+export function epochBytesToInt(bytes: Uint8Array): number {
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const epoch = dv.getUint32(0, true);
+  log.info("decoded epoch", epoch, bytes);
+  return epoch;
+}

package/src/utils/hash.ts

@@ -0,0 +1,15 @@
+import * as zerokitRLN from "@waku/zerokit-rln-wasm";
+
+import { concatenate, writeUIntLE } from "./bytes.js";
+
+export function poseidonHash(...input: Array<Uint8Array>): Uint8Array {
+  const inputLen = writeUIntLE(new Uint8Array(8), input.length, 0, 8);
+  const lenPrefixedData = concatenate(inputLen, ...input);
+  return zerokitRLN.poseidonHash(lenPrefixedData);
+}
+
+export function sha256(input: Uint8Array): Uint8Array {
+  const inputLen = writeUIntLE(new Uint8Array(8), input.length, 0, 8);
+  const lenPrefixedData = concatenate(inputLen, input);
+  return zerokitRLN.hash(lenPrefixedData);
+}

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+export { extractMetaMaskSigner } from "./metamask.js";
+export {
+  concatenate,
+  writeUIntLE,
+  buildBigIntFromUint8Array,
+  zeroPadLE
+} from "./bytes.js";
+export { sha256, poseidonHash } from "./hash.js";
+export { dateToEpoch, epochIntToBytes, epochBytesToInt } from "./epoch.js";

package/src/utils/metamask.ts

@@ -0,0 +1,17 @@
+import { ethers } from "ethers";
+
+export const extractMetaMaskSigner = async (): Promise<ethers.Signer> => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const ethereum = (window as any).ethereum;
+
+  if (!ethereum) {
+    throw Error(
+      "Missing or invalid Ethereum provider. Please install a Web3 wallet such as MetaMask."
+    );
+  }
+
+  await ethereum.request({ method: "eth_requestAccounts" });
+  const provider = new ethers.providers.Web3Provider(ethereum, "any");
+
+  return provider.getSigner();
+};

package/src/zerokit.ts

@@ -0,0 +1,243 @@
+import type { IRateLimitProof } from "@waku/interfaces";
+import * as zerokitRLN from "@waku/zerokit-rln-wasm";
+
+import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from "./contract/constants.js";
+import { IdentityCredential } from "./identity.js";
+import { Proof, proofToBytes } from "./proof.js";
+import { WitnessCalculator } from "./resources/witness_calculator";
+import {
+  concatenate,
+  dateToEpoch,
+  epochIntToBytes,
+  writeUIntLE
+} from "./utils/index.js";
+
+export class Zerokit {
+  public constructor(
+    private readonly zkRLN: number,
+    private readonly witnessCalculator: WitnessCalculator,
+    private readonly rateLimit: number = DEFAULT_RATE_LIMIT
+  ) {}
+
+  public get getZkRLN(): number {
+    return this.zkRLN;
+  }
+
+  public get getWitnessCalculator(): WitnessCalculator {
+    return this.witnessCalculator;
+  }
+
+  public get getRateLimit(): number {
+    return this.rateLimit;
+  }
+
+  public generateIdentityCredentials(): IdentityCredential {
+    const memKeys = zerokitRLN.generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
+    return IdentityCredential.fromBytes(memKeys);
+  }
+
+  public generateSeededIdentityCredential(seed: string): IdentityCredential {
+    const stringEncoder = new TextEncoder();
+    const seedBytes = stringEncoder.encode(seed);
+    // TODO: rename this function in zerokit rln-wasm
+    const memKeys = zerokitRLN.generateSeededExtendedMembershipKey(
+      this.zkRLN,
+      seedBytes
+    );
+    return IdentityCredential.fromBytes(memKeys);
+  }
+
+  public insertMember(idCommitment: Uint8Array): void {
+    zerokitRLN.insertMember(this.zkRLN, idCommitment);
+  }
+
+  public insertMembers(
+    index: number,
+    ...idCommitments: Array<Uint8Array>
+  ): void {
+    // serializes a seq of IDCommitments to a byte seq
+    // the order of serialization is |id_commitment_len<8>|id_commitment<var>|
+    const idCommitmentLen = writeUIntLE(
+      new Uint8Array(8),
+      idCommitments.length,
+      0,
+      8
+    );
+    const idCommitmentBytes = concatenate(idCommitmentLen, ...idCommitments);
+    zerokitRLN.setLeavesFrom(this.zkRLN, index, idCommitmentBytes);
+  }
+
+  public deleteMember(index: number): void {
+    zerokitRLN.deleteLeaf(this.zkRLN, index);
+  }
+
+  public getMerkleRoot(): Uint8Array {
+    return zerokitRLN.getRoot(this.zkRLN);
+  }
+
+  public serializeMessage(
+    uint8Msg: Uint8Array,
+    memIndex: number,
+    epoch: Uint8Array,
+    idKey: Uint8Array,
+    rateLimit?: number
+  ): Uint8Array {
+    // calculate message length
+    const msgLen = writeUIntLE(new Uint8Array(8), uint8Msg.length, 0, 8);
+    const memIndexBytes = writeUIntLE(new Uint8Array(8), memIndex, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
+
+    // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> | rate_limit<8> ]
+    return concatenate(
+      idKey,
+      memIndexBytes,
+      epoch,
+      msgLen,
+      uint8Msg,
+      rateLimitBytes
+    );
+  }
+
+  public async generateRLNProof(
+    msg: Uint8Array,
+    index: number,
+    epoch: Uint8Array | Date | undefined,
+    idSecretHash: Uint8Array,
+    rateLimit?: number
+  ): Promise<IRateLimitProof> {
+    if (epoch === undefined) {
+      epoch = epochIntToBytes(dateToEpoch(new Date()));
+    } else if (epoch instanceof Date) {
+      epoch = epochIntToBytes(dateToEpoch(epoch));
+    }
+
+    const effectiveRateLimit = rateLimit ?? this.rateLimit;
+
+    if (epoch.length !== 32) throw new Error("invalid epoch");
+    if (idSecretHash.length !== 32) throw new Error("invalid id secret hash");
+    if (index < 0) throw new Error("index must be >= 0");
+    if (
+      effectiveRateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
+      effectiveRateLimit > RATE_LIMIT_PARAMS.MAX_RATE
+    ) {
+      throw new Error(
+        `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`
+      );
+    }
+
+    const serialized_msg = this.serializeMessage(
+      msg,
+      index,
+      epoch,
+      idSecretHash,
+      effectiveRateLimit
+    );
+    const rlnWitness = zerokitRLN.getSerializedRLNWitness(
+      this.zkRLN,
+      serialized_msg
+    );
+    const inputs = zerokitRLN.RLNWitnessToJson(this.zkRLN, rlnWitness);
+    const calculatedWitness = await this.witnessCalculator.calculateWitness(
+      inputs,
+      false
+    );
+
+    const proofBytes = zerokitRLN.generate_rln_proof_with_witness(
+      this.zkRLN,
+      calculatedWitness,
+      rlnWitness
+    );
+
+    return new Proof(proofBytes);
+  }
+
+  public verifyRLNProof(
+    proof: IRateLimitProof | Uint8Array,
+    msg: Uint8Array,
+    rateLimit?: number
+  ): boolean {
+    let pBytes: Uint8Array;
+    if (proof instanceof Uint8Array) {
+      pBytes = proof;
+    } else {
+      pBytes = proofToBytes(proof);
+    }
+
+    // calculate message length
+    const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
+
+    return zerokitRLN.verifyRLNProof(
+      this.zkRLN,
+      concatenate(pBytes, msgLen, msg, rateLimitBytes)
+    );
+  }
+
+  public verifyWithRoots(
+    proof: IRateLimitProof | Uint8Array,
+    msg: Uint8Array,
+    roots: Array<Uint8Array>,
+    rateLimit?: number
+  ): boolean {
+    let pBytes: Uint8Array;
+    if (proof instanceof Uint8Array) {
+      pBytes = proof;
+    } else {
+      pBytes = proofToBytes(proof);
+    }
+    // calculate message length
+    const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
+
+    const rootsBytes = concatenate(...roots);
+
+    return zerokitRLN.verifyWithRoots(
+      this.zkRLN,
+      concatenate(pBytes, msgLen, msg, rateLimitBytes),
+      rootsBytes
+    );
+  }
+
+  public verifyWithNoRoot(
+    proof: IRateLimitProof | Uint8Array,
+    msg: Uint8Array,
+    rateLimit?: number
+  ): boolean {
+    let pBytes: Uint8Array;
+    if (proof instanceof Uint8Array) {
+      pBytes = proof;
+    } else {
+      pBytes = proofToBytes(proof);
+    }
+
+    // calculate message length
+    const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
+
+    return zerokitRLN.verifyWithRoots(
+      this.zkRLN,
+      concatenate(pBytes, msgLen, msg, rateLimitBytes),
+      new Uint8Array()
+    );
+  }
+}