@waku/rln 0.1.6-b133417.0 → 0.1.6-b4748fd.0

package/src/keystore/keystore.ts

@@ -14,8 +14,6 @@ import {
 import _ from "lodash";
 import { v4 as uuidV4 } from "uuid";
 
-import { BytesUtils } from "../utils/bytes.js";
-
 import { decryptEipKeystore, keccak256Checksum } from "./cipher.js";
 import { isCredentialValid, isKeystoreValid } from "./schema_validator.js";
 import type {
@@ -250,7 +248,6 @@ export class Keystore {
       const str = bytesToUtf8(bytes);
       const obj = JSON.parse(str);
 
-      // Little Endian
       const idCommitmentLE = Keystore.fromArraylikeToBytes(
         _.get(obj, "identityCredential.idCommitment", [])
       );
@@ -264,21 +261,12 @@ export class Keystore {
         _.get(obj, "identityCredential.idSecretHash", [])
       );
 
-      // Big Endian
-      const idCommitmentBE = BytesUtils.switchEndianness(idCommitmentLE);
-      const idTrapdoorBE = BytesUtils.switchEndianness(idTrapdoorLE);
-      const idNullifierBE = BytesUtils.switchEndianness(idNullifierLE);
-      const idSecretHashBE = BytesUtils.switchEndianness(idSecretHashLE);
-      const idCommitmentBigInt =
-        BytesUtils.buildBigIntFromUint8ArrayBE(idCommitmentBE);
-
       return {
         identity: {
-          IDCommitment: idCommitmentBE,
-          IDTrapdoor: idTrapdoorBE,
-          IDNullifier: idNullifierBE,
-          IDSecretHash: idSecretHashBE,
-          IDCommitmentBigInt: idCommitmentBigInt
+          IDCommitment: idCommitmentLE,
+          IDTrapdoor: idTrapdoorLE,
+          IDNullifier: idNullifierLE,
+          IDSecretHash: idSecretHashLE
         },
         membership: {
           treeIndex: _.get(obj, "treeIndex"),
@@ -329,24 +317,22 @@ export class Keystore {
 
   // follows nwaku implementation
   // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L98
-  // IdentityCredential is stored in Big Endian format => switch to Little Endian
   private static fromIdentityToBytes(options: KeystoreEntity): Uint8Array {
+    function toLittleEndian(bytes: Uint8Array): Uint8Array {
+      return new Uint8Array(bytes).reverse();
+    }
     return utf8ToBytes(
       JSON.stringify({
         treeIndex: options.membership.treeIndex,
         identityCredential: {
           idCommitment: Array.from(
-            BytesUtils.switchEndianness(options.identity.IDCommitment)
-          ),
-          idNullifier: Array.from(
-            BytesUtils.switchEndianness(options.identity.IDNullifier)
+            toLittleEndian(options.identity.IDCommitment)
           ),
+          idNullifier: Array.from(toLittleEndian(options.identity.IDNullifier)),
           idSecretHash: Array.from(
-            BytesUtils.switchEndianness(options.identity.IDSecretHash)
+            toLittleEndian(options.identity.IDSecretHash)
           ),
-          idTrapdoor: Array.from(
-            BytesUtils.switchEndianness(options.identity.IDTrapdoor)
-          )
+          idTrapdoor: Array.from(toLittleEndian(options.identity.IDTrapdoor))
         },
         membershipContract: {
           chainId: options.membership.chainId,

package/src/proof.ts

@@ -1,6 +1,6 @@
 import type { IRateLimitProof } from "@waku/interfaces";
 
-import { BytesUtils, poseidonHash } from "./utils/index.js";
+import { concatenate, poseidonHash } from "./utils/index.js";
 
 const proofOffset = 128;
 const rootOffset = proofOffset + 32;
@@ -57,7 +57,7 @@ export class Proof implements IRateLimitProof {
 }
 
 export function proofToBytes(p: IRateLimitProof): Uint8Array {
-  return BytesUtils.concatenate(
+  return concatenate(
     p.proof,
     p.merkleRoot,
     p.epoch,

package/src/utils/bytes.ts

@@ -1,130 +1,80 @@
-export class BytesUtils {
-  /**
-   * Switches endianness of a byte array
-   */
-  public static switchEndianness(bytes: Uint8Array): Uint8Array {
-    return new Uint8Array(bytes.reverse());
+/**
+ * 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;
   }
-
-  /**
-   * Builds a BigInt from a big-endian Uint8Array
-   * @param bytes The big-endian bytes to convert
-   * @returns The resulting BigInt in big-endian format
-   */
-  public static buildBigIntFromUint8ArrayBE(bytes: Uint8Array): bigint {
-    let result = 0n;
-    for (let i = 0; i < bytes.length; i++) {
-      result = (result << 8n) + BigInt(bytes[i]);
-    }
-    return result;
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of input) {
+    result.set(arr, offset);
+    offset += arr.length;
   }
+  return result;
+}
 
-  /**
-   * Switches endianness of a bigint value
-   * @param value The bigint value to switch endianness for
-   * @returns The bigint value with reversed endianness
-   */
-  public static switchEndiannessBigInt(value: bigint): bigint {
-    // Convert bigint to byte array
-    const bytes = [];
-    let tempValue = value;
-    while (tempValue > 0n) {
-      bytes.push(Number(tempValue & 0xffn));
-      tempValue >>= 8n;
-    }
+export function switchEndianness(bytes: Uint8Array): Uint8Array {
+  return new Uint8Array(bytes.reverse());
+}
 
-    // Reverse bytes and convert back to bigint
-    return bytes
-      .reverse()
-      .reduce((acc, byte) => (acc << 8n) + BigInt(byte), 0n);
-  }
+export function buildBigIntFromUint8ArrayBE(bytes: Uint8Array): bigint {
+  // Interpret bytes as big-endian
+  return bytes.reduce((acc, byte) => (acc << 8n) + BigInt(byte), 0n);
+}
 
-  /**
-   * Converts a big-endian bigint to a 32-byte big-endian Uint8Array
-   * @param value The big-endian bigint to convert
-   * @returns A 32-byte big-endian Uint8Array
-   */
-  public static bigIntToUint8Array32BE(value: bigint): Uint8Array {
-    const bytes = new Uint8Array(32);
-    for (let i = 31; i >= 0; i--) {
-      bytes[i] = Number(value & 0xffn);
-      value >>= 8n;
-    }
-    return bytes;
+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);
   }
 
-  /**
-   * Writes an unsigned integer to a buffer in little-endian format
-   */
-  public static 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;
-      BytesUtils.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;
+  let mul = 1;
+  let i = 0;
+  buf[offset] = value & 0xff;
+  while (++i < byteLength && (mul *= 0x100)) {
+    buf[offset + i] = (value / mul) & 0xff;
   }
 
-  /**
-   * 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
-   */
-  public static 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;
-  }
+  return buf;
+}
 
-  // Adapted from https://github.com/feross/buffer
-  public static 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");
+/**
+ * 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;
+}
 
-  /**
-   * Concatenate Uint8Arrays
-   * @param input
-   * @returns concatenation of all Uint8Array received as input
-   */
-  public static 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");
 }

package/src/utils/hash.ts

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

package/src/utils/index.ts

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

package/src/zerokit.ts

@@ -5,7 +5,12 @@ 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 { BytesUtils, dateToEpoch, epochIntToBytes } from "./utils/index.js";
+import {
+  concatenate,
+  dateToEpoch,
+  epochIntToBytes,
+  writeUIntLE
+} from "./utils/index.js";
 
 export class Zerokit {
   public constructor(
@@ -52,16 +57,13 @@ export class Zerokit {
   ): void {
     // serializes a seq of IDCommitments to a byte seq
     // the order of serialization is |id_commitment_len<8>|id_commitment<var>|
-    const idCommitmentLen = BytesUtils.writeUIntLE(
+    const idCommitmentLen = writeUIntLE(
       new Uint8Array(8),
       idCommitments.length,
       0,
       8
     );
-    const idCommitmentBytes = BytesUtils.concatenate(
-      idCommitmentLen,
-      ...idCommitments
-    );
+    const idCommitmentBytes = concatenate(idCommitmentLen, ...idCommitments);
     zerokitRLN.setLeavesFrom(this.zkRLN, index, idCommitmentBytes);
   }
 
@@ -81,19 +83,9 @@ export class Zerokit {
     rateLimit?: number
   ): Uint8Array {
     // calculate message length
-    const msgLen = BytesUtils.writeUIntLE(
-      new Uint8Array(8),
-      uint8Msg.length,
-      0,
-      8
-    );
-    const memIndexBytes = BytesUtils.writeUIntLE(
-      new Uint8Array(8),
-      memIndex,
-      0,
-      8
-    );
-    const rateLimitBytes = BytesUtils.writeUIntLE(
+    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,
@@ -101,7 +93,7 @@ export class Zerokit {
     );
 
     // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> | rate_limit<8> ]
-    return BytesUtils.concatenate(
+    return concatenate(
       idKey,
       memIndexBytes,
       epoch,
@@ -177,8 +169,8 @@ export class Zerokit {
     }
 
     // calculate message length
-    const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-    const rateLimitBytes = BytesUtils.writeUIntLE(
+    const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
       new Uint8Array(8),
       rateLimit ?? this.rateLimit,
       0,
@@ -187,7 +179,7 @@ export class Zerokit {
 
     return zerokitRLN.verifyRLNProof(
       this.zkRLN,
-      BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes)
+      concatenate(pBytes, msgLen, msg, rateLimitBytes)
     );
   }
 
@@ -204,19 +196,19 @@ export class Zerokit {
       pBytes = proofToBytes(proof);
     }
     // calculate message length
-    const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-    const rateLimitBytes = BytesUtils.writeUIntLE(
+    const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
       new Uint8Array(8),
       rateLimit ?? this.rateLimit,
       0,
       8
     );
 
-    const rootsBytes = BytesUtils.concatenate(...roots);
+    const rootsBytes = concatenate(...roots);
 
     return zerokitRLN.verifyWithRoots(
       this.zkRLN,
-      BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes),
+      concatenate(pBytes, msgLen, msg, rateLimitBytes),
       rootsBytes
     );
   }
@@ -234,8 +226,8 @@ export class Zerokit {
     }
 
     // calculate message length
-    const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-    const rateLimitBytes = BytesUtils.writeUIntLE(
+    const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
       new Uint8Array(8),
       rateLimit ?? this.rateLimit,
       0,
@@ -244,7 +236,7 @@ export class Zerokit {
 
     return zerokitRLN.verifyWithRoots(
       this.zkRLN,
-      BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes),
+      concatenate(pBytes, msgLen, msg, rateLimitBytes),
       new Uint8Array()
     );
   }