classic-ui/store/governance/gov.js

/* eslint-disable no-console */
/* eslint-disable import/order */

import Web3 from 'web3'
import { utils } from 'ethers'
import { ToastProgrammatic as Toast } from 'buefy'

import networkConfig from '@/networkConfig'

import GovernanceABI from '@/abis/Governance.abi.json'
import AggregatorABI from '@/abis/Aggregator.abi.json'

import { httpConfig } from '@/constants'

const { numberToHex, toWei, fromWei, toBN, hexToNumber, hexToNumberString } = require('web3-utils')

const state = () => {
  return {
    approvalAmount: 'unlimited',
    lockedBalance: '0',
    isFetchingLockedBalance: false,
    currentDelegate: '0x0000000000000000000000000000000000000000',
    timestamp: 0,
    delegatedBalance: '0',
    isFetchingDelegatedBalance: false,
    delegators: [],
    latestProposalId: {
      value: null,
      status: null
    },
    isFetchingProposals: true,
    isCastingVote: false,
    proposals: [],
    voterReceipts: [],
    hasActiveProposals: false,
    constants: {
      EXECUTION_DELAY: 172800,
      EXECUTION_EXPIRATION: 259200,
      PROPOSAL_THRESHOLD: '1000000000000000000000',
      QUORUM_VOTES: '25000000000000000000000',
      VOTING_PERIOD: 432000
    }
  }
}

const getters = {
  getConfig: (state, getters, rootState) => ({ netId }) => {
    return networkConfig[`netId${netId}`]
  },
  getWeb3: (state, getters, rootState) => ({ netId }) => {
    const { url } = rootState.settings[`netId${netId}`].rpc
    const httpProvider = new Web3.providers.HttpProvider(url, httpConfig)

    return new Web3(httpProvider)
  },
  govContract: (state, getters, rootState) => ({ netId }) => {
    const config = getters.getConfig({ netId })
    const address = config['governance.contract.tornadocash.eth']
    if (address) {
      const web3 = getters.getWeb3({ netId })
      const contract = new web3.eth.Contract(GovernanceABI, address)
      return contract
    }

    return null
  },
  aggregatorContract: (state, getters, rootState, rootGetters) => {
    const { aggregatorContract } = rootGetters['metamask/networkConfig']
    const { url } = rootGetters['settings/currentRpc']
    const web3 = new Web3(url)
    return new web3.eth.Contract(AggregatorABI, aggregatorContract)
  },
  isFetchingProposals: ({ proposals, isFetchingProposals }) => {
    if (proposals && proposals.length && !isFetchingProposals) {
      return false
    }

    return isFetchingProposals
  },
  votingPower: (state) => {
    return toBN(state.lockedBalance)
      .add(toBN(state.delegatedBalance))
      .toString(10)
  },
  quorumVotes: (state, getters, rootState, rootGetters) => {
    return rootGetters['token/toDecimals'](state.constants.QUORUM_VOTES, 18)
  },
  votingPeriod: (state) => {
    return toBN(state.constants.VOTING_PERIOD)
      .divRound(toBN(24 * 60 * 60))
      .toNumber()
  },
  isEnabledGovernance: (state, getters, rootState, rootGetters) => {
    return Boolean(rootGetters['metamask/networkConfig']['governance.contract.tornadocash.eth'])
  },
  constants: (state) => {
    return state.constants
  },
  isFetchingBalances: (state) => {
    return state.isFetchingLockedBalance || state.isFetchingDelegatedBalance
  }
}

