modules/account/store/actions/decryptNotes/encryptFormatTx.js

@@ -25,7 +25,7 @@ export async function _encryptFormatTx({ dispatch, getters, rootGetters }, { eve
     if (!instance) {
       return acc
     }
-    const name = `${netId}${instance.amount}${instance.currency}`
+    const name = `${instance.amount}${instance.currency}`
     if (!acc[name]) {
       const service = eventsInterface.getService({ netId, ...instance })
       acc[name] = { ...instance, service }
@@ -49,7 +49,7 @@ export async function _encryptFormatTx({ dispatch, getters, rootGetters }, { eve
         if (!instance) {
           return
         }
-        const { service } = instances[`${netId}${instance.amount}${instance.currency}`]
+        const { service } = instances[`${instance.amount}${instance.currency}`]
         return getDeposit({ event, netId, service, instance })
       })
 

networkConfig.js

@@ -1,5 +1,3 @@
-export const enabledChains = ['1', '10', '56', '100', '137', '42161']
-export const chainsWithEncryptedNotes = ['1', '5', '56', '100', '137']
 export default {
   netId1: {
     rpcCallRetryAttempt: 15,
@@ -28,14 +26,9 @@ export default {
       mevblockerRPC: {
         name: 'MevblockerRPC',
         url: 'https://rpc.mevblocker.io'
-      },
-      llamaRPC: {
-        name: 'llamarpc',
-        url: 'https://eth.llamarpc.com'
       }
     },
     multicall: '0xeefba1e63905ef1d7acba5a8513c70307c1ce441',
-    routerContract: '0xd90e2f925DA726b50C4Ed8D0Fb90Ad053324F31b',
     registryContract: '0x58E8dCC13BE9780fC42E8723D8EaD4CF46943dF2',
     echoContractAccount: '0x9B27DD5Bb15d42DC224FCD0B7caEbBe16161Df42',
     aggregatorContract: '0xE8F47A78A6D52D317D0D2FFFac56739fE14D1b49',
@@ -304,10 +297,6 @@ export default {
         name: 'Tornado RPC',
         url: 'https://arbitrum-one.chainnodes.org/d692ae63-0a7e-43e0-9da9-fe4f4cc6c607'
       },
-      oneRpc: {
-        name: '1rpc',
-        url: 'https://1rpc.io/arb'
-      },
       Arbitrum: {
         name: 'Arbitrum RPC',
         url: 'https://arb1.arbitrum.io/rpc'

plugins/idb.js

@@ -264,24 +264,24 @@ export default async (ctx, inject) => {
       Object.keys(tokens[token].instanceAddress).forEach((amount) => {
         if (nativeCurrency === token && netId === 1) {
           stores.push({
-            name: `stringify_bloom_${netId}_${token}_${amount}`,
+            name: `stringify_bloom_${token}_${amount}`,
             keyPath: 'hashBloom'
           })
         }
 
         stores.push(
           {
-            name: `deposits_${netId}_${token}_${amount}`,
+            name: `deposits_${token}_${amount}`,
             keyPath: 'leafIndex', // the key by which it refers to the object must be in all instances of the storage
             indexes: DEPOSIT_INDEXES
           },
           {
-            name: `withdrawals_${netId}_${token}_${amount}`,
+            name: `withdrawals_${token}_${amount}`,
             keyPath: 'blockNumber',
             indexes: WITHDRAWAL_INDEXES
           },
           {
-            name: `stringify_tree_${netId}_${token}_${amount}`,
+            name: `stringify_tree_${token}_${amount}`,
             keyPath: 'hashTree'
           }
         )

scripts/checkEventsSync.js

@@ -1,21 +1,24 @@
-import networkConfig, { enabledChains } from '../networkConfig'
+import networkConfig from '../networkConfig'
-import { loadCachedEvents } from './helpers'
+import ABI from '../abis/Instance.abi.json'
+import { loadCachedEvents, getPastEvents } from './helpers'
 
 const EVENTS_PATH = './static/events/'
+const enabledChains = ['1', '56', '100', '137' ]
 
-function main() {
+async function main() {
-  for (const netId of enabledChains) {
+  for (let network in enabledChains) {
+    const netId = enabledChains[network]
     const config = networkConfig[`netId${netId}`]
     const { constants, tokens, nativeCurrency, deployedBlock } = config
     const CONTRACTS = tokens[nativeCurrency].instanceAddress
 
     console.log(`\n ::: ${netId} [${nativeCurrency.toUpperCase()}] :::`)
 
-    for (const [instance] of Object.entries(CONTRACTS)) {
+    for (const [instance, _contract] of Object.entries(CONTRACTS)) {
       console.log(`\n instanceDenomation - ${instance}`)
 
-      const withdrawalCachedEvents = loadCachedEvents({
+      const withdrawalCachedEvents = await loadCachedEvents({
-        name: `withdrawals_${netId}_${nativeCurrency}_${instance}.json`,
+        name: `withdrawals_${nativeCurrency}_${instance}.json`,
         directory: EVENTS_PATH,
         deployedBlock
       })
@@ -24,8 +27,8 @@ function main() {
       console.log('cachedEvents count - ', withdrawalCachedEvents.events.length)
       console.log('lastBlock - ', withdrawalCachedEvents.lastBlock)
 
-      const depositCachedEvents = loadCachedEvents({
+      const depositCachedEvents = await loadCachedEvents({
-        name: `deposits_${netId}_${nativeCurrency}_${instance}.json`,
+        name: `withdrawals_${nativeCurrency}_${instance}.json`,
         directory: EVENTS_PATH,
         deployedBlock
       })
@@ -34,7 +37,7 @@ function main() {
       console.log('cachedEvents count - ', depositCachedEvents.events.length)
       console.log('lastBlock - ', depositCachedEvents.lastBlock)
 
-      const notesCachedEvents = loadCachedEvents({
+      const notesCachedEvents = await loadCachedEvents({
         name: `encrypted_notes_${netId}.json`,
         directory: EVENTS_PATH,
         deployedBlock: constants.ENCRYPTED_NOTES_BLOCK
@@ -43,6 +46,7 @@ function main() {
       console.log('- Notes')
       console.log('cachedEvents count - ', notesCachedEvents.events.length)
       console.log('lastBlock - ', notesCachedEvents.lastBlock)
+
     }
   }
 }

scripts/helpers/download.js

@@ -4,25 +4,25 @@ import Web3 from 'web3'
 
 import networkConfig from '../../networkConfig'
 
-export function download({ name, directory }) {
+export async function download({ name, directory, contentType }) {
   const path = `${directory}${name}.gz`.toLowerCase()
 
-  const data = fs.readFileSync(path, { flag: 'as+' })
+  const data = fs.readFileSync(path)
   const content = zlib.inflateSync(data)
 
   return content
 }
 
-export function loadCachedEvents({ name, directory, deployedBlock }) {
+export async function loadCachedEvents({ name, directory, deployedBlock }) {
   try {
-    const module = download({ contentType: 'string', directory, name })
+    const module = await download({ contentType: 'string', directory, name })
 
     if (module) {
       const events = JSON.parse(module)
 
       return {
         events,
-        lastBlock: events[events.length - 1].blockNumber
+        lastBlock:  events[events.length - 1].blockNumber
       }
     }
   } catch (err) {
@@ -67,7 +67,6 @@ export async function getPastEvents({ type, fromBlock, netId, events, contractAt
     }
 
     console.log(`Fetching ${type}, chainId - ${netId}`, `chunksCount - ${chunksCount}`)
-
     for (let i = 0; i < chunksCount; i++)
       try {
         await new Promise((resolve) => setTimeout(resolve, 200))

scripts/helpers/save.js

@@ -1,11 +1,14 @@
 import fs from 'fs'
 import zlib from 'zlib'
 
-export function save(filePath) {
+export async function save(filePath) {
+  const directories = filePath.split('/')
+  const fileName = directories[directories.length - 1]
+
   try {
     const data = fs.readFileSync(`${filePath}`)
 
-    const payload = zlib.deflateSync(data, {
+    const payload = await zlib.deflateSync(data, {
       level: zlib.constants.Z_BEST_COMPRESSION,
       strategy: zlib.constants.Z_FILTERED
     })

scripts/updateEncryptedEvents.js

@@ -3,12 +3,12 @@ import 'dotenv/config'
 import fs from 'fs'
 import { uniqBy } from 'lodash'
 
-import networkConfig, { enabledChains } from '../networkConfig'
+import networkConfig from '../networkConfig'
 import ABI from '../abis/TornadoProxy.abi.json'
-
 import { getPastEvents, loadCachedEvents } from './helpers'
 
 const EVENTS_PATH = './static/events/'
+const enabledChains = ['1', '5', '56', '100', '137']
 
 async function saveEncryptedNote(netId) {
   const {
@@ -23,7 +23,7 @@ async function saveEncryptedNote(netId) {
   let encryptedEvents = []
   const name = `encrypted_notes_${netId}.json`
 
-  const cachedEvents = loadCachedEvents({
+  const cachedEvents = await loadCachedEvents({
     name,
     directory: EVENTS_PATH,
     deployedBlock: constants.ENCRYPTED_NOTES_BLOCK
@@ -57,13 +57,11 @@ async function saveEncryptedNote(netId) {
   freshEvents = uniqBy(freshEvents, 'encryptedNote').sort((a, b) => b.blockNumber - a.blockNumber)
 
   const eventsJson = JSON.stringify(freshEvents, null, 2) + '\n'
-
   fs.writeFileSync(`${EVENTS_PATH}${name}`, eventsJson)
 }
 
 async function main() {
   const [, , , chain] = process.argv
-
   if (!enabledChains.includes(chain)) {
     throw new Error(`Supported chain ids ${enabledChains.join(', ')}`)
   }

scripts/updateEvents.js

@@ -3,120 +3,87 @@ import 'dotenv/config'
 import fs from 'fs'
 import { uniqBy } from 'lodash'
 
-import networkConfig, { enabledChains } from '../networkConfig'
+import networkConfig from '../networkConfig'
 import ABI from '../abis/Instance.abi.json'
-
 import { loadCachedEvents, getPastEvents } from './helpers'
 
 const EVENTS_PATH = './static/events/'
+const EVENTS = ['Deposit', 'Withdrawal']
+const enabledChains = ['1', '56', '100', '137']
 
-function parseArg(netId, tokenOrEvent) {
+async function main(type, netId) {
-  const { tokens } = networkConfig[`netId${netId}`]
+  const { tokens, nativeCurrency, deployedBlock } = networkConfig[`netId${netId}`]
-  const keys = Object.keys(tokens)
+  const CONTRACTS = tokens[nativeCurrency].instanceAddress
-  if (tokenOrEvent !== undefined) {
-    const lower = tokenOrEvent.toLowerCase()
-    return keys.includes(lower)
-      ? { token: lower }
-      : { event: lower[0].toUpperCase() + lower.slice(1).toLowerCase() }
-  } else return undefined
-}
 
-function parseDepositEvent({ blockNumber, transactionHash, returnValues }) {
+  for (const [instance, _contract] of Object.entries(CONTRACTS)) {
-  const { commitment, leafIndex, timestamp } = returnValues
+    const cachedEvents = await loadCachedEvents({
-  return {
+      name: `${type.toLowerCase()}s_${nativeCurrency}_${instance}.json`,
-    timestamp,
+      directory: EVENTS_PATH,
-    commitment,
+      deployedBlock
-    blockNumber,
+    })
-    transactionHash,
-    leafIndex: Number(leafIndex)
-  }
-}
 
-function parseWithdrawalEvent({ blockNumber, transactionHash, returnValues }) {
+    console.log('Update events for', instance, nativeCurrency.toUpperCase(), `${type.toLowerCase()}s`)
-  const { nullifierHash, to, fee } = returnValues
+    console.log('cachedEvents count - ', cachedEvents.events.length)
-  return {
+    console.log('lastBlock - ', cachedEvents.lastBlock)
-    to,
-    fee,
-    blockNumber,
-    nullifierHash,
-    transactionHash
-  }
-}
 
-function filterWithdrawalEvents(events) {
+    let events = []
-  return uniqBy(events, 'nullifierHash').sort((a, b) => a.blockNumber - b.blockNumber)
-}
 
-function filterDepositEvents(events) {
+    events = await getPastEvents({
-  return events.filter((e, index) => Number(e.leafIndex) === index)
+      type,
-}
+      netId,
+      events,
+      contractAttrs: [ABI, _contract],
+      fromBlock: cachedEvents.lastBlock + 1
+    })
 
-async function main(netId, chosenToken, chosenEvent) {
+    if (type === 'Deposit') {
-  const { tokens, deployedBlock } = networkConfig[`netId${netId}`]
+      events = events.map(({ blockNumber, transactionHash, returnValues }) => {
-
+        const { commitment, leafIndex, timestamp } = returnValues
-  const tokenSymbols = chosenToken !== undefined ? [chosenToken] : Object.keys(tokens)
+        return {
-  const eventNames = chosenEvent !== undefined ? [chosenEvent] : ['Deposit', 'Withdrawal']
+          timestamp,
-
+          commitment,
-  for (const eventName of eventNames) {
+          blockNumber,
-    // Get the parser that we need
+          transactionHash,
-    const parser = eventName === 'Deposit' ? parseDepositEvent : parseWithdrawalEvent
+          leafIndex: Number(leafIndex)
-    // Get the parser that we need
+        }
-    const filter = eventName === 'Deposit' ? filterDepositEvents : filterWithdrawalEvents
+      })
-
-    for (const tokenSymbol of tokenSymbols) {
-      // Now load the denominations and address
-      const instanceData = Object.entries(tokens[tokenSymbol].instanceAddress)
-
-      // And now sync
-      for (const data of instanceData) {
-        const denom = data[0]
-        const address = data[1]
-
-        // Now load cached events
-        const cachedEvents = loadCachedEvents({
-          name: `${eventName.toLowerCase()}s_${netId}_${tokenSymbol}_${denom}.json`,
-          directory: EVENTS_PATH,
-          deployedBlock
-        })
-
-        console.log('Update events for', denom, tokenSymbol.toUpperCase(), `${eventName.toLowerCase()}s`)
-        console.log('cachedEvents count - ', cachedEvents.events.length)
-        console.log('lastBlock - ', cachedEvents.lastBlock)
-
-        let events = await getPastEvents({
-          type: eventName,
-          fromBlock: cachedEvents.lastBlock + 1,
-          netId: netId,
-          events: [],
-          contractAttrs: [ABI, address]
-        })
-
-        events = filter(cachedEvents.events.concat(events.map(parser)))
-
-        fs.writeFileSync(
-          `${EVENTS_PATH}${eventName.toLowerCase()}s_${netId}_${tokenSymbol}_${denom}.json`,
-          JSON.stringify(events, null, 2) + '\n'
-        )
-      }
     }
+
+    if (type === 'Withdrawal') {
+      events = events.map(({ blockNumber, transactionHash, returnValues }) => {
+        const { nullifierHash, to, fee } = returnValues
+        return {
+          to,
+          fee,
+          blockNumber,
+          nullifierHash,
+          transactionHash
+        }
+      })
+    }
+
+    let freshEvents = cachedEvents.events.concat(events)
+
+    if (type === 'Withdrawal') {
+      freshEvents = uniqBy(freshEvents, 'nullifierHash').sort((a, b) => a.blockNumber - b.blockNumber)
+    } else {
+      freshEvents = freshEvents.filter((e, index) => Number(e.leafIndex) === index)
+    }
+
+    const eventsJson = JSON.stringify(freshEvents, null, 2) + '\n'
+    fs.writeFileSync(`${EVENTS_PATH}${type.toLowerCase()}s_${nativeCurrency}_${instance}.json`, eventsJson)
   }
 }
 
-/**
- * @param netId ID of the network for which event(s) should be synced.
- * @param tokenOrEvent Optional token or event.
- * @param eventOrToken Optional token or event. Overwrites the former option.
- */
 async function start() {
-  const [, , , netId, tokenOrEvent, eventOrToken] = process.argv
+  const [, , , chain] = process.argv
-
+  if (!enabledChains.includes(chain)) {
-  const args = { ...parseArg(netId, tokenOrEvent), ...parseArg(netId, eventOrToken) }
-
-  if (!enabledChains.includes(netId)) {
     throw new Error(`Supported chain ids ${enabledChains.join(', ')}`)
   }
 
-  await main(netId, args.token, args.event)
+  for await (const event of EVENTS) {
+    await main(event, chain)
+  }
 }
 
 start()

scripts/updateTree.js

@@ -1,12 +1,11 @@
 import 'dotenv/config'
 
 import fs from 'fs'
-
 import BloomFilter from 'bloomfilter.js'
 import { MerkleTree } from 'fixed-merkle-tree'
 import { buildMimcSponge } from 'circomlibjs'
 
-import networkConfig, { enabledChains } from '../networkConfig'
+import networkConfig from '../networkConfig'
 
 import { loadCachedEvents, save } from './helpers'
 
@@ -15,7 +14,7 @@ const TREES_PATH = './static/trees/'
 const EVENTS_PATH = './static/events/'
 
 const EVENTS = ['deposit']
-
+const enabledChains = ['1', '56', '100', '137' ]
 let mimcHash
 
 const trees = {
@@ -23,8 +22,8 @@ const trees = {
   LEVELS: 20 // const from contract
 }
 
-function getName({ path, type, netId, instance, format = '.json', currName = 'eth' }) {
+function getName({ path, type, instance, format = '.json', currName = 'eth' }) {
-  return `${path}${type.toLowerCase()}s_${netId}_${currName}_${instance}${format}`
+  return `${path}${type.toLowerCase()}s_${currName}_${instance}${format}`
 }
 
 function createTreeZip(netId) {
@@ -37,7 +36,6 @@ function createTreeZip(netId) {
         const baseFilename = getName({
           type,
           instance,
-          netId,
           format: '',
           path: TREES_PATH,
           currName: currencyName.toLowerCase()
@@ -47,7 +45,6 @@ function createTreeZip(netId) {
 
         treesFolder.forEach((fileName) => {
           fileName = `${TREES_PATH}${fileName}`
-
           const isInstanceFile = !fileName.includes('.gz') && fileName.includes(baseFilename)
 
           if (isInstanceFile) {
@@ -70,7 +67,6 @@ async function createTree(netId) {
         const filePath = getName({
           type,
           instance,
-          netId,
           format: '',
           path: TREES_PATH,
           currName: currencyName.toLowerCase()
@@ -78,8 +74,8 @@ async function createTree(netId) {
 
         console.log('createTree', { type, instance })
 
-        const { events } = loadCachedEvents({
+        const { events } = await loadCachedEvents({
-          name: `${type}s_${netId}_${nativeCurrency}_${instance}.json`,
+          name: `${type}s_${nativeCurrency}_${instance}.json`,
           directory: EVENTS_PATH,
           deployedBlock
         })
@@ -122,12 +118,10 @@ async function createTree(netId) {
           }, [])
 
           const sliceJson = JSON.stringify(slice, null, 2) + '\n'
-
           fs.writeFileSync(`${filePath}_slice${index + 1}.json`, sliceJson)
         })
 
         const bloomCache = bloom.serialize()
-
         fs.writeFileSync(`${filePath}_bloom.json`, bloomCache)
       }
     }
@@ -143,16 +137,13 @@ async function initMimc() {
 
 async function main() {
   const [, , , chain] = process.argv
-
   if (!enabledChains.includes(chain)) {
     throw new Error(`Supported chain ids ${enabledChains.join(', ')}`)
   }
-
   await initMimc()
 
   await createTree(chain)
-
+  await createTreeZip(chain)
-  createTreeZip(chain)
 }
 
 main()

scripts/updateZip.js

@@ -1,7 +1,6 @@
 import { uniqBy } from 'lodash'
 
-import networkConfig, { enabledChains, chainsWithEncryptedNotes } from '../networkConfig'
+import networkConfig from '../networkConfig'
-
 import { loadCachedEvents, save } from './helpers'
 
 const EVENTS_PATH = './static/events/'
@@ -10,26 +9,22 @@ const EVENTS = ['Deposit', 'Withdrawal']
 function updateEncrypted(netId) {
   try {
     const file = `${EVENTS_PATH}encrypted_notes_${netId}.json`
+
     save(file)
   } catch {}
 }
-
 async function updateCommon(netId) {
   const { nativeCurrency, tokens } = networkConfig[`netId${netId}`]
 
   console.log(Object.keys(tokens[nativeCurrency].instanceAddress))
-
   for await (const type of EVENTS) {
     for await (const instance of Object.keys(tokens[nativeCurrency].instanceAddress)) {
       console.warn('instance', instance)
-
+      const filename = `${type.toLowerCase()}s_${nativeCurrency}_${instance}.json`
-      const filename = `${type.toLowerCase()}s_${netId}_${nativeCurrency}_${instance}.json`
-
       const isSaved = save(`${EVENTS_PATH}${filename}`)
-
       if (isSaved) {
         try {
-          testCommon(netId, type, filename)
+          await testCommon(netId, type, filename)
         } catch (err) {
           console.error(err.message)
         }
@@ -38,10 +33,10 @@ async function updateCommon(netId) {
   }
 }
 
-function testCommon(netId, type, filename) {
+async function testCommon(netId, type, filename) {
   const { deployedBlock } = networkConfig[`netId${netId}`]
 
-  const cachedEvents = loadCachedEvents({
+  const cachedEvents = await loadCachedEvents({
     name: filename,
     directory: EVENTS_PATH,
     deployedBlock
@@ -50,13 +45,11 @@ function testCommon(netId, type, filename) {
   console.log('cachedEvents', cachedEvents.events.length, type)
 
   let events = cachedEvents.events
-
   if (type === 'Withdrawal') {
     events = uniqBy(cachedEvents.events, 'nullifierHash')
   } else if (type === 'Deposit') {
     events = cachedEvents.events.filter((e, index) => Number(e.leafIndex) === index)
   }
-
   if (events.length !== cachedEvents.events.length) {
     console.error('events.length', events.length)
     console.error('cachedEvents.events.length', cachedEvents.events.length)
@@ -65,11 +58,10 @@ function testCommon(netId, type, filename) {
 }
 
 async function main() {
-  for (let i = 0; i < enabledChains.length; i++) {
+  const NETWORKS = [1, 5, 56, 100, 137 ]
-    const netId = enabledChains[i]
-
-    if (netId === chainsWithEncryptedNotes[i]) updateEncrypted(netId)
 
+  for await (const netId of NETWORKS) {
+    updateEncrypted(netId)
     await updateCommon(netId)
   }
 }

services/events.js

@@ -2,11 +2,13 @@ import Web3 from 'web3'
 
 import graph from '@/services/graph'
 import { download } from '@/store/snark'
-import networkConfig, { enabledChains } from '@/networkConfig'
+import networkConfig from '@/networkConfig'
 import InstanceABI from '@/abis/Instance.abi.json'
 import { CONTRACT_INSTANCES, eventsType, httpConfig } from '@/constants'
 import { sleep, flattenNArray, formatEvents, capitalizeFirstLetter } from '@/utils'
 
+const supportedCaches = ['1', '56', '100', '137']
+
 let store
 if (process.browser) {
   window.onNuxtReady(({ $store }) => {
@@ -19,7 +21,7 @@ class EventService {
     this.idb = window.$nuxt.$indexedDB(netId)
 
     const { nativeCurrency } = networkConfig[`netId${netId}`]
-    const hasCache = enabledChains.includes(netId.toString())
+    const hasCache = supportedCaches.includes(netId.toString())
 
     this.netId = netId
     this.amount = amount
@@ -33,7 +35,7 @@ class EventService {
   }
 
   getInstanceName(type) {
-    return `${type}s_${this.netId}_${this.currency}_${this.amount}`
+    return `${type}s_${this.currency}_${this.amount}`
   }
 
   updateEventProgress(percentage, type) {
@@ -464,7 +466,7 @@ class EventsFactory {
   }
 
   getService = (payload) => {
-    const instanceName = `${payload.netId}_${payload.currency}_${payload.amount}`
+    const instanceName = `${payload.currency}_${payload.amount}`
 
     if (this.instances.has(instanceName)) {
       return this.instances.get(instanceName)

services/merkleTree.js

@@ -16,19 +16,18 @@ class MerkleTreeService {
     this.instanceName = instanceName
 
     this.idb = window.$nuxt.$indexedDB(netId)
-
     this.bloomService = bloomService({
       netId,
       amount,
       commitment,
       instanceName,
       fileFolder: 'trees',
-      fileName: `deposits_${netId}_${currency}_${amount}_bloom.json.gz`
+      fileName: `deposits_${currency}_${amount}_bloom.json.gz`
     })
   }
 
   getFileName(partNumber = trees.PARTS_COUNT) {
-    return `trees/deposits_${this.netId}_${this.currency}_${this.amount}_slice${partNumber}.json.gz`
+    return `trees/deposits_${this.currency}_${this.amount}_slice${partNumber}.json.gz`
   }
 
   createTree({ events }) {
@@ -186,7 +185,7 @@ class TreesFactory {
   instances = new Map()
 
   getService = (payload) => {
-    const instanceName = `${payload.netId}_${payload.currency}_${payload.amount}`
+    const instanceName = `${payload.currency}_${payload.amount}`
     if (this.instances.has(instanceName)) {
       return this.instances.get(instanceName)
     }