classic-ui/store/relayer.js

694 lines
19 KiB
JavaScript
Raw Normal View History

2022-04-22 06:05:56 +03:00
/* eslint-disable no-console */
import Web3 from 'web3'
import BN from 'bignumber.js'
import namehash from 'eth-ens-namehash'
2022-11-23 14:28:56 +03:00
import { httpConfig } from '@/constants'
2022-04-22 06:05:56 +03:00
import { schema, relayerRegisterService } from '@/services'
import { createChainIdState, parseNote, parseSemanticVersion } from '@/utils'
import ENSABI from '@/abis/ENS.abi.json'
import networkConfig from '@/networkConfig'
const getAxios = () => {
return import('axios')
}
const calculateScore = ({ stakeBalance, tornadoServiceFee }, minFee = 0.33, maxFee = 0.53) => {
if (tornadoServiceFee < minFee) {
tornadoServiceFee = minFee
} else if (tornadoServiceFee >= maxFee) {
return new BN(0)
}
const serviceFeeCoefficient = (tornadoServiceFee - minFee) ** 2
const feeDiffCoefficient = 1 / (maxFee - minFee) ** 2
const coefficientsMultiplier = 1 - feeDiffCoefficient * serviceFeeCoefficient
return new BN(stakeBalance).multipliedBy(coefficientsMultiplier)
}
const getWeightRandom = (weightsScores, random) => {
for (let i = 0; i < weightsScores.length; i++) {
if (random.isLessThan(weightsScores[i])) {
return i
}
random = random.minus(weightsScores[i])
}
return Math.floor(Math.random() * weightsScores.length)
}
const pickWeightedRandomRelayer = (items, netId) => {
let minFee, maxFee
if (netId !== 1) {
minFee = 0.01
maxFee = 0.3
}
const weightsScores = items.map((el) => calculateScore(el, minFee, maxFee))
const totalWeight = weightsScores.reduce((acc, curr) => {
return (acc = acc.plus(curr))
}, new BN('0'))
const random = totalWeight.multipliedBy(Math.random())
const weightRandomIndex = getWeightRandom(weightsScores, random)
return items[weightRandomIndex]
}
const initialJobsState = createChainIdState({
tornado: {}
})
export const state = () => {
return {
prices: {
dai: '6700000000000000'
},
selectedRelayer: {
url: '',
name: '',
stakeBalance: 0,
tornadoServiceFee: 0.05,
address: null,
ethPrices: {
torn: '1'
}
},
isLoadingRelayers: false,
validRelayers: [],
jobs: initialJobsState,
jobWatchers: {}
}
}
export const getters = {
ethProvider: (state, getters, rootState) => {
const { url } = rootState.settings.netId1.rpc
2022-11-23 14:28:56 +03:00
const httpProvider = new Web3.providers.HttpProvider(url, httpConfig)
2022-04-22 06:05:56 +03:00
2022-11-23 14:28:56 +03:00
return new Web3(httpProvider)
2022-04-22 06:05:56 +03:00
},
jobs: (state, getters, rootState, rootGetters) => (type) => {
const netId = rootGetters['metamask/netId']
const jobsToRender = Object.entries(state.jobs[`netId${netId}`][type])
.reverse()
.map(
([
id,
{
action,
relayerUrl,
amount,
currency,
fee,
timestamp,
txHash,
confirmations,
status,
failedReason
}
]) => {
return {
id,
action,
relayerUrl,
amount,
currency,
fee,
timestamp,
txHash,
confirmations,
status,
failedReason
}
}
)
return jobsToRender
}
}
export const mutations = {
SET_SELECTED_RELAYER(state, payload) {
this._vm.$set(state, 'selectedRelayer', payload)
},
SAVE_VALIDATED_RELAYERS(state, relayers) {
state.validRelayers = relayers
},
SAVE_JOB(
state,
{
id,
netId,
type,
action,
relayerUrl,
amount,
currency,
fee,
commitmentHex,
timestamp,
note,
accountAfter,
account
}
) {
this._vm.$set(state.jobs[`netId${netId}`][type], id, {
action,
relayerUrl,
amount,
currency,
fee,
commitmentHex,
timestamp,
note,
accountAfter,
account
})
},
UPDATE_JOB(state, { id, netId, type, txHash, confirmations, status, failedReason }) {
const job = state.jobs[`netId${netId}`][type][id]
this._vm.$set(state.jobs[`netId${netId}`][type], id, {
...job,
txHash,
confirmations,
status,
failedReason
})
},
DELETE_JOB(state, { id, netId, type }) {
this._vm.$delete(state.jobs[`netId${netId}`][type], id)
},
ADD_JOB_WATCHER(state, { id, timerId }) {
this._vm.$set(state.jobWatchers, id, {
timerId
})
},
DELETE_JOB_WATCHER(state, { id }) {
this._vm.$delete(state.jobWatchers, id)
},
SET_IS_LOADING_RELAYERS(state, isLoadingRelayers) {
state.isLoadingRelayers = isLoadingRelayers
}
}
export const actions = {
async askRelayerStatus(
{ rootState, dispatch, rootGetters },
{ hostname, relayerAddress, stakeBalance, ensName }
) {
try {
const axios = await getAxios()
if (!hostname.endsWith('/')) {
hostname += '/'
}
const url = `${window.location.protocol}//${hostname}`
2022-11-23 14:28:56 +03:00
const reqConfig = {
headers: {
'Content-Type': 'application/json, application/x-www-form-urlencoded'
},
timeout: 10000
}
const response = await axios.get(`${url}status`, reqConfig).catch(() => {
2022-04-22 06:05:56 +03:00
throw new Error(this.app.i18n.t('canNotFetchStatusFromTheRelayer'))
})
if (Number(response.data.currentQueue) > 5) {
throw new Error(this.app.i18n.t('withdrawalQueueIsOverloaded'))
}
const netId = Number(rootGetters['metamask/netId'])
if (Number(response.data.netId) !== netId) {
throw new Error(this.app.i18n.t('thisRelayerServesADifferentNetwork'))
}
const validate = schema.getRelayerValidateFunction(netId)
// check rewardAccount === relayerAddress for TORN burn, custom relayer - exception
if (netId === 1 && relayerAddress && response.data.rewardAccount !== relayerAddress) {
throw new Error('The Relayer reward address must match registered address')
}
const isValid = validate(response.data)
if (!isValid) {
console.error('askRelayerStatus', ensName, validate?.errors)
throw new Error(this.app.i18n.t('canNotFetchStatusFromTheRelayer'))
}
const isRelayerUpdated = () => {
2022-07-04 15:22:09 +03:00
const relayerVersion = response.data.version
const { major, patch, prerelease } = parseSemanticVersion(relayerVersion)
// Save backwards compatibility with V4 relayers for Ethereum Mainnet
const requiredMajor = netId === 1 ? '4' : '5'
const isUpdatedMajor = major === requiredMajor
2022-04-22 06:05:56 +03:00
if (prerelease) return false
return isUpdatedMajor && (Number(patch) >= 5 || netId !== 1) // Patch checking - also backwards compatibility for Mainnet
2022-04-22 06:05:56 +03:00
}
if (!isRelayerUpdated()) {
2022-04-22 06:05:56 +03:00
throw new Error('Outdated version.')
}
return {
isValid,
realUrl: url,
stakeBalance,
name: ensName,
relayerAddress,
netId: response.data.netId,
ethPrices: response.data.ethPrices,
address: response.data.rewardAccount,
currentQueue: response.data.currentQueue,
tornadoServiceFee: response.data.tornadoServiceFee
}
} catch (e) {
console.error('askRelayerStatus', ensName, e.message)
return { isValid: false, error: e.message }
}
},
async observeRelayer({ dispatch }, { relayer }) {
const result = await dispatch('askRelayerStatus', relayer)
return result
},
async pickRandomRelayer({ rootGetters, commit, dispatch, getters }) {
const netId = rootGetters['metamask/netId']
const { ensSubdomainKey } = rootGetters['metamask/networkConfig']
commit('SET_IS_LOADING_RELAYERS', true)
const registeredRelayers = await relayerRegisterService(getters.ethProvider).getRelayers(ensSubdomainKey)
const requests = []
for (const registeredRelayer of registeredRelayers) {
requests.push(dispatch('observeRelayer', { relayer: registeredRelayer }))
}
let statuses = await Promise.all(requests)
statuses = statuses.filter((status) => status.isValid)
// const validRelayerENSnames = statuses.map((relayer) => relayer.name)
commit('SAVE_VALIDATED_RELAYERS', statuses)
console.log('filtered statuses ', statuses)
try {
const {
name,
realUrl,
address,
ethPrices,
stakeBalance,
2022-08-02 07:47:28 +03:00
tornadoServiceFee
2022-04-22 06:05:56 +03:00
} = pickWeightedRandomRelayer(statuses, netId)
console.log('Selected relayer', name, tornadoServiceFee)
commit('SET_SELECTED_RELAYER', {
name,
address,
ethPrices,
url: realUrl,
stakeBalance,
2022-08-02 07:47:28 +03:00
tornadoServiceFee
2022-04-22 06:05:56 +03:00
})
} catch {
console.error('Method pickRandomRelayer has not picked relayer')
2022-11-23 14:28:56 +03:00
dispatch(
'notice/addNotice',
{
notice: {
untranslatedTitle: 'Failed to fetch relayers',
type: 'warning'
},
interval: 1500
},
{ root: true }
)
2022-04-22 06:05:56 +03:00
}
commit('SET_IS_LOADING_RELAYERS', false)
},
async getKnownRelayerData({ rootGetters, getters }, { relayerAddress, name }) {
const { ensSubdomainKey } = rootGetters['metamask/networkConfig']
const [validRelayer] = await relayerRegisterService(getters.ethProvider).getValidRelayers(
[{ relayerAddress, ensName: name.replace(`${ensSubdomainKey}.`, '') }],
ensSubdomainKey
)
console.warn('validRelayer', validRelayer)
return validRelayer
},
async getCustomRelayerData({ rootState, state, getters, rootGetters, dispatch }, { url, name }) {
const provider = getters.ethProvider.eth
2022-06-06 17:26:00 +03:00
const PROTOCOL_REGEXP = /^(http(s?))/
if (!PROTOCOL_REGEXP.test(url)) {
if (url.endsWith('.onion')) {
2022-04-22 06:05:56 +03:00
url = `http://${url}`
} else {
url = `https://${url}`
}
}
2022-06-06 17:26:00 +03:00
2022-04-22 06:05:56 +03:00
const urlParser = new URL(url)
urlParser.href = url
let ensName = name
if (urlParser.hostname.endsWith('.eth')) {
ensName = urlParser.hostname
let resolverInstance = await provider.ens.getResolver(ensName)
if (new BN(resolverInstance._address).isZero()) {
throw new Error('missingENSSubdomain')
}
resolverInstance = new provider.Contract(ENSABI, resolverInstance._address)
const ensNameHash = namehash.hash(ensName)
const hostname = await resolverInstance.methods.text(ensNameHash, 'url').call()
if (!hostname) {
throw new Error('canNotFetchStatusFromTheRelayer')
}
urlParser.host = hostname
}
const hostname = urlParser.host
return { hostname, ensName, stakeBalance: 0 }
},
async getRelayerData({ state, dispatch }, { url, name }) {
const knownRelayer = state.validRelayers.find((el) => el.name === name)
if (knownRelayer) {
const knownRelayerData = await dispatch('getKnownRelayerData', knownRelayer)
return knownRelayerData
}
const customRelayerData = await dispatch('getCustomRelayerData', { url, name })
return customRelayerData
},
async setupRelayer({ commit, rootState, dispatch }, { url, name }) {
try {
const relayerData = await dispatch('getRelayerData', { url, name })
2022-08-02 07:47:28 +03:00
const { error, isValid, realUrl, address, ethPrices, tornadoServiceFee } = await dispatch(
'askRelayerStatus',
relayerData
)
2022-04-22 06:05:56 +03:00
if (!isValid) {
return { error, isValid: false }
}
return {
isValid,
name,
url: realUrl || '',
address: address || '',
tornadoServiceFee: tornadoServiceFee || 0.0,
ethPrices: ethPrices || { torn: '1' }
}
} catch (err) {
return {
isValid: false,
error: this.app.i18n.t(err.message)
}
}
},
async relayTornadoWithdraw({ state, commit, dispatch, rootState }, { note }) {
const { currency, netId, amount, commitmentHex } = parseNote(note)
const config = networkConfig[`netId${netId}`]
const contract = config.tokens[currency].instanceAddress[amount]
try {
const { proof, args } = rootState.application.notes[note]
const message = {
args,
proof,
contract
}
dispatch(
'loading/changeText',
{ message: this.app.i18n.t('relayerIsNowSendingYourTransaction') },
{ root: true }
)
const response = await fetch(state.selectedRelayer.url + 'v1/tornadoWithdraw', {
method: 'POST',
mode: 'cors',
cache: 'no-cache',
headers: {
'Content-Type': 'application/json'
},
redirect: 'error',
body: JSON.stringify(message)
})
if (response.status === 400) {
const { error } = await response.json()
throw new Error(error)
}
if (response.status === 200) {
const { id } = await response.json()
const timestamp = Math.round(new Date().getTime() / 1000)
commit('SAVE_JOB', {
id,
netId,
type: 'tornado',
action: 'Deposit',
relayerUrl: state.selectedRelayer.url,
commitmentHex,
amount,
currency,
timestamp,
note
})
dispatch('runJobWatcherWithNotifications', { id, type: 'tornado', netId })
} else {
throw new Error(this.app.i18n.t('unknownError'))
}
} catch (e) {
console.error('relayTornadoWithdraw', e)
const { name, url } = state.selectedRelayer
throw new Error(this.app.i18n.t('relayRequestFailed', { relayerName: name === 'custom' ? url : name }))
}
},
async runJobWatcherWithNotifications({ dispatch, state }, { routerLink, id, netId, type }) {
const { amount, currency } = state.jobs[`netId${netId}`][type][id]
const noticeId = await dispatch(
'notice/addNotice',
{
notice: {
title: {
path: 'withdrawing',
amount,
currency
},
type: 'loading',
routerLink
}
},
{ root: true }
)
try {
await dispatch('runJobWatcher', { id, netId, type, noticeId })
dispatch('deleteJob', { id, netId, type })
} catch (err) {
dispatch(
'notice/updateNotice',
{
id: noticeId,
notice: {
title: 'transactionFailed',
type: 'danger',
routerLink: undefined
}
},
{ root: true }
)
dispatch(
'notice/addNoticeWithInterval',
{
notice: {
title: 'relayerError',
type: 'danger'
}
},
{ root: true }
)
}
},
deleteJob({ state, dispatch, commit }, { id, netId, type }) {
dispatch('stopFinishJobWatcher', { id })
const { amount, currency, action, fee, txHash, note } = state.jobs[`netId${netId}`][type][id]
commit('DELETE_JOB', { id, netId, type })
dispatch(
'txHashKeeper/updateDeposit',
{ amount, currency, netId, type, action, note, txHash, fee },
{ root: true }
)
},
runJobWatcher({ state, dispatch }, { id, netId, type, noticeId }) {
console.log('runJobWatcher started for job', id)
return new Promise((resolve, reject) => {
const getConfirmations = async ({ id, netId, type, noticeId, retryAttempt = 0, noticeCalls = 0 }) => {
try {
const job = state.jobs[`netId${netId}`][type][id]
if (job.status === 'FAILED') {
retryAttempt = 6
throw new Error('Relayer is not responding')
}
const response = await fetch(`${job.relayerUrl}v1/jobs/${id}`, {
method: 'GET',
mode: 'cors',
cache: 'no-cache',
headers: {
'Content-Type': 'application/json'
},
redirect: 'error'
})
if (response.status === 400) {
const { error } = await response.json()
console.error('runJobWatcher', error)
throw new Error(this.app.i18n.t('relayerError'))
}
if (response.status === 200) {
await dispatch('handleResponse', {
id,
response,
job,
type,
netId,
retryAttempt,
noticeId,
noticeCalls,
resolve,
getConfirmations
})
} else {
throw new Error(this.app.i18n.t('unknownError'))
}
} catch (e) {
if (retryAttempt < 5) {
retryAttempt++
setTimeout(
() =>
getConfirmations({
id,
netId,
type,
noticeId,
retryAttempt,
noticeCalls
}),
3000
)
}
reject(e.message)
}
}
getConfirmations({ id, netId, type, noticeId })
dispatch('finishJobWatcher', { id, netId, type })
})
},
async handleResponse(
{ state, rootGetters, commit, dispatch, getters, rootState },
{ response, id, job, type, netId, retryAttempt, resolve, getConfirmations, noticeId, noticeCalls }
) {
const { amount, currency } = job
const { txHash, confirmations, status, failedReason } = await response.json()
console.log('txHash, confirmations, status, failedReason', txHash, confirmations, status, failedReason)
commit('UPDATE_JOB', { id, netId, type, txHash, confirmations, status, failedReason })
if (status === 'FAILED') {
dispatch('stopFinishJobWatcher', { id })
commit('DELETE_JOB', { id, netId, type })
retryAttempt = 6
console.error('runJobWatcher.handleResponse', failedReason)
throw new Error(this.app.i18n.t('relayerError'))
}
if (txHash && noticeCalls === 0 && (Number(confirmations) > 0 || status === 'CONFIRMED')) {
noticeCalls++
dispatch(
'notice/updateNotice',
{
id: noticeId,
notice: {
title: {
path: 'withdrawnValue',
amount,
currency
},
type: 'success',
txHash
},
interval: 10000
},
{ root: true }
)
}
if (status === 'CONFIRMED') {
console.log(`Job ${id} has enough confirmations`)
resolve(txHash)
} else {
setTimeout(() => getConfirmations({ id, netId, type, noticeId, retryAttempt, noticeCalls }), 3000)
}
},
finishJobWatcher({ state, rootGetters, commit, dispatch, getters, rootState }, { id, netId, type }) {
const timerId = setTimeout(() => {
const { txHash, confirmations } = state.jobs[`netId${netId}`][type][id]
commit('UPDATE_JOB', {
id,
netId,
type,
txHash,
confirmations,
status: 'FAILED',
failedReason: this.app.i18n.t('relayerIsNotResponding')
})
commit('DELETE_JOB_WATCHER', { id })
}, 15 * 60 * 1000)
commit('ADD_JOB_WATCHER', { id, timerId })
},
stopFinishJobWatcher({ state, rootGetters, commit, dispatch, getters, rootState }, { id }) {
console.log(`Stop finishJobWatcher ${id}`)
const { timerId } = state.jobWatchers[id]
clearTimeout(timerId)
commit('DELETE_JOB_WATCHER', { id })
},
runAllJobs({ state, commit, dispatch, rootState }) {
const netId = rootState.metamask.netId
const jobs = state.jobs[`netId${netId}`]
for (const type in jobs) {
for (const [id, { status }] of Object.entries(jobs[type])) {
const job = { id, netId, type }
if (status === 'FAILED') {
commit('DELETE_JOB', job)
} else {
dispatch('runJobWatcherWithNotifications', job)
}
}
}
}
}