@waku/rln 0.1.1-fa49e29 → 0.1.2-126bce3

package/src/epoch.ts

@@ -1,30 +0,0 @@
-import debug from "debug";
-
-const DefaultEpochUnitSeconds = 10; // the rln-relay epoch length in seconds
-
-const log = debug("waku:rln:epoch");
-
-export function dateToEpoch(
-  timestamp: Date,
-  epochUnitSeconds: number = DefaultEpochUnitSeconds
-): number {
-  const time = timestamp.getTime();
-  const epoch = Math.floor(time / 1000 / epochUnitSeconds);
-  log("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("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("decoded epoch", epoch, bytes);
-  return epoch;
-}

package/src/rln_contract.ts

@@ -1,346 +0,0 @@
-import { ethers } from "ethers";
-
-import { RLN_REGISTRY_ABI, RLN_STORAGE_ABI } from "./constants.js";
-import { IdentityCredential, RLNInstance } from "./rln.js";
-import { MerkleRootTracker } from "./root_tracker.js";
-
-type Member = {
-  idCommitment: string;
-  index: ethers.BigNumber;
-};
-
-type Provider = ethers.Signer | ethers.providers.Provider;
-
-type RLNContractOptions = {
-  provider: Provider;
-  registryAddress: string;
-};
-
-type RLNStorageOptions = {
-  storageIndex?: number;
-};
-
-type RLNContractInitOptions = RLNContractOptions & RLNStorageOptions;
-
-type FetchMembersOptions = {
-  fromBlock?: number;
-  fetchRange?: number;
-  fetchChunks?: number;
-};
-
-export class RLNContract {
-  private registryContract: ethers.Contract;
-  private merkleRootTracker: MerkleRootTracker;
-
-  private deployBlock: undefined | number;
-  private storageIndex: undefined | number;
-  private storageContract: undefined | ethers.Contract;
-  private _membersFilter: undefined | ethers.EventFilter;
-
-  private _members: Map<number, Member> = new Map();
-
-  public static async init(
-    rlnInstance: RLNInstance,
-    options: RLNContractInitOptions
-  ): Promise<RLNContract> {
-    const rlnContract = new RLNContract(rlnInstance, options);
-
-    await rlnContract.initStorageContract(options.provider);
-    await rlnContract.fetchMembers(rlnInstance);
-    rlnContract.subscribeToMembers(rlnInstance);
-
-    return rlnContract;
-  }
-
-  constructor(
-    rlnInstance: RLNInstance,
-    { registryAddress, provider }: RLNContractOptions
-  ) {
-    const initialRoot = rlnInstance.getMerkleRoot();
-
-    this.registryContract = new ethers.Contract(
-      registryAddress,
-      RLN_REGISTRY_ABI,
-      provider
-    );
-    this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
-  }
-
-  private async initStorageContract(
-    provider: Provider,
-    options: RLNStorageOptions = {}
-  ): Promise<void> {
-    const storageIndex = options?.storageIndex
-      ? options.storageIndex
-      : await this.registryContract.usingStorageIndex();
-    const storageAddress = await this.registryContract.storages(storageIndex);
-
-    if (!storageAddress || storageAddress === ethers.constants.AddressZero) {
-      throw Error("No RLN Storage initialized on registry contract.");
-    }
-
-    this.storageIndex = storageIndex;
-    this.storageContract = new ethers.Contract(
-      storageAddress,
-      RLN_STORAGE_ABI,
-      provider
-    );
-    this._membersFilter = this.storageContract.filters.MemberRegistered();
-
-    this.deployBlock = await this.storageContract.deployedBlockNumber();
-  }
-
-  public get contract(): ethers.Contract {
-    if (!this.storageContract) {
-      throw Error("Storage contract was not initialized");
-    }
-    return this.storageContract as ethers.Contract;
-  }
-
-  public get members(): Member[] {
-    const sortedMembers = Array.from(this._members.values()).sort(
-      (left, right) => left.index.toNumber() - right.index.toNumber()
-    );
-    return sortedMembers;
-  }
-
-  private get membersFilter(): ethers.EventFilter {
-    if (!this._membersFilter) {
-      throw Error("Members filter was not initialized.");
-    }
-    return this._membersFilter as ethers.EventFilter;
-  }
-
-  public async fetchMembers(
-    rlnInstance: RLNInstance,
-    options: FetchMembersOptions = {}
-  ): Promise<void> {
-    const registeredMemberEvents = await queryFilter(this.contract, {
-      fromBlock: this.deployBlock,
-      ...options,
-      membersFilter: this.membersFilter,
-    });
-    this.processEvents(rlnInstance, registeredMemberEvents);
-  }
-
-  public processEvents(rlnInstance: RLNInstance, events: ethers.Event[]): void {
-    const toRemoveTable = new Map<number, number[]>();
-    const toInsertTable = new Map<number, ethers.Event[]>();
-
-    events.forEach((evt) => {
-      if (!evt.args) {
-        return;
-      }
-
-      if (evt.removed) {
-        const index: ethers.BigNumber = evt.args.index;
-        const toRemoveVal = toRemoveTable.get(evt.blockNumber);
-        if (toRemoveVal != undefined) {
-          toRemoveVal.push(index.toNumber());
-          toRemoveTable.set(evt.blockNumber, toRemoveVal);
-        } else {
-          toRemoveTable.set(evt.blockNumber, [index.toNumber()]);
-        }
-      } else {
-        let eventsPerBlock = toInsertTable.get(evt.blockNumber);
-        if (eventsPerBlock == undefined) {
-          eventsPerBlock = [];
-        }
-
-        eventsPerBlock.push(evt);
-        toInsertTable.set(evt.blockNumber, eventsPerBlock);
-      }
-
-      this.removeMembers(rlnInstance, toRemoveTable);
-      this.insertMembers(rlnInstance, toInsertTable);
-    });
-  }
-
-  private insertMembers(
-    rlnInstance: RLNInstance,
-    toInsert: Map<number, ethers.Event[]>
-  ): void {
-    toInsert.forEach((events: ethers.Event[], blockNumber: number) => {
-      events.forEach((evt) => {
-        const _idCommitment = evt?.args?.idCommitment;
-        const index: ethers.BigNumber = evt?.args?.index;
-
-        if (!_idCommitment || !index) {
-          return;
-        }
-
-        const idCommitment = ethers.utils.zeroPad(
-          ethers.utils.arrayify(_idCommitment),
-          32
-        );
-        rlnInstance.insertMember(idCommitment);
-        this._members.set(index.toNumber(), {
-          index,
-          idCommitment:
-            _idCommitment?._hex || ethers.utils.hexlify(idCommitment),
-        });
-      });
-
-      const currentRoot = rlnInstance.getMerkleRoot();
-      this.merkleRootTracker.pushRoot(blockNumber, currentRoot);
-    });
-  }
-
-  private removeMembers(
-    rlnInstance: RLNInstance,
-    toRemove: Map<number, number[]>
-  ): void {
-    const removeDescending = new Map([...toRemove].sort().reverse());
-    removeDescending.forEach((indexes: number[], blockNumber: number) => {
-      indexes.forEach((index) => {
-        if (this._members.has(index)) {
-          this._members.delete(index);
-        }
-        rlnInstance.deleteMember(index);
-      });
-
-      this.merkleRootTracker.backFill(blockNumber);
-    });
-  }
-
-  public subscribeToMembers(rlnInstance: RLNInstance): void {
-    this.contract.on(this.membersFilter, (_pubkey, _index, event) =>
-      this.processEvents(rlnInstance, [event])
-    );
-  }
-
-  public async registerWithSignature(
-    rlnInstance: RLNInstance,
-    signature: string
-  ): Promise<Member | undefined> {
-    const identityCredential =
-      await rlnInstance.generateSeededIdentityCredential(signature);
-
-    return this.registerWithKey(identityCredential);
-  }
-
-  public async registerWithKey(
-    credential: IdentityCredential
-  ): Promise<Member | undefined> {
-    if (this.storageIndex === undefined) {
-      throw Error(
-        "Cannot register credential, no storage contract index found."
-      );
-    }
-    const txRegisterResponse: ethers.ContractTransaction =
-      await this.registryContract["register(uint16,uint256)"](
-        this.storageIndex,
-        credential.IDCommitmentBigInt,
-        { gasLimit: 100000 }
-      );
-    const txRegisterReceipt = await txRegisterResponse.wait();
-
-    // assumption: register(uint16,uint256) emits one event
-    const memberRegistered = txRegisterReceipt?.events?.[0];
-
-    if (!memberRegistered) {
-      return undefined;
-    }
-
-    const decodedData = this.contract.interface.decodeEventLog(
-      "MemberRegistered",
-      memberRegistered.data
-    );
-
-    return {
-      idCommitment: decodedData.idCommitment,
-      index: decodedData.index,
-    };
-  }
-
-  public roots(): Uint8Array[] {
-    return this.merkleRootTracker.roots();
-  }
-}
-
-type CustomQueryOptions = FetchMembersOptions & {
-  membersFilter: ethers.EventFilter;
-};
-
-// these value should be tested on other networks
-const FETCH_CHUNK = 5;
-const BLOCK_RANGE = 3000;
-
-async function queryFilter(
-  contract: ethers.Contract,
-  options: CustomQueryOptions
-): Promise<ethers.Event[]> {
-  const {
-    fromBlock,
-    membersFilter,
-    fetchRange = BLOCK_RANGE,
-    fetchChunks = FETCH_CHUNK,
-  } = options;
-
-  if (!fromBlock) {
-    return contract.queryFilter(membersFilter);
-  }
-
-  if (!contract.signer.provider) {
-    throw Error("No provider found on the contract's signer.");
-  }
-
-  const toBlock = await contract.signer.provider.getBlockNumber();
-
-  if (toBlock - fromBlock < fetchRange) {
-    return contract.queryFilter(membersFilter);
-  }
-
-  const events: ethers.Event[][] = [];
-  const chunks = splitToChunks(fromBlock, toBlock, fetchRange);
-
-  for (const portion of takeN<[number, number]>(chunks, fetchChunks)) {
-    const promises = portion.map(([left, right]) =>
-      ignoreErrors(contract.queryFilter(membersFilter, left, right), [])
-    );
-    const fetchedEvents = await Promise.all(promises);
-    events.push(fetchedEvents.flatMap((v) => v));
-  }
-
-  return events.flatMap((v) => v);
-}
-
-function splitToChunks(
-  from: number,
-  to: number,
-  step: number
-): Array<[number, number]> {
-  const chunks = [];
-
-  let left = from;
-  while (left < to) {
-    const right = left + step < to ? left + step : to;
-
-    chunks.push([left, right] as [number, number]);
-
-    left = right;
-  }
-
-  return chunks;
-}
-
-function* takeN<T>(array: T[], size: number): Iterable<T[]> {
-  let start = 0;
-  let skip = size;
-
-  while (skip < array.length) {
-    const portion = array.slice(start, skip);
-
-    yield portion;
-
-    start = skip;
-    skip += size;
-  }
-}
-
-function ignoreErrors<T>(promise: Promise<T>, defaultValue: T): Promise<T> {
-  return promise.catch((err) => {
-    console.error(`Ignoring an error during query: ${err?.message}`);
-    return defaultValue;
-  });
-}

package/src/witness_calculator.d.ts

@@ -1,8 +0,0 @@
-export async function builder(
-  code: Uint8Array,
-  sanityCheck: bool
-): Promise<WitnessCalculator>;
-
-export class WitnessCalculator {
-  calculateWitness(input, sanityCheck): Array<bigint>;
-}

package/src/witness_calculator.js

@@ -1,335 +0,0 @@
-// File generated with https://github.com/iden3/circom 
-// following the instructions from:
-// https://github.com/vacp2p/zerokit/tree/master/rln#compiling-circuits
-
-export 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;
-}