@waku/rln 0.1.3 → 0.1.4-d27db21.0

package/bundle/packages/rln/dist/resources/witness_calculator.js

@@ -0,0 +1,330 @@
+// File generated with https://github.com/iden3/circom
+// following the instructions from:
+// https://github.com/vacp2p/zerokit/tree/master/rln#compiling-circuits
+
+async function builder(code, options) {
+  options = options || {};
+
+  let wasmModule;
+  try {
+    wasmModule = await WebAssembly.compile(code);
+  } catch (err) {
+    console.log(err);
+    console.log(
+      "\nTry to run circom --c in order to generate c++ code instead\n"
+    );
+    throw new Error(err);
+  }
+
+  let wc;
+
+  let errStr = "";
+  let msgStr = "";
+
+  const instance = await WebAssembly.instantiate(wasmModule, {
+    runtime: {
+      exceptionHandler: function (code) {
+        let err;
+        if (code == 1) {
+          err = "Signal not found.\n";
+        } else if (code == 2) {
+          err = "Too many signals set.\n";
+        } else if (code == 3) {
+          err = "Signal already set.\n";
+        } else if (code == 4) {
+          err = "Assert Failed.\n";
+        } else if (code == 5) {
+          err = "Not enough memory.\n";
+        } else if (code == 6) {
+          err = "Input signal array access exceeds the size.\n";
+        } else {
+          err = "Unknown error.\n";
+        }
+        throw new Error(err + errStr);
+      },
+      printErrorMessage: function () {
+        errStr += getMessage() + "\n";
+        // console.error(getMessage());
+      },
+      writeBufferMessage: function () {
+        const msg = getMessage();
+        // Any calls to `log()` will always end with a `\n`, so that's when we print and reset
+        if (msg === "\n") {
+          console.log(msgStr);
+          msgStr = "";
+        } else {
+          // If we've buffered other content, put a space in between the items
+          if (msgStr !== "") {
+            msgStr += " ";
+          }
+          // Then append the message to the message we are creating
+          msgStr += msg;
+        }
+      },
+      showSharedRWMemory: function () {
+        printSharedRWMemory();
+      }
+    }
+  });
+
+  const sanityCheck = options;
+  //        options &&
+  //        (
+  //            options.sanityCheck ||
+  //            options.logGetSignal ||
+  //            options.logSetSignal ||
+  //            options.logStartComponent ||
+  //            options.logFinishComponent
+  //        );
+
+  wc = new WitnessCalculator(instance, sanityCheck);
+  return wc;
+
+  function getMessage() {
+    var message = "";
+    var c = instance.exports.getMessageChar();
+    while (c != 0) {
+      message += String.fromCharCode(c);
+      c = instance.exports.getMessageChar();
+    }
+    return message;
+  }
+
+  function printSharedRWMemory() {
+    const shared_rw_memory_size = instance.exports.getFieldNumLen32();
+    const arr = new Uint32Array(shared_rw_memory_size);
+    for (let j = 0; j < shared_rw_memory_size; j++) {
+      arr[shared_rw_memory_size - 1 - j] =
+        instance.exports.readSharedRWMemory(j);
+    }
+
+    // If we've buffered other content, put a space in between the items
+    if (msgStr !== "") {
+      msgStr += " ";
+    }
+    // Then append the value to the message we are creating
+    msgStr += fromArray32(arr).toString();
+  }
+}
+
+class WitnessCalculator {
+  constructor(instance, sanityCheck) {
+    this.instance = instance;
+
+    this.version = this.instance.exports.getVersion();
+    this.n32 = this.instance.exports.getFieldNumLen32();
+
+    this.instance.exports.getRawPrime();
+    const arr = new Uint32Array(this.n32);
+    for (let i = 0; i < this.n32; i++) {
+      arr[this.n32 - 1 - i] = this.instance.exports.readSharedRWMemory(i);
+    }
+    this.prime = fromArray32(arr);
+
+    this.witnessSize = this.instance.exports.getWitnessSize();
+
+    this.sanityCheck = sanityCheck;
+  }
+
+  circom_version() {
+    return this.instance.exports.getVersion();
+  }
+
+  async _doCalculateWitness(input, sanityCheck) {
+    //input is assumed to be a map from signals to arrays of bigints
+    this.instance.exports.init(this.sanityCheck || sanityCheck ? 1 : 0);
+    const keys = Object.keys(input);
+    var input_counter = 0;
+    keys.forEach((k) => {
+      const h = fnvHash(k);
+      const hMSB = parseInt(h.slice(0, 8), 16);
+      const hLSB = parseInt(h.slice(8, 16), 16);
+      const fArr = flatArray(input[k]);
+      let signalSize = this.instance.exports.getInputSignalSize(hMSB, hLSB);
+      if (signalSize < 0) {
+        throw new Error(`Signal ${k} not found\n`);
+      }
+      if (fArr.length < signalSize) {
+        throw new Error(`Not enough values for input signal ${k}\n`);
+      }
+      if (fArr.length > signalSize) {
+        throw new Error(`Too many values for input signal ${k}\n`);
+      }
+      for (let i = 0; i < fArr.length; i++) {
+        const arrFr = toArray32(BigInt(fArr[i]) % this.prime, this.n32);
+        for (let j = 0; j < this.n32; j++) {
+          this.instance.exports.writeSharedRWMemory(j, arrFr[this.n32 - 1 - j]);
+        }
+        try {
+          this.instance.exports.setInputSignal(hMSB, hLSB, i);
+          input_counter++;
+        } catch (err) {
+          // console.log(`After adding signal ${i} of ${k}`)
+          throw new Error(err);
+        }
+      }
+    });
+    if (input_counter < this.instance.exports.getInputSize()) {
+      throw new Error(
+        `Not all inputs have been set. Only ${input_counter} out of ${this.instance.exports.getInputSize()}`
+      );
+    }
+  }
+
+  async calculateWitness(input, sanityCheck) {
+    const w = [];
+
+    await this._doCalculateWitness(input, sanityCheck);
+
+    for (let i = 0; i < this.witnessSize; i++) {
+      this.instance.exports.getWitness(i);
+      const arr = new Uint32Array(this.n32);
+      for (let j = 0; j < this.n32; j++) {
+        arr[this.n32 - 1 - j] = this.instance.exports.readSharedRWMemory(j);
+      }
+      w.push(fromArray32(arr));
+    }
+
+    return w;
+  }
+
+  async calculateBinWitness(input, sanityCheck) {
+    const buff32 = new Uint32Array(this.witnessSize * this.n32);
+    const buff = new Uint8Array(buff32.buffer);
+    await this._doCalculateWitness(input, sanityCheck);
+
+    for (let i = 0; i < this.witnessSize; i++) {
+      this.instance.exports.getWitness(i);
+      const pos = i * this.n32;
+      for (let j = 0; j < this.n32; j++) {
+        buff32[pos + j] = this.instance.exports.readSharedRWMemory(j);
+      }
+    }
+
+    return buff;
+  }
+
+  async calculateWTNSBin(input, sanityCheck) {
+    const buff32 = new Uint32Array(this.witnessSize * this.n32 + this.n32 + 11);
+    const buff = new Uint8Array(buff32.buffer);
+    await this._doCalculateWitness(input, sanityCheck);
+
+    //"wtns"
+    buff[0] = "w".charCodeAt(0);
+    buff[1] = "t".charCodeAt(0);
+    buff[2] = "n".charCodeAt(0);
+    buff[3] = "s".charCodeAt(0);
+
+    //version 2
+    buff32[1] = 2;
+
+    //number of sections: 2
+    buff32[2] = 2;
+
+    //id section 1
+    buff32[3] = 1;
+
+    const n8 = this.n32 * 4;
+    //id section 1 length in 64bytes
+    const idSection1length = 8 + n8;
+    const idSection1lengthHex = idSection1length.toString(16);
+    buff32[4] = parseInt(idSection1lengthHex.slice(0, 8), 16);
+    buff32[5] = parseInt(idSection1lengthHex.slice(8, 16), 16);
+
+    //this.n32
+    buff32[6] = n8;
+
+    //prime number
+    this.instance.exports.getRawPrime();
+
+    var pos = 7;
+    for (let j = 0; j < this.n32; j++) {
+      buff32[pos + j] = this.instance.exports.readSharedRWMemory(j);
+    }
+    pos += this.n32;
+
+    // witness size
+    buff32[pos] = this.witnessSize;
+    pos++;
+
+    //id section 2
+    buff32[pos] = 2;
+    pos++;
+
+    // section 2 length
+    const idSection2length = n8 * this.witnessSize;
+    const idSection2lengthHex = idSection2length.toString(16);
+    buff32[pos] = parseInt(idSection2lengthHex.slice(0, 8), 16);
+    buff32[pos + 1] = parseInt(idSection2lengthHex.slice(8, 16), 16);
+
+    pos += 2;
+    for (let i = 0; i < this.witnessSize; i++) {
+      this.instance.exports.getWitness(i);
+      for (let j = 0; j < this.n32; j++) {
+        buff32[pos + j] = this.instance.exports.readSharedRWMemory(j);
+      }
+      pos += this.n32;
+    }
+
+    return buff;
+  }
+}
+
+function toArray32(rem, size) {
+  const res = []; //new Uint32Array(size); //has no unshift
+  const radix = BigInt(0x100000000);
+  while (rem) {
+    res.unshift(Number(rem % radix));
+    rem = rem / radix;
+  }
+  if (size) {
+    var i = size - res.length;
+    while (i > 0) {
+      res.unshift(0);
+      i--;
+    }
+  }
+  return res;
+}
+
+function fromArray32(arr) {
+  //returns a BigInt
+  var res = BigInt(0);
+  const radix = BigInt(0x100000000);
+  for (let i = 0; i < arr.length; i++) {
+    res = res * radix + BigInt(arr[i]);
+  }
+  return res;
+}
+
+function flatArray(a) {
+  var res = [];
+  fillArray(res, a);
+  return res;
+
+  function fillArray(res, a) {
+    if (Array.isArray(a)) {
+      for (let i = 0; i < a.length; i++) {
+        fillArray(res, a[i]);
+      }
+    } else {
+      res.push(a);
+    }
+  }
+}
+
+function fnvHash(str) {
+  const uint64_max = BigInt(2) ** BigInt(64);
+  let hash = BigInt("0xCBF29CE484222325");
+  for (var i = 0; i < str.length; i++) {
+    hash ^= BigInt(str[i].charCodeAt());
+    hash *= BigInt(0x100000001b3);
+    hash %= uint64_max;
+  }
+  let shash = hash.toString(16);
+  let n = 16 - shash.length;
+  shash = "0".repeat(n).concat(shash);
+  return shash;
+}
+
+export { builder };