const mutations = {
  SET_APPROVAL_AMOUNT(state, { approvalAmount }) {
    state.approvalAmount = approvalAmount
  },
  SAVE_FETCHING_PROPOSALS(state, status) {
    this._vm.$set(state, 'isFetchingProposals', status)
  },
  SAVE_CASTING_VOTE(state, status) {
    this._vm.$set(state, 'isCastingVote', status)
  },
  SAVE_LOCKED_BALANCE(state, { balance }) {
    this._vm.$set(state, 'lockedBalance', balance)
  },
  SAVE_FETCHING_LOCKED_BALANCE(state, status) {
    this._vm.$set(state, 'isFetchingLockedBalance', status)
  },
  SAVE_LOCKED_TIMESTAMP(state, { timestamp }) {
    this._vm.$set(state, 'timestamp', timestamp)
  },
  SAVE_LATEST_PROPOSAL_ID(state, { id, status }) {
    this._vm.$set(state, 'latestProposalId', { value: id, status })
  },
  SAVE_DELEGATEE(state, { currentDelegate }) {
    this._vm.$set(state, 'currentDelegate', currentDelegate)
  },
  SAVE_PROPOSALS(state, proposals) {
    this._vm.$set(state, 'proposals', proposals)
  },
  SAVE_VOTER_RECEIPT(state, { hasVoted, support, balance, id }) {
    this._vm.$set(state.voterReceipts, id, { hasVoted, support, balance })
  },
  SAVE_DELEGATED_BALANCE(state, balance) {
    this._vm.$set(state, 'delegatedBalance', balance)
  },
  SAVE_FETCHING_DELEGATED_BALANCE(state, status) {
    this._vm.$set(state, 'isFetchingDelegatedBalance', status)
  },
  SAVE_DELEGATORS(state, uniq) {
    this._vm.$set(state, 'delegators', uniq)
  },
  SET_HAS_ACTIVE_PROPOSALS(state, condition) {
    this._vm.$set(state, 'hasActiveProposals', condition)
  },
  SAVE_CONSTANTS(state, constants) {
    this._vm.$set(state, 'constants', constants)
  }
}

// enum ProposalState { Pending, Active, Defeated, Timelocked, AwaitingExecution, Executed, Expired }

const ProposalState = [
  'pending',
  'active',
  'defeated',
  'timeLocked',
  'awaitingExecution',
  'executed',
  'expired'
]

const proposalIntervalConstants = [
  // 'CLOSING_PERIOD',
  'EXECUTION_DELAY',
  'EXECUTION_EXPIRATION',
  // 'VOTE_EXTEND_TIME',
  // 'VOTING_DELAY',
  'VOTING_PERIOD'
]

const govConstants = ['PROPOSAL_THRESHOLD', 'QUORUM_VOTES']

