Add fields for syncedBlock and leaves in EVMChainStorage class

packages/apps/src/configs/storages/evm-chain-storage.interface.ts

@@ -0,0 +1,22 @@
+import { MixerSize } from '@webb-dapp/react-environment';
+
+export class EvmChainStorage {
+  constructor(
+    public contractsInfo: { 
+      address: string;
+      size: number;
+      symbol: string;
+      syncedBlock: number;
+      leaves: string[];
+    }[]
+  ) {}
+
+  get mixerSize(): MixerSize[] {
+    return this.contractsInfo.map((contract, index) => {
+      return {
+        id: contract.address,
+        title: `${contract.size} ${contract.symbol}`,
+      };
+    });
+  }
+}

packages/apps/src/configs/storages/evm-storage.ts

@@ -0,0 +1,93 @@
+import { EvmChainStorage } from '@webb-dapp/apps/configs/storages/evm-chain-storage.interface';
+import { StorageHandler } from '@webb-dapp/utils';
+import { EVMStorage } from '@webb-dapp/react-environment/api-providers/web3';
+
+const rinkebyStore = new EvmChainStorage([
+  {
+    size: 0.1,
+    address: '0x876eCe69618e8E8dd743250B036785813824D2D7',
+    symbol: 'ETH',
+    syncedBlock: 120000, // should be hardcoded to deployed block number
+    leaves: [],
+  },
+]);
+
+const ethMainNet = new EvmChainStorage([
+  {
+    size: 0.1,
+    address: '0x876eCe69618e8E8dd743250B036785813824D2D7',
+    symbol: 'ETH',
+    syncedBlock: 1, 
+    leaves: [],
+  },
+]);
+
+const beresheet = new EvmChainStorage([
+  {
+    size: 10,
+    address: '0x5f771fc87F87DB48C9fB11aA228D833226580689',
+    symbol: 'tEDG',
+    syncedBlock: 1, 
+    leaves: [],
+  },
+  {
+    size: 100,
+    address: '0x2ee2e51cab1561E4482cacc8Be8b46CE61E46991',
+    symbol: 'tEDG',
+    syncedBlock: 1, 
+    leaves: [],
+  },
+  {
+    size: 1000,
+    address: '0x5696b4AfBc169454d7FA26e0a41828d445CFae20',
+    symbol: 'tEDG',
+    syncedBlock: 1, 
+    leaves: [],
+  },
+  {
+    size: 10000,
+    address: '0x626FEc5Ffa7Bf1EE8CEd7daBdE545630473E3ABb',
+    symbol: 'tEDG',
+    syncedBlock: 1, 
+    leaves: [],
+  },
+]);
+
+const defaultHandler: Omit<StorageHandler<EVMStorage>, 'inner'> = {
+  async fetch(key: string) {
+    const data = localStorage.getItem(key);
+    if (!data) {
+      return {
+        nativeAnchor: new EvmChainStorage([]),
+      };
+    }
+    const address = JSON.parse(data).contractsAddresses;
+    return {
+      nativeAnchor: new EvmChainStorage(address),
+    };
+  },
+  async commit(key: string, data) {
+    localStorage.setItem(key, JSON.stringify(data.contractsAddresses));
+  },
+};
+
+export const rinkebyStorage: StorageHandler<EVMStorage> = {
+  ...defaultHandler,
+  inner: {
+    nativeAnchor: rinkebyStore,
+  },
+};
+
+export const mainStorage: StorageHandler<EVMStorage> = {
+  ...defaultHandler,
+  inner: {
+    nativeAnchor: ethMainNet,
+  },
+};
+
+export const beresheetStorage: StorageHandler<EVMStorage> = {
+  ...defaultHandler,
+  inner: {
+    nativeAnchor: beresheet,
+  }
+}

packages/contracts/src/contracts/anchor.ts

@@ -30,14 +30,20 @@ export class AnchorContract {
     return this._contract.nextIndex();
   }
 
+  get denomination() {
+    return this._contract.denomination();
+  }
+
   get inner() {
     return this._contract;
   }
 
