import Web3 from 'web3' import namehash from 'eth-ens-namehash' import { BigNumber as BN } from 'bignumber.js' import { toChecksumAddress, isAddress } from 'web3-utils' import networkConfig from '@/networkConfig' import { REGISTRY_DEPLOYED_BLOCK, corsConfig } from '@/constants' import { sleep, flattenNArray } from '@/utils' import AggregatorABI from '@/abis/Aggregator.abi.json' import RelayerRegistryABI from '@/abis/RelayerRegistry.abi.json' const MIN_STAKE_BALANCE = '0x22B1C8C1227A00000' // 40 TORN const subdomains = Object.values(networkConfig).map(({ ensSubdomainKey }) => ensSubdomainKey) class RelayerRegister { constructor(provider) { this.provider = provider this.$indexedDB = window.$nuxt.$indexedDB(1) const { registryContract, aggregatorContract } = networkConfig.netId1 this.aggregator = new this.provider.Contract(AggregatorABI, aggregatorContract) this.relayerRegistry = new this.provider.Contract(RelayerRegistryABI, registryContract) } fetchEvents = ({ fromBlock, toBlock }) => { if (fromBlock <= toBlock) { return new Promise((resolve, reject) => { try { const registeredEventsPart = this.relayerRegistry.getPastEvents('RelayerRegistered', { fromBlock, toBlock }) resolve(registeredEventsPart) } catch (error) { sleep(200) const midBlock = (fromBlock + toBlock) >> 1 if (midBlock - fromBlock < 2) { reject(new Error(`error fetching events: ${error.message}`)) } const arr1 = this.fetchEvents({ fromBlock, toBlock: midBlock }) const arr2 = this.fetchEvents({ fromBlock: midBlock + 1, toBlock }) resolve([...arr1, ...arr2]) } }) } else { return [] } } batchFetchEvents = async ({ fromBlock, toBlock }) => { const blockRange = 10000 const blockDifference = toBlock - fromBlock const chunkCount = Math.ceil(blockDifference / blockRange) const blockDenom = Math.ceil(blockDifference / chunkCount) const promises = new Array(chunkCount).fill('').map((_, i) => this.fetchEvents({ fromBlock: i * blockDenom + fromBlock, toBlock: (i + 1) * blockDenom + fromBlock }) ) const batchEvents = flattenNArray(await Promise.all(promises)) const events = batchEvents.map((e) => ({ ...e.returnValues })) return events } saveEvents = async ({ events, lastSyncBlock, storeName }) => { try { if (this.$indexedDB.isBlocked) { return } await this.$indexedDB.putItem({ data: { blockNumber: lastSyncBlock, name: storeName }, storeName: 'lastEvents' }) if (events.length) { this.$indexedDB.createMultipleTransactions({ data: events, storeName }) } } catch (err) { console.error(`saveEvents has error: ${err.message}`) } } getCachedData = async () => { let blockFrom = REGISTRY_DEPLOYED_BLOCK[1] try { const blockTo = await this.provider.getBlockNumber() const cachedEvents = await this.$indexedDB.getAll({ storeName: 'register_events' }) const lastBlock = await this.$indexedDB.getFromIndex({ indexName: 'name', key: 'register_events', storeName: 'lastEvents' }) if (lastBlock) { blockFrom = blockTo >= lastBlock.blockNumber ? lastBlock.blockNumber + 1 : blockTo } return { blockFrom, blockTo, cachedEvents } } catch { return { blockFrom, blockTo: 'latest', cachedEvents: [] } } } getENSAddress = async (ensName) => { const { url } = Object.values(networkConfig.netId1.rpcUrls)[0] const httpProvider = new Web3.providers.HttpProvider(url, corsConfig(url)) const provider = new Web3(httpProvider) const ensAddress = await provider.eth.ens.getAddress(ensName) return ensAddress } fetchRelayers = async () => { const blockRange = 10000 // eslint-disable-next-line prefer-const let { blockTo, cachedEvents } = await this.getCachedData() let allRelayers = cachedEvents const currentBlockNumber = await this.provider.getBlockNumber() const fromBlock = cachedEvents.length === 0 ? REGISTRY_DEPLOYED_BLOCK[1] : blockTo const blockDifference = currentBlockNumber - fromBlock try { let toBlock let registerRelayerEvents let lastBlock if (cachedEvents.length > 0 || blockDifference === 0) { return cachedEvents } else if (blockDifference >= blockRange) { toBlock = currentBlockNumber registerRelayerEvents = await this.batchFetchEvents({ fromBlock, toBlock }) lastBlock = toBlock } else { toBlock = fromBlock + blockRange registerRelayerEvents = await this.fetchEvents({ fromBlock, toBlock }) lastBlock = toBlock } const lastIndex = registerRelayerEvents.length - 1 const lastSyncBlock = registerRelayerEvents[lastIndex]?.blockNumber || lastBlock const relayerEvents = cachedEvents.concat(registerRelayerEvents || []) const events = [] for (let x = 0; x < relayerEvents.length; x++) { const { ensName, relayerAddress } = relayerEvents[x] let ensAddress if (!isAddress(relayerAddress)) { ensAddress = await this.getENSAddress(ensName) ensAddress = toChecksumAddress(ensAddress) } else { ensAddress = relayerAddress } events.push({ ensName, relayerAddress: ensAddress }) } await this.saveEvents({ storeName: 'register_events', lastSyncBlock, events }) allRelayers = allRelayers.concat(events) } catch (e) { return cachedEvents } return allRelayers } filterRelayer = (acc, curr, ensSubdomainKey, relayer) => { const subdomainIndex = subdomains.indexOf(ensSubdomainKey) const mainnetSubdomain = curr.records[0] const hostname = curr.records[subdomainIndex] const isHostWithProtocol = hostname.includes('http') const isOwner = relayer.relayerAddress === curr.owner const hasMinBalance = new BN(curr.balance).gte(MIN_STAKE_BALANCE) if ( hostname && isOwner && mainnetSubdomain && curr.isRegistered && hasMinBalance && !isHostWithProtocol ) { acc.push({ hostname, ensName: relayer.ensName, stakeBalance: curr.balance, relayerAddress: relayer.relayerAddress }) } else { console.error(`${relayer.ensName} invalid: `, { isOwner, hasTXT: Boolean(hostname), isHasMinBalance: hasMinBalance, isRegistered: curr.isRegistered, isHostWithoutProtocol: !isHostWithProtocol, isMainnetSubdomain: Boolean(mainnetSubdomain) }) } return acc } getValidRelayers = async (relayers, ensSubdomainKey) => { const relayerNameHashes = relayers.map((r) => namehash.hash(r.ensName)) const relayersData = await this.aggregator.methods.relayersData(relayerNameHashes, subdomains).call() const validRelayers = relayersData.reduce( (acc, curr, index) => this.filterRelayer(acc, curr, ensSubdomainKey, relayers[index]), [] ) return validRelayers } getRelayers = async (ensSubdomainKey) => { const relayers = await this.fetchRelayers() const validRelayers = await this.getValidRelayers(relayers, ensSubdomainKey) return validRelayers } } export const relayerRegisterService = (provider) => new RelayerRegister(provider.eth)