init

store/token.js

@@ -0,0 +1,222 @@
+/* eslint-disable no-console */
+/* eslint-disable import/order */
+import Web3 from 'web3'
+import networkConfig from '@/networkConfig'
+import ERC20ABI from '@/abis/ERC20.abi.json'
+const { numberToHex, toBN, toWei } = require('web3-utils')
+const BN = require('bn.js')
+const zero = new BN(0)
+const negative1 = new BN(-1)
+
+export const state = () => {
+  return {
+    approvalAmount: 'unlimited',
+    allowance: '',
+    balance: ''
+  }
+}
+
+export const getters = {
+  tokenContract: (state, getters, rootState, rootGetters) => ({ currency, netId }) => {
+    const config = networkConfig[`netId${netId}`]
+    const { url } = rootState.settings[`netId${netId}`].rpc
+    const address = config.tokens[currency].tokenAddress
+    const web3 = new Web3(url)
+    return new web3.eth.Contract(ERC20ABI, address)
+  },
+  // similar to fromWei from web3
+  toDecimals: (state, getters, rootState, rootGetters) => (value, decimals, fixed) => {
+    const { currency } = rootState.application.selectedStatistic
+    decimals = decimals || rootGetters['metamask/networkConfig'].tokens[currency].decimals
+    fixed = fixed || 2
+
+    value = new BN(value)
+    const negative = value.lt(zero)
+    const base = new BN('10').pow(new BN(decimals))
+    const baseLength = base.toString(10).length - 1 || 1
+
+    if (negative) {
+      value = value.mul(negative1)
+    }
+
+    let fraction = value.mod(base).toString(10)
+    while (fraction.length < baseLength) {
+      fraction = `0${fraction}`
+    }
+    fraction = fraction.match(/^([0-9]*[1-9]|0)(0*)/)[1]
+    const whole = value.div(base).toString(10)
+
+    if (fixed && fraction !== '0') {
+      fraction = fraction.slice(0, fixed)
+    }
+    value = `${whole}${fraction === '0' ? '' : `.${fraction}`}`
+
+    if (negative) {
+      value = `-${value}`
+    }
+
+    return value
+  },
+  // similar to toWei from web3
+  fromDecimals: (state, getters, rootState, rootGetters) => (value, decimals) => {
+    const { currency } = rootState.application.selectedStatistic
+    decimals = decimals || rootGetters['metamask/networkConfig'].tokens[currency].decimals
+    value = value.toString()
+    let ether = value.toString()
+    const base = new BN('10').pow(new BN(decimals))
+    const baseLength = base.toString(10).length - 1 || 1
+
+    const negative = ether.substring(0, 1) === '-'
+    if (negative) {
+      ether = ether.substring(1)
+    }
+
+    if (ether === '.') {
+      throw new Error(this.app.i18n.t('unitInvalidValue', { value }))
+    }
+
+    // Split it into a whole and fractional part
+    const comps = ether.split('.')
+    if (comps.length > 2) {
+      throw new Error(this.app.i18n.t('tooManyDecimalPoints', { value }))
+    }
+
+    let whole = comps[0]
+    let fraction = comps[1]
+
+    if (!whole) {
+      whole = '0'
+    }
+    if (!fraction) {
+      fraction = '0'
+    }
+    if (fraction.length > baseLength) {
+      throw new Error(this.app.i18n.t('tooManyDecimalPlaces', { value }))
+    }
+
+    while (fraction.length < baseLength) {
+      fraction += '0'
+    }
+
+    whole = new BN(whole)
+    fraction = new BN(fraction)
+    let wei = whole.mul(base).add(fraction)
+
+    if (negative) {
+      wei = wei.mul(negative)
+    }
+
+    return new BN(wei.toString(10), 10)
+  },
+  isSufficientAllowance: (state, getters, rootState, rootGetters) => {
+    const { currency, amount } = rootState.application.selectedInstance
+    const { decimals } = rootGetters['metamask/networkConfig'].tokens[currency]
+    return toBN(state.allowance).gte(toBN(getters.fromDecimals(amount, decimals)))
+  },
+  isSufficientBalance: (state, getters, rootState, rootGetters) => {
+    const ethBalance = rootState.metamask.ethBalance
+    const { currency, amount } = rootState.application.selectedInstance
+    const { decimals } = rootGetters['metamask/networkConfig'].tokens[currency]
+    const nativeCurrency = rootGetters['metamask/nativeCurrency']
+    if (currency === nativeCurrency) {
+      return toBN(ethBalance).gte(toBN(toWei(amount.toString())))
+    } else {
+      return toBN(state.balance).gte(toBN(getters.fromDecimals(amount, decimals)))
+    }
+  },
+  getSymbol: (state, getters, rootState, rootGetters) => (currency) => {
+    const tokens = rootGetters['metamask/networkConfig'].tokens
+    if (tokens[currency]) {
+      return tokens[currency].symbol
+    }
+    return currency.toUpperCase()
+  }
+}
+
+export const mutations = {
+  SET_APPROVAL_AMOUNT(state, { approvalAmount }) {
+    state.approvalAmount = approvalAmount
+  },
+  SAVE_ALLOWANCE(state, { allowance }) {
+    this._vm.$set(state, 'allowance', allowance)
+  },
+  SAVE_BALANCE(state, { balance }) {
+    this._vm.$set(state, 'balance', balance)
+  }
+}
+
+export const actions = {
+  async approve({ rootState, getters, dispatch, rootGetters, state }) {
+    try {
+      const netId = rootGetters['metamask/netId']
+      const { currency } = rootState.application.selectedInstance
+      const { decimals } = rootGetters['metamask/networkConfig'].tokens[currency]
+      const tokenInstance = getters.tokenContract({ currency, netId })
+      const tornadoProxy = rootGetters['application/tornadoProxyContract']({ netId })
+
+      const { ethAccount } = rootState.metamask
+      const amountToApprove =
+        state.approvalAmount === 'unlimited'
+          ? toBN('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
+          : toBN(getters.fromDecimals(state.approvalAmount, decimals))
+      const data = tokenInstance.methods
+        .approve(tornadoProxy._address, amountToApprove.toString())
+        .encodeABI()
+      const gas = await tokenInstance.methods
+        .approve(tornadoProxy._address, amountToApprove.toString())
+        .estimateGas({
+          from: ethAccount
+        })
+
+      const callParams = {
+        method: 'eth_sendTransaction',
+        params: {
+          to: tokenInstance._address,
+          gas: numberToHex(gas + 30000),
+          data
+        },
+        watcherParams: {
+          title: 'approve',
+          successTitle: 'approved'
+        },
+        isSaving: false
+      }
+
+      await dispatch('metamask/sendTransaction', callParams, { root: true })
+    } catch (e) {
+      console.error('approve action', e)
+      throw new Error(e.message)
+    }
+  },
+  async fetchTokenAllowance({ getters, rootGetters, commit, rootState }) {
+    const netId = rootGetters['metamask/netId']
+    const { currency } = rootState.application.selectedInstance
+    const { ethAccount } = rootState.metamask
+    try {
+      const tornadoInstance = rootGetters['application/tornadoProxyContract']({ netId })
+      const nativeCurrency = rootGetters['metamask/nativeCurrency']
+      if (currency !== nativeCurrency && ethAccount) {
+        const tokenInstance = getters.tokenContract({ currency, netId })
+        const allowance = await tokenInstance.methods.allowance(ethAccount, tornadoInstance._address).call()
+        commit('SAVE_ALLOWANCE', { allowance })
+      }
+    } catch (e) {
+      console.error('fetchTokenAllowance', e.message)
+    }
+  },
+  async fetchTokenBalance({ state, getters, rootGetters, commit, rootState }) {
+    try {
+      const netId = rootGetters['metamask/netId']
+      const { currency } = rootState.application.selectedInstance
+      const { ethAccount } = rootState.metamask
+      const nativeCurrency = rootGetters['metamask/nativeCurrency']
+      if (currency !== nativeCurrency && ethAccount) {
+        const tokenInstance = getters.tokenContract({ currency, netId })
+        const balance = await tokenInstance.methods.balanceOf(ethAccount).call()
+        commit('SAVE_BALANCE', { balance })
+      }
+    } catch (e) {
+      console.error('fetchTokenBalance', e.message)
+    }
+  }
+}