init

store/application.js

@@ -0,0 +1,981 @@
+/* eslint-disable camelcase */
+/* eslint-disable no-console, import/order */
+import Web3 from 'web3'
+
+import networkConfig from '@/networkConfig'
+import { cachedEventsLength, eventsType } from '@/constants'
+
+import MulticallABI from '@/abis/Multicall.json'
+import InstanceABI from '@/abis/Instance.abi.json'
+import TornadoProxyABI from '@/abis/TornadoProxy.abi.json'
+
+import { ACTION, ACTION_GAS } from '@/constants/variables'
+import { graph, treesInterface, EventsFactory } from '@/services'
+
+import {
+  randomBN,
+  parseNote,
+  toFixedHex,
+  saveAsFile,
+  isEmptyArray,
+  decimalPlaces,
+  parseHexNote,
+  checkCommitments,
+  buffPedersenHash
+} from '@/utils'
+
+import { buildGroth16, download, getTornadoKeys } from './snark'
+
+let groth16
+
+const websnarkUtils = require('websnark/src/utils')
+const { toWei, numberToHex, toBN, isAddress } = require('web3-utils')
+
+const getStatisticStore = (acc, { tokens }) => {
+  Object.entries(tokens).forEach(([currency, { instanceAddress }]) => {
+    acc[currency] = Object.assign({}, acc[currency])
+
+    Object.keys(instanceAddress).forEach((amount) => {
+      if (!acc[currency][amount]) {
+        acc[currency][amount] = {
+          latestDeposits: [],
+          nextDepositIndex: null,
+          anonymitySet: null
+        }
+      }
+    })
+  })
+  return acc
+}
+
+const defaultStatistics = Object.values(networkConfig).reduce(getStatisticStore, {})
+
+const state = () => {
+  return {
+    note: null,
+    commitment: null,
+    prefix: null,
+    errors: [],
+    notes: {},
+    statistic: defaultStatistics,
+    ip: {},
+    selectedInstance: { currency: 'eth', amount: 0.1 },
+    selectedStatistic: { currency: 'eth', amount: 0.1 },
+    withdrawType: 'relayer',
+    ethToReceive: '20000000000000000',
+    defaultEthToReceive: '20000000000000000',
+    withdrawNote: ''
+  }
+}
+
+const mutations = {
+  SAVE_DEPOSIT(state, { note, commitment, prefix }) {
+    state.note = note
+    state.commitment = commitment
+    state.prefix = prefix
+  },
+  SAVE_PROOF(state, { proof, args, note }) {
+    this._vm.$set(state.notes, note, { proof, args })
+  },
+  REMOVE_PROOF(state, { note }) {
+    this._vm.$delete(state.notes, note)
+  },
+  SAVE_ERROR(state, message) {
+    state.errors.push(message)
+  },
+  REMOVE_ERRORS(state) {
+    this._vm.$set(state, 'errors', [])
+  },
+  SAVE_LAST_INDEX(state, { nextDepositIndex, anonymitySet, currency, amount }) {
+    const currentState = state.statistic[currency][amount]
+    this._vm.$set(state.statistic[currency], `${amount}`, { ...currentState, nextDepositIndex, anonymitySet })
+  },
+  SAVE_LAST_EVENTS(state, { latestDeposits, currency, amount }) {
+    const currentState = state.statistic[currency][amount]
+    this._vm.$set(state.statistic[currency], `${amount}`, { ...currentState, latestDeposits })
+  },
+  SET_SELECTED_INSTANCE(state, selectedInstance) {
+    state.selectedInstance = selectedInstance
+  },
+  SET_SELECTED_STATISTIC(state, selectedStatistic) {
+    state.selectedStatistic = selectedStatistic
+  },
+  SET_WITHDRAW_TYPE(state, { withdrawType }) {
+    this._vm.$set(state, 'withdrawType', withdrawType)
+  },
+  SAVE_ETH_TO_RECEIVE(state, { ethToReceive }) {
+    this._vm.$set(state, 'ethToReceive', ethToReceive)
+  },
+  SAVE_DEFAULT_ETH_TO_RECEIVE(state, { ethToReceive }) {
+    this._vm.$set(state, 'defaultEthToReceive', ethToReceive)
+  },
+  SET_WITHDRAW_NOTE(state, withdrawNote) {
+    state.withdrawNote = withdrawNote
+  }
+}
+
+const getters = {
+  eventsInterface: (state, getters, rootState, rootGetters) => {
+    const netId = rootGetters['metamask/netId']
+    const { url } = rootState.settings[`netId${netId}`].rpc
+    return new EventsFactory(url)
+  },
+  instanceContract: (state, getters, rootState) => ({ currency, amount, netId }) => {
+    const config = networkConfig[`netId${netId}`]
+    const { url } = rootState.settings[`netId${netId}`].rpc
+    const address = config.tokens[currency].instanceAddress[amount]
+    const web3 = new Web3(url)
+    return new web3.eth.Contract(InstanceABI, address)
+  },
+  multicallContract: (state, getters, rootState) => ({ netId }) => {
+    const config = networkConfig[`netId${netId}`]
+    const { url } = rootState.settings[`netId${netId}`].rpc
+    const web3 = new Web3(url)
+    return new web3.eth.Contract(MulticallABI, config.multicall)
+  },
+  tornadoProxyContract: (state, getters, rootState) => ({ netId }) => {
+    const {
+      'tornado-proxy.contract.tornadocash.eth': tornadoProxy,
+      'tornado-router.contract.tornadocash.eth': tornadoRouter,
+      'tornado-proxy-light.contract.tornadocash.eth': tornadoProxyLight
+    } = networkConfig[`netId${netId}`]
+
+    const proxyContract = tornadoRouter || tornadoProxy || tornadoProxyLight
+    const { url } = rootState.settings[`netId${netId}`].rpc
+    const web3 = new Web3(url)
+    return new web3.eth.Contract(TornadoProxyABI, proxyContract)
+  },
+  currentContract: (state, getters) => (params) => {
+    return getters.tornadoProxyContract(params)
+  },
+  withdrawGas: (state, getters, rootState, rootGetters) => {
+    const netId = rootGetters['metamask/netId']
+    let action = ACTION.WITHDRAW_WITH_EXTRA
+
+    if (getters.hasEnabledLightProxy) {
+      action = ACTION.WITHDRAW
+    }
+
+    if (Number(netId) === 10) {
+      action = ACTION.OP_WITHDRAW
+    }
+
+    if (Number(netId) === 42161) {
+      action = ACTION.ARB_WITHDRAW
+    }
+
+    return ACTION_GAS[action]
+  },
+  networkFee: (state, getters, rootState, rootGetters) => {
+    const gasPrice = rootGetters['gasPrices/fastGasPrice']
+
+    return toBN(gasPrice).mul(toBN(getters.withdrawGas))
+  },
+  relayerFee: (state, getters, rootState, rootGetters) => {
+    const { currency, amount } = rootState.application.selectedStatistic
+    const { decimals } = rootGetters['metamask/networkConfig'].tokens[currency]
+    const nativeCurrency = rootGetters['metamask/nativeCurrency']
+    const total = toBN(rootGetters['token/fromDecimals'](amount.toString()))
+    const fee = rootState.relayer.selectedRelayer.tornadoServiceFee
+    const decimalsPoint = decimalPlaces(fee)
+    const roundDecimal = 10 ** decimalsPoint
+    const aroundFee = toBN(parseInt(fee * roundDecimal, 10))
+    const tornadoServiceFee = total.mul(aroundFee).div(toBN(roundDecimal * 100))
+    const ethFee = getters.networkFee
+    switch (currency) {
+      case nativeCurrency: {
+        return ethFee.add(tornadoServiceFee)
+      }
+      default: {
+        const tokenFee = ethFee.mul(toBN(10 ** decimals)).div(toBN(rootState.price.prices[currency]))
+        return tokenFee.add(tornadoServiceFee)
+      }
+    }
+  },
+  ethToReceiveInToken: (state, getters, rootState, rootGetters) => {
+    const { currency } = rootState.application.selectedStatistic
+    const { decimals } = rootGetters['metamask/networkConfig'].tokens[currency]
+    const price = rootState.price.prices[currency]
+    const ethToReceive = toBN(state.ethToReceive)
+    return ethToReceive.mul(toBN(10 ** decimals)).div(toBN(price))
+  },
+  isNotEnoughTokens: (state, getters, rootState, rootGetters) => {
+    const { amount, currency } = rootState.application.selectedStatistic
+    let total = toBN(rootGetters['token/fromDecimals'](amount.toString()))
+
+    if (state.withdrawType === 'relayer') {
+      const relayerFee = getters.relayerFee
+      const nativeCurrency = rootGetters['metamask/nativeCurrency']
+
+      if (currency === nativeCurrency) {
+        total = total.sub(relayerFee)
+      } else {
+        const ethToReceiveInToken = getters.ethToReceiveInToken
+        total = total.sub(relayerFee).sub(ethToReceiveInToken)
+      }
+    }
+
+    return total.isNeg()
+  },
+  maxEthToReceive: (state, getters, rootState, rootGetters) => {
+    const { currency, amount } = rootState.application.selectedStatistic
+    const { decimals } = rootGetters['metamask/networkConfig'].tokens[currency]
+    const total = toBN(rootGetters['token/fromDecimals'](amount.toString()))
+    const price = rootState.price.prices[currency]
+    const relayerFee = getters.relayerFee
+    return total
+      .sub(relayerFee)
+      .mul(toBN(price))
+      .div(toBN(10 ** decimals))
+  },
+  selectedCurrency: (state, getters, rootState, rootGetters) => {
+    const tokens = rootGetters['metamask/networkConfig'].tokens
+    return tokens[state.selectedInstance.currency].symbol
+  },
+  selectedStatisticCurrency: (state, getters, rootState, rootGetters) => {
+    const tokens = rootGetters['metamask/networkConfig'].tokens
+    return tokens[state.selectedStatistic.currency].symbol
+  },
+  lastEventIndex: (state) => ({ currency, amount }) => {
+    return state.statistic[currency][amount].anonymitySet
+  },
+  latestDeposits: (state) => {
+    const { currency, amount } = state.selectedStatistic
+    return state.statistic[currency][amount].latestDeposits
+  },
+  hasEnabledLightProxy: (state, getters, rootState, rootGetters) => {
+    return Boolean(rootGetters['metamask/networkConfig']['tornado-proxy-light.contract.tornadocash.eth'])
+  }
+}
+
+const actions = {
+  setAndUpdateStatistic({ dispatch, commit }, { currency, amount }) {
+    commit('SET_SELECTED_STATISTIC', { currency, amount })
+    dispatch('updateSelectEvents')
+  },
+  async updateSelectEvents({ dispatch, commit, state, rootGetters, getters }) {
+    const netId = rootGetters['metamask/netId']
+    const { currency, amount } = state.selectedStatistic
+    const { deployedBlock } = networkConfig[`netId${netId}`]
+
+    const eventService = getters.eventsInterface.getService({ netId, amount, currency })
+
+    const savedEvents = await eventService.getEvents(eventsType.DEPOSIT)
+    const fromBlock = savedEvents?.lastBlock || deployedBlock
+
+    const graphEvents = await eventService.getEventsFromGraph({ fromBlock, methodName: 'getStatistic' })
+
+    let statistic = graphEvents?.events
+
+    if (!statistic || !statistic.length) {
+      const fresh = await eventService.getStatisticsRpc({ fromBlock, eventsCount: 10 })
+
+      statistic = fresh || []
+    }
+
+    const { nextDepositIndex, anonymitySet } = await dispatch('getLastDepositIndex', {
+      currency,
+      amount,
+      netId
+    })
+
+    statistic = statistic.sort((a, b) => a.leafIndex - b.leafIndex)
+
+    const latestDeposits = []
+
+    for (const event of statistic.slice(-10)) {
+      latestDeposits.unshift({
+        index: event.leafIndex,
+        depositTime: this.$moment.unix(event.timestamp).fromNow()
+      })
+    }
+
+    commit('SAVE_LAST_EVENTS', {
+      amount,
+      currency,
+      latestDeposits
+    })
+    commit('SAVE_LAST_INDEX', {
+      amount,
+      currency,
+      anonymitySet,
+      nextDepositIndex
+    })
+  },
+  async updateEvents({ getters, rootGetters }, payload) {
+    try {
+      const eventService = getters.eventsInterface.getService(payload)
+
+      const freshEvents = await eventService.updateEvents(payload.type)
+
+      return freshEvents
+    } catch (err) {
+      throw new Error(`Method updateEvents has error: ${err.message}`)
+    }
+  },
+  async updateCurrentEvents({ dispatch, rootGetters }, { amount, currency, lastEvent, type, netId }) {
+    let lastBlock = lastEvent
+    const nativeCurrency = rootGetters['metamask/nativeCurrency']
+    const { deployedBlock } = networkConfig[`netId${netId}`]
+
+    if (currency === nativeCurrency && !lastEvent) {
+      lastBlock = await this.$indexedDB.getFromIndex({
+        indexName: 'name',
+        storeName: `lastEvents_${netId}`,
+        key: `${type}s_${currency}_${amount}`
+      })
+    }
+
+    const params = {
+      type,
+      netId,
+      amount,
+      currency,
+      fromBlock: lastBlock ? lastBlock.blockNumber + 1 : deployedBlock
+    }
+
+    const events = await dispatch('updateEvents', params)
+
+    return events
+  },
+  async getLastDepositIndex({ getters }, params) {
+    try {
+      const contractInstance = getters.instanceContract(params)
+      const nextDepositIndex = await contractInstance.methods.nextIndex().call()
+
+      return {
+        nextDepositIndex,
+        anonymitySet: toBN(nextDepositIndex)
+      }
+    } catch (err) {
+      throw new Error(`Method getLastDepositIndex has error: ${err.message}`)
+    }
+  },
+  async loadEncryptedEvents(_, { netId }) {
+    try {
+      const module = await download({
+        contentType: 'string',
+        name: `events/encrypted_notes_${netId}.json.zip`
+      })
+
+      if (module) {
+        const events = JSON.parse(module)
+
+        return {
+          events,
+          lastBlock: events[events.length - 1].blockNumber
+        }
+      }
+    } catch (err) {
+      throw new Error(`Method loadCachedEvents has error: ${err.message}`)
+    }
+  },
+  prepareDeposit({ getters, dispatch, commit, rootGetters }, { prefix }) {
+    try {
+      const [, currency, amount, netId] = prefix.split('-')
+      const contractInstance = getters.instanceContract({ currency, amount, netId })
+
+      const secret = randomBN(31)
+      const nullifier = randomBN(31)
+
+      const preimage = Buffer.concat([nullifier.toBuffer('le', 31), secret.toBuffer('le', 31)])
+
+      const commitment = buffPedersenHash(preimage)
+      const commitmentHex = toFixedHex(commitment)
+
+      const note = `0x${preimage.toString('hex')}`
+
+      const isEnabled = rootGetters['encryptedNote/isEnabledSaveFile']
+
+      if (isEnabled) {
+        setTimeout(() => {
+          try {
+            dispatch('saveFile', { prefix, note })
+          } catch (err) {
+            console.warn('NoteAccount backup as a file is not supported on this device', err)
+          }
+        }, 1000)
+      }
+
+      commit('SAVE_DEPOSIT', { note, commitment: commitmentHex, prefix })
+      if (!contractInstance._address) {
+        throw new Error(this.app.i18n.t('networkIsNotSupported'))
+      }
+    } catch (e) {
+      console.error('prepareDeposit', e)
+    }
+  },
+  saveFile(_, { prefix, note }) {
+    try {
+      const data = new Blob([`${prefix}-${note}`], { type: 'text/plain;charset=utf-8' })
+
+      saveAsFile(data, `backup-${prefix}-${note.slice(0, 10)}.txt`)
+    } catch (err) {
+      console.error('saveFile', err.message)
+    }
+  },
+  async getEncryptedEventsFromDb(_, { netId }) {
+    try {
+      if (this.$indexedDB.isBlocked) {
+        return []
+      }
+
+      const cachedEvents = await this.$indexedDB.getAll({ storeName: `encrypted_events_${netId}` })
+
+      return cachedEvents
+    } catch (err) {
+      console.warn(`Method getEventsFromDb has error: ${err.message}`)
+    }
+  },
+  async getEncryptedNotes({ rootState, rootGetters, dispatch, getters }) {
+    try {
+      const { netId } = rootState.metamask
+      const rpc = rootGetters['settings/currentRpc']
+      let { NOTE_ACCOUNT_BLOCK: deployedBlock } = networkConfig[`netId${netId}`].constants
+
+      const contractInstance = getters.tornadoProxyContract({ netId })
+
+      let cachedEvents = await dispatch('getEncryptedEventsFromDb', { netId })
+
+      const networksWithCache = [1, 5]
+
+      const LENGTH_CACHE =
+        Number(netId) === 1
+          ? cachedEventsLength.mainnet.ENCRYPTED_NOTES
+          : cachedEventsLength.goerli.ENCRYPTED_NOTES
+
+      if (
+        ((isEmptyArray(cachedEvents) || !cachedEvents) && networksWithCache.includes(netId)) ||
+        (cachedEvents.length < LENGTH_CACHE && networksWithCache.includes(netId))
+      ) {
+        ;({ events: cachedEvents } = await dispatch('loadEncryptedEvents', { netId }))
+      }
+
+      const hasCache = Boolean(cachedEvents && cachedEvents.length)
+
+      if (hasCache) {
+        const [lastEvent] = cachedEvents.sort((a, b) => a.blockNumber - b.blockNumber).slice(-1)
+
+        deployedBlock = lastEvent.blockNumber + 1
+      }
+
+      const web3 = this.$provider.getWeb3(rpc.url)
+      const currentBlockNumber = await web3.eth.getBlockNumber()
+
+      let events = []
+
+      const { events: graphEvents, lastSyncBlock } = await graph.getAllEncryptedNotes({
+        netId,
+        fromBlock: deployedBlock
+      })
+
+      if (!isEmptyArray(graphEvents)) {
+        deployedBlock = lastSyncBlock
+      }
+
+      let NUMBER_PARTS = hasCache ? 2 : 10
+
+      if (Number(netId) === 56) {
+        NUMBER_PARTS = parseInt((currentBlockNumber - deployedBlock) / 4950) || 1
+      }
+
+      const part = parseInt((currentBlockNumber - deployedBlock) / NUMBER_PARTS)
+
+      let fromBlock = deployedBlock
+      let toBlock = deployedBlock + part
+
+      if (toBlock >= currentBlockNumber || toBlock === deployedBlock) {
+        toBlock = 'latest'
+        NUMBER_PARTS = 1
+      }
+
+      for (let i = 0; i < NUMBER_PARTS; i++) {
+        const partOfEvents = await contractInstance.getPastEvents('EncryptedNote', {
+          toBlock,
+          fromBlock
+        })
+        if (partOfEvents) {
+          events = events.concat(partOfEvents)
+        }
+        fromBlock = toBlock
+        toBlock += part
+      }
+
+      if (events && events.length) {
+        events = events
+          .filter((i) => i.returnValues.encryptedNote)
+          .map((e) => ({
+            txHash: e.transactionHash,
+            transactionHash: e.transactionHash,
+            blockNumber: Number(e.blockNumber),
+            encryptedNote: e.returnValues.encryptedNote
+          }))
+      }
+
+      const allEvents = [].concat(cachedEvents, graphEvents, events)
+
+      await dispatch('saveEncryptedEventsToDB', { events: allEvents, netId })
+
+      return allEvents
+    } catch (err) {
+      console.log('getEncryptedNotes', err)
+    }
+  },
+  async saveEncryptedEventsToDB(_, { events, netId }) {
+    if (!events || !events.length || this.$indexedDB.isBlocked) {
+      return
+    }
+
+    await this.$indexedDB.createMultipleTransactions({
+      data: events,
+      storeName: `encrypted_events_${netId}`
+    })
+  },
+  async sendDeposit({ state, rootState, getters, rootGetters, dispatch, commit }, { isEncrypted, gasPrice }) {
+    try {
+      const { commitment, note, prefix } = state
+      // eslint-disable-next-line prefer-const
+      let [, currency, amount, netId] = prefix.split('-')
+      const config = networkConfig[`netId${netId}`]
+      const contractInstance = getters.tornadoProxyContract({ netId })
+
+      if (!state.commitment) {
+        throw new Error(this.app.i18n.t('failToGenerateNote'))
+      }
+
+      const { nextDepositIndex: index } = await dispatch('getLastDepositIndex', { netId, currency, amount })
+
+      const { ethAccount } = rootState.metamask
+      const nativeCurrency = rootGetters['metamask/nativeCurrency']
+      const isNative = currency === nativeCurrency
+
+      const value = isNative ? toWei(amount, 'ether') : '0'
+      const instance = config.tokens[currency].instanceAddress[amount]
+
+      let params = [instance, commitment, []]
+
+      if (isEncrypted) {
+        const encryptedNote = await dispatch(
+          'encryptedNote/getEncryptedNote',
+          { data: `${instance}-${note}` },
+          { root: true }
+        )
+
+        params = [instance, commitment, encryptedNote]
+      }
+
+      const data = contractInstance.methods.deposit(...params).encodeABI()
+      const gas = await contractInstance.methods.deposit(...params).estimateGas({ from: ethAccount, value })
+
+      const callParams = {
+        method: 'eth_sendTransaction',
+        params: {
+          gasPrice,
+          to: contractInstance._address,
+          gas: numberToHex(gas + 50000),
+          value: numberToHex(value),
+          data
+        },
+        watcherParams: {
+          title: { path: 'depositing', amount, currency },
+          successTitle: {
+            path: 'depositedValue',
+            amount,
+            currency
+          },
+          storeType: isEncrypted ? 'encryptedTxs' : 'txs'
+        },
+        isAwait: false
+      }
+
+      const txHash = await dispatch('metamask/sendTransaction', callParams, { root: true })
+
+      // there may be a race condition, you need to request an index and a timestamp of the deposit after tx is mined
+      const timestamp = Math.round(new Date().getTime() / 1000)
+
+      const { nullifierHex, commitmentHex } = parseHexNote(state.note)
+      const storeType = isEncrypted ? 'encryptedTxs' : 'txs'
+
+      const accounts = rootGetters['encryptedNote/accounts']
+
+      const tx = {
+        txHash,
+        type: 'Deposit',
+        note,
+        amount,
+        storeType,
+        prefix,
+        netId,
+        timestamp,
+        index,
+        nullifierHex,
+        commitmentHex,
+        currency
+      }
+      console.log('tx', tx)
+
+      if (isEncrypted) {
+        tx.note = params[2]
+        tx.owner = isAddress(accounts.encrypt) ? accounts.encrypt : ''
+        tx.backupAccount = isAddress(accounts.backup) ? accounts.backup : ''
+      }
+
+      commit('txHashKeeper/SAVE_TX_HASH', tx, { root: true })
+    } catch (e) {
+      console.error('sendDeposit', e)
+      return false
+    }
+  },
+  async checkSpentEventFromNullifier({ getters, dispatch }, parsedNote) {
+    try {
+      const isSpent = await dispatch('loadEvent', {
+        note: parsedNote,
+        eventName: 'nullifierHash',
+        type: eventsType.WITHDRAWAL,
+        methodName: 'getAllWithdrawals',
+        eventToFind: parsedNote.nullifierHex
+      })
+
+      return Boolean(isSpent)
+    } catch (err) {
+      console.error(`Method checkSpentEventFromNullifier has error: ${err.message}`)
+    }
+  },
+  async checkRoot({ getters }, { root, parsedNote }) {
+    const contractInstance = getters.instanceContract(parsedNote)
+
+    const isKnownRoot = await contractInstance.methods.isKnownRoot(root).call()
+
+    if (!isKnownRoot) {
+      throw new Error(this.app.i18n.t('invalidRoot'))
+    }
+  },
+  async buildTree({ dispatch }, { currency, amount, netId, commitmentHex }) {
+    const treeInstanceName = `${currency}_${amount}_${netId}`
+    const params = { netId, amount, currency }
+
+    const treeService = treesInterface.getService({
+      ...params,
+      commitment: commitmentHex,
+      instanceName: treeInstanceName
+    })
+
+    const [cachedTree, eventsData] = await Promise.all([
+      treeService.getTree(),
+      dispatch('updateEvents', { ...params, type: eventsType.DEPOSIT })
+    ])
+
+    const commitments = eventsData.events.map((el) => el.commitment.toString(10))
+
+    let tree = cachedTree
+    if (tree) {
+      const newLeaves = commitments.slice(tree.elements.length)
+      tree.bulkInsert(newLeaves)
+    } else {
+      console.log('events', eventsData)
+      checkCommitments(eventsData.events)
+      tree = treeService.createTree({ events: commitments })
+    }
+
+    const root = toFixedHex(tree.root)
+    await dispatch('checkRoot', { root, parsedNote: params })
+
+    await treeService.saveTree({ tree })
+
+    return { tree, root }
+  },
+  async createSnarkProof(
+    { rootGetters, rootState, state, getters },
+    { root, note, tree, recipient, leafIndex }
+  ) {
+    const { pathElements, pathIndices } = tree.path(leafIndex)
+    console.log('pathElements, pathIndices', pathElements, pathIndices)
+
+    const nativeCurrency = rootGetters['metamask/nativeCurrency']
+    const withdrawType = state.withdrawType
+
+    let relayer = BigInt(recipient)
+    let fee = BigInt(0)
+    let refund = BigInt(0)
+
+    if (withdrawType === 'relayer') {
+      let totalRelayerFee = getters.relayerFee
+      relayer = BigInt(rootState.relayer.selectedRelayer.address)
+
+      if (note.currency !== nativeCurrency) {
+        refund = BigInt(state.ethToReceive.toString())
+        totalRelayerFee = totalRelayerFee.add(getters.ethToReceiveInToken)
+      }
+
+      fee = BigInt(totalRelayerFee.toString())
+    }
+
+    const input = {
+      // public
+      fee,
+      root,
+      refund,
+      relayer,
+      recipient: BigInt(recipient),
+      nullifierHash: note.nullifierHash,
+      // private
+      pathIndices,
+      pathElements,
+      secret: note.secret,
+      nullifier: note.nullifier
+    }
+
+    const { circuit, provingKey } = await getTornadoKeys()
+
+    if (!groth16) {
+      groth16 = await buildGroth16()
+    }
+
+    console.log('Start generating SNARK proof', input)
+    console.time('SNARK proof time')
+    const proofData = await websnarkUtils.genWitnessAndProve(groth16, input, circuit, provingKey)
+    const { proof } = websnarkUtils.toSolidityInput(proofData)
+
+    const args = [
+      toFixedHex(input.root),
+      toFixedHex(input.nullifierHash),
+      toFixedHex(input.recipient, 20),
+      toFixedHex(input.relayer, 20),
+      toFixedHex(input.fee),
+      toFixedHex(input.refund)
+    ]
+    return { args, proof }
+  },
+  async prepareWithdraw({ dispatch, getters, commit }, { note, recipient }) {
+    commit('REMOVE_ERRORS')
+    commit('REMOVE_PROOF', { note })
+    try {
+      const parsedNote = parseNote(note)
+
+      const { tree, root } = await dispatch('buildTree', parsedNote)
+
+      const isSpent = await dispatch('checkSpentEventFromNullifier', parsedNote)
+
+      if (isSpent) {
+        throw new Error(this.app.i18n.t('noteHasBeenSpent'))
+      }
+
+      const { proof, args } = await dispatch('createSnarkProof', {
+        root,
+        tree,
+        recipient,
+        note: parsedNote,
+        leafIndex: tree.indexOf(parsedNote.commitmentHex)
+      })
+      console.timeEnd('SNARK proof time')
+      commit('SAVE_PROOF', { proof, args, note })
+    } catch (e) {
+      console.error('prepareWithdraw', e)
+      commit('SAVE_ERROR', e.message)
+    }
+  },
+  async withdraw({ state, rootState, dispatch, getters }, { note }) {
+    try {
+      const [, currency, amount, netId] = note.split('-')
+      const config = networkConfig[`netId${netId}`]
+      const { proof, args } = state.notes[note]
+      const { ethAccount } = rootState.metamask
+
+      const contractInstance = getters.tornadoProxyContract({ netId })
+
+      const instance = config.tokens[currency].instanceAddress[amount]
+      const params = [instance, proof, ...args]
+
+      const data = contractInstance.methods.withdraw(...params).encodeABI()
+      const gas = await contractInstance.methods
+        .withdraw(...params)
+        .estimateGas({ from: ethAccount, value: args[5] })
+
+      const callParams = {
+        method: 'eth_sendTransaction',
+        params: {
+          data,
+          value: args[5],
+          to: contractInstance._address,
+          gas: numberToHex(gas + 200000)
+        },
+        watcherParams: {
+          title: { path: 'withdrawing', amount, currency },
+          successTitle: {
+            amount,
+            currency,
+            path: 'withdrawnValue'
+          },
+          onSuccess: (txHash) => {
+            dispatch('txHashKeeper/updateDeposit', { amount, currency, netId, note, txHash }, { root: true })
+          }
+        },
+        isAwait: false,
+        isSaving: false
+      }
+
+      await dispatch('metamask/sendTransaction', callParams, { root: true })
+    } catch (e) {
+      console.error(e)
+      throw new Error(e.message)
+    }
+  },
+  loadAllNotesData({ dispatch, rootGetters }) {
+    const { tokens } = rootGetters['metamask/networkConfig']
+
+    for (const [currency, { instanceAddress }] of Object.entries(tokens)) {
+      for (const amount in instanceAddress) {
+        if (instanceAddress[amount]) {
+          dispatch('updateLastIndex', { currency, amount })
+        }
+      }
+    }
+  },
+  async updateLastIndex({ dispatch, commit, rootState }, { currency, amount }) {
+    const netId = rootState.metamask.netId
+    const { nextDepositIndex, anonymitySet } = await dispatch('getLastDepositIndex', {
+      currency,
+      netId,
+      amount
+    })
+
+    commit('SAVE_LAST_INDEX', {
+      amount,
+      currency,
+      anonymitySet,
+      nextDepositIndex
+    })
+  },
+  async loadEvent({ getters, rootGetters }, { note, type, eventName, eventToFind }) {
+    try {
+      const eventService = getters.eventsInterface.getService(note)
+
+      const foundEvent = await eventService.findEvent({ eventName, eventToFind, type })
+
+      return foundEvent
+    } catch (err) {
+      console.error(`Method loadEvent has error: ${err.message}`)
+    }
+  },
+  async loadDepositEvent({ state, dispatch }, { withdrawNote }) {
+    try {
+      const note = parseNote(withdrawNote)
+
+      const lastEvent = await dispatch('loadEvent', {
+        note,
+        eventName: 'commitment',
+        type: eventsType.DEPOSIT,
+        methodName: 'getAllDeposits',
+        eventToFind: note.commitmentHex
+      })
+
+      if (lastEvent) {
+        const { nextDepositIndex } = state.statistic[note.currency][note.amount]
+        const depositsPast = nextDepositIndex - lastEvent.leafIndex - 1
+
+        const isSpent = await dispatch('checkSpentEventFromNullifier', note)
+
+        return {
+          isSpent,
+          depositsPast,
+          timestamp: lastEvent.timestamp,
+          leafIndex: lastEvent.leafIndex,
+          txHash: lastEvent.transactionHash,
+          depositBlock: lastEvent.blockNumber
+        }
+      }
+    } catch (err) {
+      console.error(`Method loadDepositEvent has error: ${err.message}`)
+    }
+  },
+  async loadWithdrawalEvent({ dispatch }, { withdrawNote }) {
+    try {
+      const note = parseNote(withdrawNote)
+
+      const lastEvent = await dispatch('loadEvent', {
+        note,
+        eventName: 'nullifierHash',
+        type: eventsType.WITHDRAWAL,
+        methodName: 'getAllWithdrawals',
+        eventToFind: note.nullifierHex
+      })
+
+      if (lastEvent) {
+        return {
+          to: lastEvent.to,
+          fee: lastEvent.fee,
+          txHash: lastEvent.transactionHash,
+          blockNumber: lastEvent.blockNumber
+        }
+      }
+    } catch (err) {
+      console.error(`Method loadWithdrawalEvent has error: ${err.message}`)
+    }
+  },
+  async loadWithdrawalData({ commit, dispatch, rootGetters }, { withdrawNote }) {
+    try {
+      const toDecimals = rootGetters['token/toDecimals']
+
+      const { currency, amount } = parseNote(withdrawNote)
+      const { fee, txHash, blockNumber, to } = await dispatch('loadWithdrawalEvent', { withdrawNote })
+
+      const decimals = rootGetters['metamask/networkConfig'].tokens[currency].decimals
+      const withdrawalAmount = toBN(rootGetters['token/fromDecimals'](amount.toString(), decimals)).sub(
+        toBN(fee)
+      )
+
+      return {
+        to,
+        txHash,
+        withdrawalBlock: blockNumber,
+        fee: toDecimals(fee, decimals, 4),
+        amount: toDecimals(withdrawalAmount, decimals, 4)
+      }
+    } catch (e) {
+      console.error(`Method loadWithdrawalData has error: ${e}`)
+      commit('SAVE_ERROR', e.message)
+    }
+  },
+  calculateEthToReceive({ commit, state, rootGetters }, { currency }) {
+    const gasLimit = rootGetters['metamask/networkConfig'].tokens[currency].gasLimit
+    const gasPrice = toBN(rootGetters['gasPrices/fastGasPrice'])
+
+    const ethToReceive = gasPrice
+      .mul(toBN(gasLimit))
+      .mul(toBN(2))
+      .toString()
+    return ethToReceive
+  },
+  async setDefaultEthToReceive({ dispatch, commit }, { currency }) {
+    const ethToReceive = await dispatch('calculateEthToReceive', { currency })
+    commit('SAVE_ETH_TO_RECEIVE', { ethToReceive })
+    commit('SAVE_DEFAULT_ETH_TO_RECEIVE', { ethToReceive })
+  },
+  setNativeCurrency({ commit }, { netId }) {
+    const currency = networkConfig[`netId${netId}`].nativeCurrency
+    const amounts = Object.keys(networkConfig[`netId${netId}`].tokens[currency].instanceAddress)
+    const amount = Math.min(...amounts)
+
+    commit('SET_SELECTED_INSTANCE', { currency, amount })
+    commit('SET_SELECTED_STATISTIC', { currency, amount })
+  },
+  async aggregateMulticall({ rootGetters, getters }, { params }) {
+    try {
+      const netId = rootGetters['metamask/netId']
+      const multicallContract = getters.multicallContract({ netId })
+
+      const result = await multicallContract.methods.aggregate(params).call()
+
+      return result.returnData
+    } catch (err) {
+      console.log('err', err.message)
+    }
+  }
+}
+export default {
+  namespaced: true,
+  state,
+  getters,
+  mutations,
+  actions
+}