-  async createDeposit(): Promise<{ note: EvmNote; deposit: Deposit }> {
+  async createDeposit(assetSymbol: string): Promise<{ note: EvmNote; deposit: Deposit }> {
     const deposit = createDeposit();
     const chainId = await this.signer.getChainId();
-    const note = new EvmNote('eth', 0.1, chainId, deposit.preimage);
+    const depositSizeBN = await this.denomination;
+    const depositSize = Number.parseFloat(utils.fromWei(depositSizeBN.toString(), "ether"));
+    const note = new EvmNote(assetSymbol, depositSize, chainId, deposit.preimage);
     return {
       note,
       deposit,
@@ -48,8 +54,9 @@ export class AnchorContract {
     const overrides = {
       gasLimit: 6000000,
       gasPrice: utils.toWei('1', 'gwei'),
-      value: '0x16345785D8A0000',
+      value: await this.denomination,
     };
+    console.log(commitment);
     const filters = await this._contract.filters.Deposit(commitment, null, null);
     this._contract.once(filters, (commitment, insertedIndex, timestamp) => {
       onComplete?.([commitment, insertedIndex, timestamp]);
@@ -60,17 +67,47 @@ export class AnchorContract {
 
   private async getDepositEvents(commitment: string | null = null) {
     const filter = this._contract.filters.Deposit(commitment, null, null);
-    const logs = await this.web3Provider.getLogs({
-      fromBlock: 0,
-      toBlock: 'latest',
-      ...filter,
-    });
+    const currentBlock = await this.web3Provider.getBlockNumber();
+
+    // Look in the localStorage for this mixer (should be indexed under address)
+    // and get the syncedBlock / leaves that are present in the storage.
+    // Then query the blocks after the syncedBlock to update the leaves.
+
+    const startingBlock = 1; // Read starting block from cached storage, syncedBlock
+    var logs = []; // variable that holds newly fetched logs
+
+    try {
+      logs = await this.web3Provider.getLogs({
+        fromBlock: startingBlock,
+        toBlock: 'latest',
+        ...filter,
+      });
+    } catch (e) {
+      console.log(e);
+
+      // If there is a timeout, query the logs in block increments.
+      if (e.code == -32603) {
+        for (var i=startingBlock; i < currentBlock; i+= 1000)
+        {
+          logs = [...logs, ...(await this.web3Provider.getLogs({
+            fromBlock: i,
+            toBlock: (currentBlock - i > 1000) ? i + 1000 : currentBlock,
+            ...filter,
+          }))];
+        }
+      } else {
+        throw e;
+      }
+    }
     console.log(logs);
-    return logs.map((log) => this._contract.interface.parseLog(log));
-  }
 
-  private async generateSnarkProof(deposit: Deposit) {
-    // const { path_elements, path_index, root } = await this.generateMerkleProof(deposit);
+    // After getting the events, we should parse out and sort the commitments (leaves) and
+    // append to the leaves localStorage for this mixer.
+    // Dynamically update the storage at _this.contract.address, querying the appropriate
+    // EVMChainStorage key of 'main', 'rinkeby', etc. using this.signer.getChainId() and
+    // WebbWeb3Provider.storageName(chainId);
+
+    return logs.map((log) => this._contract.interface.parseLog(log));
   }
 
   async generateMerkleProof(deposit: Deposit) {
@@ -105,7 +142,6 @@ export class AnchorContract {
     let proving_key = require('../circuits/withdraw_proving_key.bin');
     proving_key = await fetch(proving_key);
     proving_key = await proving_key.arrayBuffer();
-    const bigInt = snarkjs.bigInt;
 
     const input = {
       // public

packages/react-environment/src/WebbProvider.tsx

@@ -1,5 +1,5 @@
 import WalletConnectProvider from '@walletconnect/web3-provider';
-import { mainStorage, rankebyStorage } from '@webb-dapp/apps/configs/storages/rinkeby-storage';
+import { beresheetStorage, mainStorage, rinkebyStorage } from '@webb-dapp/apps/configs/storages/rinkeby-storage';
 import { chainsConfig } from '@webb-dapp/apps/configs/wallets/chain-config';
 import { walletsConfig, WalletsIds } from '@webb-dapp/apps/configs/wallets/wallets-config';
 import { EVMStorage, WebbEVMChain, WebbWeb3Provider } from '@webb-dapp/react-environment/api-providers/web3';
@@ -88,20 +88,27 @@ export const WebbProvider: FC<WebbProviderProps> = ({ applicationName = 'Webb Da
       case WalletsIds.MetaMask:
         {
           const web3Provider = await Web3Provider.fromExtension();
-          const net = await web3Provider.netowrk;
-          const chainType = WebbWeb3Provider.chainType(net); //  use this to pick the storage
-          const rainkybeS = await Storage.newFresh(WebbEVMChain.Rinkeby, rankebyStorage);
-          const mainS = await Storage.newFresh(WebbEVMChain.Main, mainStorage);
+          const net = await web3Provider.network; // storage based on network id
+          const chainType = WebbWeb3Provider.storageName(net);
+          // const rinkebyS = await Storage.newFresh(WebbEVMChain.Rinkeby, rinkebyStorage);
+          // const mainS = await Storage.newFresh(WebbEVMChain.Main, mainStorage);
+          // const beresheetS = await Storage.newFresh(WebbEVMChain.Beresheet, beresheetStorage);
           let storage: Storage<EVMStorage>;
-          switch (chainType) {
+          switch (net) {
             case WebbEVMChain.Main:
-              storage = mainS;
+              storage = await Storage.newFresh(chainType, mainStorage);
               break;
             case WebbEVMChain.Rinkeby:
-              storage = rainkybeS;
+              storage = await Storage.newFresh(chainType, rinkebyStorage);
+              break;
+            case WebbEVMChain.Beresheet:
+              storage = await Storage.newFresh(chainType, beresheetStorage);
+              break;
+            default:
+              storage = await Storage.newFresh(chainType, beresheetStorage);
               break;
           }
-          const webbWeb3Provider = await WebbWeb3Provider.init(web3Provider, rainkybeS);
+          const webbWeb3Provider = await WebbWeb3Provider.init(web3Provider, storage);
           const accounts = await webbWeb3Provider.accounts.accounts();
           setAccounts(accounts);
           await setActiveAccount(accounts[0]);
@@ -121,20 +128,24 @@ export const WebbProvider: FC<WebbProviderProps> = ({ applicationName = 'Webb Da
         });
         const web3Provider = await Web3Provider.fromWalletConnectProvider(provider);
         await web3Provider.eth.net.isListening();
-        const net = await web3Provider.netowrk;
-        const chainType = WebbWeb3Provider.chainType(net); //  use this to pick the storage
-        const rainkybeS = await Storage.newFresh(WebbEVMChain.Rinkeby, rankebyStorage);
-        const mainS = await Storage.newFresh(WebbEVMChain.Main, mainStorage);
+        const net = await web3Provider.network; // storage based on network id
+        const chainType = WebbWeb3Provider.storageName(net);
         let storage: Storage<EVMStorage>;
-        switch (chainType) {
-          case WebbEVMChain.Main:
-            storage = mainS;
-            break;
-          case WebbEVMChain.Rinkeby:
-            storage = rainkybeS;
-            break;
-        }
-        const webbWeb3Provider = await WebbWeb3Provider.init(web3Provider, rainkybeS);
+          switch (net) {
+            case WebbEVMChain.Main:
+              storage = await Storage.newFresh(chainType, mainStorage);
+              break;
+            case WebbEVMChain.Rinkeby:
+              storage = await Storage.newFresh(chainType, rinkebyStorage);
+              break;
+            case WebbEVMChain.Beresheet:
+              storage = await Storage.newFresh(chainType, beresheetStorage);
+              break;
+            default:
+              storage = await Storage.newFresh(chainType, beresheetStorage);
+              break;
+          }
+        const webbWeb3Provider = await WebbWeb3Provider.init(web3Provider, storage);
 
         const accounts = await webbWeb3Provider.accounts.accounts();
         setAccounts(accounts);

packages/react-environment/src/api-providers/web3/web3-mixer-deposit.ts

@@ -36,16 +36,15 @@ export class Web3MixerDeposit extends MixerDeposit<WebbWeb3Provider, DepositPayl
   async generateNote(mixerId: string, contractName: string = 'nativeAnchor'): Promise<DepositPayload> {
     const contract = await this.inner.getContractWithAddress(mixerId);
     const storages = await this.inner.chainStorage;
-    const mixerSize = storages[contractName].contractsAddresses.find((config) => config.address === mixerId);
-    if (!mixerSize) {
-      throw new Error(`mixer size  not found on this contract`);
+    const mixerInfo = storages[contractName].contractsInfo.find((config) => config.address === mixerId);
+    if (!mixerInfo) {
+      throw new Error(`mixer not found from storage`);
     }
 
-    const depositPayload = await contract.createDeposit();
-    console.log(depositPayload);
+    const depositPayload = await contract.createDeposit(mixerInfo.symbol);
     return {
       note: depositPayload.note,
-      params: [depositPayload.deposit, mixerSize.size],
+      params: [depositPayload.deposit, mixerInfo.size],
     };
   }
 

packages/react-environment/src/api-providers/web3/web3-mixer-withdraw.ts

@@ -11,8 +11,8 @@ export class Web3MixerWithdraw extends MixerWithdraw<WebbWeb3Provider> {
   async withdraw(note: string, recipient: string, contractName: string = 'nativeAnchor'): Promise<void> {
     this.emit('stateChange', WithdrawState.GeneratingZk);
     const evmNote = EvmNote.deserialize(note);
-    const contarct = await this.inner.getContract(evmNote.amount, contractName);
-    const txReset = await contarct.withdraw(note, recipient);
+    const contract = await this.inner.getContract(evmNote.amount, contractName);
+    const txReset = await contract.withdraw(note, recipient);
     transactionNotificationConfig.loading?.({
       address: '',
       data: undefined,