package/bundle/packages/rln/dist/rln.js

@@ -0,0 +1,220 @@
+import { createEncoder, createDecoder } from '../../core/dist/lib/message/version_0.js';
+import '../../core/dist/lib/filter/filter.js';
+import '../../core/dist/lib/light_push/light_push.js';
+import '../../core/dist/lib/store/store.js';
+import '../../core/dist/lib/connection_manager/connection_manager.js';
+import '../../interfaces/dist/protocols.js';
+import '../../interfaces/dist/connection_manager.js';
+import '../../interfaces/dist/health_indicator.js';
+import '../../../node_modules/multiformats/dist/src/bases/base10.js';
+import '../../../node_modules/multiformats/dist/src/bases/base16.js';
+import '../../../node_modules/multiformats/dist/src/bases/base2.js';
+import '../../../node_modules/multiformats/dist/src/bases/base256emoji.js';
+import '../../../node_modules/multiformats/dist/src/bases/base32.js';
+import '../../../node_modules/multiformats/dist/src/bases/base36.js';
+import '../../../node_modules/multiformats/dist/src/bases/base58.js';
+import '../../../node_modules/multiformats/dist/src/bases/base64.js';
+import '../../../node_modules/multiformats/dist/src/bases/base8.js';
+import '../../../node_modules/multiformats/dist/src/bases/identity.js';
+import '../../../node_modules/multiformats/dist/src/codecs/json.js';
+import { Logger } from '../../utils/dist/logger/index.js';
+import '../../core/dist/lib/metadata/metadata.js';
+import __wbg_init, { init_panic_hook, newRLN } from '../../../node_modules/@waku/zerokit-rln-wasm/rln_wasm.js';
+import { createRLNEncoder, createRLNDecoder } from './codec.js';
+import { DEFAULT_RATE_LIMIT, SEPOLIA_CONTRACT } from './contract/constants.js';
+import { RLNContract } from './contract/rln_contract.js';
+import { Keystore } from './keystore/keystore.js';
+import verificationKey from './resources/verification_key.js';
+import { builder } from './resources/witness_calculator.js';
+import { extractMetaMaskSigner } from './utils/metamask.js';
+import './utils/epoch.js';
+import { Zerokit } from './zerokit.js';
+
+const log = new Logger("waku:rln");
+async function loadWitnessCalculator() {
+    try {
+        const url = new URL("./resources/rln.wasm", import.meta.url);
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch witness calculator: ${response.status} ${response.statusText}`);
+        }
+        return await builder(new Uint8Array(await response.arrayBuffer()), false);
+    }
+    catch (error) {
+        log.error("Error loading witness calculator:", error);
+        throw new Error(`Failed to load witness calculator: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function loadZkey() {
+    try {
+        const url = new URL("./resources/rln_final.zkey", import.meta.url);
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch zkey: ${response.status} ${response.statusText}`);
+        }
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    catch (error) {
+        log.error("Error loading zkey:", error);
+        throw new Error(`Failed to load zkey: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Create an instance of RLN
+ * @returns RLNInstance
+ */
+async function create() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await __wbg_init?.();
+        init_panic_hook();
+        const witnessCalculator = await loadWitnessCalculator();
+        const zkey = await loadZkey();
+        const stringEncoder = new TextEncoder();
+        const vkey = stringEncoder.encode(JSON.stringify(verificationKey));
+        const DEPTH = 20;
+        const zkRLN = newRLN(DEPTH, zkey, vkey);
+        const zerokit = new Zerokit(zkRLN, witnessCalculator, DEFAULT_RATE_LIMIT);
+        return new RLNInstance(zerokit);
+    }
+    catch (error) {
+        log.error("Failed to initialize RLN:", error);
+        throw error;
+    }
+}
+class RLNInstance {
+    zerokit;
+    started = false;
+    starting = false;
+    _contract;
+    _signer;
+    keystore = Keystore.create();
+    _credentials;
+    constructor(zerokit) {
+        this.zerokit = zerokit;
+    }
+    get contract() {
+        return this._contract;
+    }
+    get signer() {
+        return this._signer;
+    }
+    async start(options = {}) {
+        if (this.started || this.starting) {
+            return;
+        }
+        this.starting = true;
+        try {
+            const { credentials, keystore } = await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
+            const { signer, address } = await this.determineStartOptions(options, credentials);
+            if (keystore) {
+                this.keystore = keystore;
+            }
+            this._credentials = credentials;
+            this._signer = signer;
+            this._contract = await RLNContract.init(this, {
+                address: address,
+                signer: signer,
+                rateLimit: options.rateLimit ?? this.zerokit.getRateLimit
+            });
+            this.started = true;
+        }
+        finally {
+            this.starting = false;
+        }
+    }
+    async determineStartOptions(options, credentials) {
+        let chainId = credentials?.membership.chainId;
+        const address = credentials?.membership.address ||
+            options.address ||
+            SEPOLIA_CONTRACT.address;
+        if (address === SEPOLIA_CONTRACT.address) {
+            chainId = SEPOLIA_CONTRACT.chainId;
+        }
+        const signer = options.signer || (await extractMetaMaskSigner());
+        const currentChainId = await signer.getChainId();
+        if (chainId && chainId !== currentChainId) {
+            throw Error(`Failed to start RLN contract, chain ID of contract is different from current one: contract-${chainId}, current network-${currentChainId}`);
+        }
+        return {
+            signer,
+            address
+        };
+    }
+    static async decryptCredentialsIfNeeded(credentials) {
+        if (!credentials) {
+            return {};
+        }
+        if ("identity" in credentials) {
+            return { credentials };
+        }
+        const keystore = Keystore.fromString(credentials.keystore);
+        if (!keystore) {
+            return {};
+        }
+        const decryptedCredentials = await keystore.readCredential(credentials.id, credentials.password);
+        return {
+            keystore,
+            credentials: decryptedCredentials
+        };
+    }
+    async registerMembership(options) {
+        if (!this.contract) {
+            throw Error("RLN Contract is not initialized.");
+        }
+        let identity = "identity" in options && options.identity;
+        if ("signature" in options) {
+            identity = this.zerokit.generateSeededIdentityCredential(options.signature);
+        }
+        if (!identity) {
+            throw Error("Missing signature or identity to register membership.");
+        }
+        return this.contract.registerWithIdentity(identity);
+    }
+    /**
+     * Changes credentials in use by relying on provided Keystore earlier in rln.start
+     * @param id: string, hash of credentials to select from Keystore
+     * @param password: string or bytes to use to decrypt credentials from Keystore
+     */
+    async useCredentials(id, password) {
+        this._credentials = await this.keystore?.readCredential(id, password);
+    }
+    async createEncoder(options) {
+        const { credentials: decryptedCredentials } = await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
+        const credentials = decryptedCredentials || this._credentials;
+        if (!credentials) {
+            throw Error("Failed to create Encoder: missing RLN credentials. Use createRLNEncoder directly.");
+        }
+        await this.verifyCredentialsAgainstContract(credentials);
+        return createRLNEncoder({
+            encoder: createEncoder(options),
+            rlnInstance: this,
+            index: credentials.membership.treeIndex,
+            credential: credentials.identity
+        });
+    }
+    async verifyCredentialsAgainstContract(credentials) {
+        if (!this._contract) {
+            throw Error("Failed to verify chain coordinates: no contract initialized.");
+        }
+        const registryAddress = credentials.membership.address;
+        const currentRegistryAddress = this._contract.address;
+        if (registryAddress !== currentRegistryAddress) {
+            throw Error(`Failed to verify chain coordinates: credentials contract address=${registryAddress} is not equal to registryContract address=${currentRegistryAddress}`);
+        }
+        const chainId = credentials.membership.chainId;
+        const network = await this._contract.provider.getNetwork();
+        const currentChainId = network.chainId;
+        if (chainId !== currentChainId) {
+            throw Error(`Failed to verify chain coordinates: credentials chainID=${chainId} is not equal to registryContract chainID=${currentChainId}`);
+        }
+    }
+    createDecoder(contentTopic) {
+        return createRLNDecoder({
+            rlnInstance: this,
+            decoder: createDecoder(contentTopic)
+        });
+    }
+}
+
+export { RLNInstance, create };

package/bundle/packages/rln/dist/root_tracker.js

@@ -0,0 +1,76 @@
+class RootPerBlock {
+    root;
+    blockNumber;
+    constructor(root, blockNumber) {
+        this.root = root;
+        this.blockNumber = blockNumber;
+    }
+}
+const maxBufferSize = 20;
+class MerkleRootTracker {
+    acceptableRootWindowSize;
+    validMerkleRoots = new Array();
+    merkleRootBuffer = new Array();
+    constructor(acceptableRootWindowSize, initialRoot) {
+        this.acceptableRootWindowSize = acceptableRootWindowSize;
+        this.pushRoot(0, initialRoot);
+    }
+    backFill(fromBlockNumber) {
+        if (this.validMerkleRoots.length == 0)
+            return;
+        let numBlocks = 0;
+        for (let i = this.validMerkleRoots.length - 1; i >= 0; i--) {
+            if (this.validMerkleRoots[i].blockNumber >= fromBlockNumber) {
+                numBlocks++;
+            }
+        }
+        if (numBlocks == 0)
+            return;
+        const olderBlock = fromBlockNumber < this.validMerkleRoots[0].blockNumber;
+        // Remove last roots
+        let rootsToPop = numBlocks;
+        if (this.validMerkleRoots.length < rootsToPop) {
+            rootsToPop = this.validMerkleRoots.length;
+        }
+        this.validMerkleRoots = this.validMerkleRoots.slice(0, this.validMerkleRoots.length - rootsToPop);
+        if (this.merkleRootBuffer.length == 0)
+            return;
+        if (olderBlock) {
+            const idx = this.merkleRootBuffer.findIndex((x) => x.blockNumber == fromBlockNumber);
+            if (idx > -1) {
+                this.merkleRootBuffer = this.merkleRootBuffer.slice(0, idx);
+            }
+        }
+        // Backfill the tree's acceptable roots
+        let rootsToRestore = this.acceptableRootWindowSize - this.validMerkleRoots.length;
+        if (this.merkleRootBuffer.length < rootsToRestore) {
+            rootsToRestore = this.merkleRootBuffer.length;
+        }
+        for (let i = 0; i < rootsToRestore; i++) {
+            const x = this.merkleRootBuffer.pop();
+            if (x)
+                this.validMerkleRoots.unshift(x);
+        }
+    }
+    pushRoot(blockNumber, root) {
+        this.validMerkleRoots.push(new RootPerBlock(root, blockNumber));
+        // Maintain valid merkle root window
+        if (this.validMerkleRoots.length > this.acceptableRootWindowSize) {
+            const x = this.validMerkleRoots.shift();
+            if (x)
+                this.merkleRootBuffer.push(x);
+        }
+        // Maintain merkle root buffer
+        if (this.merkleRootBuffer.length > maxBufferSize) {
+            this.merkleRootBuffer.shift();
+        }
+    }
+    roots() {
+        return this.validMerkleRoots.map((x) => x.root);
+    }
+    buffer() {
+        return this.merkleRootBuffer.map((x) => x.root);
+    }
+}
+
+export { MerkleRootTracker };

package/bundle/packages/rln/dist/utils/bytes.js

@@ -0,0 +1,65 @@
+/**
+ * Concatenate Uint8Arrays
+ * @param input
+ * @returns concatenation of all Uint8Array received as input
+ */
+function concatenate(...input) {
+    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, value, offset, ext, max, min) {
+    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");
+}
+function writeUIntLE(buf, value, offset, byteLength, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    byteLength = byteLength >>> 0;
+    {
+        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
+ */
+function buildBigIntFromUint8Array(array, byteOffset = 0) {
+    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
+ */
+function zeroPadLE(array, length) {
+    const result = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = array[i] || 0;
+    }
+    return result;
+}
+
+export { buildBigIntFromUint8Array, concatenate, writeUIntLE, zeroPadLE };