const actions = {
  async createProposal(
    { getters, rootGetters, state, commit, rootState, dispatch },
    { proposalAddress, title, description }
  ) {
    try {
      const { ethAccount } = rootState.metamask
      const { lockedBalance, constants, delegators } = state
      const netId = rootGetters['metamask/netId']

      const proposalThreshold = toBN(constants.PROPOSAL_THRESHOLD)
      const proposeIndependently = toBN(lockedBalance).gte(proposalThreshold)

      const govInstance = getters.govContract({ netId })
      const json = JSON.stringify({ title, description })
      const delegatorAddress = delegators[delegators.length - 1]

      let data, gas

      if (proposeIndependently) {
        data = await govInstance.methods.propose(proposalAddress, json).encodeABI()
        gas = await govInstance.methods.propose(proposalAddress, json).estimateGas({
          from: ethAccount,
          value: 0
        })
      } else {
        data = await govInstance.methods
          .proposeByDelegate(delegatorAddress, proposalAddress, json)
          .encodeABI()
        gas = await govInstance.methods
          .proposeByDelegate(delegatorAddress, proposalAddress, json)
          .estimateGas({
            from: ethAccount,
            value: 0
          })
      }

      const callParams = {
        method: 'eth_sendTransaction',
        params: {
          to: govInstance._address,
          gas: numberToHex(gas + 100000),
          data
        },
        watcherParams: {
          title: 'creatingProposal',
          successTitle: 'proposalCreated',
          storeType: 'govTxs',
          onSuccess: () => {
            dispatch('torn/fetchTokenBalance', {}, { root: true })
          }
        },
        isSaving: false
      }

      const txHash = await dispatch('metamask/sendTransaction', callParams, { root: true })

      commit(
        'txHashKeeper/SAVE_TX_HASH',
        {
          txHash,
          storeType: 'govTxs',
          type: 'Proposal',
          netId
        },
        { root: true }
      )

      await dispatch('fetchProposals', { requestId: state.proposals.length })

      this.$router.push('/governance')
    } catch (e) {
      console.error('createProposal', e.message)
      dispatch(
        'notice/addNoticeWithInterval',
        {
          notice: {
            title: 'internalError',
            type: 'danger'
          },
          interval: 3000
        },
        { root: true }
      )
    }
  },
  async lock({ getters, rootGetters, commit, rootState, dispatch }) {
    try {
      const { ethAccount } = rootState.metamask
      const netId = rootGetters['metamask/netId']
      const { deadline, v, r, s } = rootState.torn.signature
      const govInstance = getters.govContract({ netId })
      const amount = toWei(rootState.torn.signature.amount.toString())
      const gas = await govInstance.methods
        .lock(ethAccount, amount, deadline, v, r, s)
        .estimateGas({ from: ethAccount, value: 0 })
      const data = await govInstance.methods.lock(ethAccount, amount, deadline, v, r, s).encodeABI()

      const callParams = {
        method: 'eth_sendTransaction',
        params: {
          to: govInstance._address,
          gas: numberToHex(gas + 30000),
          data
        },
        watcherParams: {
          title: 'locking',
          successTitle: 'lockedNotice',
          storeType: 'govTxs',
          onSuccess: () => {
            dispatch('fetchBalances')
            dispatch('torn/fetchTokenBalance', {}, { root: true })
            commit('torn/REMOVE_SIGNATURE', {}, { root: true })
          }
        },
        isAwait: false
      }

      const txHash = await dispatch('metamask/sendTransaction', callParams, { root: true })

      commit(
        'txHashKeeper/SAVE_TX_HASH',
        {
          txHash,
          storeType: 'govTxs',
          type: 'Lock',
          netId
        },
        { root: true }
      )
    } catch (e) {
      console.error('lock', e.message)
      dispatch(
        'notice/addNoticeWithInterval',
        {
          notice: {
            title: 'internalError',
            type: 'danger'
          },
          interval: 3000
        },
        { root: true }
      )
    }
  },
  async lockWithApproval({ getters, rootGetters, commit, rootState, dispatch }, { amount }) {
    try {
      const { ethAccount } = rootState.metamask
      const netId = rootGetters['metamask/netId']
      const govInstance = getters.govContract({ netId })
      amount = toWei(amount.toString())
      const gas = await govInstance.methods
        .lockWithApproval(amount)
        .estimateGas({ from: ethAccount, value: 0 })
      const data = await govInstance.methods.lockWithApproval(amount).encodeABI()

      const callParams = {
        method: 'eth_sendTransaction',
        params: {
          to: govInstance._address,
          gas: numberToHex(gas + 100000),
          data
        },
        watcherParams: {
          title: 'locking',
          successTitle: 'lockedNotice',
          storeType: 'govTxs',
          onSuccess: () => {
            dispatch('fetchBalances')
            dispatch('torn/fetchTokenBalance', {}, { root: true })
            dispatch('torn/fetchTokenAllowance', {}, { root: true })
          }
        },
        isAwait: false
      }

      const txHash = await dispatch('metamask/sendTransaction', callParams, { root: true })

      commit(
        'txHashKeeper/SAVE_TX_HASH',
        {
          txHash,
          storeType: 'govTxs',
          type: 'Lock',
          netId
        },
        { root: true }
      )
    } catch (e) {
      console.error('lockWithApproval', e.message)
      Toast.open({
        message: this.app.i18n.t('internalError'),
        type: 'is-danger',
        duration: 3000
      })
    }
  },
  async castVote(context, payload) {
    const { getters, rootGetters, commit, rootState, dispatch, state } = context
    const { id, support, contact = '', message = '' } = payload

    commit('SAVE_CASTING_VOTE', true)

    try {
      const { ethAccount } = rootState.metamask
      const netId = rootGetters['metamask/netId']
      const govInstance = getters.govContract({ netId })
      const delegators = [...state.delegators]
      const web3 = getters.getWeb3({ netId })

      if (toBN(state.lockedBalance).gt(toBN('0'))) {
        delegators.push(ethAccount)
      }

      const data = govInstance.methods.castDelegatedVote(delegators, id, support).encodeABI()
      let dataWithTail = data

      if (contact || message) {
        const value = JSON.stringify([contact, message])
        const tail = utils.defaultAbiCoder.encode(['string'], [value])
        dataWithTail = utils.hexConcat([data, tail])
      }

      const gas = await web3.eth.estimateGas({
        from: ethAccount,
        to: govInstance._address,
        value: 0,
        data: dataWithTail
      })

      const callParams = {
        method: 'eth_sendTransaction',
        params: {
          to: govInstance._address,
          gas: numberToHex(gas + 30000),
          data: dataWithTail
        },
        watcherParams: {
          title: support ? 'votingFor' : 'votingAgainst',
          successTitle: support ? 'votedFor' : 'votedAgainst',
          storeType: 'govTxs',
          onSuccess: () => {
            dispatch('fetchProposals', { requestId: id })
          }
        },
        isAwait: false
      }

      const txHash = await dispatch('metamask/sendTransaction', callParams, { root: true })

      commit(
        'txHashKeeper/SAVE_TX_HASH',
        {
          txHash,
          storeType: 'govTxs',
          type: 'CastVote',
          netId
        },
        { root: true }
      )
    } catch (e) {
      console.error('castVote', e.message)
      dispatch(
        'notice/addNoticeWithInterval',
        {
          notice: {
            title: 'internalError',
            type: 'danger'
          },
          interval: 3000
        },
        { root: true }
      )
    } finally {
      dispatch('loading/disable', {}, { root: true })
      commit('SAVE_CASTING_VOTE', false)
    }
  },
  async executeProposal({ getters, rootGetters, commit, rootState, dispatch }, { id }) {
    try {
      const { ethAccount } = rootState.metamask
      const netId = rootGetters['metamask/netId']
      const govInstance = getters.govContract({ netId })
      const gas = await govInstance.methods.execute(id).estimateGas({ from: ethAccount, value: 0 })
      const data = await govInstance.methods.execute(id).encodeABI()

      const callParams = {
        method: 'eth_sendTransaction',
        params: {
          to: govInstance._address,
          gas: numberToHex(gas + 100000),
          data
        },
        watcherParams: {
          title: 'executingProposal',
          successTitle: 'proposalExecuted',
          storeType: 'govTxs',
          onSuccess: () => {
            dispatch('fetchProposals', { requestId: id })
          }
        },
        isAwait: false
      }

      const txHash = await dispatch('metamask/sendTransaction', callParams, { root: true })

      commit(
        'txHashKeeper/SAVE_TX_HASH',
        {
          txHash,
          storeType: 'govTxs',
          type: 'ExecuteProposal',
          netId
        },
        { root: true }
      )
    } catch (e) {
      console.error('executeProposal', e.message)
      dispatch(
        'notice/addNoticeWithInterval',
        {
          notice: {
            title: 'internalError',
            type: 'danger'
          },
          interval: 3000
        },
        { root: true }
      )
    }
  },
  async unlock({ getters, rootGetters, commit, rootState, dispatch }, { amount }) {
    try {
      const { ethAccount } = rootState.metamask
      const netId = rootGetters['metamask/netId']
      const govInstance = getters.govContract({ netId })
      amount = toWei(amount.toString())
      const gas = await govInstance.methods.unlock(amount).estimateGas({ from: ethAccount, value: 0 })
      const data = await govInstance.methods.unlock(amount).encodeABI()

      const callParams = {
        method: 'eth_sendTransaction',
        params: {
          to: govInstance._address,
          gas: numberToHex(gas + 100000),
          data
        },
        watcherParams: {
          title: 'unlocking',
          successTitle: 'unlocked',
          storeType: 'govTxs',
          onSuccess: () => {
            dispatch('fetchBalances')
            dispatch('torn/fetchTokenBalance', {}, { root: true })
            commit('torn/REMOVE_SIGNATURE', {}, { root: true })
          }
        },
        isAwait: false
      }

      const txHash = await dispatch('metamask/sendTransaction', callParams, { root: true })

      commit(
        'txHashKeeper/SAVE_TX_HASH',
        {
          txHash,
          storeType: 'govTxs',
          type: 'Unlock',
          netId
        },
        { root: true }
      )
    } catch (e) {
      console.error('unlock', e.message)
      dispatch(
        'notice/addNoticeWithInterval',
        {
          notice: {
            title: 'internalError',
            type: 'danger'
          },
          interval: 3000
        },
        { root: true }
      )
    }
  },
  async delegate({ getters, rootGetters, commit, rootState, dispatch }, { delegatee }) {
    try {
      const { ethAccount } = rootState.metamask
      const netId = rootGetters['metamask/netId']

      const govInstance = getters.govContract({ netId })
      const gas = await govInstance.methods.delegate(delegatee).estimateGas({ from: ethAccount, value: 0 })
      const data = await govInstance.methods.delegate(delegatee).encodeABI()

      const callParams = {
        method: 'eth_sendTransaction',
        params: {
          to: govInstance._address,
          gas: numberToHex(gas + 100000),
          data
        },
        watcherParams: {
          title: 'delegating',
          successTitle: 'delegated',
          storeType: 'govTxs',
          onSuccess: () => {
            dispatch('fetchDelegatee')
          }
        },
        isAwait: false
      }

      const txHash = await dispatch('metamask/sendTransaction', callParams, { root: true })

      commit(
        'txHashKeeper/SAVE_TX_HASH',
        {
          storeType: 'govTxs',
          txHash,
          type: 'Delegate',
          netId
        },
        { root: true }
      )
    } catch (e) {
      console.error('delegate', e.message)
      dispatch(
        'notice/addNoticeWithInterval',
        {
          notice: {
            title: 'internalError',
            type: 'danger'
          },
          interval: 3000
        },
        { root: true }
      )
    }
  },
  async undelegate({ getters, rootGetters, commit, rootState, dispatch }) {
    try {
      const { ethAccount } = rootState.metamask
      const netId = rootGetters['metamask/netId']

      const govInstance = getters.govContract({ netId })
      const gas = await govInstance.methods.undelegate().estimateGas({ from: ethAccount, value: 0 })
      const data = await govInstance.methods.undelegate().encodeABI()

      const callParams = {
        method: 'eth_sendTransaction',
        params: {
          to: govInstance._address,
          gas: numberToHex(gas + 100000),
          data
        },
        watcherParams: {
          title: 'undelegating',
          successTitle: 'undelegated',
          storeType: 'govTxs',
          onSuccess: () => {
            dispatch('fetchDelegatee')
          }
        },
        isAwait: false
      }

      const txHash = await dispatch('metamask/sendTransaction', callParams, { root: true })

      commit(
        'txHashKeeper/SAVE_TX_HASH',
        {
          txHash,
          storeType: 'govTxs',
          type: 'Undelegate',
          netId
        },
        { root: true }
      )
    } catch (e) {
      console.error('undelegate', e.message)
      dispatch(
        'notice/addNoticeWithInterval',
        {
          notice: {
            title: 'internalError',
            type: 'danger'
          },
          interval: 3000
        },
        { root: true }
      )
    }
  },
  async fetchProposals({ rootGetters, getters, commit }, { requestId }) {
    let proposals = []
    try {
      commit('SAVE_FETCHING_PROPOSALS', true)

      const netId = rootGetters['metamask/netId']
      const aggregatorContract = getters.aggregatorContract
      const govInstance = getters.govContract({ netId })
      const config = getters.getConfig({ netId })

      if (!govInstance) {
        return
      }

      const [events, statuses] = await Promise.all([
        govInstance.getPastEvents('ProposalCreated', {
          fromBlock: config.constants.GOVERNANCE_BLOCK,
          toBlock: 'latest'
        }),
        aggregatorContract.methods.getAllProposals(govInstance._address).call()
      ])

      const parseDescription = ({ id, text }) => {
        if (netId === 1) {
          switch (id) {
            case 1:
              return {
                title: text,
                description: 'See: https://torn.community/t/proposal-1-enable-torn-transfers/38'
              }
            case 10:
              text = text.replace('\n', '\\n\\n')
              break
            case 11:
              text = text.replace('"description"', ',"description"')
              break
            case 13:
              text = text.replace(/\\\\n\\\\n(\s)?(\\n)?/g, '\\n')
          }
        }

        if (text.includes(`'`)) {
          text = text.replaceAll(`'`, `"`)
        }
        if (text.includes(`" "`)) {
          text = text.replace(`" "`, `", "`)
        }

        let title, description, rest
        try {
          ;({ title, description } = JSON.parse(text))
        } catch {
          ;[title, ...rest] = text.split('\n', 2)
          description = rest.join('\n')
        }

        return { title, description }
      }

      proposals = events
        .map(({ returnValues, blockNumber }, index) => {
          const id = Number(returnValues.id)
          const { state, startTime, endTime, forVotes, againstVotes } = statuses[index]
          const { title, description } = parseDescription({ id, text: returnValues.description })

          return {
            id,
            title,
            description,
            target: returnValues.target,
            proposer: returnValues.proposer,
            endTime: Number(endTime),
            startTime: Number(startTime),
            status: ProposalState[Number(state)],
            blockNumber,
            results: {
              for: fromWei(forVotes),
              against: fromWei(againstVotes)
            }
          }
        })
        .sort((a, b) => {
          return a.id - b.id
        })

      if (requestId) {
        return proposals[requestId]
      }
    } catch (e) {
      console.error('fetchProposals', e.message)
    } finally {
      commit('SAVE_PROPOSALS', proposals)
      commit('SAVE_FETCHING_PROPOSALS', false)
    }
  },
  async fetchBalances({ getters, rootGetters, commit, rootState }) {
    try {
      commit('SAVE_FETCHING_LOCKED_BALANCE', true)
      const { ethAccount } = rootState.metamask

      if (!ethAccount) {
        return
      }

      const netId = rootGetters['metamask/netId']

      const govInstance = getters.govContract({ netId })
      const balance = await govInstance.methods.lockedBalance(ethAccount).call()
      commit('SAVE_LOCKED_BALANCE', { balance })
    } catch (e) {
      console.error('fetchBalances', e.message)
    } finally {
      commit('SAVE_FETCHING_LOCKED_BALANCE', false)
    }
  },
  async fetchedLockedTimestamp({ getters, rootGetters, commit, rootState, dispatch }) {
    try {
      const { ethAccount } = rootState.metamask

      if (!ethAccount) {
        return
      }

      const netId = rootGetters['metamask/netId']

      const govInstance = getters.govContract({ netId })
      const timestamp = await govInstance.methods.canWithdrawAfter(ethAccount).call()
      commit('SAVE_LOCKED_TIMESTAMP', { timestamp })
    } catch (e) {
      console.error('fetchedLockedTimestamp', e.message)
    }
  },
  async fetchLatestProposalId({ getters, rootGetters, commit, rootState, state }) {
    try {
      const { ethAccount } = rootState.metamask

      if (!ethAccount) {
        return
      }

      const netId = rootGetters['metamask/netId']

      const govInstance = getters.govContract({ netId })
      const id = await govInstance.methods.latestProposalIds(ethAccount).call()
      let status = null
      if (Number(id)) {
        status = await govInstance.methods.state(id).call()
        status = Number(status) > 1 ? null : 'active'
      }
      commit('SAVE_LATEST_PROPOSAL_ID', { id, status })
      console.log('status', state.latestProposalId)
    } catch (e) {
      console.error('fetchLatestProposalId', e.message)
    }
  },
  async fetchDelegatedBalance({ getters, rootGetters, commit, rootState, dispatch }) {
    try {
      commit('SAVE_FETCHING_DELEGATED_BALANCE', true)
      const { ethAccount } = rootState.metamask

      if (!ethAccount) {
        return
      }

      const netId = rootGetters['metamask/netId']
      const config = getters.getConfig({ netId })

      const aggregatorContract = getters.aggregatorContract
      const govInstance = getters.govContract({ netId })
      let delegatedAccs = await govInstance.getPastEvents('Delegated', {
        filter: {
          to: ethAccount
        },
        fromBlock: config.constants.GOVERNANCE_BLOCK,
        toBlock: 'latest'
      })
      let undelegatedAccs = await govInstance.getPastEvents('Undelegated', {
        filter: {
          from: ethAccount
        },
        fromBlock: config.constants.GOVERNANCE_BLOCK,
        toBlock: 'latest'
      })
      delegatedAccs = delegatedAccs.map((acc) => acc.returnValues.account)
      undelegatedAccs = undelegatedAccs.map((acc) => acc.returnValues.account)
      const uniq = delegatedAccs.filter((obj, index, self) => {
        const indexUndelegated = undelegatedAccs.indexOf(obj)
        if (indexUndelegated !== -1) {
          undelegatedAccs.splice(indexUndelegated, 1)
          return false
        }
        return true
      })
      let balances = await aggregatorContract.methods.getGovernanceBalances(govInstance._address, uniq).call()
      balances = balances.reduce((acc, balance, i) => {
        acc = acc.add(toBN(balance))
        return acc
      }, toBN('0'))
      commit('SAVE_DELEGATED_BALANCE', balances.toString(10))
      commit('SAVE_DELEGATORS', uniq)
    } catch (e) {
      console.error('fetchDelegatedBalance', e.message)
    } finally {
      commit('SAVE_FETCHING_DELEGATED_BALANCE', false)
    }
  },
  async fetchDelegatee({ getters, rootGetters, commit, rootState, dispatch }) {
    try {
      const { ethAccount } = rootState.metamask

      if (!ethAccount) {
        return
      }

      const netId = rootGetters['metamask/netId']

      const govInstance = getters.govContract({ netId })
      const currentDelegate = await govInstance.methods.delegatedTo(ethAccount).call()
      console.log('currentDelegate', currentDelegate)
      commit('SAVE_DELEGATEE', { currentDelegate })
    } catch (e) {
      console.error('fetchDelegatee', e.message)
    }
  },
  async fetchReceipt({ getters, rootGetters, commit, rootState, dispatch }, { id }) {
    try {
      const { ethAccount } = rootState.metamask
      const netId = rootGetters['metamask/netId']
      console.log('fetchReceipt', id)
      const govInstance = getters.govContract({ netId })
      const [hasVoted, support, balance] = await govInstance.methods.getReceipt(id, ethAccount).call()
      console.log('fetchReceipt', hasVoted, support, balance)
      commit('SAVE_VOTER_RECEIPT', { hasVoted, support, balance, id })
    } catch (e) {
      console.error('fetchReceipt', e.message)
    }
  },
  async fetchUserData({ getters, rootGetters, commit, rootState, dispatch }) {
    try {
      commit('SAVE_FETCHING_LOCKED_BALANCE', true)
      const { ethAccount } = rootState.metamask

      if (!ethAccount) {
        return
      }

      const netId = rootGetters['metamask/netId']
      const govInstance = getters.govContract({ netId })
      const aggregatorContract = getters.aggregatorContract
      const {
        balance,
        latestProposalId,
        timelock,
        delegatee,
        ...userdata
      } = await aggregatorContract.methods.getUserData(govInstance._address, ethAccount).call()
      commit('SAVE_DELEGATEE', { currentDelegate: delegatee })

      const latestProposalIdState = ProposalState[Number(userdata.latestProposalIdState)]
      commit('SAVE_LATEST_PROPOSAL_ID', { id: Number(latestProposalId), status: latestProposalIdState })
      commit('SAVE_LOCKED_TIMESTAMP', { timestamp: Number(timelock) })
      commit('SAVE_LOCKED_BALANCE', { balance })
    } catch (e) {
      console.error('fetchUserData', e.message)
    } finally {
      commit('SAVE_FETCHING_LOCKED_BALANCE', false)
    }
  },
  async checkActiveProposals({ getters, rootGetters, commit }) {
    if (!getters.isEnabledGovernance) {
      return
    }

    const { 'governance.contract.tornadocash.eth': governanceAddress } = rootGetters['metamask/networkConfig']
    const aggregatorContract = getters.aggregatorContract

    const statuses = await aggregatorContract.methods.getAllProposals(governanceAddress).call()
    let isActive = false
    if (statuses && Array.isArray(statuses)) {
      isActive = statuses.find((status) => Number(status.state) === 1)
    }

    commit('SET_HAS_ACTIVE_PROPOSALS', Boolean(isActive))
  },
  async fetchConstants({ commit, getters, dispatch, rootGetters }) {
    const netId = rootGetters['metamask/netId']
    const govInstance = getters.govContract({ netId })
    const constants = [].concat(govConstants, proposalIntervalConstants)

    const params = constants.map((name) => {
      return {
        target: govInstance._address,
        callData: govInstance.methods[name]().encodeABI()
      }
    })

    const multicallArray = await dispatch('application/aggregateMulticall', { params }, { root: true })

    if (multicallArray) {
      const hexToNumberConverter = (acc, curr, index) => {
        const name = constants[index]
        const value = govConstants.includes(name) ? hexToNumberString(curr) : hexToNumber(curr)

        return { ...acc, [name]: value }
      }

      const result = multicallArray.reduce(hexToNumberConverter, {})

      commit('SAVE_CONSTANTS', result)
    }
  }
}

export default {
  namespaced: true,
  state,
  getters,
  mutations,
  actions
}