classic-ui/store/txHashKeeper.js

458 lines
13 KiB
JavaScript
Raw Normal View History

2022-04-22 06:05:56 +03:00
/* eslint-disable no-console */
import { hexToNumber } from 'web3-utils'
import txStatus from './txStatus'
import { eventsType } from '@/constants'
import { createChainIdState, parseNote } from '@/utils'
const initialState = createChainIdState({
txs: {},
govTxs: {},
encryptedTxs: {}
})
export const state = () => {
return initialState
}
export const getters = {
txExplorerUrl: (state, getters, rootState, rootGetters) => (txHash) => {
const { explorerUrl } = rootGetters['metamask/networkConfig']
return explorerUrl.tx + txHash
},
addressExplorerUrl: (state, getters, rootState, rootGetters) => (address) => {
const { explorerUrl } = rootGetters['metamask/networkConfig']
return explorerUrl.address + address
},
blockExplorerUrl: (state, getters, rootState, rootGetters) => (block) => {
const { explorerUrl } = rootGetters['metamask/networkConfig']
return explorerUrl.block + block
},
encryptedTxs: (state, getters, rootState, rootGetters) => {
const netId = rootGetters['metamask/netId']
const txsToRender = Object.entries(state[`netId${netId}`].encryptedTxs)
.reverse()
.map(([txHash, tx]) => {
return {
isEncrypted: true,
txHash,
status,
...tx
}
})
return txsToRender
},
txs: (state, getters, rootState, rootGetters) => {
const netId = rootGetters['metamask/netId']
const txsToRender = Object.entries(state[`netId${netId}`].txs)
.reverse()
.map(([txHash, tx]) => {
return {
txHash,
status,
...tx
}
})
return txsToRender
},
allTxs: (state, getters) => {
const { txs, encryptedTxs } = getters
return txs.concat(encryptedTxs)
},
allTxsHash: (state, getters, rootState, rootGetters) => {
const netId = rootGetters['metamask/netId']
return Object.entries(state[`netId${netId}`].txs)
.reverse()
.map(([txHash]) => txHash)
},
txStatusClass: () => (status) => {
let cssClass
switch (status) {
case txStatus.waitingForReciept:
cssClass = 'is-loading'
break
case txStatus.success:
cssClass = 'is-success'
break
case txStatus.fail:
cssClass = 'is-danger'
break
default:
break
}
return cssClass
}
}
export const mutations = {
SAVE_TX_HASH(state, { storeType = 'txs', amount = '0', note = null, netId, txHash, status, ...rest }) {
this._vm.$set(state[`netId${netId}`][storeType], [txHash], {
...rest,
status: status || txStatus.waitingForReciept,
note,
amount
})
},
CHANGE_TX_STATUS(state, { storeType = 'txs', txHash, status, blockNumber, netId }) {
this._vm.$set(state[`netId${netId}`][storeType][txHash], 'status', status)
this._vm.$set(state[`netId${netId}`][storeType][txHash], 'blockNumber', blockNumber)
},
SET_SPENT(state, { netId, storeType = 'txs', txHash }) {
this._vm.$set(state[`netId${netId}`][storeType][txHash], 'isSpent', true)
},
DELETE_TX(state, { storeType = 'txs', txHash }) {
const netId = this._vm['metamask/netId']
this._vm.$delete(state[`netId${netId}`][storeType], txHash)
},
UPDATE_DEPOSIT(state, { storeType = 'txs', txHash, netId, withdrawTxHash, timestamp, status, ...rest }) {
const tx = state[`netId${netId}`][storeType][txHash]
this._vm.$delete(state[`netId${netId}`][storeType], txHash)
this._vm.$set(state[`netId${netId}`][storeType], withdrawTxHash, {
...tx,
timestamp,
depositTxHash: txHash,
txHash: withdrawTxHash,
depositBlock: tx.blockNumber,
status: status || txStatus.waitingForReciept,
...rest
})
}
}
export const actions = {
async getInstances({ rootGetters, dispatch }, { txs }) {
2022-04-22 06:05:56 +03:00
const eventsInterface = rootGetters['application/eventsInterface']
const instances = txs.reduce((acc, curr) => {
const [, currency, amount, netId] = curr.prefix.split('-')
const name = `${netId}${amount}${currency}`
2022-04-22 06:05:56 +03:00
if (!acc[name]) {
const service = eventsInterface.getService({ netId, amount, currency })
acc[name] = { currency, amount, netId, service }
}
return acc
}, {})
await Promise.all(
[].concat(
Object.values(instances).map((instance) => instance.service.updateEvents(eventsType.DEPOSIT)),
Object.values(instances).map((instance) => instance.service.updateEvents(eventsType.WITHDRAWAL))
)
)
dispatch('loading/disable', {}, { root: true })
2022-04-22 06:05:56 +03:00
return instances
},
async checkPendingEncryptedTransaction({ dispatch, getters }) {
const transactions = getters.encryptedTxs
const pendingTxs = transactions.filter((tx) => tx.status === 1)
const instances = await dispatch('getInstances', { txs: pendingTxs })
for (const tx of pendingTxs) {
const [, currency, amount, netId] = tx.prefix.split('-')
dispatch('checkSpeedUpEncryptedTx', {
netId,
txHash: tx.txHash,
type: eventsType.DEPOSIT,
commitment: tx.commitmentHex,
service: instances[`${netId}${amount}${currency}`]
2022-04-22 06:05:56 +03:00
})
}
},
async checkSpeedUpEncryptedTx({ commit, dispatch }, { txHash, commitment, netId, service, type }) {
try {
const result = await this.$provider.web3.eth.getTransactionReceipt(txHash)
if (result) {
const status = result.status === '0x0' ? txStatus.fail : txStatus.success
commit('CHANGE_TX_STATUS', {
netId,
txHash,
status,
storeType: 'encryptedTxs',
blockNumber: hexToNumber(result.blockNumber)
})
} else {
const foundEvent = await service.findEvent({ eventName: 'commitment', eventToFind: commitment, type })
if (foundEvent) {
commit('UPDATE_DEPOSIT', {
netId,
txHash,
storeType: 'encryptedTxs',
status: txStatus.success,
timestamp: foundEvent.timestamp,
withdrawTxHash: foundEvent.txHash,
blockNumber: foundEvent.depositBlock
})
}
}
} catch (err) {
throw new Error(`Method checkSpeedUpEncryptedTx has error ${err.message}`)
}
},
async cleanEncryptedTxs({ getters, commit, dispatch }) {
getters.encryptedTxs.forEach(({ status, txHash, type }) => {
if (status === txStatus.fail) {
commit('DELETE_TX', { txHash, storeType: 'encryptedTxs' })
}
})
const instances = await dispatch('getInstances', {
txs: getters.encryptedTxs
})
for (const tx of getters.encryptedTxs) {
if (!tx.isSpent) {
const { currency, amount, netId, nullifierHex } = parseNote(`${tx.prefix}-${tx.note}`)
const isSpent = await instances[`${netId}${amount}${currency}`].service.findEvent({
2022-04-22 06:05:56 +03:00
eventName: 'nullifierHash',
eventToFind: nullifierHex,
type: eventsType.WITHDRAWAL
})
if (isSpent) {
commit('SET_SPENT', { txHash: tx.txHash, storeType: 'encryptedTxs', netId })
}
}
}
dispatch('loading/disable', {}, { root: true })
2022-04-22 06:05:56 +03:00
},
checkPendingTransaction({ getters, dispatch }) {
const transactions = getters.txs
const pendingTxs = transactions.filter((tx) => tx.status === 1)
for (const tx of pendingTxs) {
const [, , , netId] = tx.prefix.split('-')
dispatch('checkPendingSpeedUpTx', { txHash: tx.txHash, note: `${tx.prefix}-${tx.note}`, netId })
}
},
async checkPendingSpeedUpTx({ commit, dispatch }, { txHash, netId, note }) {
try {
const result = await this.$provider.web3.eth.getTransactionReceipt(txHash)
if (result) {
const status = result.status === '0x0' ? txStatus.fail : txStatus.success
commit('CHANGE_TX_STATUS', {
storeType: 'txs',
txHash,
blockNumber: hexToNumber(result.blockNumber),
status,
netId
})
} else {
const response = await dispatch(
'application/loadDepositEvent',
{ withdrawNote: note },
{ root: true }
)
if (response) {
commit('UPDATE_DEPOSIT', {
netId,
txHash,
storeType: 'txs',
status: txStatus.success,
timestamp: response.timestamp,
withdrawTxHash: response.txHash,
blockNumber: response.depositBlock
})
}
}
} catch (err) {
throw new Error(`Method checkPendingSpeedUpTx has error ${err.message}`)
}
},
async runTxWatcher({ commit, dispatch }, { storeType = 'txs', txHash, netId, isSaving = true }) {
console.log('runTxWatcher storeType txHash, netId', storeType, txHash, netId)
try {
// eslint-disable-next-line prefer-const
let { status, blockNumber } = await this.$provider.waitForTxReceipt({ txHash })
status = status === '0x0' ? txStatus.fail : txStatus.success
if (isSaving) {
commit('CHANGE_TX_STATUS', {
storeType,
txHash,
blockNumber: hexToNumber(blockNumber),
status,
netId
})
}
return status === txStatus.success
} catch (e) {
console.error('runTxWatcher', e)
return false
}
},
async runTxWatcherWithNotifications(
{ dispatch },
{ title, successTitle, storeType = 'txs', txHash, netId, onSuccess, isSaving }
) {
try {
const noticeId = await dispatch(
'notice/addNotice',
{
notice: {
title,
type: 'loading',
txHash
}
},
{ root: true }
)
const success = await dispatch('runTxWatcher', { storeType, txHash, netId, isSaving })
if (success) {
dispatch(
'notice/updateNotice',
{
id: noticeId,
notice: {
title: successTitle,
type: 'success'
},
interval: 10000
},
{ root: true }
)
if (typeof onSuccess === 'function') {
onSuccess(txHash)
}
} else {
dispatch(
'notice/updateNotice',
{
id: noticeId,
notice: {
title: 'transactionFailed',
type: 'danger'
}
},
{ root: true }
)
}
return success
} catch (e) {
console.error('runTxWatcherWithNotifications', e)
return false
}
},
async cleanTxs({ getters, commit, dispatch }) {
// isSpentArray
getters.txs.forEach(({ status, txHash, type }) => {
if (status === txStatus.fail) {
commit('DELETE_TX', { txHash })
}
})
const instances = await dispatch('getInstances', {
txs: getters.txs
})
for (const tx of getters.txs) {
if (tx && !tx.isSpent) {
const { currency, amount, netId, nullifierHex } = parseNote(`${tx.prefix}-${tx.note}`)
const isSpent = await instances[`${netId}${amount}${currency}`].service.findEvent({
2022-04-22 06:05:56 +03:00
eventName: 'nullifierHash',
eventToFind: nullifierHex,
type: eventsType.WITHDRAWAL
})
if (isSpent) {
commit('SET_SPENT', { txHash: tx.txHash, netId })
}
}
}
dispatch('loading/disable', {}, { root: true })
2022-04-22 06:05:56 +03:00
},
async updateDeposit(
{ getters, commit, dispatch, rootGetters },
{ netId, type = 'tornado', action = 'Withdraw', note, txHash, fee, amount, currency }
) {
const timestamp = Math.round(new Date().getTime() / 1000)
let txMutation = 'SAVE_TX_HASH'
const tx = {
txHash,
type: action,
amount,
currency,
fee,
netId,
timestamp,
status: 2
}
if (type === 'tornado') {
const [tornado, , , , hexNote] = note.split('-')
const { commitmentHex } = parseNote(note)
tx.prefix = `${tornado}-${currency}-${amount}-${netId}`
tx.isSpent = true
const encryptedTxs = getters.encryptedTxs
const encrypted = encryptedTxs.find((tx) => {
return tx.commitmentHex === commitmentHex
})
tx.storeType = encrypted ? 'encryptedTxs' : 'txs'
const deposit =
encrypted ||
getters.txs.find(({ note }) => {
return note === hexNote
})
tx.note = encrypted ? encrypted.note : hexNote
const blockNumber = await dispatch('getBlockNumber', { txHash })
tx.blockNumber = blockNumber
if (deposit && deposit.txHash) {
txMutation = 'UPDATE_DEPOSIT'
tx.txHash = deposit.txHash
tx.withdrawTxHash = txHash
} else {
const events = await dispatch('application/loadDepositEvent', { withdrawNote: note }, { root: true })
tx.withdrawTxHash = txHash
tx.txHash = events.txHash
tx.depositBlock = events.depositBlock
tx.index = events.leafIndex
}
}
commit(txMutation, tx)
},
async getBlockNumber({ rootState }, { txHash }) {
try {
const { netId } = rootState.metamask
const { url } = rootState.settings[`netId${netId}`].rpc
const web3 = this.$provider.getWeb3(url)
const { blockNumber } = await web3.eth.getTransaction(txHash)
return blockNumber
} catch (err) {
console.log('getBlockNumber has error:', err.message)
}
}
}