Fix BSC RPC exceed maximum block range

This merge contains the following set of changes:
  * [Improvement] Add /metrics endpoint for prometheus support (#512)
  * [Improvement] Add monitor script for detecting failed AMB messages (#513)
  * [Improvement] Improve performance of BS requests in ALM (#516)
  * [Fix] Add pretty error messages for manual execution transaction reverts (#511)
  * [Fix] Fix resend of stuck pending transactions (#514)

CONFIGURATION.md

@@ -42,6 +42,8 @@ ORACLE_HOME_TO_FOREIGN_BLOCK_LIST | Filename with a list of addresses, separated
 ORACLE_HOME_TO_FOREIGN_CHECK_SENDER | If set to `true`, instructs the oracle to do an extra check for transaction origin in the block/allowance list. `false` by default. | `true` / `false`
 ORACLE_ALWAYS_RELAY_SIGNATURES | If set to `true`, the oracle will always relay signatures even if it was not the last who finilized the signatures collecting process. The default is `false`. | `true` / `false`
 ORACLE_RPC_REQUEST_TIMEOUT | Timeout in milliseconds for a single RPC request. Default value is `ORACLE_*_RPC_POLLING_INTERVAL * 2`. | integer
+ORACLE_HOME_TX_RESEND_INTERVAL | Interval in milliseconds for automatic resending of stuck transactions for Home sender service. Defaults to 20 minutes. | integer  
+ORACLE_FOREIGN_TX_RESEND_INTERVAL | Interval in milliseconds for automatic resending of stuck transactions for Foreign sender service. Defaults to 20 minutes. | integer  
 
 
 ## UI configuration
@@ -84,3 +86,5 @@ MONITOR_HOME_TO_FOREIGN_BLOCK_LIST | File with a list of addresses, separated by
 MONITOR_HOME_TO_FOREIGN_CHECK_SENDER | If set to `true`, instructs the oracle to do an extra check for transaction origin in the block/allowance list. `false` by default. | `true` / `false`
 MONITOR_HOME_VALIDATORS_BALANCE_ENABLE | If set, defines the list of home validator addresses for which balance should be checked. | `string`
 MONITOR_FOREIGN_VALIDATORS_BALANCE_ENABLE | If set, defines the list of foreign validator addresses for which balance should be checked. | `string`
+MONITOR_HOME_EXPLORER_API | The HTTPS URL of the Home network explorer API. If set, may be used as a fallback in case of the RPC node failure. | URL
+MONITOR_FOREIGN_EXPLORER_API | The HTTPS URL of the Foreign network explorer API. If set, may be used as a fallback in case of the RPC node failure. | URL

alm/Dockerfile

@@ -19,7 +19,7 @@ COPY --from=contracts /mono/contracts/build ./contracts/build
 COPY commons/package.json ./commons/
 COPY alm/package.json ./alm/
 COPY yarn.lock .
-RUN NOYARNPOSTINSTALL=1 yarn install --frozen-lockfile --production
+RUN NOYARNPOSTINSTALL=1 yarn install --frozen-lockfile
 
 COPY ./commons ./commons
 COPY ./alm ./alm

alm/package.json

@@ -58,6 +58,7 @@
     ]
   },
   "devDependencies": {
-    "eslint-plugin-prettier": "^3.1.3"
+    "eslint-plugin-prettier": "^3.1.3",
+    "node-fetch": "^2.6.1"
   }
 }

alm/scripts/createSnapshots.js

@@ -3,6 +3,8 @@ const { BRIDGE_VALIDATORS_ABI, HOME_AMB_ABI } = require('commons')
 const path = require('path')
 require('dotenv').config()
 const Web3 = require('web3')
+const fetch = require('node-fetch')
+const { URL } = require('url')
 
 const fs = require('fs')
 
@@ -10,7 +12,9 @@ const {
   COMMON_HOME_RPC_URL,
   COMMON_HOME_BRIDGE_ADDRESS,
   COMMON_FOREIGN_RPC_URL,
-  COMMON_FOREIGN_BRIDGE_ADDRESS
+  COMMON_FOREIGN_BRIDGE_ADDRESS,
+  ALM_FOREIGN_EXPLORER_API,
+  ALM_HOME_EXPLORER_API
 } = process.env
 
 const generateSnapshot = async (side, url, bridgeAddress) => {
@@ -19,6 +23,31 @@ const generateSnapshot = async (side, url, bridgeAddress) => {
   const snapshot = {}
 
   const web3 = new Web3(new Web3.providers.HttpProvider(url))
+  const api = side === 'home' ? ALM_HOME_EXPLORER_API : ALM_FOREIGN_EXPLORER_API
+
+  const getPastEventsWithFallback = (contract, eventName, options) =>
+    contract.getPastEvents(eventName, options).catch(async e => {
+      if (e.message.includes('exceed maximum block range')) {
+        const abi = contract.options.jsonInterface.find(abi => abi.type === 'event' && abi.name === eventName)
+
+        const url = new URL(api)
+        url.searchParams.append('module', 'logs')
+        url.searchParams.append('action', 'getLogs')
+        url.searchParams.append('address', contract.options.address)
+        url.searchParams.append('fromBlock', options.fromBlock)
+        url.searchParams.append('toBlock', options.toBlock || 'latest')
+        url.searchParams.append('topic0', web3.eth.abi.encodeEventSignature(abi))
+
+        const logs = await fetch(url).then(res => res.json())
+
+        return logs.result.map(log => ({
+          transactionHash: log.transactionHash,
+          blockNumber: parseInt(log.blockNumber.slice(2), 16),
+          returnValues: web3.eth.abi.decodeLog(abi.inputs, log.data, log.topics.slice(1))
+        }))
+      }
+      throw e
+    })
 
   const currentBlockNumber = await web3.eth.getBlockNumber()
   snapshot.snapshotBlockNumber = currentBlockNumber
@@ -29,10 +58,14 @@ const generateSnapshot = async (side, url, bridgeAddress) => {
   const bridgeContract = new web3.eth.Contract(HOME_AMB_ABI, bridgeAddress)
 
   // Save RequiredBlockConfirmationChanged events
-  let requiredBlockConfirmationChangedEvents = await bridgeContract.getPastEvents('RequiredBlockConfirmationChanged', {
-    fromBlock: 0,
-    toBlock: currentBlockNumber
-  })
+  let requiredBlockConfirmationChangedEvents = await getPastEventsWithFallback(
+    bridgeContract,
+    'RequiredBlockConfirmationChanged',
+    {
+      fromBlock: 0,
+      toBlock: currentBlockNumber
+    }
+  )
 
   // In case RequiredBlockConfirmationChanged was not emitted during initialization in early versions of AMB
   // manually generate an event for this. Example Sokol - Kovan bridge
@@ -59,10 +92,14 @@ const generateSnapshot = async (side, url, bridgeAddress) => {
   const validatorContract = new web3.eth.Contract(BRIDGE_VALIDATORS_ABI, validatorAddress)
 
   // Save RequiredSignaturesChanged events
-  const RequiredSignaturesChangedEvents = await validatorContract.getPastEvents('RequiredSignaturesChanged', {
-    fromBlock: 0,
-    toBlock: currentBlockNumber
-  })
+  const RequiredSignaturesChangedEvents = await getPastEventsWithFallback(
+    validatorContract,
+    'RequiredSignaturesChanged',
+    {
+      fromBlock: 0,
+      toBlock: currentBlockNumber
+    }
+  )
   snapshot.RequiredSignaturesChanged = RequiredSignaturesChangedEvents.map(e => ({
     blockNumber: e.blockNumber,
     returnValues: {
@@ -71,7 +108,7 @@ const generateSnapshot = async (side, url, bridgeAddress) => {
   }))
 
   // Save ValidatorAdded events
-  const validatorAddedEvents = await validatorContract.getPastEvents('ValidatorAdded', {
+  const validatorAddedEvents = await getPastEventsWithFallback(validatorContract, 'ValidatorAdded', {
     fromBlock: 0,
     toBlock: currentBlockNumber
   })
@@ -85,7 +122,7 @@ const generateSnapshot = async (side, url, bridgeAddress) => {
   }))
 
   // Save ValidatorRemoved events
-  const validatorRemovedEvents = await validatorContract.getPastEvents('ValidatorRemoved', {
+  const validatorRemovedEvents = await getPastEventsWithFallback(validatorContract, 'ValidatorRemoved', {
     fromBlock: 0,
     toBlock: currentBlockNumber
   })

alm/src/components/ConfirmationsContainer.tsx

@@ -39,10 +39,17 @@ export interface ConfirmationsContainerParams {
   message: MessageObject
   receipt: Maybe<TransactionReceipt>
   fromHome: boolean
-  timestamp: number
+  homeStartBlock: Maybe<number>
+  foreignStartBlock: Maybe<number>
 }
 
-export const ConfirmationsContainer = ({ message, receipt, fromHome, timestamp }: ConfirmationsContainerParams) => {
+export const ConfirmationsContainer = ({
+  message,
+  receipt,
+  fromHome,
+  homeStartBlock,
+  foreignStartBlock
+}: ConfirmationsContainerParams) => {
   const {
     home: { name: homeName },
     foreign: { name: foreignName }
@@ -62,7 +69,8 @@ export const ConfirmationsContainer = ({ message, receipt, fromHome, timestamp }
     message,
     receipt,
     fromHome,
-    timestamp,
+    homeStartBlock,
+    foreignStartBlock,
     requiredSignatures,
     validatorList,
     blockConfirmations

alm/src/components/ExecutionConfirmation.tsx

@@ -36,10 +36,12 @@ export const ExecutionConfirmation = ({
   const availableManualExecution =
     !isHome &&
     (executionData.status === VALIDATOR_CONFIRMATION_STATUS.WAITING ||
+      executionData.status === VALIDATOR_CONFIRMATION_STATUS.FAILED ||
       (executionData.status === VALIDATOR_CONFIRMATION_STATUS.UNDEFINED &&
         executionEventsFetched &&
         !!executionData.validator))
   const requiredManualExecution = availableManualExecution && ALM_HOME_TO_FOREIGN_MANUAL_EXECUTION
+  const showAgeColumn = !requiredManualExecution || executionData.status === VALIDATOR_CONFIRMATION_STATUS.FAILED
   const windowWidth = useWindowWidth()
 
   const txExplorerLink = getExplorerTxUrl(executionData.txHash, isHome)
@@ -71,7 +73,7 @@ export const ExecutionConfirmation = ({
           <tr>
             <th>{requiredManualExecution ? 'Execution info' : 'Executed by'}</th>
             <th className="text-center">Status</th>
-            {!requiredManualExecution && <th className="text-center">Age</th>}
+            {showAgeColumn && <th className="text-center">Age</th>}
             {availableManualExecution && <th className="text-center">Actions</th>}
           </tr>
         </Thead>
@@ -87,7 +89,7 @@ export const ExecutionConfirmation = ({
               )}
             </td>
             <StatusTd className="text-center">{getExecutionStatusElement(executionData.status)}</StatusTd>
-            {!requiredManualExecution && (
+            {showAgeColumn && (
               <AgeTd className="text-center">
                 {executionData.timestamp > 0 ? (
                   <ExplorerTxLink href={txExplorerLink} target="_blank">

alm/src/components/ManualExecutionButton.tsx

@@ -2,9 +2,18 @@ import React, { useState, useEffect } from 'react'
 import styled from 'styled-components'
 import { InjectedConnector } from '@web3-react/injected-connector'
 import { useWeb3React } from '@web3-react/core'
-import { INCORRECT_CHAIN_ERROR, VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
+import {
+  DOUBLE_EXECUTION_ATTEMPT_ERROR,
+  EXECUTION_FAILED_ERROR,
+  EXECUTION_OUT_OF_GAS_ERROR,
+  FOREIGN_EXPLORER_API,
+  INCORRECT_CHAIN_ERROR,
+  VALIDATOR_CONFIRMATION_STATUS
+} from '../config/constants'
 import { useStateProvider } from '../state/StateProvider'
 import { signatureToVRS, packSignatures } from '../utils/signatures'
+import { getSuccessExecutionData } from '../utils/getFinalizationEvent'
+import { TransactionReceipt } from 'web3-eth'
 
 const StyledButton = styled.button`
   color: var(--button-color);
@@ -61,7 +70,9 @@ export const ManualExecutionButton = ({
       if (!library || !foreign.bridgeContract || !signatureCollected || !signatureCollected.length) return
 
       const signatures = packSignatures(signatureCollected.map(signatureToVRS))
-      const data = foreign.bridgeContract.methods.executeSignatures(messageData, signatures).encodeABI()
+      const messageId = messageData.slice(0, 66)
+      const bridge = foreign.bridgeContract
+      const data = bridge.methods.executeSignatures(messageData, signatures).encodeABI()
       setManualExecution(false)
 
       library.eth
@@ -80,7 +91,33 @@ export const ManualExecutionButton = ({
           })
           setPendingExecution(true)
         })
-        .on('error', (e: Error) => setError(e.message))
+        .on('error', async (e: Error, receipt: TransactionReceipt) => {
+          if (e.message.includes('Transaction has been reverted by the EVM')) {
+            const successExecutionData = await getSuccessExecutionData(
+              bridge,
+              'RelayedMessage',
+              library,
+              messageId,
+              FOREIGN_EXPLORER_API
+            )
+            if (successExecutionData) {
+              setExecutionData(successExecutionData)
+              setError(DOUBLE_EXECUTION_ATTEMPT_ERROR)
+            } else {
+              const { gas } = await library.eth.getTransaction(receipt.transactionHash)
+              setExecutionData({
+                status: VALIDATOR_CONFIRMATION_STATUS.FAILED,
+                validator: account,
+                txHash: receipt.transactionHash,
+                timestamp: Math.floor(new Date().getTime() / 1000.0),
+                executionResult: false
+              })
+              setError(gas === receipt.gasUsed ? EXECUTION_OUT_OF_GAS_ERROR : EXECUTION_FAILED_ERROR)
+            }
+          } else {
+            setError(e.message)
+          }
+        })
     },
     [
       manualExecution,

alm/src/components/StatusContainer.tsx

@@ -10,6 +10,7 @@ import { ExplorerTxLink } from './commons/ExplorerTxLink'
 import { ConfirmationsContainer } from './ConfirmationsContainer'
 import { TransactionReceipt } from 'web3-eth'
 import { BackButton } from './commons/BackButton'
+import { useClosestBlock } from '../hooks/useClosestBlock'
 
 export interface StatusContainerParam {
   onBackToMain: () => void
@@ -23,12 +24,15 @@ export const StatusContainer = ({ onBackToMain, setNetworkFromParams, receiptPar
   const { chainId, txHash, messageIdParam } = useParams()
   const validChainId = chainId === home.chainId.toString() || chainId === foreign.chainId.toString()
   const validParameters = validChainId && validTxHash(txHash)
+  const isHome = chainId === home.chainId.toString()
 
   const { messages, receipt, status, description, timestamp, loading } = useTransactionStatus({
     txHash: validParameters ? txHash : '',
     chainId: validParameters ? parseInt(chainId) : 0,
     receiptParam
   })
+  const homeStartBlock = useClosestBlock(true, isHome, receipt, timestamp)
+  const foreignStartBlock = useClosestBlock(false, isHome, receipt, timestamp)
 
   const selectedMessageId = messageIdParam === undefined || messages[messageIdParam] === undefined ? -1 : messageIdParam
 
@@ -64,7 +68,6 @@ export const StatusContainer = ({ onBackToMain, setNetworkFromParams, receiptPar
   const displayReference = multiMessageSelected ? messages[selectedMessageId].id : txHash
   const formattedMessageId = formatTxHash(displayReference)
 
-  const isHome = chainId === home.chainId.toString()
   const txExplorerLink = getExplorerTxUrl(txHash, isHome)
   const displayExplorerLink = status !== TRANSACTION_STATUS.NOT_FOUND
 
@@ -101,7 +104,13 @@ export const StatusContainer = ({ onBackToMain, setNetworkFromParams, receiptPar
       )}
       {displayMessageSelector && <MessageSelector messages={messages} onMessageSelected={onMessageSelected} />}
       {displayConfirmations && (
-        <ConfirmationsContainer message={messageToConfirm} receipt={receipt} fromHome={isHome} timestamp={timestamp} />
+        <ConfirmationsContainer
+          message={messageToConfirm}
+          receipt={receipt}
+          fromHome={isHome}
+          homeStartBlock={homeStartBlock}
+          foreignStartBlock={foreignStartBlock}
+        />
       )}
       <BackButton onBackToMain={onBackToMain} />
     </div>

alm/src/components/commons/ErrorAlert.tsx

@@ -2,6 +2,7 @@ import React from 'react'
 import styled from 'styled-components'
 import { InfoIcon } from './InfoIcon'
 import { CloseIcon } from './CloseIcon'
+import { ExplorerTxLink } from './ExplorerTxLink'
 
 const StyledErrorAlert = styled.div`
   border: 1px solid var(--failed-color);
@@ -15,17 +16,33 @@ const CloseIconContainer = styled.div`
 `
 
 const TextContainer = styled.div`
+  white-space: pre-wrap;
   flex-direction: column;
 `
 
-export const ErrorAlert = ({ onClick, error }: { onClick: () => void; error: string }) => (
-  <div className="row is-center">
-    <StyledErrorAlert className="col-10 is-vertical-align row">
-      <InfoIcon color="var(--failed-color)" />
-      <TextContainer className="col-10">{error}</TextContainer>
-      <CloseIconContainer className="col-1 is-vertical-align is-center" onClick={onClick}>
-        <CloseIcon color="var(--failed-color)" />
-      </CloseIconContainer>
-    </StyledErrorAlert>
-  </div>
-)
+export const ErrorAlert = ({ onClick, error }: { onClick: () => void; error: string }) => {
+  const errorArray = error.split('%link')
+  const text = errorArray[0]
+  let link
+  if (errorArray.length > 1) {
+    link = (
+      <ExplorerTxLink href={errorArray[1]} target="_blank" rel="noopener noreferrer">
+        {errorArray[1]}
+      </ExplorerTxLink>
+    )
+  }
+  return (
+    <div className="row is-center">
+      <StyledErrorAlert className="col-10 is-vertical-align row">
+        <InfoIcon color="var(--failed-color)" />
+        <TextContainer className="col-10">
+          {text}
+          {link}
+        </TextContainer>
+        <CloseIconContainer className="col-1 is-vertical-align is-center" onClick={onClick}>
+          <CloseIcon color="var(--failed-color)" />
+        </CloseIconContainer>
+      </StyledErrorAlert>
+    </div>
+  )
+}

alm/src/config/constants.ts

@@ -18,9 +18,8 @@ export const ALM_HOME_TO_FOREIGN_MANUAL_EXECUTION: boolean =
 
 export const HOME_RPC_POLLING_INTERVAL: number = 5000
 export const FOREIGN_RPC_POLLING_INTERVAL: number = 5000
-export const BLOCK_RANGE: number = 50
-export const ONE_DAY_TIMESTAMP: number = 86400
-export const THREE_DAYS_TIMESTAMP: number = 259200
+export const BLOCK_RANGE: number = 500
+export const MAX_TX_SEARCH_BLOCK_RANGE: number = 10000
 
 export const EXECUTE_AFFIRMATION_HASH = 'e7a2c01f'
 export const SUBMIT_SIGNATURE_HASH = '630cea8e'
@@ -66,3 +65,12 @@ export const VALIDATOR_CONFIRMATION_STATUS = {
 export const SEARCHING_TX = 'Searching Transaction...'
 
 export const INCORRECT_CHAIN_ERROR = `Incorrect chain chosen. Switch to ${FOREIGN_NETWORK_NAME} in the wallet.`
+
+export const DOUBLE_EXECUTION_ATTEMPT_ERROR = `Your execution transaction has been reverted.
+However, the execution completed successfully in the transaction sent by a different party.`
+
+export const EXECUTION_FAILED_ERROR = `Your execution transaction has been reverted.
+Please, contact the support by messaging on %linkhttps://forum.poa.network/c/support`
+
+export const EXECUTION_OUT_OF_GAS_ERROR = `Your execution transaction has been reverted due to Out-of-Gas error.
+Please, resend the transaction and provide more gas to it.`

alm/src/hooks/useBlockConfirmations.ts

@@ -4,6 +4,8 @@ import { useStateProvider } from '../state/StateProvider'
 import { Contract } from 'web3-eth-contract'
 import { getRequiredBlockConfirmations } from '../utils/contract'
 import { foreignSnapshotProvider, homeSnapshotProvider, SnapshotProvider } from '../services/SnapshotProvider'
+import Web3 from 'web3'
+import { FOREIGN_EXPLORER_API, HOME_EXPLORER_API } from '../config/constants'
 
 export interface UseBlockConfirmationsParams {
   fromHome: boolean
@@ -19,9 +21,11 @@ export const useBlockConfirmations = ({ receipt, fromHome }: UseBlockConfirmatio
     contract: Contract,
     receipt: TransactionReceipt,
     setResult: Function,
-    snapshotProvider: SnapshotProvider
+    snapshotProvider: SnapshotProvider,
+    web3: Web3,
+    api: string
   ) => {
-    const result = await getRequiredBlockConfirmations(contract, receipt.blockNumber, snapshotProvider)
+    const result = await getRequiredBlockConfirmations(contract, receipt.blockNumber, snapshotProvider, web3, api)
     setResult(result)
   }
 
@@ -29,10 +33,12 @@ export const useBlockConfirmations = ({ receipt, fromHome }: UseBlockConfirmatio
     () => {
       const bridgeContract = fromHome ? home.bridgeContract : foreign.bridgeContract
       const snapshotProvider = fromHome ? homeSnapshotProvider : foreignSnapshotProvider
-      if (!bridgeContract || !receipt) return
-      callRequireBlockConfirmations(bridgeContract, receipt, setBlockConfirmations, snapshotProvider)
+      const web3 = fromHome ? home.web3 : foreign.web3
+      const api = fromHome ? HOME_EXPLORER_API : FOREIGN_EXPLORER_API
+      if (!bridgeContract || !receipt || !web3) return
+      callRequireBlockConfirmations(bridgeContract, receipt, setBlockConfirmations, snapshotProvider, web3, api)
     },
-    [home.bridgeContract, foreign.bridgeContract, receipt, fromHome]
+    [home.bridgeContract, foreign.bridgeContract, receipt, fromHome, home.web3, foreign.web3]
   )
 
   return {

alm/src/hooks/useClosestBlock.ts

@@ -0,0 +1,68 @@
+import { useEffect, useState } from 'react'
+import { TransactionReceipt } from 'web3-eth'
+import { useStateProvider } from '../state/StateProvider'
+import { FOREIGN_EXPLORER_API, HOME_EXPLORER_API } from '../config/constants'
+import { getClosestBlockByTimestamp } from '../utils/explorer'
+
+export function useClosestBlock(
+  searchHome: boolean,
+  fromHome: boolean,
+  receipt: Maybe<TransactionReceipt>,
+  timestamp: number
+) {
+  const { home, foreign } = useStateProvider()
+  const [blockNumber, setBlockNumber] = useState<number | null>(null)
+
+  useEffect(
+    () => {
+      if (!receipt || blockNumber || !timestamp) return
+
+      if (fromHome === searchHome) {
+        setBlockNumber(receipt.blockNumber)
+        return
+      }
+
+      const web3 = searchHome ? home.web3 : foreign.web3
+      if (!web3) return
+
+      const getBlock = async () => {
+        // try to fast-fetch closest block number from the chain explorer
+        try {
+          const api = searchHome ? HOME_EXPLORER_API : FOREIGN_EXPLORER_API
+          setBlockNumber(await getClosestBlockByTimestamp(api, timestamp))
+          return
+        } catch {}
+
+        const lastBlock = await web3.eth.getBlock('latest')
+        if (lastBlock.timestamp <= timestamp) {
+          setBlockNumber(lastBlock.number)
+          return
+        }
+
+        const oldBlock = await web3.eth.getBlock(Math.max(lastBlock.number - 10000, 1))
+        const blockDiff = lastBlock.number - oldBlock.number
+        const timeDiff = (lastBlock.timestamp as number) - (oldBlock.timestamp as number)
+        const averageBlockTime = timeDiff / blockDiff
+        let currentBlock = lastBlock
+
+        let prevBlockDiff = Infinity
+        while (true) {
+          const timeDiff = (currentBlock.timestamp as number) - timestamp
+          const blockDiff = Math.ceil(timeDiff / averageBlockTime)
+          if (Math.abs(blockDiff) < 5 || Math.abs(blockDiff) >= Math.abs(prevBlockDiff)) {
+            setBlockNumber(currentBlock.number - blockDiff - 5)
+            break
+          }
+
+          prevBlockDiff = blockDiff
+          currentBlock = await web3.eth.getBlock(currentBlock.number - blockDiff)
+        }
+      }
+
+      getBlock()
+    },
+    [blockNumber, foreign.web3, fromHome, home.web3, receipt, searchHome, timestamp]
+  )
+
+  return blockNumber
+}

alm/src/hooks/useMessageConfirmations.ts

@@ -11,9 +11,6 @@ import {
   VALIDATOR_CONFIRMATION_STATUS
 } from '../config/constants'
 import { homeBlockNumberProvider, foreignBlockNumberProvider } from '../services/BlockNumberProvider'
-import { checkSignaturesWaitingForBLocks } from '../utils/signatureWaitingForBlocks'
-import { getCollectedSignaturesEvent } from '../utils/getCollectedSignaturesEvent'
-import { checkWaitingBlocksForExecution } from '../utils/executionWaitingForBlocks'
 import { getConfirmationsForTx } from '../utils/getConfirmationsForTx'
 import { getFinalizationEvent } from '../utils/getFinalizationEvent'
 import {
@@ -28,7 +25,8 @@ export interface useMessageConfirmationsParams {
   message: MessageObject
   receipt: Maybe<TransactionReceipt>
   fromHome: boolean
-  timestamp: number
+  homeStartBlock: Maybe<number>
+  foreignStartBlock: Maybe<number>
   requiredSignatures: number
   validatorList: string[]
   blockConfirmations: number
@@ -56,17 +54,18 @@ export const useMessageConfirmations = ({
   message,
   receipt,
   fromHome,
-  timestamp,
+  homeStartBlock,
+  foreignStartBlock,
   requiredSignatures,
   validatorList,
   blockConfirmations
 }: useMessageConfirmationsParams) => {
   const { home, foreign } = useStateProvider()
-  const [confirmations, setConfirmations] = useState([])
+  const [confirmations, setConfirmations] = useState<ConfirmationParam[]>([])
   const [status, setStatus] = useState(CONFIRMATIONS_STATUS.UNDEFINED)
   const [waitingBlocks, setWaitingBlocks] = useState(false)
   const [waitingBlocksResolved, setWaitingBlocksResolved] = useState(false)
-  const [signatureCollected, setSignatureCollected] = useState(false)
+  const [signatureCollected, setSignatureCollected] = useState<boolean | string[]>(false)
   const [executionEventsFetched, setExecutionEventsFetched] = useState(false)
   const [collectedSignaturesEvent, setCollectedSignaturesEvent] = useState<Maybe<EventData>>(null)
   const [executionData, setExecutionData] = useState<ExecutionData>({
@@ -83,150 +82,175 @@ export const useMessageConfirmations = ({
   const [pendingConfirmations, setPendingConfirmations] = useState(false)
   const [pendingExecution, setPendingExecution] = useState(false)
 
-  const existsConfirmation = (confirmationArray: ConfirmationParam[]) => {
-    const filteredList = confirmationArray.filter(
+  const existsConfirmation = (confirmationArray: ConfirmationParam[]) =>
+    confirmationArray.some(
       c => c.status !== VALIDATOR_CONFIRMATION_STATUS.UNDEFINED && c.status !== VALIDATOR_CONFIRMATION_STATUS.WAITING
     )
-    return filteredList.length > 0
-  }
+
+  // start watching blocks at the start
+  useEffect(
+    () => {
+      if (!home.web3 || !foreign.web3) return
+
+      homeBlockNumberProvider.start(home.web3)
+      foreignBlockNumberProvider.start(foreign.web3)
+    },
+    [foreign.web3, home.web3]
+  )
 
   // Check if the validators are waiting for block confirmations to verify the message
   useEffect(
     () => {
       if (!receipt || !blockConfirmations || waitingBlocksResolved) return
 
-      const subscriptions: Array<number> = []
-
-      const unsubscribe = () => {
-        subscriptions.forEach(s => {
-          clearTimeout(s)
-        })
-      }
+      let timeoutId: number
 
       const blockProvider = fromHome ? homeBlockNumberProvider : foreignBlockNumberProvider
       const interval = fromHome ? HOME_RPC_POLLING_INTERVAL : FOREIGN_RPC_POLLING_INTERVAL
-      const web3 = fromHome ? home.web3 : foreign.web3
-      blockProvider.start(web3)
-
       const targetBlock = receipt.blockNumber + blockConfirmations
+      const validatorsWaiting = validatorList.map(validator => ({
+        validator,
+        status: VALIDATOR_CONFIRMATION_STATUS.WAITING,
+        txHash: '',
+        timestamp: 0
+      }))
 
-      checkSignaturesWaitingForBLocks(
-        targetBlock,
-        setWaitingBlocks,
-        setWaitingBlocksResolved,
-        validatorList,
-        setConfirmations,
-        blockProvider,
-        interval,
-        subscriptions
-      )
+      const checkSignaturesWaitingForBLocks = () => {
+        const currentBlock = blockProvider.get()
 
-      return () => {
-        unsubscribe()
-        blockProvider.stop()
+        if (currentBlock && currentBlock >= targetBlock) {
+          setWaitingBlocksResolved(true)
+          setWaitingBlocks(false)
+        } else if (currentBlock) {
+          setWaitingBlocks(true)
+          setConfirmations(validatorsWaiting)
+          timeoutId = setTimeout(checkSignaturesWaitingForBLocks, interval)
+        } else {
+          timeoutId = setTimeout(checkSignaturesWaitingForBLocks, 500)
+        }
       }
+
+      checkSignaturesWaitingForBLocks()
+
+      return () => clearTimeout(timeoutId)
     },
-    [
-      blockConfirmations,
-      foreign.web3,
-      fromHome,
-      validatorList,
-      home.web3,
-      receipt,
-      setConfirmations,
-      waitingBlocksResolved
-    ]
+    [blockConfirmations, fromHome, receipt, validatorList, waitingBlocksResolved]
   )
 
   // The collected signature event is only fetched once the signatures are collected on tx from home to foreign, to calculate if
   // the execution tx on the foreign network is waiting for block confirmations
   // This is executed if the message is in Home to Foreign direction only
+  const hasCollectedSignatures = !!signatureCollected // true or string[]
   useEffect(
     () => {
-      if (!fromHome || !receipt || !home.web3 || !signatureCollected) return
+      if (!fromHome || !receipt || !home.web3 || !home.bridgeContract || !hasCollectedSignatures) return
 
-      const subscriptions: Array<number> = []
+      let timeoutId: number
+      let isCancelled = false
 
-      const unsubscribe = () => {
-        subscriptions.forEach(s => {
-          clearTimeout(s)
-        })
+      const messageHash = home.web3.utils.soliditySha3Raw(message.data)
+      const contract = home.bridgeContract
+
+      const getCollectedSignaturesEvent = async (fromBlock: number, toBlock: number) => {
+        const currentBlock = homeBlockNumberProvider.get()
+
+        if (currentBlock) {
+          // prevent errors if the toBlock parameter is bigger than the latest
+          const securedToBlock = toBlock >= currentBlock ? currentBlock : toBlock
+          const events = await contract.getPastEvents('CollectedSignatures', {
+            fromBlock,
+            toBlock: securedToBlock
+          })
+          const event = events.find(e => e.returnValues.messageHash === messageHash)
+          if (event) {
+            setCollectedSignaturesEvent(event)
+          } else if (!isCancelled) {
+            timeoutId = setTimeout(() => getCollectedSignaturesEvent(securedToBlock, securedToBlock + BLOCK_RANGE), 500)
+          }
+        } else if (!isCancelled) {
+          timeoutId = setTimeout(() => getCollectedSignaturesEvent(fromBlock, toBlock), 500)
+        }
       }
 
-      homeBlockNumberProvider.start(home.web3)
-
-      const fromBlock = receipt.blockNumber
-      const toBlock = fromBlock + BLOCK_RANGE
-      const messageHash = home.web3.utils.soliditySha3Raw(message.data)
-
-      getCollectedSignaturesEvent(
-        home.web3,
-        home.bridgeContract,
-        fromBlock,
-        toBlock,
-        messageHash,
-        setCollectedSignaturesEvent,
-        subscriptions
-      )
+      getCollectedSignaturesEvent(receipt.blockNumber, receipt.blockNumber + BLOCK_RANGE)
 
       return () => {
-        unsubscribe()
-        homeBlockNumberProvider.stop()
+        clearTimeout(timeoutId)
+        isCancelled = true
       }
     },
-    [fromHome, home.bridgeContract, home.web3, message.data, receipt, signatureCollected]
+    [fromHome, home.bridgeContract, home.web3, message.data, receipt, hasCollectedSignatures]
   )
 
   // Check if the responsible validator is waiting for block confirmations to execute the message on foreign network
   // This is executed if the message is in Home to Foreign direction only
   useEffect(
     () => {
-      if (!fromHome || !home.web3 || !receipt || !collectedSignaturesEvent || !blockConfirmations) return
+      if (!fromHome || !home.web3 || !collectedSignaturesEvent || !blockConfirmations) return
       if (waitingBlocksForExecutionResolved) return
 
-      const subscriptions: Array<number> = []
+      let timeoutId: number
 
-      const unsubscribe = () => {
-        subscriptions.forEach(s => {
-          clearTimeout(s)
-        })
-      }
-
-      homeBlockNumberProvider.start(home.web3)
       const targetBlock = collectedSignaturesEvent.blockNumber + blockConfirmations
 
-      checkWaitingBlocksForExecution(
-        homeBlockNumberProvider,
-        HOME_RPC_POLLING_INTERVAL,
-        targetBlock,
-        collectedSignaturesEvent,
-        setWaitingBlocksForExecution,
-        setWaitingBlocksForExecutionResolved,
-        setExecutionData,
-        subscriptions
-      )
+      const checkWaitingBlocksForExecution = () => {
+        const currentBlock = homeBlockNumberProvider.get()
 
-      return () => {
-        unsubscribe()
-        homeBlockNumberProvider.stop()
+        if (currentBlock && currentBlock >= targetBlock) {
+          const undefinedExecutionState = {
+            status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
+            validator: collectedSignaturesEvent.returnValues.authorityResponsibleForRelay,
+            txHash: '',
+            timestamp: 0,
+            executionResult: false
+          }
+          setExecutionData(
+            (data: any) =>
+              data.status === VALIDATOR_CONFIRMATION_STATUS.UNDEFINED ||
+              data.status === VALIDATOR_CONFIRMATION_STATUS.WAITING
+                ? undefinedExecutionState
+                : data
+          )
+          setWaitingBlocksForExecutionResolved(true)
+          setWaitingBlocksForExecution(false)
+        } else if (currentBlock) {
+          setWaitingBlocksForExecution(true)
+          const waitingExecutionState = {
+            status: VALIDATOR_CONFIRMATION_STATUS.WAITING,
+            validator: collectedSignaturesEvent.returnValues.authorityResponsibleForRelay,
+            txHash: '',
+            timestamp: 0,
+            executionResult: false
+          }
+          setExecutionData(
+            (data: any) =>
+              data.status === VALIDATOR_CONFIRMATION_STATUS.UNDEFINED ||
+              data.status === VALIDATOR_CONFIRMATION_STATUS.WAITING
+                ? waitingExecutionState
+                : data
+          )
+          timeoutId = setTimeout(() => checkWaitingBlocksForExecution(), HOME_RPC_POLLING_INTERVAL)
+        } else {
+          timeoutId = setTimeout(() => checkWaitingBlocksForExecution(), 500)
+        }
       }
+
+      checkWaitingBlocksForExecution()
+
+      return () => clearTimeout(timeoutId)
     },
-    [collectedSignaturesEvent, fromHome, blockConfirmations, home.web3, receipt, waitingBlocksForExecutionResolved]
+    [collectedSignaturesEvent, fromHome, blockConfirmations, home.web3, waitingBlocksForExecutionResolved]
   )
 
   // Checks if validators verified the message
   // To avoid making extra requests, this is only executed when validators finished waiting for blocks confirmations
   useEffect(
     () => {
-      if (!waitingBlocksResolved || !timestamp || !requiredSignatures) return
+      if (!waitingBlocksResolved || !homeStartBlock || !requiredSignatures || !home.web3 || !home.bridgeContract) return
+      if (!validatorList || !validatorList.length) return
 
-      const subscriptions: Array<number> = []
-
-      const unsubscribe = () => {
-        subscriptions.forEach(s => {
-          clearTimeout(s)
-        })
-      }
+      let timeoutId: number
+      let isCancelled = false
 
       getConfirmationsForTx(
         message.data,
@@ -237,9 +261,9 @@ export const useMessageConfirmations = ({
         setConfirmations,
         requiredSignatures,
         setSignatureCollected,
-        waitingBlocksResolved,
-        subscriptions,
-        timestamp,
+        id => (timeoutId = id),
+        () => isCancelled,
+        homeStartBlock,
         getValidatorFailedTransactionsForMessage,
         setFailedConfirmations,
         getValidatorPendingTransactionsForMessage,
@@ -248,7 +272,8 @@ export const useMessageConfirmations = ({
       )
 
       return () => {
-        unsubscribe()
+        clearTimeout(timeoutId)
+        isCancelled = true
       }
     },
     [
@@ -259,8 +284,7 @@ export const useMessageConfirmations = ({
       home.bridgeContract,
       requiredSignatures,
       waitingBlocksResolved,
-      timestamp,
-      setConfirmations
+      homeStartBlock
     ]
   )
 
@@ -271,29 +295,23 @@ export const useMessageConfirmations = ({
     () => {
       if ((fromHome && !waitingBlocksForExecutionResolved) || (!fromHome && !waitingBlocksResolved)) return
 
-      const subscriptions: Array<number> = []
-
-      const unsubscribe = () => {
-        subscriptions.forEach(s => {
-          clearTimeout(s)
-        })
-      }
-
-      const contractEvent = fromHome ? 'RelayedMessage' : 'AffirmationCompleted'
       const bridgeContract = fromHome ? foreign.bridgeContract : home.bridgeContract
-      const providedWeb3 = fromHome ? foreign.web3 : home.web3
-      const interval = fromHome ? FOREIGN_RPC_POLLING_INTERVAL : HOME_RPC_POLLING_INTERVAL
+      const web3 = fromHome ? foreign.web3 : home.web3
+      const startBlock = fromHome ? foreignStartBlock : homeStartBlock
+      if (!startBlock || !bridgeContract || !web3) return
+
+      let timeoutId: number
+      let isCancelled = false
 
       getFinalizationEvent(
+        fromHome,
         bridgeContract,
-        contractEvent,
-        providedWeb3,
+        web3,
         setExecutionData,
-        waitingBlocksResolved,
         message,
-        interval,
-        subscriptions,
-        timestamp,
+        id => (timeoutId = id),
+        () => isCancelled,
+        startBlock,
         collectedSignaturesEvent,
         getExecutionFailedTransactionForMessage,
         setFailedExecution,
@@ -303,7 +321,8 @@ export const useMessageConfirmations = ({
       )
 
       return () => {
-        unsubscribe()
+        clearTimeout(timeoutId)
+        isCancelled = true
       }
     },
     [
@@ -315,8 +334,9 @@ export const useMessageConfirmations = ({
       home.web3,
       waitingBlocksResolved,
       waitingBlocksForExecutionResolved,
-      timestamp,
-      collectedSignaturesEvent
+      collectedSignaturesEvent,
+      foreignStartBlock,
+      homeStartBlock
     ]
   )
 
@@ -328,6 +348,9 @@ export const useMessageConfirmations = ({
           ? CONFIRMATIONS_STATUS.SUCCESS
           : CONFIRMATIONS_STATUS.SUCCESS_MESSAGE_FAILED
         setStatus(newStatus)
+
+        foreignBlockNumberProvider.stop()
+        homeBlockNumberProvider.stop()
       } else if (signatureCollected) {
         if (fromHome) {
           if (waitingBlocksForExecution) {

alm/src/hooks/useTransactionFinder.ts

@@ -11,40 +11,23 @@ export const useTransactionFinder = ({ txHash, web3 }: { txHash: string; web3: M
     () => {
       if (!txHash || !web3) return
 
-      const subscriptions: number[] = []
+      let timeoutId: number
 
-      const unsubscribe = () => {
-        subscriptions.forEach(s => {
-          clearTimeout(s)
-        })
-      }
-
-      const getReceipt = async (
-        web3: Web3,
-        txHash: string,
-        setReceipt: Function,
-        setStatus: Function,
-        subscriptions: number[]
-      ) => {
+      const getReceipt = async () => {
         const txReceipt = await web3.eth.getTransactionReceipt(txHash)
         setReceipt(txReceipt)
 
         if (!txReceipt) {
           setStatus(TRANSACTION_STATUS.NOT_FOUND)
-          const timeoutId = setTimeout(
-            () => getReceipt(web3, txHash, setReceipt, setStatus, subscriptions),
-            HOME_RPC_POLLING_INTERVAL
-          )
-          subscriptions.push(timeoutId)
+          timeoutId = setTimeout(getReceipt, HOME_RPC_POLLING_INTERVAL)
         } else {
           setStatus(TRANSACTION_STATUS.FOUND)
         }
       }
 
-      getReceipt(web3, txHash, setReceipt, setStatus, subscriptions)
-      return () => {
-        unsubscribe()
-      }
+      getReceipt()
+
+      return () => clearTimeout(timeoutId)
     },
     [txHash, web3]
   )

alm/src/hooks/useTransactionStatus.ts

@@ -31,19 +31,14 @@ export const useTransactionStatus = ({
 
   useEffect(
     () => {
-      const subscriptions: Array<number> = []
+      if (!chainId || !txHash || !home.chainId || !foreign.chainId || !home.web3 || !foreign.web3) return
+      const isHome = chainId === home.chainId
+      const web3 = isHome ? home.web3 : foreign.web3
 
-      const unsubscribe = () => {
-        subscriptions.forEach(s => {
-          clearTimeout(s)
-        })
-      }
+      let timeoutId: number
 
       const getReceipt = async () => {
-        if (!chainId || !txHash || !home.chainId || !foreign.chainId || !home.web3 || !foreign.web3) return
         setLoading(true)
-        const isHome = chainId === home.chainId
-        const web3 = isHome ? home.web3 : foreign.web3
 
         let txReceipt
 
@@ -59,8 +54,7 @@ export const useTransactionStatus = ({
           setStatus(TRANSACTION_STATUS.NOT_FOUND)
           setDescription(getTransactionStatusDescription(TRANSACTION_STATUS.NOT_FOUND))
           setMessages([{ id: txHash, data: '' }])
-          const timeoutId = setTimeout(() => getReceipt(), HOME_RPC_POLLING_INTERVAL)
-          subscriptions.push(timeoutId)
+          timeoutId = setTimeout(() => getReceipt(), HOME_RPC_POLLING_INTERVAL)
         } else {
           const blockNumber = txReceipt.blockNumber
           const block = await getBlock(web3, blockNumber)
@@ -70,9 +64,9 @@ export const useTransactionStatus = ({
           if (txReceipt.status) {
             let bridgeMessages: Array<MessageObject>
             if (isHome) {
-              bridgeMessages = getHomeMessagesFromReceipt(txReceipt, home.web3, home.bridgeAddress)
+              bridgeMessages = getHomeMessagesFromReceipt(txReceipt, web3, home.bridgeAddress)
             } else {
-              bridgeMessages = getForeignMessagesFromReceipt(txReceipt, foreign.web3, foreign.bridgeAddress)
+              bridgeMessages = getForeignMessagesFromReceipt(txReceipt, web3, foreign.bridgeAddress)
             }
 
             if (bridgeMessages.length === 0) {
@@ -98,14 +92,9 @@ export const useTransactionStatus = ({
         setLoading(false)
       }
 
-      // unsubscribe from previous txHash
-      unsubscribe()
-
       getReceipt()
-      return () => {
-        // unsubscribe when unmount component
-        unsubscribe()
-      }
+
+      return () => clearTimeout(timeoutId)
     },
     [
       txHash,

alm/src/hooks/useValidatorContract.ts

@@ -6,6 +6,7 @@ import { BRIDGE_VALIDATORS_ABI } from '../abis'
 import { useStateProvider } from '../state/StateProvider'
 import { TransactionReceipt } from 'web3-eth'
 import { foreignSnapshotProvider, homeSnapshotProvider, SnapshotProvider } from '../services/SnapshotProvider'
+import { FOREIGN_EXPLORER_API, HOME_EXPLORER_API } from '../config/constants'
 
 export interface useValidatorContractParams {
   fromHome: boolean
@@ -30,10 +31,12 @@ export const useValidatorContract = ({ receipt, fromHome }: useValidatorContract
     contract: Maybe<Contract>,
     receipt: TransactionReceipt,
     setResult: Function,
-    snapshotProvider: SnapshotProvider
+    snapshotProvider: SnapshotProvider,
+    web3: Web3,
+    api: string
   ) => {
     if (!contract) return
-    const result = await getRequiredSignatures(contract, receipt.blockNumber, snapshotProvider)
+    const result = await getRequiredSignatures(contract, receipt.blockNumber, snapshotProvider, web3, api)
     setResult(result)
   }
 
@@ -41,32 +44,35 @@ export const useValidatorContract = ({ receipt, fromHome }: useValidatorContract
     contract: Maybe<Contract>,
     receipt: TransactionReceipt,
     setResult: Function,
-    snapshotProvider: SnapshotProvider
+    snapshotProvider: SnapshotProvider,
+    web3: Web3,
+    api: string
   ) => {
     if (!contract) return
-    const result = await getValidatorList(contract, receipt.blockNumber, snapshotProvider)
+    const result = await getValidatorList(contract, receipt.blockNumber, snapshotProvider, web3, api)
     setResult(result)
   }
 
+  const web3 = fromHome ? home.web3 : foreign.web3
+  const api = fromHome ? HOME_EXPLORER_API : FOREIGN_EXPLORER_API
+  const bridgeContract = fromHome ? home.bridgeContract : foreign.bridgeContract
+  const snapshotProvider = fromHome ? homeSnapshotProvider : foreignSnapshotProvider
+
   useEffect(
     () => {
-      const web3 = fromHome ? home.web3 : foreign.web3
-      const bridgeContract = fromHome ? home.bridgeContract : foreign.bridgeContract
-
       if (!web3 || !bridgeContract) return
       callValidatorContract(bridgeContract, web3, setValidatorContract)
     },
-    [home.web3, foreign.web3, home.bridgeContract, foreign.bridgeContract, fromHome]
+    [web3, bridgeContract]
   )
 
   useEffect(
     () => {
-      if (!receipt) return
-      const snapshotProvider = fromHome ? homeSnapshotProvider : foreignSnapshotProvider
-      callRequiredSignatures(validatorContract, receipt, setRequiredSignatures, snapshotProvider)
-      callValidatorList(validatorContract, receipt, setValidatorList, snapshotProvider)
+      if (!web3 || !receipt) return
+      callRequiredSignatures(validatorContract, receipt, setRequiredSignatures, snapshotProvider, web3, api)
+      callValidatorList(validatorContract, receipt, setValidatorList, snapshotProvider, web3, api)
     },
-    [validatorContract, receipt, fromHome]
+    [validatorContract, receipt, web3, snapshotProvider, api]
   )
 
   return {

alm/src/services/BlockNumberProvider.ts

@@ -1,6 +1,6 @@
 import Web3 from 'web3'
 import differenceInMilliseconds from 'date-fns/differenceInMilliseconds'
-import { HOME_RPC_POLLING_INTERVAL } from '../config/constants'
+import { FOREIGN_RPC_POLLING_INTERVAL, HOME_RPC_POLLING_INTERVAL } from '../config/constants'
 
 export class BlockNumberProvider {
   private running: number
@@ -61,4 +61,4 @@ export class BlockNumberProvider {
 }
 
 export const homeBlockNumberProvider = new BlockNumberProvider(HOME_RPC_POLLING_INTERVAL)
-export const foreignBlockNumberProvider = new BlockNumberProvider(HOME_RPC_POLLING_INTERVAL)
+export const foreignBlockNumberProvider = new BlockNumberProvider(FOREIGN_RPC_POLLING_INTERVAL)

alm/src/utils/__tests__/contracts.test.ts

@@ -16,7 +16,7 @@ describe('getRequiredBlockConfirmations', () => {
 
   test('Should call requiredBlockConfirmations method if no events present', async () => {
     const contract = ({
-      getPastEvents: () => {
+      getPastEvents: async () => {
         return []
       },
       methods: methodsBuilder('1')
@@ -37,7 +37,7 @@ describe('getRequiredBlockConfirmations', () => {
   })
   test('Should not call to get events if block number was included in the snapshot', async () => {
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(() => []),
+      getPastEvents: jest.fn().mockImplementation(async () => []),
       methods: methodsBuilder('3')
     } as unknown) as Contract
 
@@ -64,7 +64,7 @@ describe('getRequiredBlockConfirmations', () => {
   })
   test('Should call to get events if block number was not included in the snapshot', async () => {
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(() => [
+      getPastEvents: jest.fn().mockImplementation(async () => [
         {
           blockNumber: 9,
           returnValues: {
@@ -102,7 +102,7 @@ describe('getRequiredBlockConfirmations', () => {
   })
   test('Should use the most updated event', async () => {
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(() => [
+      getPastEvents: jest.fn().mockImplementation(async () => [
         {
           blockNumber: 9,
           returnValues: {
@@ -141,7 +141,7 @@ describe('getRequiredBlockConfirmations', () => {
 describe('getRequiredSignatures', () => {
   test('Should not call to get events if block number was included in the snapshot', async () => {
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(() => [])
+      getPastEvents: jest.fn().mockImplementation(async () => [])
     } as unknown) as Contract
 
     const snapshotProvider = ({
@@ -173,7 +173,7 @@ describe('getRequiredSignatures', () => {
   })
   test('Should call to get events if block number is higher than the snapshot block number', async () => {
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(() => [
+      getPastEvents: jest.fn().mockImplementation(async () => [
         {
           blockNumber: 15,
           returnValues: {
@@ -216,7 +216,7 @@ describe('getRequiredSignatures', () => {
   })
   test('Should use the most updated event before the block number', async () => {
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(() => [
+      getPastEvents: jest.fn().mockImplementation(async () => [
         {
           blockNumber: 15,
           returnValues: {
@@ -270,7 +270,7 @@ describe('getValidatorList', () => {
   test('Should return the current validator list if no events found', async () => {
     const currentValidators = [validator1, validator2, validator3]
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(() => []),
+      getPastEvents: jest.fn().mockImplementation(async () => []),
       methods: methodsBuilder(currentValidators)
     } as unknown) as Contract
 
@@ -301,7 +301,7 @@ describe('getValidatorList', () => {
   test('If validator was added later from snapshot it should not include it', async () => {
     const currentValidators = [validator1, validator2, validator3]
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(() => []),
+      getPastEvents: jest.fn().mockImplementation(async () => []),
       methods: methodsBuilder(currentValidators)
     } as unknown) as Contract
 
@@ -340,7 +340,7 @@ describe('getValidatorList', () => {
   test('If validator was added later from chain it should not include it', async () => {
     const currentValidators = [validator1, validator2, validator3]
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(event => {
+      getPastEvents: jest.fn().mockImplementation(async event => {
         if (event === 'ValidatorAdded') {
           return [
             {
@@ -385,7 +385,7 @@ describe('getValidatorList', () => {
   test('If validator was removed later from snapshot it should include it', async () => {
     const currentValidators = [validator1, validator2]
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(() => []),
+      getPastEvents: jest.fn().mockImplementation(async () => []),
       methods: methodsBuilder(currentValidators)
     } as unknown) as Contract
 
@@ -424,7 +424,7 @@ describe('getValidatorList', () => {
   test('If validator was removed later from chain it should include it', async () => {
     const currentValidators = [validator1, validator2]
     const contract = ({
-      getPastEvents: jest.fn().mockImplementation(event => {
+      getPastEvents: jest.fn().mockImplementation(async event => {
         if (event === 'ValidatorRemoved') {
           return [
             {

alm/src/utils/__tests__/explorer.test.ts

@@ -17,19 +17,33 @@ const otherAddress = '0xD4075FB57fCf038bFc702c915Ef9592534bED5c1'
 
 describe('getFailedTransactions', () => {
   test('should only return failed transactions', async () => {
-    const transactions = [{ isError: '0' }, { isError: '1' }, { isError: '0' }, { isError: '1' }, { isError: '1' }]
+    const to = otherAddress
+    const transactions = [
+      { isError: '0', to },
+      { isError: '1', to },
+      { isError: '0', to },
+      { isError: '1', to },
+      { isError: '1', to }
+    ]
 
     const fetchAccountTransactions = jest.fn().mockImplementation(() => transactions)
-    const result = await getFailedTransactions('', '', 0, 1, '', fetchAccountTransactions)
+    const result = await getFailedTransactions('', to, 0, 1, '', fetchAccountTransactions)
     expect(result.length).toEqual(3)
   })
 })
 describe('getSuccessTransactions', () => {
   test('should only return success transactions', async () => {
-    const transactions = [{ isError: '0' }, { isError: '1' }, { isError: '0' }, { isError: '1' }, { isError: '1' }]
+    const to = otherAddress
+    const transactions = [
+      { isError: '0', to },
+      { isError: '1', to },
+      { isError: '0', to },
+      { isError: '1', to },
+      { isError: '1', to }
+    ]
 
     const fetchAccountTransactions = jest.fn().mockImplementation(() => transactions)
-    const result = await getSuccessTransactions('', '', 0, 1, '', fetchAccountTransactions)
+    const result = await getSuccessTransactions('', to, 0, 1, '', fetchAccountTransactions)
     expect(result.length).toEqual(2)
   })
 })
@@ -74,8 +88,8 @@ describe('getExecutionFailedTransactionForMessage', () => {
         account: '',
         to: '',
         messageData,
-        startTimestamp: 0,
-        endTimestamp: 1
+        startBlock: 0,
+        endBlock: 1
       },
       fetchAccountTransactions
     )

alm/src/utils/__tests__/getConfirmationsForTx.test.ts

@@ -34,7 +34,7 @@ const bridgeContract = {
   }
 } as Contract
 const requiredSignatures = 2
-const waitingBlocksResolved = true
+const isCancelled = () => false
 let subscriptions: Array<number> = []
 const timestamp = 1594045859
 const getFailedTransactions = (): Promise<APITransaction[]> => Promise.resolve([])
@@ -94,8 +94,8 @@ describe('getConfirmationsForTx', () => {
       setResult,
       requiredSignatures,
       setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       getFailedTransactions,
       setFailedConfirmations,
@@ -177,8 +177,8 @@ describe('getConfirmationsForTx', () => {
       setResult,
       requiredSignatures,
       setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       getFailedTransactions,
       setFailedConfirmations,
@@ -241,8 +241,8 @@ describe('getConfirmationsForTx', () => {
       setResult,
       requiredSignatures,
       setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       getFailedTransactions,
       setFailedConfirmations,
@@ -340,8 +340,8 @@ describe('getConfirmationsForTx', () => {
       setResult,
       requiredSignatures,
       setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       getFailedTransactions,
       setFailedConfirmations,
@@ -453,8 +453,8 @@ describe('getConfirmationsForTx', () => {
       setResult,
       requiredSignatures,
       setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       getFailedTransactions,
       setFailedConfirmations,
@@ -557,8 +557,8 @@ describe('getConfirmationsForTx', () => {
       setResult,
       requiredSignatures,
       setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       getFailedTransactions,
       setFailedConfirmations,
@@ -678,8 +678,8 @@ describe('getConfirmationsForTx', () => {
       setResult,
       requiredSignatures,
       setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       getFailedTransactions,
       setFailedConfirmations,
@@ -746,8 +746,8 @@ describe('getConfirmationsForTx', () => {
       setResult,
       requiredSignatures,
       setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       getFailedTransactions,
       setFailedConfirmations,

alm/src/utils/__tests__/getFinalizationEvent.test.ts

@@ -4,7 +4,6 @@ import Web3 from 'web3'
 import { getFinalizationEvent } from '../getFinalizationEvent'
 import { VALIDATOR_CONFIRMATION_STATUS } from '../../config/constants'
 
-const eventName = 'RelayedMessage'
 const timestamp = 1594045859
 const validator1 = '0x45b96809336A8b714BFbdAB3E4B5e0fe5d839908'
 const txHash = '0xdab36c9210e7e45fb82af10ffe4960461e41661dce0c9cd36b2843adaa1df156'
@@ -20,12 +19,11 @@ const web3 = ({
     toChecksumAddress: (a: string) => a
   }
 } as unknown) as Web3
-const waitingBlocksResolved = true
 const message = {
   id: '0x123',
   data: '0x123456789'
 }
-const interval = 10000
+const isCancelled = () => false
 let subscriptions: Array<number> = []
 
 const event = {
@@ -50,7 +48,7 @@ beforeEach(() => {
 describe('getFinalizationEvent', () => {
   test('should get finalization event and not try to get failed or pending transactions', async () => {
     const contract = ({
-      getPastEvents: () => {
+      getPastEvents: async () => {
         return [event]
       }
     } as unknown) as Contract
@@ -64,14 +62,13 @@ describe('getFinalizationEvent', () => {
     const setExecutionEventsFetched = jest.fn()
 
     await getFinalizationEvent(
+      true,
       contract,
-      eventName,
       web3,
       setResult,
-      waitingBlocksResolved,
       message,
-      interval,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       collectedSignaturesEvent,
       getFailedExecution,
@@ -101,7 +98,7 @@ describe('getFinalizationEvent', () => {
   })
   test('should retry to get finalization event and not try to get failed or pending transactions if foreign to home transaction', async () => {
     const contract = ({
-      getPastEvents: () => {
+      getPastEvents: async () => {
         return []
       }
     } as unknown) as Contract
@@ -115,14 +112,13 @@ describe('getFinalizationEvent', () => {
     const setExecutionEventsFetched = jest.fn()
 
     await getFinalizationEvent(
+      true,
       contract,
-      eventName,
       web3,
       setResult,
-      waitingBlocksResolved,
       message,
-      interval,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       collectedSignaturesEvent,
       getFailedExecution,
@@ -145,7 +141,7 @@ describe('getFinalizationEvent', () => {
   })
   test('should retry to get finalization event and try to get failed and pending transactions if home to foreign transaction', async () => {
     const contract = ({
-      getPastEvents: () => {
+      getPastEvents: async () => {
         return []
       },
       options: {
@@ -166,14 +162,13 @@ describe('getFinalizationEvent', () => {
     const setExecutionEventsFetched = jest.fn()
 
     await getFinalizationEvent(
+      true,
       contract,
-      eventName,
       web3,
       setResult,
-      waitingBlocksResolved,
       message,
-      interval,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       collectedSignaturesEvent,
       getFailedExecution,
@@ -196,7 +191,7 @@ describe('getFinalizationEvent', () => {
   })
   test('should retry to get finalization event and not to try to get failed transaction if pending transactions found if home to foreign transaction', async () => {
     const contract = ({
-      getPastEvents: () => {
+      getPastEvents: async () => {
         return []
       },
       options: {
@@ -217,14 +212,13 @@ describe('getFinalizationEvent', () => {
     const setExecutionEventsFetched = jest.fn()
 
     await getFinalizationEvent(
+      true,
       contract,
-      eventName,
       web3,
       setResult,
-      waitingBlocksResolved,
       message,
-      interval,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       collectedSignaturesEvent,
       getFailedExecution,
@@ -254,7 +248,7 @@ describe('getFinalizationEvent', () => {
   })
   test('should retry to get finalization event even if failed transaction found if home to foreign transaction', async () => {
     const contract = ({
-      getPastEvents: () => {
+      getPastEvents: async () => {
         return []
       },
       options: {
@@ -275,14 +269,13 @@ describe('getFinalizationEvent', () => {
     const setExecutionEventsFetched = jest.fn()
 
     await getFinalizationEvent(
+      true,
       contract,
-      eventName,
       web3,
       setResult,
-      waitingBlocksResolved,
       message,
-      interval,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
       timestamp,
       collectedSignaturesEvent,
       getFailedExecution,

alm/src/utils/contract.ts

@@ -1,18 +1,33 @@
 import { Contract } from 'web3-eth-contract'
 import { EventData } from 'web3-eth-contract'
 import { SnapshotProvider } from '../services/SnapshotProvider'
+import { getLogs } from './explorer'
+import Web3 from 'web3'
+
+const getPastEventsWithFallback = (
+  api: string,
+  web3: Web3 | null,
+  contract: Contract,
+  eventName: string,
+  options: any
+) =>
+  contract
+    .getPastEvents(eventName, options)
+    .catch(() => (api && web3 ? getLogs(api, web3, contract, eventName, options) : []))
 
 export const getRequiredBlockConfirmations = async (
   contract: Contract,
   blockNumber: number,
-  snapshotProvider: SnapshotProvider
+  snapshotProvider: SnapshotProvider,
+  web3: Web3 | null = null,
+  api: string = ''
 ) => {
   const eventsFromSnapshot = snapshotProvider.requiredBlockConfirmationEvents(blockNumber)
   const snapshotBlockNumber = snapshotProvider.snapshotBlockNumber()
 
   let contractEvents: EventData[] = []
   if (blockNumber > snapshotBlockNumber) {
-    contractEvents = await contract.getPastEvents('RequiredBlockConfirmationChanged', {
+    contractEvents = await getPastEventsWithFallback(api, web3, contract, 'RequiredBlockConfirmationChanged', {
       fromBlock: snapshotBlockNumber + 1,
       toBlock: blockNumber
     })
@@ -38,14 +53,16 @@ export const getValidatorAddress = (contract: Contract) => contract.methods.vali
 export const getRequiredSignatures = async (
   contract: Contract,
   blockNumber: number,
-  snapshotProvider: SnapshotProvider
+  snapshotProvider: SnapshotProvider,
+  web3: Web3 | null = null,
+  api: string = ''
 ) => {
   const eventsFromSnapshot = snapshotProvider.requiredSignaturesEvents(blockNumber)
   const snapshotBlockNumber = snapshotProvider.snapshotBlockNumber()
 
   let contractEvents: EventData[] = []
   if (blockNumber > snapshotBlockNumber) {
-    contractEvents = await contract.getPastEvents('RequiredSignaturesChanged', {
+    contractEvents = await getPastEventsWithFallback(api, web3, contract, 'RequiredSignaturesChanged', {
       fromBlock: snapshotBlockNumber + 1,
       toBlock: blockNumber
     })
@@ -59,7 +76,13 @@ export const getRequiredSignatures = async (
   return parseInt(requiredSignatures)
 }
 
-export const getValidatorList = async (contract: Contract, blockNumber: number, snapshotProvider: SnapshotProvider) => {
+export const getValidatorList = async (
+  contract: Contract,
+  blockNumber: number,
+  snapshotProvider: SnapshotProvider,
+  web3: Web3 | null = null,
+  api: string = ''
+) => {
   const addedEventsFromSnapshot = snapshotProvider.validatorAddedEvents(blockNumber)
   const removedEventsFromSnapshot = snapshotProvider.validatorRemovedEvents(blockNumber)
   const snapshotBlockNumber = snapshotProvider.snapshotBlockNumber()
@@ -67,10 +90,10 @@ export const getValidatorList = async (contract: Contract, blockNumber: number,
   const fromBlock = snapshotBlockNumber > blockNumber ? snapshotBlockNumber + 1 : blockNumber
   const [currentList, added, removed] = await Promise.all([
     contract.methods.validatorList().call(),
-    contract.getPastEvents('ValidatorAdded', {
+    getPastEventsWithFallback(api, web3, contract, 'ValidatorAdded', {
       fromBlock
     }),
-    contract.getPastEvents('ValidatorRemoved', {
+    getPastEventsWithFallback(api, web3, contract, 'ValidatorRemoved', {
       fromBlock
     })
   ])

alm/src/utils/executionWaitingForBlocks.ts

@@ -1,71 +0,0 @@
-import { BlockNumberProvider } from '../services/BlockNumberProvider'
-import { VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
-import { EventData } from 'web3-eth-contract'
-
-export const checkWaitingBlocksForExecution = async (
-  blockProvider: BlockNumberProvider,
-  interval: number,
-  targetBlock: number,
-  collectedSignaturesEvent: EventData,
-  setWaitingBlocksForExecution: Function,
-  setWaitingBlocksForExecutionResolved: Function,
-  setExecutionData: Function,
-  subscriptions: number[]
-) => {
-  const currentBlock = blockProvider.get()
-
-  if (currentBlock && currentBlock >= targetBlock) {
-    const undefinedExecutionState = {
-      status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      validator: collectedSignaturesEvent.returnValues.authorityResponsibleForRelay,
-      txHash: '',
-      timestamp: 0,
-      executionResult: false
-    }
-    setExecutionData(
-      (data: any) =>
-        data.status === VALIDATOR_CONFIRMATION_STATUS.UNDEFINED || data.status === VALIDATOR_CONFIRMATION_STATUS.WAITING
-          ? undefinedExecutionState
-          : data
-    )
-    setWaitingBlocksForExecutionResolved(true)
-    setWaitingBlocksForExecution(false)
-    blockProvider.stop()
-  } else {
-    let nextInterval = interval
-    if (!currentBlock) {
-      nextInterval = 500
-    } else {
-      setWaitingBlocksForExecution(true)
-      const waitingExecutionState = {
-        status: VALIDATOR_CONFIRMATION_STATUS.WAITING,
-        validator: collectedSignaturesEvent.returnValues.authorityResponsibleForRelay,
-        txHash: '',
-        timestamp: 0,
-        executionResult: false
-      }
-      setExecutionData(
-        (data: any) =>
-          data.status === VALIDATOR_CONFIRMATION_STATUS.UNDEFINED ||
-          data.status === VALIDATOR_CONFIRMATION_STATUS.WAITING
-            ? waitingExecutionState
-            : data
-      )
-    }
-    const timeoutId = setTimeout(
-      () =>
-        checkWaitingBlocksForExecution(
-          blockProvider,
-          interval,
-          targetBlock,
-          collectedSignaturesEvent,
-          setWaitingBlocksForExecution,
-          setWaitingBlocksForExecutionResolved,
-          setExecutionData,
-          subscriptions
-        ),
-      nextInterval
-    )
-    subscriptions.push(timeoutId)
-  }
-}

alm/src/utils/explorer.ts

@@ -1,10 +1,15 @@
 import {
+  BLOCK_RANGE,
   EXECUTE_AFFIRMATION_HASH,
   EXECUTE_SIGNATURES_HASH,
   FOREIGN_EXPLORER_API,
   HOME_EXPLORER_API,
+  MAX_TX_SEARCH_BLOCK_RANGE,
   SUBMIT_SIGNATURE_HASH
 } from '../config/constants'
+import { AbiItem } from 'web3-utils'
+import Web3 from 'web3'
+import { Contract } from 'web3-eth-contract'
 
 export interface APITransaction {
   timeStamp: string
@@ -12,6 +17,7 @@ export interface APITransaction {
   input: string
   to: string
   hash: string
+  blockNumber: string
 }
 
 export interface APIPendingTransaction {
@@ -27,110 +33,54 @@ export interface PendingTransactionsParams {
 
 export interface AccountTransactionsParams {
   account: string
-  to: string
-  startTimestamp: number
-  endTimestamp: number
+  startBlock: number
+  endBlock: number
   api: string
 }
 
-export interface GetFailedTransactionParams {
-  account: string
-  to: string
-  messageData: string
-  startTimestamp: number
-  endTimestamp: number
-}
-
 export interface GetPendingTransactionParams {
   account: string
   to: string
   messageData: string
 }
 
-export const fetchAccountTransactionsFromBlockscout = async ({
-  account,
-  to,
-  startTimestamp,
-  endTimestamp,
-  api
-}: AccountTransactionsParams): Promise<APITransaction[]> => {
-  const url = `${api}?module=account&action=txlist&address=${account}&filterby=from=${account}&to=${to}&starttimestamp=${startTimestamp}&endtimestamp=${endTimestamp}`
-
-  try {
-    const result = await fetch(url).then(res => res.json())
-    if (result.status === '0') {
-      return []
-    }
-
-    return result.result
-  } catch (e) {
-    console.log(e)
-    return []
-  }
+export interface GetTransactionParams extends GetPendingTransactionParams {
+  startBlock: number
+  endBlock: number
 }
 
-export const getBlockByTimestampUrl = (api: string, timestamp: number) =>
-  `${api}&module=block&action=getblocknobytime&timestamp=${timestamp}&closest=before`
+export const fetchAccountTransactions = async ({ account, startBlock, endBlock, api }: AccountTransactionsParams) => {
+  const url = new URL(api)
+  url.searchParams.append('module', 'account')
+  url.searchParams.append('action', 'txlist')
+  url.searchParams.append('address', account)
+  url.searchParams.append('filterby', 'from')
+  url.searchParams.append('startblock', startBlock.toString())
+  url.searchParams.append('endblock', endBlock.toString())
 
-export const fetchAccountTransactionsFromEtherscan = async ({
-  account,
-  to,
-  startTimestamp,
-  endTimestamp,
-  api
-}: AccountTransactionsParams): Promise<APITransaction[]> => {
-  const startBlockUrl = getBlockByTimestampUrl(api, startTimestamp)
-  const endBlockUrl = getBlockByTimestampUrl(api, endTimestamp)
-  let fromBlock = 0
-  let toBlock = 9999999999999
-  try {
-    const [fromBlockResult, toBlockResult] = await Promise.all([
-      fetch(startBlockUrl).then(res => res.json()),
-      fetch(endBlockUrl).then(res => res.json())
-    ])
+  const result = await fetch(url.toString()).then(res => res.json())
 
-    if (fromBlockResult.status !== '0') {
-      fromBlock = parseInt(fromBlockResult.result)
-    }
-
-    if (toBlockResult.status !== '0') {
-      toBlock = parseInt(toBlockResult.result)
-    }
-  } catch (e) {
-    console.log(e)
+  if (result.message === 'No transactions found') {
     return []
   }
 
-  const url = `${api}&module=account&action=txlist&address=${account}&startblock=${fromBlock}&endblock=${toBlock}`
-
-  try {
-    const result = await fetch(url).then(res => res.json())
-
-    if (result.status === '0') {
-      return []
-    }
-
-    const toAddressLowerCase = to.toLowerCase()
-    const transactions: APITransaction[] = result.result
-    return transactions.filter(t => t.to.toLowerCase() === toAddressLowerCase)
-  } catch (e) {
-    console.log(e)
-    return []
-  }
-}
-
-export const fetchAccountTransactions = (api: string) => {
-  return api.includes('blockscout') ? fetchAccountTransactionsFromBlockscout : fetchAccountTransactionsFromEtherscan
+  return result.result
 }
 
 export const fetchPendingTransactions = async ({
   account,
   api
 }: PendingTransactionsParams): Promise<APIPendingTransaction[]> => {
-  const url = `${api}?module=account&action=pendingtxlist&address=${account}`
+  if (!api.includes('blockscout')) {
+    return []
+  }
+  const url = new URL(api)
+  url.searchParams.append('module', 'account')
+  url.searchParams.append('action', 'pendingtxlist')
+  url.searchParams.append('address', account)
 
   try {
-    const result = await fetch(url).then(res => res.json())
+    const result = await fetch(url.toString()).then(res => res.json())
     if (result.status === '0') {
       return []
     }
@@ -141,30 +91,135 @@ export const fetchPendingTransactions = async ({
   }
 }
 
+export const getClosestBlockByTimestamp = async (api: string, timestamp: number): Promise<number> => {
+  if (api.includes('blockscout')) {
+    throw new Error('Blockscout does not support getblocknobytime')
+  }
+
+  const url = new URL(api)
+  url.searchParams.append('module', 'block')
+  url.searchParams.append('action', 'getblocknobytime')
+  url.searchParams.append('timestamp', timestamp.toString())
+  url.searchParams.append('closest', 'before')
+
+  const blockNumber = await fetch(url.toString()).then(res => res.json())
+
+  return parseInt(blockNumber.result)
+}
+
+// fast version of fetchAccountTransactions
+// sequentially fetches transactions in small batches
+// caches the result
+const transactionsCache: { [key: string]: { lastBlock: number; transactions: APITransaction[] } } = {}
+export const getAccountTransactions = async ({
+  account,
+  startBlock,
+  endBlock,
+  api
+}: AccountTransactionsParams): Promise<APITransaction[]> => {
+  const key = `${account}-${startBlock}-${api}`
+
+  // initialize empty cache if it doesn't exist yet
+  if (!transactionsCache[key]) {
+    transactionsCache[key] = { lastBlock: startBlock - 1, transactions: [] }
+  }
+
+  // if cache contains events up to block X,
+  // new batch is fetched for range [X + 1, X + 1 + BLOCK_RANGE]
+  const newStartBlock = transactionsCache[key].lastBlock + 1
+  const newEndBlock = newStartBlock + BLOCK_RANGE
+
+  // search for new transactions only if max allowed block range is not yet exceeded
+  if (newEndBlock <= startBlock + MAX_TX_SEARCH_BLOCK_RANGE) {
+    const newTransactions = await fetchAccountTransactions({
+      account,
+      startBlock: newStartBlock,
+      endBlock: newEndBlock,
+      api
+    })
+
+    const transactions = transactionsCache[key].transactions.concat(...newTransactions)
+
+    // cache updated transactions list
+    transactionsCache[key].transactions = transactions
+
+    // enbBlock is assumed to be the current block number of the chain
+    // if the whole range is finalized, last block can be safely updated to the end of the range
+    // this works even if there are no transactions in the list
+    if (newEndBlock < endBlock) {
+      transactionsCache[key].lastBlock = newEndBlock
+    } else if (transactions.length > 0) {
+      transactionsCache[key].lastBlock = parseInt(transactions[transactions.length - 1].blockNumber, 10)
+    }
+
+    return transactions
+  }
+
+  console.warn(`Reached max transaction searching range, returning previously cached transactions for ${account}`)
+  return transactionsCache[key].transactions
+}
+
+export const getLogs = async (
+  api: string,
+  web3: Web3,
+  contract: Contract,
+  event: string,
+  options: { fromBlock: number; toBlock: number | 'latest'; topics: (string | null)[] }
+) => {
+  const abi = contract.options.jsonInterface.find((abi: AbiItem) => abi.type === 'event' && abi.name === event)!
+
+  const url = new URL(api)
+  url.searchParams.append('module', 'logs')
+  url.searchParams.append('action', 'getLogs')
+  url.searchParams.append('address', contract.options.address)
+  url.searchParams.append('fromBlock', options.fromBlock.toString())
+  url.searchParams.append('toBlock', (options.toBlock || 'latest').toString())
+
+  const topics = [web3.eth.abi.encodeEventSignature(abi), ...(options.topics || [])]
+  for (let i = 0; i < topics.length; i++) {
+    if (topics[i] !== null) {
+      url.searchParams.append(`topic${i}`, topics[i] as string)
+      for (let j = 0; j < i; j++) {
+        url.searchParams.append(`topic${j}_${i}_opr`, 'and')
+      }
+    }
+  }
+
+  const logs = await fetch(url.toString()).then(res => res.json())
+
+  return logs.result.map((log: any) => ({
+    transactionHash: log.transactionHash,
+    blockNumber: parseInt(log.blockNumber.slice(2), 16),
+    returnValues: web3.eth.abi.decodeLog(abi.inputs!, log.data, log.topics.slice(1))
+  }))
+}
+
+const filterReceiver = (to: string) => (tx: APITransaction) => tx.to.toLowerCase() === to.toLowerCase()
+
 export const getFailedTransactions = async (
   account: string,
   to: string,
-  startTimestamp: number,
-  endTimestamp: number,
+  startBlock: number,
+  endBlock: number,
   api: string,
-  fetchAccountTransactions: (args: AccountTransactionsParams) => Promise<APITransaction[]>
+  getAccountTransactionsMethod = getAccountTransactions
 ): Promise<APITransaction[]> => {
-  const transactions = await fetchAccountTransactions({ account, to, startTimestamp, endTimestamp, api })
+  const transactions = await getAccountTransactionsMethod({ account, startBlock, endBlock, api })
 
-  return transactions.filter(t => t.isError !== '0')
+  return transactions.filter(t => t.isError !== '0').filter(filterReceiver(to))
 }
 
 export const getSuccessTransactions = async (
   account: string,
   to: string,
-  startTimestamp: number,
-  endTimestamp: number,
+  startBlock: number,
+  endBlock: number,
   api: string,
-  fetchAccountTransactions: (args: AccountTransactionsParams) => Promise<APITransaction[]>
+  getAccountTransactionsMethod = getAccountTransactions
 ): Promise<APITransaction[]> => {
-  const transactions = await fetchAccountTransactions({ account, to, startTimestamp, endTimestamp, api })
+  const transactions = await getAccountTransactionsMethod({ account, startBlock, endBlock, api })
 
-  return transactions.filter(t => t.isError === '0')
+  return transactions.filter(t => t.isError === '0').filter(filterReceiver(to))
 }
 
 export const filterValidatorSignatureTransaction = (
@@ -183,17 +238,10 @@ export const getValidatorFailedTransactionsForMessage = async ({
   account,
   to,
   messageData,
-  startTimestamp,
-  endTimestamp
-}: GetFailedTransactionParams): Promise<APITransaction[]> => {
-  const failedTransactions = await getFailedTransactions(
-    account,
-    to,
-    startTimestamp,
-    endTimestamp,
-    HOME_EXPLORER_API,
-    fetchAccountTransactionsFromBlockscout
-  )
+  startBlock,
+  endBlock
+}: GetTransactionParams): Promise<APITransaction[]> => {
+  const failedTransactions = await getFailedTransactions(account, to, startBlock, endBlock, HOME_EXPLORER_API)
 
   return filterValidatorSignatureTransaction(failedTransactions, messageData)
 }
@@ -202,33 +250,19 @@ export const getValidatorSuccessTransactionsForMessage = async ({
   account,
   to,
   messageData,
-  startTimestamp,
-  endTimestamp
-}: GetFailedTransactionParams): Promise<APITransaction[]> => {
-  const transactions = await getSuccessTransactions(
-    account,
-    to,
-    startTimestamp,
-    endTimestamp,
-    HOME_EXPLORER_API,
-    fetchAccountTransactionsFromBlockscout
-  )
+  startBlock,
+  endBlock
+}: GetTransactionParams): Promise<APITransaction[]> => {
+  const transactions = await getSuccessTransactions(account, to, startBlock, endBlock, HOME_EXPLORER_API)
 
   return filterValidatorSignatureTransaction(transactions, messageData)
 }
 
 export const getExecutionFailedTransactionForMessage = async (
-  { account, to, messageData, startTimestamp, endTimestamp }: GetFailedTransactionParams,
+  { account, to, messageData, startBlock, endBlock }: GetTransactionParams,
   getFailedTransactionsMethod = getFailedTransactions
 ): Promise<APITransaction[]> => {
-  const failedTransactions = await getFailedTransactionsMethod(
-    account,
-    to,
-    startTimestamp,
-    endTimestamp,
-    FOREIGN_EXPLORER_API,
-    fetchAccountTransactions(FOREIGN_EXPLORER_API)
-  )
+  const failedTransactions = await getFailedTransactionsMethod(account, to, startBlock, endBlock, FOREIGN_EXPLORER_API)
 
   const messageDataValue = messageData.replace('0x', '')
   return failedTransactions.filter(t => t.input.includes(EXECUTE_SIGNATURES_HASH) && t.input.includes(messageDataValue))

alm/src/utils/getCollectedSignaturesEvent.ts

@@ -1,53 +0,0 @@
-import Web3 from 'web3'
-import { Contract, EventData } from 'web3-eth-contract'
-import { homeBlockNumberProvider } from '../services/BlockNumberProvider'
-import { BLOCK_RANGE } from '../config/constants'
-
-export const getCollectedSignaturesEvent = async (
-  web3: Maybe<Web3>,
-  contract: Maybe<Contract>,
-  fromBlock: number,
-  toBlock: number,
-  messageHash: string,
-  setCollectedSignaturesEvent: Function,
-  subscriptions: number[]
-) => {
-  if (!web3 || !contract) return
-  const currentBlock = homeBlockNumberProvider.get()
-
-  let events: EventData[] = []
-  let securedToBlock = toBlock
-  if (currentBlock) {
-    // prevent errors if the toBlock parameter is bigger than the latest
-    securedToBlock = toBlock >= currentBlock ? currentBlock : toBlock
-    events = await contract.getPastEvents('CollectedSignatures', {
-      fromBlock,
-      toBlock: securedToBlock
-    })
-  }
-
-  const filteredEvents = events.filter(e => e.returnValues.messageHash === messageHash)
-
-  if (filteredEvents.length) {
-    const event = filteredEvents[0]
-    setCollectedSignaturesEvent(event)
-    homeBlockNumberProvider.stop()
-  } else {
-    const newFromBlock = currentBlock ? securedToBlock : fromBlock
-    const newToBlock = currentBlock ? toBlock + BLOCK_RANGE : toBlock
-    const timeoutId = setTimeout(
-      () =>
-        getCollectedSignaturesEvent(
-          web3,
-          contract,
-          newFromBlock,
-          newToBlock,
-          messageHash,
-          setCollectedSignaturesEvent,
-          subscriptions
-        ),
-      500
-    )
-    subscriptions.push(timeoutId)
-  }
-}

alm/src/utils/getConfirmationsForTx.ts

@@ -1,12 +1,7 @@
 import Web3 from 'web3'
 import { Contract } from 'web3-eth-contract'
 import { HOME_RPC_POLLING_INTERVAL, VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
-import {
-  GetFailedTransactionParams,
-  APITransaction,
-  APIPendingTransaction,
-  GetPendingTransactionParams
-} from './explorer'
+import { GetTransactionParams, APITransaction, APIPendingTransaction, GetPendingTransactionParams } from './explorer'
 import { getAffirmationsSigned, getMessagesSigned } from './contract'
 import {
   getValidatorConfirmation,
@@ -34,24 +29,22 @@ const mergeConfirmations = (oldConfirmations: BasicConfirmationParam[], newConfi
 
 export const getConfirmationsForTx = async (
   messageData: string,
-  web3: Maybe<Web3>,
+  web3: Web3,
   validatorList: string[],
-  bridgeContract: Maybe<Contract>,
+  bridgeContract: Contract,
   fromHome: boolean,
   setResult: Function,
   requiredSignatures: number,
   setSignatureCollected: Function,
-  waitingBlocksResolved: boolean,
-  subscriptions: number[],
-  timestamp: number,
-  getFailedTransactions: (args: GetFailedTransactionParams) => Promise<APITransaction[]>,
+  setTimeoutId: (timeoutId: number) => void,
+  isCancelled: () => boolean,
+  startBlock: number,
+  getFailedTransactions: (args: GetTransactionParams) => Promise<APITransaction[]>,
   setFailedConfirmations: Function,
   getPendingTransactions: (args: GetPendingTransactionParams) => Promise<APIPendingTransaction[]>,
   setPendingConfirmations: Function,
-  getSuccessTransactions: (args: GetFailedTransactionParams) => Promise<APITransaction[]>
+  getSuccessTransactions: (args: GetTransactionParams) => Promise<APITransaction[]>
 ) => {
-  if (!web3 || !validatorList || !validatorList.length || !bridgeContract || !waitingBlocksResolved) return
-
   const confirmationContractMethod = fromHome ? getMessagesSigned : getAffirmationsSigned
 
   const hashMsg = web3.utils.soliditySha3Raw(messageData)
@@ -102,7 +95,7 @@ export const getConfirmationsForTx = async (
   // Check if confirmation failed
   const validatorFailedConfirmationsChecks = await Promise.all(
     undefinedConfirmations.map(
-      getValidatorFailedTransaction(bridgeContract, messageData, timestamp, getFailedTransactions)
+      getValidatorFailedTransaction(bridgeContract, messageData, startBlock, getFailedTransactions)
     )
   )
   const validatorFailedConfirmations = validatorFailedConfirmationsChecks.filter(
@@ -136,7 +129,7 @@ export const getConfirmationsForTx = async (
   // get transactions from success signatures
   const successConfirmationWithData = await Promise.all(
     successConfirmations.map(
-      getSuccessExecutionTransaction(web3, bridgeContract, fromHome, messageData, timestamp, getSuccessTransactions)
+      getSuccessExecutionTransaction(web3, bridgeContract, fromHome, messageData, startBlock, getSuccessTransactions)
     )
   )
 
@@ -149,28 +142,30 @@ export const getConfirmationsForTx = async (
     (!hasEnoughSignatures && missingConfirmations.length > 0) ||
     successConfirmationWithTxFound.length < successConfirmationWithData.length
   ) {
-    const timeoutId = setTimeout(
-      () =>
-        getConfirmationsForTx(
-          messageData,
-          web3,
-          validatorList,
-          bridgeContract,
-          fromHome,
-          setResult,
-          requiredSignatures,
-          setSignatureCollected,
-          waitingBlocksResolved,
-          subscriptions,
-          timestamp,
-          getFailedTransactions,
-          setFailedConfirmations,
-          getPendingTransactions,
-          setPendingConfirmations,
-          getSuccessTransactions
-        ),
-      HOME_RPC_POLLING_INTERVAL
-    )
-    subscriptions.push(timeoutId)
+    if (!isCancelled()) {
+      const timeoutId = setTimeout(
+        () =>
+          getConfirmationsForTx(
+            messageData,
+            web3,
+            validatorList,
+            bridgeContract,
+            fromHome,
+            setResult,
+            requiredSignatures,
+            setSignatureCollected,
+            setTimeoutId,
+            isCancelled,
+            startBlock,
+            getFailedTransactions,
+            setFailedConfirmations,
+            getPendingTransactions,
+            setPendingConfirmations,
+            getSuccessTransactions
+          ),
+        HOME_RPC_POLLING_INTERVAL
+      )
+      setTimeoutId(timeoutId)
+    }
   }
 }

alm/src/utils/getFinalizationEvent.ts

@@ -1,41 +1,51 @@
 import { Contract, EventData } from 'web3-eth-contract'
 import Web3 from 'web3'
-import { CACHE_KEY_EXECUTION_FAILED, THREE_DAYS_TIMESTAMP, VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
+import {
+  CACHE_KEY_EXECUTION_FAILED,
+  FOREIGN_EXPLORER_API,
+  FOREIGN_RPC_POLLING_INTERVAL,
+  HOME_EXPLORER_API,
+  HOME_RPC_POLLING_INTERVAL,
+  VALIDATOR_CONFIRMATION_STATUS
+} from '../config/constants'
 import { ExecutionData } from '../hooks/useMessageConfirmations'
 import {
   APIPendingTransaction,
   APITransaction,
-  GetFailedTransactionParams,
-  GetPendingTransactionParams
+  GetTransactionParams,
+  GetPendingTransactionParams,
+  getLogs
 } from './explorer'
 import { getBlock, MessageObject } from './web3'
 import validatorsCache from '../services/ValidatorsCache'
+import { foreignBlockNumberProvider, homeBlockNumberProvider } from '../services/BlockNumberProvider'
 
-export const getFinalizationEvent = async (
-  contract: Maybe<Contract>,
+const getPastEventsWithFallback = (api: string, web3: Web3, contract: Contract, eventName: string, options: any) =>
+  contract.getPastEvents(eventName, options).catch(
+    () =>
+      api
+        ? getLogs(api, web3, contract, eventName, {
+            fromBlock: options.fromBlock,
+            toBlock: options.toBlock,
+            topics: [null, null, options.filter.messageId]
+          })
+        : []
+  )
+
+export const getSuccessExecutionData = async (
+  contract: Contract,
   eventName: string,
-  web3: Maybe<Web3>,
-  setResult: React.Dispatch<React.SetStateAction<ExecutionData>>,
-  waitingBlocksResolved: boolean,
-  message: MessageObject,
-  interval: number,
-  subscriptions: number[],
-  timestamp: number,
-  collectedSignaturesEvent: Maybe<EventData>,
-  getFailedExecution: (args: GetFailedTransactionParams) => Promise<APITransaction[]>,
-  setFailedExecution: Function,
-  getPendingExecution: (args: GetPendingTransactionParams) => Promise<APIPendingTransaction[]>,
-  setPendingExecution: Function,
-  setExecutionEventsFetched: Function
+  web3: Web3,
+  messageId: string,
+  api: string = ''
 ) => {
-  if (!contract || !web3 || !waitingBlocksResolved) return
   // Since it filters by the message id, only one event will be fetched
   // so there is no need to limit the range of the block to reduce the network traffic
-  const events: EventData[] = await contract.getPastEvents(eventName, {
+  const events: EventData[] = await getPastEventsWithFallback(api, web3, contract, eventName, {
     fromBlock: 0,
     toBlock: 'latest',
     filter: {
-      messageId: message.id
+      messageId
     }
   })
   if (events.length > 0) {
@@ -48,13 +58,40 @@ export const getFinalizationEvent = async (
     const blockTimestamp = typeof block.timestamp === 'string' ? parseInt(block.timestamp) : block.timestamp
     const validatorAddress = web3.utils.toChecksumAddress(txReceipt.from)
 
-    setResult({
+    return {
       status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
       validator: validatorAddress,
       txHash: event.transactionHash,
       timestamp: blockTimestamp,
       executionResult: event.returnValues.status
-    })
+    }
+  }
+  return null
+}
+
+export const getFinalizationEvent = async (
+  fromHome: boolean,
+  contract: Contract,
+  web3: Web3,
+  setResult: React.Dispatch<React.SetStateAction<ExecutionData>>,
+  message: MessageObject,
+  setTimeoutId: (timeoutId: number) => void,
+  isCancelled: () => boolean,
+  startBlock: number,
+  collectedSignaturesEvent: Maybe<EventData>,
+  getFailedExecution: (args: GetTransactionParams) => Promise<APITransaction[]>,
+  setFailedExecution: Function,
+  getPendingExecution: (args: GetPendingTransactionParams) => Promise<APIPendingTransaction[]>,
+  setPendingExecution: Function,
+  setExecutionEventsFetched: Function
+) => {
+  const eventName = fromHome ? 'RelayedMessage' : 'AffirmationCompleted'
+  const api = fromHome ? FOREIGN_EXPLORER_API : HOME_EXPLORER_API
+
+  const successExecutionData = await getSuccessExecutionData(contract, eventName, web3, message.id, api)
+
+  if (successExecutionData) {
+    setResult(successExecutionData)
   } else {
     setExecutionEventsFetched(true)
     // If event is defined, it means it is a message from Home to Foreign
@@ -84,14 +121,15 @@ export const getFinalizationEvent = async (
       } else {
         const validatorExecutionCacheKey = `${CACHE_KEY_EXECUTION_FAILED}${validator}-${message.id}`
         const failedFromCache = validatorsCache.get(validatorExecutionCacheKey)
+        const blockProvider = fromHome ? foreignBlockNumberProvider : homeBlockNumberProvider
 
         if (!failedFromCache) {
           const failedTransactions = await getFailedExecution({
             account: validator,
             to: contract.options.address,
             messageData: message.data,
-            startTimestamp: timestamp,
-            endTimestamp: timestamp + THREE_DAYS_TIMESTAMP
+            startBlock,
+            endBlock: blockProvider.get() || 0
           })
 
           if (failedTransactions.length > 0) {
@@ -114,27 +152,28 @@ export const getFinalizationEvent = async (
       }
     }
 
-    const timeoutId = setTimeout(
-      () =>
-        getFinalizationEvent(
-          contract,
-          eventName,
-          web3,
-          setResult,
-          waitingBlocksResolved,
-          message,
-          interval,
-          subscriptions,
-          timestamp,
-          collectedSignaturesEvent,
-          getFailedExecution,
-          setFailedExecution,
-          getPendingExecution,
-          setPendingExecution,
-          setExecutionEventsFetched
-        ),
-      interval
-    )
-    subscriptions.push(timeoutId)
+    if (!isCancelled()) {
+      const timeoutId = setTimeout(
+        () =>
+          getFinalizationEvent(
+            fromHome,
+            contract,
+            web3,
+            setResult,
+            message,
+            setTimeoutId,
+            isCancelled,
+            startBlock,
+            collectedSignaturesEvent,
+            getFailedExecution,
+            setFailedExecution,
+            getPendingExecution,
+            setPendingExecution,
+            setExecutionEventsFetched
+          ),
+        fromHome ? FOREIGN_RPC_POLLING_INTERVAL : HOME_RPC_POLLING_INTERVAL
+      )
+      setTimeoutId(timeoutId)
+    }
   }
 }

alm/src/utils/signatureWaitingForBlocks.ts

@@ -1,50 +0,0 @@
-import { VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
-import { BlockNumberProvider } from '../services/BlockNumberProvider'
-
-export const checkSignaturesWaitingForBLocks = async (
-  targetBlock: number,
-  setWaitingStatus: Function,
-  setWaitingBlocksResolved: Function,
-  validatorList: string[],
-  setConfirmations: Function,
-  blockProvider: BlockNumberProvider,
-  interval: number,
-  subscriptions: number[]
-) => {
-  const currentBlock = blockProvider.get()
-
-  if (currentBlock && currentBlock >= targetBlock) {
-    setWaitingBlocksResolved(true)
-    setWaitingStatus(false)
-    blockProvider.stop()
-  } else {
-    let nextInterval = interval
-    if (!currentBlock) {
-      nextInterval = 500
-    } else {
-      const validatorsWaiting = validatorList.map(validator => {
-        return {
-          validator,
-          status: VALIDATOR_CONFIRMATION_STATUS.WAITING
-        }
-      })
-      setWaitingStatus(true)
-      setConfirmations(validatorsWaiting)
-    }
-    const timeoutId = setTimeout(
-      () =>
-        checkSignaturesWaitingForBLocks(
-          targetBlock,
-          setWaitingStatus,
-          setWaitingBlocksResolved,
-          validatorList,
-          setConfirmations,
-          blockProvider,
-          interval,
-          subscriptions
-        ),
-      nextInterval
-    )
-    subscriptions.push(timeoutId)
-  }
-}

alm/src/utils/validatorConfirmationHelpers.ts

@@ -2,18 +2,9 @@ import Web3 from 'web3'
 import { Contract } from 'web3-eth-contract'
 import { BasicConfirmationParam, ConfirmationParam } from '../hooks/useMessageConfirmations'
 import validatorsCache from '../services/ValidatorsCache'
-import {
-  CACHE_KEY_FAILED,
-  CACHE_KEY_SUCCESS,
-  ONE_DAY_TIMESTAMP,
-  VALIDATOR_CONFIRMATION_STATUS
-} from '../config/constants'
-import {
-  APIPendingTransaction,
-  APITransaction,
-  GetFailedTransactionParams,
-  GetPendingTransactionParams
-} from './explorer'
+import { CACHE_KEY_FAILED, CACHE_KEY_SUCCESS, VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
+import { APIPendingTransaction, APITransaction, GetTransactionParams, GetPendingTransactionParams } from './explorer'
+import { homeBlockNumberProvider } from '../services/BlockNumberProvider'
 
 export const getValidatorConfirmation = (
   web3: Web3,
@@ -50,8 +41,8 @@ export const getSuccessExecutionTransaction = (
   bridgeContract: Contract,
   fromHome: boolean,
   messageData: string,
-  timestamp: number,
-  getSuccessTransactions: (args: GetFailedTransactionParams) => Promise<APITransaction[]>
+  startBlock: number,
+  getSuccessTransactions: (args: GetTransactionParams) => Promise<APITransaction[]>
 ) => async (validatorData: BasicConfirmationParam): Promise<ConfirmationParam> => {
   const { validator } = validatorData
   const validatorCacheKey = `${CACHE_KEY_SUCCESS}${validatorData.validator}-${messageData}`
@@ -65,8 +56,8 @@ export const getSuccessExecutionTransaction = (
     account: validatorData.validator,
     to: bridgeContract.options.address,
     messageData,
-    startTimestamp: timestamp,
-    endTimestamp: timestamp + ONE_DAY_TIMESTAMP
+    startBlock,
+    endBlock: homeBlockNumberProvider.get() || 0
   })
 
   let txHashTimestamp = 0
@@ -98,8 +89,8 @@ export const getSuccessExecutionTransaction = (
 export const getValidatorFailedTransaction = (
   bridgeContract: Contract,
   messageData: string,
-  timestamp: number,
-  getFailedTransactions: (args: GetFailedTransactionParams) => Promise<APITransaction[]>
+  startBlock: number,
+  getFailedTransactions: (args: GetTransactionParams) => Promise<APITransaction[]>
 ) => async (validatorData: BasicConfirmationParam): Promise<ConfirmationParam> => {
   const validatorCacheKey = `${CACHE_KEY_FAILED}${validatorData.validator}-${messageData}`
   const failedFromCache = validatorsCache.getData(validatorCacheKey)
@@ -112,8 +103,8 @@ export const getValidatorFailedTransaction = (
     account: validatorData.validator,
     to: bridgeContract.options.address,
     messageData,
-    startTimestamp: timestamp,
-    endTimestamp: timestamp + ONE_DAY_TIMESTAMP
+    startBlock,
+    endBlock: homeBlockNumberProvider.get() || 0
   })
   const newStatus =
     failedTransactions.length > 0 ? VALIDATOR_CONFIRMATION_STATUS.FAILED : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED

commons/abis.js

@@ -56,6 +56,11 @@ const OLD_AMB_USER_REQUEST_FOR_SIGNATURE_ABI = [
   {
     anonymous: false,
     inputs: [
+      {
+        indexed: true,
+        name: 'messageId',
+        type: 'bytes32'
+      },
       {
         indexed: false,
         name: 'encodedData',
@@ -71,6 +76,11 @@ const OLD_AMB_USER_REQUEST_FOR_AFFIRMATION_ABI = [
   {
     anonymous: false,
     inputs: [
+      {
+        indexed: true,
+        name: 'messageId',
+        type: 'bytes32'
+      },
       {
         indexed: false,
         name: 'encodedData',

deployment/roles/common/tasks/dependencies.yml

@@ -33,7 +33,7 @@
     mode: "0755"
 
 - name: Upgrade pip version
-  shell: pip3 install --upgrade pip
+  shell: pip3 install --upgrade pip==19.3.1
 
 - name: Install python docker library
   shell: pip3 install docker docker-compose setuptools

monitor/.env.example

@@ -28,3 +28,6 @@ MONITOR_HOME_TO_FOREIGN_BLOCK_LIST=
 
 # MONITOR_HOME_VALIDATORS_BALANCE_ENABLE=0x... 0x... 0x...
 # MONITOR_FOREIGN_VALIDATORS_BALANCE_ENABLE=0x... 0x... 0x...
+
+# MONITOR_HOME_EXPLORER_API=
+MONITOR_FOREIGN_EXPLORER_API=https://api.bscscan.com/api?apikey=YourApiKeyToken

monitor/alerts.js

@@ -1,18 +1,19 @@
 require('dotenv').config()
 const logger = require('./logger')('alerts')
-const eventsInfo = require('./utils/events')
 const { processedMsgNotDelivered, eventWithoutReference } = require('./utils/message')
 const { BRIDGE_MODES } = require('../commons')
-const { web3Home, web3Foreign, getHomeBlockNumber, getForeignBlockNumber } = require('./utils/web3')
+const { web3Home, web3Foreign } = require('./utils/web3')
 
-async function main() {
+async function main(eventsInfo) {
   const {
+    homeBlockNumber,
+    foreignBlockNumber,
     homeToForeignRequests,
     homeToForeignConfirmations,
     foreignToHomeConfirmations,
     foreignToHomeRequests,
     bridgeMode
-  } = await eventsInfo()
+  } = eventsInfo
 
   let xSignatures
   let xAffirmations
@@ -24,8 +25,6 @@ async function main() {
     xAffirmations = foreignToHomeConfirmations.filter(eventWithoutReference(foreignToHomeRequests))
   }
   logger.debug('building misbehavior blocks')
-  const homeBlockNumber = await getHomeBlockNumber()
-  const foreignBlockNumber = await getForeignBlockNumber()
 
   const baseRange = [false, false, false, false, false]
   const xSignaturesMisbehavior = buildRangesObject(

monitor/checkWorker2.js

@@ -1,6 +1,7 @@
 require('dotenv').config()
 const logger = require('./logger')('checkWorker2')
 const eventsStats = require('./eventsStats')
+const getEventsInfo = require('./utils/events')
 const alerts = require('./alerts')
 const { writeFile, createDir } = require('./utils/file')
 const { saveCache } = require('./utils/web3Cache')
@@ -10,8 +11,10 @@ const { MONITOR_BRIDGE_NAME } = process.env
 async function checkWorker2() {
   try {
     createDir(`/responses/${MONITOR_BRIDGE_NAME}`)
+    logger.debug('calling getEventsInfo()')
+    const eventsInfo = await getEventsInfo()
     logger.debug('calling eventsStats()')
-    const evStats = await eventsStats()
+    const evStats = await eventsStats(eventsInfo)
     if (!evStats) throw new Error('evStats is empty: ' + JSON.stringify(evStats))
     evStats.ok =
       (evStats.onlyInHomeDeposits || evStats.home.deliveredMsgNotProcessedInForeign).length === 0 &&
@@ -22,7 +25,7 @@ async function checkWorker2() {
     writeFile(`/responses/${MONITOR_BRIDGE_NAME}/eventsStats.json`, evStats)
 
     logger.debug('calling alerts()')
-    const _alerts = await alerts()
+    const _alerts = await alerts(eventsInfo)
     if (!_alerts) throw new Error('alerts is empty: ' + JSON.stringify(_alerts))
     _alerts.ok = !_alerts.executeAffirmations.mostRecentTxHash && !_alerts.executeSignatures.mostRecentTxHash
     _alerts.health = true

monitor/checkWorker3.js

@@ -2,6 +2,7 @@ require('dotenv').config()
 const logger = require('./logger')('checkWorker3')
 const stuckTransfers = require('./stuckTransfers')
 const detectMediators = require('./detectMediators')
+const detectFailures = require('./detectFailures')
 const { writeFile, createDir } = require('./utils/file')
 const { web3Home } = require('./utils/web3')
 const { saveCache } = require('./utils/web3Cache')
@@ -24,11 +25,19 @@ async function checkWorker3() {
       logger.debug('Done')
     } else if (bridgeMode === BRIDGE_MODES.ARBITRARY_MESSAGE) {
       createDir(`/responses/${MONITOR_BRIDGE_NAME}`)
+
       logger.debug('calling detectMediators()')
       const mediators = await detectMediators(bridgeMode)
       mediators.ok = true
       mediators.health = true
       writeFile(`/responses/${MONITOR_BRIDGE_NAME}/mediators.json`, mediators)
+
+      logger.debug('calling detectFailures()')
+      const failures = await detectFailures(bridgeMode)
+      failures.ok = true
+      failures.health = true
+      writeFile(`/responses/${MONITOR_BRIDGE_NAME}/failures.json`, failures)
+
       saveCache()
       logger.debug('Done')
     }

monitor/detectFailures.js

@@ -0,0 +1,86 @@
+require('dotenv').config()
+const logger = require('./logger')('alerts')
+const eventsInfo = require('./utils/events')
+const { normalizeAMBMessageEvent } = require('../commons')
+const { getHomeBlockNumber, getForeignBlockNumber } = require('./utils/web3')
+
+function normalize(events) {
+  const requests = {}
+  events.forEach(event => {
+    const request = normalizeAMBMessageEvent(event)
+    request.requestTx = event.transactionHash
+    requests[request.messageId] = request
+  })
+  return confirmation => {
+    const request = requests[confirmation.returnValues.messageId] || {}
+    return {
+      ...request,
+      status: false,
+      executionTx: confirmation.transactionHash,
+      executionBlockNumber: confirmation.blockNumber
+    }
+  }
+}
+
+async function main(mode) {
+  const {
+    homeToForeignRequests,
+    homeToForeignConfirmations,
+    foreignToHomeConfirmations,
+    foreignToHomeRequests
+  } = await eventsInfo(mode)
+  const hasFailed = event => !event.returnValues.status
+  const cmp = (a, b) => b.executionBlockNumber - a.executionBlockNumber
+  const failedForeignToHomeMessages = foreignToHomeConfirmations
+    .filter(hasFailed)
+    .map(normalize(foreignToHomeRequests))
+    .sort(cmp)
+  const failedHomeToForeignMessages = homeToForeignConfirmations
+    .filter(hasFailed)
+    .map(normalize(homeToForeignRequests))
+    .sort(cmp)
+
+  const homeBlockNumber = await getHomeBlockNumber()
+  const foreignBlockNumber = await getForeignBlockNumber()
+
+  const blockRanges = [1000, 10000, 100000, 1000000]
+  const rangeNames = [
+    `last${blockRanges[0]}blocks`,
+    ...blockRanges.slice(0, blockRanges.length - 1).map((n, i) => `last${n}to${blockRanges[i + 1]}blocks`),
+    `before${blockRanges[blockRanges.length - 1]}blocks`
+  ]
+
+  const countFailures = (failedMessages, lastBlockNumber) => {
+    const result = {}
+    rangeNames.forEach(name => {
+      result[name] = 0
+    })
+    failedMessages.forEach(message => {
+      const blockAge = lastBlockNumber - message.executionBlockNumber
+      let rangeIndex = blockRanges.findIndex(n => n > blockAge)
+      if (rangeIndex === -1) {
+        rangeIndex = blockRanges.length
+      }
+      result[rangeNames[rangeIndex]] += 1
+    })
+    return result
+  }
+
+  logger.debug('Done')
+
+  return {
+    homeToForeign: {
+      total: failedHomeToForeignMessages.length,
+      stats: countFailures(failedHomeToForeignMessages, foreignBlockNumber),
+      lastFailures: failedHomeToForeignMessages.slice(0, 5)
+    },
+    foreignToHome: {
+      total: failedForeignToHomeMessages.length,
+      stats: countFailures(failedForeignToHomeMessages, homeBlockNumber),
+      lastFailures: failedForeignToHomeMessages.slice(0, 5)
+    },
+    lastChecked: Math.floor(Date.now() / 1000)
+  }
+}
+
+module.exports = main

monitor/eventsStats.js

@@ -1,5 +1,4 @@
 require('dotenv').config()
-const eventsInfo = require('./utils/events')
 const {
   processedMsgNotDelivered,
   deliveredMsgNotProcessed,
@@ -15,14 +14,14 @@ const {
   MONITOR_HOME_TO_FOREIGN_CHECK_SENDER
 } = process.env
 
-async function main() {
+async function main(eventsInfo) {
   const {
     homeToForeignRequests,
     homeToForeignConfirmations,
     foreignToHomeConfirmations,
     foreignToHomeRequests,
     bridgeMode
-  } = await eventsInfo()
+  } = eventsInfo
 
   if (bridgeMode === BRIDGE_MODES.ARBITRARY_MESSAGE) {
     return {

monitor/getBalances.js

@@ -5,7 +5,12 @@ const logger = require('./logger')('getBalances')
 const { BRIDGE_MODES } = require('../commons')
 const { web3Home, web3Foreign, getHomeBlockNumber } = require('./utils/web3')
 
-const { COMMON_HOME_BRIDGE_ADDRESS, COMMON_FOREIGN_BRIDGE_ADDRESS } = process.env
+const {
+  MONITOR_HOME_START_BLOCK,
+  MONITOR_FOREIGN_START_BLOCK,
+  COMMON_HOME_BRIDGE_ADDRESS,
+  COMMON_FOREIGN_BRIDGE_ADDRESS
+} = process.env
 
 const {
   ERC20_ABI,
@@ -20,6 +25,8 @@ const {
 
 async function main(bridgeMode, eventsInfo) {
   const {
+    homeBlockNumber,
+    foreignBlockNumber,
     homeToForeignConfirmations,
     foreignToHomeConfirmations,
     homeDelayedBlockNumber,
@@ -46,6 +53,13 @@ async function main(bridgeMode, eventsInfo) {
     ...foreignToHomeConfirmations.filter(e => e.blockNumber > homeDelayedBlockNumber).map(e => e.value)
   )
 
+  const blockRanges = {
+    startBlockHome: MONITOR_HOME_START_BLOCK,
+    endBlockHome: homeBlockNumber,
+    startBlockForeign: MONITOR_FOREIGN_START_BLOCK,
+    endBlockForeign: foreignBlockNumber
+  }
+
   if (bridgeMode === BRIDGE_MODES.ERC_TO_ERC) {
     const foreignBridge = new web3Foreign.eth.Contract(FOREIGN_ERC_TO_ERC_ABI, COMMON_FOREIGN_BRIDGE_ADDRESS)
     const erc20Address = await foreignBridge.methods.erc20token().call()
@@ -72,6 +86,7 @@ async function main(bridgeMode, eventsInfo) {
         erc20Balance: Web3Utils.fromWei(foreignErc20Balance)
       },
       balanceDiff: Number(Web3Utils.fromWei(diff)),
+      ...blockRanges,
       lastChecked: Math.floor(Date.now() / 1000)
     }
   } else if (bridgeMode === BRIDGE_MODES.NATIVE_TO_ERC || bridgeMode === BRIDGE_MODES.NATIVE_TO_ERC_V1) {
@@ -94,6 +109,7 @@ async function main(bridgeMode, eventsInfo) {
         totalSupply: Web3Utils.fromWei(totalSupply)
       },
       balanceDiff: Number(Web3Utils.fromWei(diff)),
+      ...blockRanges,
       lastChecked: Math.floor(Date.now() / 1000)
     }
   } else if (bridgeMode === BRIDGE_MODES.ERC_TO_NATIVE) {
@@ -163,12 +179,14 @@ async function main(bridgeMode, eventsInfo) {
       },
       foreign,
       balanceDiff: Number(Web3Utils.fromWei(diff)),
+      ...blockRanges,
       lastChecked: Math.floor(Date.now() / 1000)
     }
   } else if (bridgeMode === BRIDGE_MODES.ARBITRARY_MESSAGE) {
     return {
       home: {},
       foreign: {},
+      ...blockRanges,
       lastChecked: Math.floor(Date.now() / 1000)
     }
   } else {

monitor/index.js

@@ -11,9 +11,10 @@ app.use(cors())
 app.get('/favicon.ico', (req, res) => res.sendStatus(204))
 app.use('/:bridgeName', bridgeRouter)
 
-bridgeRouter.get('/', async (req, res, next) => {
+bridgeRouter.get('/:file(validators|eventsStats|alerts|mediators|stuckTransfers|failures)?', (req, res, next) => {
   try {
-    const results = await readFile(`./responses/${req.params.bridgeName}/getBalances.json`)
+    const { bridgeName, file } = req.params
+    const results = readFile(`./responses/${bridgeName}/${file || 'getBalances'}.json`)
     res.json(results)
   } catch (e) {
     // this will eventually be handled by your error handling middleware
@@ -21,49 +22,11 @@ bridgeRouter.get('/', async (req, res, next) => {
   }
 })
 
-bridgeRouter.get('/validators', async (req, res, next) => {
+bridgeRouter.get('/metrics', (req, res, next) => {
   try {
-    const results = await readFile(`./responses/${req.params.bridgeName}/validators.json`)
-    res.json(results)
-  } catch (e) {
-    // this will eventually be handled by your error handling middleware
-    next(e)
-  }
-})
-
-bridgeRouter.get('/eventsStats', async (req, res, next) => {
-  try {
-    const results = await readFile(`./responses/${req.params.bridgeName}/eventsStats.json`)
-    res.json(results)
-  } catch (e) {
-    // this will eventually be handled by your error handling middleware
-    next(e)
-  }
-})
-
-bridgeRouter.get('/alerts', async (req, res, next) => {
-  try {
-    const results = await readFile(`./responses/${req.params.bridgeName}/alerts.json`)
-    res.json(results)
-  } catch (e) {
-    next(e)
-  }
-})
-
-bridgeRouter.get('/mediators', async (req, res, next) => {
-  try {
-    const results = await readFile(`./responses/${req.params.bridgeName}/mediators.json`)
-    res.json(results)
-  } catch (e) {
-    // this will eventually be handled by your error handling middleware
-    next(e)
-  }
-})
-
-bridgeRouter.get('/stuckTransfers', async (req, res, next) => {
-  try {
-    const results = await readFile(`./responses/${req.params.bridgeName}/stuckTransfers.json`)
-    res.json(results)
+    const { bridgeName } = req.params
+    const metrics = readFile(`./responses/${bridgeName}/metrics.txt`, false)
+    res.type('text').send(metrics)
   } catch (e) {
     next(e)
   }

monitor/metricsWorker.js

@@ -0,0 +1,20 @@
+require('dotenv').config()
+const logger = require('./logger')('metricsWorker')
+const { writeFile, createDir } = require('./utils/file')
+const getPrometheusMetrics = require('./prometheusMetrics')
+
+const { MONITOR_BRIDGE_NAME } = process.env
+
+async function metricsWorker() {
+  try {
+    createDir(`/responses/${MONITOR_BRIDGE_NAME}`)
+    logger.debug('calling getPrometheusMetrics()')
+    const metrics = await getPrometheusMetrics(MONITOR_BRIDGE_NAME)
+    if (!metrics) throw new Error('metrics is empty: ' + JSON.stringify(metrics))
+    writeFile(`/responses/${MONITOR_BRIDGE_NAME}/metrics.txt`, metrics, { stringify: false })
+    logger.debug('Done')
+  } catch (e) {
+    logger.error(e)
+  }
+}
+metricsWorker()

monitor/package.json

@@ -4,7 +4,7 @@
   "description": "",
   "main": "index.js",
   "scripts": {
-    "check-all": "timeout -s 9 5m node checkWorker.js && timeout -s 9 5m node checkWorker2.js && timeout -s 9 5m node checkWorker3.js",
+    "check-all": "timeout -s 9 5m node checkWorker.js && timeout -s 9 5m node checkWorker2.js && timeout -s 9 5m node checkWorker3.js && timeout -s 9 10s node metricsWorker.js",
     "start": "node index.js",
     "check-and-start": "yarn check-all && yarn start",
     "lint": "eslint . --ignore-path ../.eslintignore",

monitor/prometheusMetrics.js

@@ -0,0 +1,137 @@
+require('dotenv').config()
+const logger = require('./logger')('getBalances')
+const { readFile } = require('./utils/file')
+
+const {
+  MONITOR_HOME_START_BLOCK,
+  MONITOR_FOREIGN_START_BLOCK,
+  MONITOR_HOME_VALIDATORS_BALANCE_ENABLE,
+  MONITOR_FOREIGN_VALIDATORS_BALANCE_ENABLE
+} = process.env
+
+function BridgeConf(type, validatorsBalanceEnable, alertTargetFunc, failureDirection) {
+  this.type = type
+  this.validatorsBalanceEnable = validatorsBalanceEnable
+  this.alertTargetFunc = alertTargetFunc
+  this.failureDirection = failureDirection
+}
+
+const BRIDGE_CONFS = [
+  new BridgeConf('home', MONITOR_HOME_VALIDATORS_BALANCE_ENABLE, 'executeAffirmations', 'homeToForeign'),
+  new BridgeConf('foreign', MONITOR_FOREIGN_VALIDATORS_BALANCE_ENABLE, 'executeSignatures', 'foreignToHome')
+]
+
+function hasError(obj) {
+  return 'error' in obj
+}
+
+// Try to collect all metrics from JSON responses and then
+// discard all unsuccessfully retrieved ones
+async function getPrometheusMetrics(bridgeName) {
+  const responsePath = jsonName => `./responses/${bridgeName}/${jsonName}.json`
+
+  const metrics = {}
+
+  // Balance metrics
+  const balancesFile = readFile(responsePath('getBalances'))
+
+  if (!hasError(balancesFile)) {
+    const { home, foreign, ...commonBalances } = balancesFile
+
+    const balanceMetrics = {
+      // ERC_TO_ERC or ERC_TO_NATIVE mode
+      balances_home_value: home.totalSupply,
+      balances_home_txs_deposit: home.deposits,
+      balances_home_txs_withdrawal: home.withdrawals,
+      balances_foreign_value: foreign.erc20Balance,
+      balances_foreign_txs_deposit: foreign.deposits,
+      balances_foreign_txs_withdrawal: foreign.withdrawals,
+
+      // Not ARBITRARY_MESSAGE mode
+      balances_diff_value: commonBalances.balanceDiff,
+      balances_diff_deposit: commonBalances.depositsDiff,
+      balances_diff_withdrawal: commonBalances.withdrawalDiff,
+
+      // MONITOR_HOME_TO_FOREIGN_ALLOWANCE_LIST or MONITOR_HOME_TO_FOREIGN_BLOCK_LIST is set
+      balances_unclaimed_txs: commonBalances.unclaimedDiff,
+      balances_unclaimed_value: commonBalances.unclaimedBalance,
+
+      // ARBITRARY_MESSAGE mode
+      txs_home_out: home.toForeign,
+      txs_home_in: home.fromForeign,
+      txs_foreign_out: foreign.toHome,
+      txs_foreign_in: foreign.fromHome,
+      txs_diff_home_out_oracles: commonBalances.fromHomeToForeignDiff,
+      txs_diff_home_out_users: commonBalances.fromHomeToForeignPBUDiff,
+      txs_diff_foreign_out: commonBalances.fromForeignToHomeDiff
+    }
+
+    const blockRanges = {
+      state_startblock_home: commonBalances.startBlockHome || MONITOR_HOME_START_BLOCK,
+      state_startblock_foreign: commonBalances.startBlockForeign || MONITOR_FOREIGN_START_BLOCK,
+      state_endblock_home: commonBalances.endBlockHome,
+      state_endblock_foreign: commonBalances.endBlockForeign
+    }
+
+    Object.assign(metrics, blockRanges, balanceMetrics)
+  }
+
+  // Validator metrics
+  const validatorsFile = readFile(responsePath('validators'))
+
+  if (!hasError(validatorsFile)) {
+    for (const bridge of BRIDGE_CONFS) {
+      const allValidators = validatorsFile[bridge.type].validators
+      const validatorAddressesWithBalanceCheck =
+        typeof bridge.validatorsBalanceEnable === 'string'
+          ? bridge.validatorsBalanceEnable.split(' ')
+          : Object.keys(allValidators)
+
+      validatorAddressesWithBalanceCheck.forEach((addr, ind) => {
+        if (addr in allValidators) {
+          metrics[`validators_balances_${bridge.type}${ind}{address="${addr}"}`] = allValidators[addr].balance
+        } else {
+          logger.debug(`Nonexistent validator address ${addr}`)
+        }
+      })
+    }
+  }
+
+  // Alert metrics
+  const alertsFile = readFile(responsePath('alerts'))
+
+  if (!hasError(alertsFile)) {
+    for (const bridge of BRIDGE_CONFS) {
+      Object.entries(alertsFile[bridge.alertTargetFunc].misbehavior).forEach(([period, val]) => {
+        metrics[`misbehavior_${bridge.type}_${period}`] = val
+      })
+    }
+  }
+
+  // Failure metrics
+  const failureFile = readFile(responsePath('failures'))
+
+  if (!hasError(failureFile)) {
+    for (const bridge of BRIDGE_CONFS) {
+      const dir = bridge.failureDirection
+      const failures = failureFile[dir]
+      metrics[`failures_${dir}_total`] = failures.total
+      Object.entries(failures.stats).forEach(([period, count]) => {
+        metrics[`failures_${dir}_${period}`] = count
+      })
+    }
+  }
+
+  // Pack metrcis into a plain text
+  return Object.entries(metrics).reduceRight(
+    // Prometheus supports `Nan` and possibly signed `Infinity`
+    // in case cast to `Number` fails
+    (acc, [key, val]) => {
+      if (typeof val === 'undefined') return acc
+      else return `${key} ${Number(val)}\n${acc}`
+    },
+    ''
+  )
+}
+
+module.exports = getPrometheusMetrics

monitor/utils/events.js

@@ -236,13 +236,15 @@ async function main(mode) {
     foreignToHomeRequests,
     isExternalErc20,
     bridgeMode,
+    homeBlockNumber,
+    foreignBlockNumber,
     homeDelayedBlockNumber,
     foreignDelayedBlockNumber
   }
 
   if (MONITOR_CACHE_EVENTS === 'true') {
     logger.debug('saving obtained events into cache file')
-    writeFile(cacheFilePath, result, false)
+    writeFile(cacheFilePath, result, { useCwd: false })
   }
   return result
 }

monitor/utils/file.js

@@ -1,23 +1,30 @@
 const fs = require('fs')
 const path = require('path')
 
-async function readFile(filePath) {
+function readFile(filePath, parseJson = true) {
   try {
-    const content = await fs.readFileSync(filePath)
+    const content = fs.readFileSync(filePath)
+    if (!parseJson) return content
     const json = JSON.parse(content)
     const timeDiff = Math.floor(Date.now() / 1000) - json.lastChecked
     return Object.assign({}, json, { timeDiff })
   } catch (e) {
-    console.error(e)
+    console.error('readFlle', e)
     return {
       error: 'the bridge statistics are not available'
     }
   }
 }
 
-function writeFile(filePath, object, useCwd = true) {
+function writeFile(filePath, object, paramOptions = {}) {
+  const defaultOptions = {
+    useCwd: true,
+    stringify: true
+  }
+  const { useCwd, stringify } = Object.assign({}, defaultOptions, paramOptions)
+
   const fullPath = useCwd ? path.join(process.cwd(), filePath) : filePath
-  fs.writeFileSync(fullPath, JSON.stringify(object, null, 4))
+  fs.writeFileSync(fullPath, stringify ? JSON.stringify(object, null, 4) : object)
 }
 
 function createDir(dirPath) {

monitor/utils/web3Cache.js

@@ -1,9 +1,15 @@
+const fetch = require('node-fetch')
 const logger = require('../logger')('web3Cache')
 const { readCacheFile, writeCacheFile } = require('./file')
 const { web3Home, web3Foreign } = require('./web3')
 const { getPastEvents: commonGetPastEvents } = require('../../commons')
 
-const { MONITOR_BRIDGE_NAME, MONITOR_CACHE_EVENTS } = process.env
+const {
+  MONITOR_BRIDGE_NAME,
+  MONITOR_CACHE_EVENTS,
+  MONITOR_FOREIGN_EXPLORER_API,
+  MONITOR_HOME_EXPLORER_API
+} = process.env
 
 let isDirty = false
 
@@ -52,6 +58,36 @@ async function isForeignContract(address) {
   return cachedForeignIsContract[address]
 }
 
+function getPastEventsWithAPIFallback(contract, options) {
+  return commonGetPastEvents(contract, options).catch(async e => {
+    const [api, web3] =
+      options.chain === 'home' ? [MONITOR_HOME_EXPLORER_API, web3Home] : [MONITOR_FOREIGN_EXPLORER_API, web3Foreign]
+    if (api && e.message.includes('exceed maximum block range')) {
+      logger.debug('BLOCK RANGE EXCEED, using fallback to the explorer API')
+
+      const abi = contract.options.jsonInterface.find(abi => abi.type === 'event' && abi.name === options.event)
+
+      const url = new URL(api)
+      url.searchParams.append('module', 'logs')
+      url.searchParams.append('action', 'getLogs')
+      url.searchParams.append('address', contract.options.address)
+      url.searchParams.append('fromBlock', options.fromBlock)
+      url.searchParams.append('toBlock', options.toBlock || 'latest')
+      url.searchParams.append('topic0', web3.eth.abi.encodeEventSignature(abi))
+
+      const logs = await fetch(url).then(res => res.json())
+
+      return logs.result.map(log => ({
+        transactionHash: log.transactionHash,
+        blockNumber: parseInt(log.blockNumber.slice(2), 16),
+        returnValues: web3.eth.abi.decodeLog(abi.inputs, log.data, log.topics.slice(1))
+      }))
+    } else {
+      throw new Error(e)
+    }
+  })
+}
+
 async function getPastEvents(contract, options) {
   if (MONITOR_CACHE_EVENTS !== 'true') {
     return commonGetPastEvents(contract, options)
@@ -94,14 +130,14 @@ async function getPastEvents(contract, options) {
     // requested:      A...B
     // cached:    C...D
     logger.debug(`Fetching events for blocks ${fromBlock}...${toBlock}`)
-    result = await commonGetPastEvents(contract, options)
+    result = await getPastEventsWithAPIFallback(contract, options)
   } else if (fromBlock < cachedFromBlock && toBlock <= cachedToBlock) {
     // requested: A...B
     // cached:      C...D
     logger.debug(`Cache hit for blocks ${cachedFromBlock}...${toBlock}`)
     logger.debug(`Fetching events for blocks ${fromBlock}...${cachedFromBlock - 1}`)
     result = [
-      ...(await commonGetPastEvents(contract, { ...options, toBlock: cachedFromBlock - 1 })),
+      ...(await getPastEventsWithAPIFallback(contract, { ...options, toBlock: cachedFromBlock - 1 })),
       ...cachedEvents.filter(e => e.blockNumber <= toBlock)
     ]
   } else if (fromBlock < cachedFromBlock && cachedToBlock < toBlock) {
@@ -111,9 +147,9 @@ async function getPastEvents(contract, options) {
     logger.debug(`Fetching events for blocks ${fromBlock}...${cachedFromBlock - 1}`)
     logger.debug(`Fetching events for blocks ${cachedToBlock + 1}...${toBlock}`)
     result = [
-      ...(await commonGetPastEvents(contract, { ...options, toBlock: cachedFromBlock - 1 })),
+      ...(await getPastEventsWithAPIFallback(contract, { ...options, toBlock: cachedFromBlock - 1 })),
       ...cachedEvents,
-      ...(await commonGetPastEvents(contract, { ...options, fromBlock: cachedToBlock + 1 }))
+      ...(await getPastEventsWithAPIFallback(contract, { ...options, fromBlock: cachedToBlock + 1 }))
     ]
   } else if (cachedFromBlock <= fromBlock && toBlock <= cachedToBlock) {
     // requested:   A.B
@@ -127,7 +163,7 @@ async function getPastEvents(contract, options) {
     logger.debug(`Fetching events for blocks ${cachedToBlock + 1}...${toBlock}`)
     result = [
       ...cachedEvents.filter(e => e.blockNumber >= fromBlock),
-      ...(await commonGetPastEvents(contract, { ...options, fromBlock: cachedToBlock + 1 }))
+      ...(await getPastEventsWithAPIFallback(contract, { ...options, fromBlock: cachedToBlock + 1 }))
     ]
   } else {
     throw new Error(

oracle/.env.example

@@ -14,12 +14,14 @@ COMMON_HOME_GAS_PRICE_SPEED_TYPE=standard
 COMMON_HOME_GAS_PRICE_FALLBACK=1000000000
 ORACLE_HOME_GAS_PRICE_UPDATE_INTERVAL=600000
 COMMON_HOME_GAS_PRICE_FACTOR=1
+ORACLE_HOME_TX_RESEND_INTERVAL=300000
 
 COMMON_FOREIGN_GAS_PRICE_SUPPLIER_URL=https://gasprice.poa.network/
 COMMON_FOREIGN_GAS_PRICE_SPEED_TYPE=standard
 COMMON_FOREIGN_GAS_PRICE_FALLBACK=1000000000
 ORACLE_FOREIGN_GAS_PRICE_UPDATE_INTERVAL=600000
 COMMON_FOREIGN_GAS_PRICE_FACTOR=1
+ORACLE_FOREIGN_TX_RESEND_INTERVAL=1200000
 
 ORACLE_QUEUE_URL=amqp://rabbit
 ORACLE_REDIS_URL=redis://redis

oracle/config/foreign-sender.config.js

@@ -1,7 +1,10 @@
 const baseConfig = require('./base.config')
 
+const { DEFAULT_TRANSACTION_RESEND_INTERVAL } = require('../src/utils/constants')
 const { web3Foreign, web3ForeignRedundant, web3ForeignFallback } = require('../src/services/web3')
 
+const { ORACLE_FOREIGN_TX_RESEND_INTERVAL } = process.env
+
 module.exports = {
   ...baseConfig.bridgeConfig,
   queue: 'foreign-prioritized',
@@ -10,5 +13,6 @@ module.exports = {
   name: 'sender-foreign',
   web3: web3Foreign,
   web3Redundant: web3ForeignRedundant,
-  web3Fallback: web3ForeignFallback
+  web3Fallback: web3ForeignFallback,
+  resendInterval: parseInt(ORACLE_FOREIGN_TX_RESEND_INTERVAL, 10) || DEFAULT_TRANSACTION_RESEND_INTERVAL
 }

oracle/config/home-sender.config.js

@@ -1,7 +1,10 @@
 const baseConfig = require('./base.config')
 
+const { DEFAULT_TRANSACTION_RESEND_INTERVAL } = require('../src/utils/constants')
 const { web3Home, web3HomeRedundant, web3HomeFallback } = require('../src/services/web3')
 
+const { ORACLE_HOME_TX_RESEND_INTERVAL } = process.env
+
 module.exports = {
   ...baseConfig.bridgeConfig,
   queue: 'home-prioritized',
@@ -10,5 +13,6 @@ module.exports = {
   name: 'sender-home',
   web3: web3Home,
   web3Redundant: web3HomeRedundant,
-  web3Fallback: web3HomeFallback
+  web3Fallback: web3HomeFallback,
+  resendInterval: parseInt(ORACLE_HOME_TX_RESEND_INTERVAL, 10) || DEFAULT_TRANSACTION_RESEND_INTERVAL
 }

oracle/src/sender.js

@@ -47,6 +47,7 @@ async function initialize() {
     connectSenderToQueue({
       queueName: config.queue,
       oldQueueName: config.oldQueue,
+      resendInterval: config.resendInterval,
       cb: options => {
         if (config.maxProcessingTime) {
           return watchdog(() => main(options), config.maxProcessingTime, () => {
@@ -173,15 +174,18 @@ async function main({ msg, ackMsg, nackMsg, channel, scheduleForRetry, scheduleT
           `Tx Failed for event Tx ${job.transactionReference}.`,
           e.message
         )
-        if (!e.message.toLowerCase().includes('transaction with the same hash was already imported')) {
-          if (isResend) {
-            resendJobs.push(job)
-          } else {
-            failedTx.push(job)
-          }
+
+        const message = e.message.toLowerCase()
+        if (isResend || message.includes('transaction with the same hash was already imported')) {
+          resendJobs.push(job)
+        } else {
+          // if initial transaction sending has failed not due to the same hash error
+          // send it to the failed tx queue
+          // this will result in the sooner resend attempt than if using resendJobs
+          failedTx.push(job)
         }
 
-        if (e.message.toLowerCase().includes('insufficient funds')) {
+        if (message.includes('insufficient funds')) {
           insufficientFunds = true
           const currentBalance = await web3Instance.eth.getBalance(ORACLE_VALIDATOR_ADDRESS)
           minimumBalance = gasLimit.multipliedBy(gasPrice)
@@ -204,7 +208,7 @@ async function main({ msg, ackMsg, nackMsg, channel, scheduleForRetry, scheduleT
       await scheduleForRetry(failedTx, msg.properties.headers['x-retries'])
     }
     if (resendJobs.length) {
-      logger.info(`Sending ${resendJobs.length} Tx Delayed Resend Requests to Queue`)
+      logger.info({ delay: config.resendInterval }, `Sending ${resendJobs.length} Tx Delayed Resend Requests to Queue`)
       await scheduleTransactionResend(resendJobs)
     }
     ackMsg(msg)

oracle/src/services/amqpClient.js

@@ -5,7 +5,6 @@ const connection = require('amqp-connection-manager').connect(process.env.ORACLE
 const logger = require('./logger')
 const { getRetrySequence } = require('../utils/utils')
 const {
-  TRANSACTION_RESEND_TIMEOUT,
   SENDER_QUEUE_MAX_PRIORITY,
   SENDER_QUEUE_SEND_PRIORITY,
   SENDER_QUEUE_CHECK_STATUS_PRIORITY
@@ -48,7 +47,7 @@ function connectWatcherToQueue({ queueName, workerQueue, cb }) {
   cb({ sendToQueue, sendToWorker, channel: channelWrapper })
 }
 
-function connectSenderToQueue({ queueName, oldQueueName, cb }) {
+function connectSenderToQueue({ queueName, oldQueueName, cb, resendInterval }) {
   const deadLetterExchange = `${queueName}-retry`
 
   async function resendMessagesToNewQueue(channel) {
@@ -97,7 +96,8 @@ function connectSenderToQueue({ queueName, oldQueueName, cb }) {
             channelWrapper,
             channel,
             queueName,
-            deadLetterExchange
+            deadLetterExchange,
+            delay: resendInterval
           })
         }
       })
@@ -164,13 +164,13 @@ async function generateRetry({ data, msgRetries, channelWrapper, channel, queueN
   })
 }
 
-async function generateTransactionResend({ data, channelWrapper, channel, queueName, deadLetterExchange }) {
-  const retryQueue = `${queueName}-check-tx-status`
+async function generateTransactionResend({ data, channelWrapper, channel, queueName, deadLetterExchange, delay }) {
+  const retryQueue = `${queueName}-check-tx-status-${delay}`
   await channel.assertQueue(retryQueue, {
     durable: true,
     deadLetterExchange,
-    messageTtl: TRANSACTION_RESEND_TIMEOUT,
-    expires: TRANSACTION_RESEND_TIMEOUT * 10,
+    messageTtl: delay,
+    expires: delay * 10,
     maxPriority: SENDER_QUEUE_MAX_PRIORITY
   })
   await channelWrapper.sendToQueue(retryQueue, data, {

oracle/src/utils/constants.js

@@ -23,7 +23,7 @@ module.exports = {
     MIN: 1,
     MAX: 1000
   },
-  TRANSACTION_RESEND_TIMEOUT: 20 * 60 * 1000,
+  DEFAULT_TRANSACTION_RESEND_INTERVAL: 20 * 60 * 1000,
   FALLBACK_RPC_URL_SWITCH_TIMEOUT: 60 * 60 * 1000,
   SENDER_QUEUE_MAX_PRIORITY: 10,
   SENDER_QUEUE_SEND_PRIORITY: 5,

yarn.lock

@@ -13953,6 +13953,11 @@ node-fetch@^2.1.2, node-fetch@^2.3.0, node-fetch@^2.5.0:
   resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.0.tgz#e633456386d4aa55863f676a7ab0daa8fdecb0fd"
   integrity sha512-8dG4H5ujfvFiqDmVu9fQ5bOHUC15JMjMY/Zumv26oOvvVJjM67KF8koCWIabKQ1GJIa9r2mMZscBq/TbdOcmNA==
 
+node-fetch@^2.6.1:
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.1.tgz#045bd323631f76ed2e2b55573394416b639a0052"
+  integrity sha512-V4aYg89jEoVRxRb2fJdAg8FHvI7cEyYdVAh94HH0UIK8oJxUfkjlDQN9RbMx+bEjP7+ggMiFRprSti032Oipxw==
+
 node-forge@0.7.5:
   version "0.7.5"
   resolved "https://registry.yarnpkg.com/node-forge/-/node-forge-0.7.5.tgz#6c152c345ce11c52f465c2abd957e8639cd674df"