@waku/rln 0.1.5-9901863.0 → 0.1.5-a824fff.0

package/src/keystore/keystore.ts

@@ -14,7 +14,6 @@ import {
 import _ from "lodash";
 import { v4 as uuidV4 } from "uuid";
 
-import { IdentityCredential } from "../identity.js";
 import { buildBigIntFromUint8Array } from "../utils/bytes.js";
 
 import { decryptEipKeystore, keccak256Checksum } from "./cipher.js";
@@ -22,8 +21,8 @@ import { isCredentialValid, isKeystoreValid } from "./schema_validator.js";
 import type {
   Keccak256Hash,
   KeystoreEntity,
+  KeystoreMembershipInfo,
   MembershipHash,
-  MembershipInfo,
   Password,
   Sha256Hash
 } from "./types.js";
@@ -251,27 +250,27 @@ export class Keystore {
       const str = bytesToUtf8(bytes);
       const obj = JSON.parse(str);
 
-      // Get identity fields from named object
-      const { idTrapdoor, idNullifier, idSecretHash, idCommitment } = _.get(
-        obj,
-        "identityCredential",
-        {}
-      );
-
-      const idTrapdoorArray = new Uint8Array(idTrapdoor || []);
-      const idNullifierArray = new Uint8Array(idNullifier || []);
-      const idSecretHashArray = new Uint8Array(idSecretHash || []);
-      const idCommitmentArray = new Uint8Array(idCommitment || []);
-      const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitmentArray);
-
+      // TODO: add runtime validation of nwaku credentials
       return {
-        identity: new IdentityCredential(
-          idTrapdoorArray,
-          idNullifierArray,
-          idSecretHashArray,
-          idCommitmentArray,
-          idCommitmentBigInt
-        ),
+        identity: {
+          IDCommitment: Keystore.fromArraylikeToBytes(
+            _.get(obj, "identityCredential.idCommitment", [])
+          ),
+          IDTrapdoor: Keystore.fromArraylikeToBytes(
+            _.get(obj, "identityCredential.idTrapdoor", [])
+          ),
+          IDNullifier: Keystore.fromArraylikeToBytes(
+            _.get(obj, "identityCredential.idNullifier", [])
+          ),
+          IDCommitmentBigInt: buildBigIntFromUint8Array(
+            Keystore.fromArraylikeToBytes(
+              _.get(obj, "identityCredential.idCommitment", [])
+            )
+          ),
+          IDSecretHash: Keystore.fromArraylikeToBytes(
+            _.get(obj, "identityCredential.idSecretHash", [])
+          )
+        },
         membership: {
           treeIndex: _.get(obj, "treeIndex"),
           chainId: _.get(obj, "membershipContract.chainId"),
@@ -285,9 +284,35 @@ export class Keystore {
     }
   }
 
+  private static fromArraylikeToBytes(
+    obj:
+      | number[]
+      | {
+          [key: number]: number;
+        }
+  ): Uint8Array {
+    if (Array.isArray(obj)) {
+      return new Uint8Array(obj);
+    }
+
+    const bytes = [];
+    let index = 0;
+    let lastElement = obj[index];
+
+    while (lastElement !== undefined) {
+      bytes.push(lastElement);
+      index += 1;
+      lastElement = obj[index];
+    }
+
+    return new Uint8Array(bytes);
+  }
+
   // follows nwaku implementation
   // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L111
-  private static computeMembershipHash(info: MembershipInfo): MembershipHash {
+  private static computeMembershipHash(
+    info: KeystoreMembershipInfo
+  ): MembershipHash {
     return bytesToHex(
       sha256(utf8ToBytes(`${info.chainId}${info.address}${info.treeIndex}`))
     ).toUpperCase();
@@ -298,16 +323,16 @@ export class Keystore {
   private static fromIdentityToBytes(options: KeystoreEntity): Uint8Array {
     return utf8ToBytes(
       JSON.stringify({
-        membershipContract: {
-          chainId: options.membership.chainId,
-          address: options.membership.address
-        },
         treeIndex: options.membership.treeIndex,
         identityCredential: {
-          idTrapdoor: Array.from(options.identity.IDTrapdoor),
+          idCommitment: Array.from(options.identity.IDCommitment),
           idNullifier: Array.from(options.identity.IDNullifier),
           idSecretHash: Array.from(options.identity.IDSecretHash),
-          idCommitment: Array.from(options.identity.IDCommitment)
+          idTrapdoor: Array.from(options.identity.IDTrapdoor)
+        },
+        membershipContract: {
+          chainId: options.membership.chainId,
+          address: options.membership.address
         },
         userMessageLimit: options.membership.rateLimit
       })

package/src/keystore/types.ts

@@ -7,7 +7,7 @@ export type Password = string | Uint8Array;
 
 // see reference
 // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L111
-export type MembershipInfo = {
+export type KeystoreMembershipInfo = {
   chainId: string;
   address: string;
   treeIndex: number;
@@ -16,7 +16,7 @@ export type MembershipInfo = {
 
 export type KeystoreEntity = {
   identity: IdentityCredential;
-  membership: MembershipInfo;
+  membership: KeystoreMembershipInfo;
 };
 
 export type DecryptedCredentials = KeystoreEntity;

package/src/rln.ts

@@ -58,6 +58,7 @@ export class RLNInstance extends RLNCredentialsManager {
       throw error;
     }
   }
+
   private constructor(public zerokit: Zerokit) {
     super(zerokit);
   }

package/src/zerokit.ts

@@ -16,7 +16,7 @@ export class Zerokit {
   public constructor(
     private readonly zkRLN: number,
     private readonly witnessCalculator: WitnessCalculator,
-    private readonly rateLimit: number = DEFAULT_RATE_LIMIT
+    private readonly _rateLimit: number = DEFAULT_RATE_LIMIT
   ) {}
 
   public get getZkRLN(): number {
@@ -27,8 +27,8 @@ export class Zerokit {
     return this.witnessCalculator;
   }
 
-  public get getRateLimit(): number {
-    return this.rateLimit;
+  public get rateLimit(): number {
+    return this._rateLimit;
   }
 
   public generateIdentityCredentials(): IdentityCredential {

package/bundle/_virtual/__node-resolve_empty.js

@@ -1,6 +0,0 @@
-import * as _nodeResolve_empty from './_node-resolve_empty.js';
-import { getAugmentedNamespace } from './_commonjsHelpers.js';
-
-var require$$0 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty);
-
-export { require$$0 as default };

package/bundle/_virtual/_node-resolve_empty.js

@@ -1,3 +0,0 @@
-var _nodeResolve_empty = {};
-
-export { _nodeResolve_empty as default };

package/bundle/_virtual/bn.js

@@ -1,3 +0,0 @@
-var bn = {exports: {}};
-
-export { bn as __module };

package/bundle/_virtual/common.js

@@ -1,3 +0,0 @@
-var common = {};
-
-export { common as __exports };

package/bundle/_virtual/common2.js

@@ -1,3 +0,0 @@
-var common = {};
-
-export { common as __exports };

package/bundle/_virtual/hash.js

@@ -1,3 +0,0 @@
-var hash = {};
-
-export { hash as __exports };

package/bundle/_virtual/inherits_browser.js

@@ -1,3 +0,0 @@
-var inherits_browser = {exports: {}};
-
-export { inherits_browser as __module };

package/bundle/_virtual/ripemd.js

@@ -1,3 +0,0 @@
-var ripemd = {};
-
-export { ripemd as __exports };

package/bundle/_virtual/sha.js

@@ -1,3 +0,0 @@
-var sha = {};
-
-export { sha as __exports };

package/bundle/_virtual/sha3.js

@@ -1,3 +0,0 @@
-var sha3 = {exports: {}};
-
-export { sha3 as __module };

package/bundle/_virtual/utils3.js

@@ -1,3 +0,0 @@
-var utils = {};
-
-export { utils as __exports };

package/bundle/node_modules/@ethersproject/abi/lib.esm/_version.js

@@ -1,3 +0,0 @@
-const version = "abi/5.7.0";
-
-export { version };

package/bundle/node_modules/@ethersproject/abi/lib.esm/abi-coder.js

@@ -1,96 +0,0 @@
-import { arrayify } from '../../bytes/lib.esm/index.js';
-import { defineReadOnly } from '../../properties/lib.esm/index.js';
-import { Logger } from '../../logger/lib.esm/index.js';
-import { version } from './_version.js';
-import { Reader, Writer } from './coders/abstract-coder.js';
-import { AddressCoder } from './coders/address.js';
-import { ArrayCoder } from './coders/array.js';
-import { BooleanCoder } from './coders/boolean.js';
-import { BytesCoder } from './coders/bytes.js';
-import { FixedBytesCoder } from './coders/fixed-bytes.js';
-import { NullCoder } from './coders/null.js';
-import { NumberCoder } from './coders/number.js';
-import { StringCoder } from './coders/string.js';
-import { TupleCoder } from './coders/tuple.js';
-import { ParamType } from './fragments.js';
-
-const logger = new Logger(version);
-const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
-const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
-class AbiCoder {
-    constructor(coerceFunc) {
-        defineReadOnly(this, "coerceFunc", coerceFunc || null);
-    }
-    _getCoder(param) {
-        switch (param.baseType) {
-            case "address":
-                return new AddressCoder(param.name);
-            case "bool":
-                return new BooleanCoder(param.name);
-            case "string":
-                return new StringCoder(param.name);
-            case "bytes":
-                return new BytesCoder(param.name);
-            case "array":
-                return new ArrayCoder(this._getCoder(param.arrayChildren), param.arrayLength, param.name);
-            case "tuple":
-                return new TupleCoder((param.components || []).map((component) => {
-                    return this._getCoder(component);
-                }), param.name);
-            case "":
-                return new NullCoder(param.name);
-        }
-        // u?int[0-9]*
-        let match = param.type.match(paramTypeNumber);
-        if (match) {
-            let size = parseInt(match[2] || "256");
-            if (size === 0 || size > 256 || (size % 8) !== 0) {
-                logger.throwArgumentError("invalid " + match[1] + " bit length", "param", param);
-            }
-            return new NumberCoder(size / 8, (match[1] === "int"), param.name);
-        }
-        // bytes[0-9]+
-        match = param.type.match(paramTypeBytes);
-        if (match) {
-            let size = parseInt(match[1]);
-            if (size === 0 || size > 32) {
-                logger.throwArgumentError("invalid bytes length", "param", param);
-            }
-            return new FixedBytesCoder(size, param.name);
-        }
-        return logger.throwArgumentError("invalid type", "type", param.type);
-    }
-    _getWordSize() { return 32; }
-    _getReader(data, allowLoose) {
-        return new Reader(data, this._getWordSize(), this.coerceFunc, allowLoose);
-    }
-    _getWriter() {
-        return new Writer(this._getWordSize());
-    }
-    getDefaultValue(types) {
-        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
-        const coder = new TupleCoder(coders, "_");
-        return coder.defaultValue();
-    }
-    encode(types, values) {
-        if (types.length !== values.length) {
-            logger.throwError("types/values length mismatch", Logger.errors.INVALID_ARGUMENT, {
-                count: { types: types.length, values: values.length },
-                value: { types: types, values: values }
-            });
-        }
-        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
-        const coder = (new TupleCoder(coders, "_"));
-        const writer = this._getWriter();
-        coder.encode(writer, values);
-        return writer.data;
-    }
-    decode(types, data, loose) {
-        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
-        const coder = new TupleCoder(coders, "_");
-        return coder.decode(this._getReader(arrayify(data), loose));
-    }
-}
-const defaultAbiCoder = new AbiCoder();
-
-export { AbiCoder, defaultAbiCoder };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/abstract-coder.js

@@ -1,148 +0,0 @@
-import { arrayify, hexlify, hexConcat, concat } from '../../../bytes/lib.esm/index.js';
-import { defineReadOnly } from '../../../properties/lib.esm/index.js';
-import { Logger } from '../../../logger/lib.esm/index.js';
-import { version } from '../_version.js';
-import { BigNumber } from '../../../bignumber/lib.esm/bignumber.js';
-
-const logger = new Logger(version);
-function checkResultErrors(result) {
-    // Find the first error (if any)
-    const errors = [];
-    const checkErrors = function (path, object) {
-        if (!Array.isArray(object)) {
-            return;
-        }
-        for (let key in object) {
-            const childPath = path.slice();
-            childPath.push(key);
-            try {
-                checkErrors(childPath, object[key]);
-            }
-            catch (error) {
-                errors.push({ path: childPath, error: error });
-            }
-        }
-    };
-    checkErrors([], result);
-    return errors;
-}
-class Coder {
-    constructor(name, type, localName, dynamic) {
-        // @TODO: defineReadOnly these
-        this.name = name;
-        this.type = type;
-        this.localName = localName;
-        this.dynamic = dynamic;
-    }
-    _throwError(message, value) {
-        logger.throwArgumentError(message, this.localName, value);
-    }
-}
-class Writer {
-    constructor(wordSize) {
-        defineReadOnly(this, "wordSize", wordSize || 32);
-        this._data = [];
-        this._dataLength = 0;
-        this._padding = new Uint8Array(wordSize);
-    }
-    get data() {
-        return hexConcat(this._data);
-    }
-    get length() { return this._dataLength; }
-    _writeData(data) {
-        this._data.push(data);
-        this._dataLength += data.length;
-        return data.length;
-    }
-    appendWriter(writer) {
-        return this._writeData(concat(writer._data));
-    }
-    // Arrayish items; padded on the right to wordSize
-    writeBytes(value) {
-        let bytes = arrayify(value);
-        const paddingOffset = bytes.length % this.wordSize;
-        if (paddingOffset) {
-            bytes = concat([bytes, this._padding.slice(paddingOffset)]);
-        }
-        return this._writeData(bytes);
-    }
-    _getValue(value) {
-        let bytes = arrayify(BigNumber.from(value));
-        if (bytes.length > this.wordSize) {
-            logger.throwError("value out-of-bounds", Logger.errors.BUFFER_OVERRUN, {
-                length: this.wordSize,
-                offset: bytes.length
-            });
-        }
-        if (bytes.length % this.wordSize) {
-            bytes = concat([this._padding.slice(bytes.length % this.wordSize), bytes]);
-        }
-        return bytes;
-    }
-    // BigNumberish items; padded on the left to wordSize
-    writeValue(value) {
-        return this._writeData(this._getValue(value));
-    }
-    writeUpdatableValue() {
-        const offset = this._data.length;
-        this._data.push(this._padding);
-        this._dataLength += this.wordSize;
-        return (value) => {
-            this._data[offset] = this._getValue(value);
-        };
-    }
-}
-class Reader {
-    constructor(data, wordSize, coerceFunc, allowLoose) {
-        defineReadOnly(this, "_data", arrayify(data));
-        defineReadOnly(this, "wordSize", wordSize || 32);
-        defineReadOnly(this, "_coerceFunc", coerceFunc);
-        defineReadOnly(this, "allowLoose", allowLoose);
-        this._offset = 0;
-    }
-    get data() { return hexlify(this._data); }
-    get consumed() { return this._offset; }
-    // The default Coerce function
-    static coerce(name, value) {
-        let match = name.match("^u?int([0-9]+)$");
-        if (match && parseInt(match[1]) <= 48) {
-            value = value.toNumber();
-        }
-        return value;
-    }
-    coerce(name, value) {
-        if (this._coerceFunc) {
-            return this._coerceFunc(name, value);
-        }
-        return Reader.coerce(name, value);
-    }
-    _peekBytes(offset, length, loose) {
-        let alignedLength = Math.ceil(length / this.wordSize) * this.wordSize;
-        if (this._offset + alignedLength > this._data.length) {
-            if (this.allowLoose && loose && this._offset + length <= this._data.length) {
-                alignedLength = length;
-            }
-            else {
-                logger.throwError("data out-of-bounds", Logger.errors.BUFFER_OVERRUN, {
-                    length: this._data.length,
-                    offset: this._offset + alignedLength
-                });
-            }
-        }
-        return this._data.slice(this._offset, this._offset + alignedLength);
-    }
-    subReader(offset) {
-        return new Reader(this._data.slice(this._offset + offset), this.wordSize, this._coerceFunc, this.allowLoose);
-    }
-    readBytes(length, loose) {
-        let bytes = this._peekBytes(0, length, !!loose);
-        this._offset += bytes.length;
-        // @TODO: Make sure the length..end bytes are all 0?
-        return bytes.slice(0, length);
-    }
-    readValue() {
-        return BigNumber.from(this.readBytes(this.wordSize));
-    }
-}
-
-export { Coder, Reader, Writer, checkResultErrors };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/address.js

@@ -1,26 +0,0 @@
-import { getAddress } from '../../../address/lib.esm/index.js';
-import { hexZeroPad } from '../../../bytes/lib.esm/index.js';
-import { Coder } from './abstract-coder.js';
-
-class AddressCoder extends Coder {
-    constructor(localName) {
-        super("address", "address", localName, false);
-    }
-    defaultValue() {
-        return "0x0000000000000000000000000000000000000000";
-    }
-    encode(writer, value) {
-        try {
-            value = getAddress(value);
-        }
-        catch (error) {
-            this._throwError(error.message, value);
-        }
-        return writer.writeValue(value);
-    }
-    decode(reader) {
-        return getAddress(hexZeroPad(reader.readValue().toHexString(), 20));
-    }
-}
-
-export { AddressCoder };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/anonymous.js

@@ -1,20 +0,0 @@
-import { Coder } from './abstract-coder.js';
-
-// Clones the functionality of an existing Coder, but without a localName
-class AnonymousCoder extends Coder {
-    constructor(coder) {
-        super(coder.name, coder.type, undefined, coder.dynamic);
-        this.coder = coder;
-    }
-    defaultValue() {
-        return this.coder.defaultValue();
-    }
-    encode(writer, value) {
-        return this.coder.encode(writer, value);
-    }
-    decode(reader) {
-        return this.coder.decode(reader);
-    }
-}
-
-export { AnonymousCoder };