@waku/rln 0.0.1 → 0.0.2-c41b319.0

package/README.md

@@ -1,121 +1,25 @@
-# js-rln
+# @waku/rln
 
-Browser library providing the cryptographic functions for Waku RLN Relay
-https://rfc.vac.dev/spec/17/
-
-### Install
-```
-npm install @waku/rln
-
-# or with yarn
-
-yarn add @waku/rln
-```
-
-### Running example app
-```
-git clone https://github.com/waku-org/js-rln
-
-cd js-rln/example
-
-npm install  # or yarn
-
-npm start
-
-```
-
-Browse http://localhost:8080 and open the dev tools console to see the proof being generated and its verification
-
-
-### Usage
-
-#### Initializing the library
-```js
-import * as rln from "@waku/rln";
-
-const rlnInstance = wait rln.create();
-```
-
-#### Generating RLN membership keypair
-```js
-let memKeys = rlnInstance.generateMembershipKey();
-```
+Rate Limiting Nullifier (RLN) implementation for Waku.
 
+## Description
 
-#### Adding membership keys into merkle tree
-```js
-rlnInstance.inserMember(memKeys.IDCommitment);
-```
-
-#### Generating a proof
-```js
-// prepare the message
-const uint8Msg = Uint8Array.from("Hello World".split("").map(x => x.charCodeAt()));
-
-// setting up the epoch (With 0s for the test)
-const epoch = new Uint8Array(32);
+This package provides RLN functionality for the Waku protocol, enabling rate-limiting capabilities while preserving privacy.
 
-// generating a proof
-const proof = await rlnInstance.generateProof(uint8Msg, index, epoch, memKeys.IDKey)
-```
+## Installation
 
-#### Verifying a proof
-```js
-try {
-    // verify the proof
-    const verifResult = rlnInstance.verifyProof(proof);
-    console.log("Is proof verified?", verifResult ? "yes" : "no");
-} catch (err) {
-    console.log("Invalid proof")
-}
+```bash
+npm install @waku/rln
 ```
 
+## Usage
 
+```typescript
+import { RLN } from '@waku/rln';
 
-### Updating circuit, verification key and zkey
-The RLN specs defines the defaults. These values are fixed and should not
-change. Currently, these [resources](https://github.com/vacp2p/zerokit/tree/master/rln/resources/tree_height_20) are being used.
-If they change, this file needs to be updated in `resources.ts` which 
-contains these values encoded in base64 in this format:
-
+// Usage examples coming soon
 ```
-const verification_key = "...";
-const circuit = "..."; // wasm file generated by circom
-const zkey = "...";
-export {verification_key, circuit, zkey};
-```
-
-A tool like GNU's `base64` could be used to encode this data. 
-
-### Updating zerokit
-1. Make sure you have nodejs installed and a C compiler
-2. Install wasm-pack
-```
-curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-```
-3. Compile RLN for wasm
-```
-git clone https://github.com/vacp2p/zerokit
-cd zerokit/rln-wasm
-wasm-pack build --release
-```
-4. Copy `pkg/rln*` into `src/zerokit`
-
-
-## Bugs, Questions & Features
-
-If you encounter any bug or would like to propose new features, feel free to [open an issue](https://github.com/waku-org/js-rln/issues/new/).
-
-For more general discussion, help and latest news,  join [Vac Discord](https://discord.gg/PQFdubGt6d) or [Telegram](https://t.me/vacp2p).
-
 
 ## License
-Licensed and distributed under either of
-
-* MIT license: [LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT
-
-or
-
-* Apache License, Version 2.0, ([LICENSE-APACHEv2](LICENSE-APACHEv2) or http://www.apache.org/licenses/LICENSE-2.0)
 
-at your option. These files may not be copied, modified, or distributed except according to those terms.
+MIT OR Apache-2.0 

package/bundle/_virtual/__node-resolve_empty.js

@@ -0,0 +1,6 @@
+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/_assert.js

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

package/bundle/_virtual/_commonjs-dynamic-modules.js

@@ -0,0 +1,5 @@
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+export { commonjsRequire };

package/bundle/_virtual/_commonjsHelpers.js

@@ -0,0 +1,32 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+export { commonjsGlobal, getAugmentedNamespace, getDefaultExportFromCjs };

package/bundle/_virtual/_node-resolve_empty.js

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

package/bundle/_virtual/_sha2.js

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

package/bundle/_virtual/_u64.js

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

package/bundle/_virtual/aes.js

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

package/bundle/_virtual/bn.js

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

package/bundle/_virtual/browser.js

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

package/bundle/_virtual/checksum.js

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

package/bundle/_virtual/cipher.js

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

package/bundle/_virtual/class.js

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

package/bundle/_virtual/common.js

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

package/bundle/_virtual/common2.js

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

package/bundle/_virtual/cryptoBrowser.js

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

package/bundle/_virtual/functional.js

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

package/bundle/_virtual/hash.js

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

package/bundle/_virtual/hmac.js

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

package/bundle/_virtual/index.js

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

package/bundle/_virtual/index2.js

@@ -0,0 +1,6 @@
+import { getAugmentedNamespace } from './_commonjsHelpers.js';
+import * as index from '../packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/uuid/dist/esm-browser/index.js';
+
+var require$$0 = /*@__PURE__*/getAugmentedNamespace(index);
+
+export { require$$0 as default };

package/bundle/_virtual/inherits_browser.js

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

package/bundle/_virtual/kdf.js

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

package/bundle/_virtual/lodash.js

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

package/bundle/_virtual/password.js

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

package/bundle/_virtual/pbkdf2.js

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

package/bundle/_virtual/pbkdf22.js

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

package/bundle/_virtual/random.js

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

package/bundle/_virtual/ripemd.js

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

package/bundle/_virtual/schema-validation-generated.js

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

package/bundle/_virtual/schema-validation.js

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

package/bundle/_virtual/scrypt.js

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

package/bundle/_virtual/scrypt2.js

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

package/bundle/_virtual/sha.js

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

package/bundle/_virtual/sha256.js

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

package/bundle/_virtual/sha2562.js

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

package/bundle/_virtual/sha3.js

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

package/bundle/_virtual/sha512.js

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

package/bundle/_virtual/types.js

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

package/bundle/_virtual/utils.js

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

package/bundle/_virtual/utils2.js

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

package/bundle/_virtual/utils3.js

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

package/bundle/index.js

@@ -1,10 +1,12 @@
-// reexport the create function, dynamically imported from rln.ts
-async function create() {
-    // 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-f87f6dbe.js');
-    return await rlnModule.create();
-}
-
-export { create };
+export { RLNDecoder, RLNEncoder } from './packages/rln/dist/codec.js';
+export { RLN_V2_ABI } from './packages/rln/dist/contract/abi/rlnv2.js';
+export { RLNContract } from './packages/rln/dist/contract/rln_contract.js';
+export { SEPOLIA_CONTRACT } from './packages/rln/dist/contract/constants.js';
+export { createRLN } from './packages/rln/dist/create.js';
+export { IdentityCredential } from './packages/rln/dist/identity.js';
+export { Keystore } from './packages/rln/dist/keystore/keystore.js';
+export { Proof } from './packages/rln/dist/proof.js';
+export { RLNInstance } from './packages/rln/dist/rln.js';
+export { MerkleRootTracker } from './packages/rln/dist/root_tracker.js';
+export { extractMetaMaskSigner } from './packages/rln/dist/utils/metamask.js';
+import './packages/rln/dist/utils/epoch.js';

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

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

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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,148 @@
+import { hexConcat, concat, arrayify, hexlify } 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 };