Fix BSC RPC exceed maximum block range

Fix monitor metrics (#533 )
Fix undefined is not an object exception (#535 )
2021-04-11 18:30:39 +03:00 · 2021-04-02 03:59:49 -06:00 · 2021-03-26 12:16:23 -06:00 · 2021-03-18 00:04:33 -06:00 · 2021-03-17 21:48:40 -06:00 · 2021-03-14 07:39:23 -06:00
55 changed files with 1461 additions and 965 deletions
--- a/CONFIGURATION.md
+++ b/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
@@ -82,3 +84,7 @@ MONITOR_CACHE_EVENTS | If set to true, monitor will cache obtained events for ot
 MONITOR_HOME_TO_FOREIGN_ALLOWANCE_LIST | File with a list of addresses, separated by newlines. If set, determines the privileged set of accounts whose requests should be automatically processed by the CollectedSignatures watcher. | string
 MONITOR_HOME_TO_FOREIGN_BLOCK_LIST | File with a list of addresses, separated by newlines. If set, determines the set of accounts whose requests should be marked as unclaimed. Has a lower priority than the `MONITOR_HOME_TO_FOREIGN_ALLOWANCE_LIST`. | string
 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
--- a/alm/Dockerfile
+++ b/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
--- a/alm/package.json
+++ b/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"
  }
 }
--- a/alm/scripts/createSnapshots.js
+++ b/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
  })
--- a/alm/src/components/ConfirmationsContainer.tsx
+++ b/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
--- a/alm/src/components/ExecutionConfirmation.tsx
+++ b/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">
--- a/alm/src/components/ManualExecutionButton.tsx
+++ b/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);
@@ -58,10 +67,12 @@ export const ManualExecutionButton = ({
        return
      }

-      if (!library || !foreign.bridgeContract) return
+      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,
--- a/alm/src/components/StatusContainer.tsx
+++ b/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>
--- a/alm/src/components/commons/ErrorAlert.tsx
+++ b/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>
+  )
+}
--- a/alm/src/config/constants.ts
+++ b/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.`
--- a/alm/src/hooks/useBlockConfirmations.ts
+++ b/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 {
--- a/alm/src/hooks/useClosestBlock.ts
+++ b/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
+}
--- a/alm/src/hooks/useMessageConfirmations.ts
+++ b/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
@@ -42,7 +40,6 @@ export interface BasicConfirmationParam {
 export interface ConfirmationParam extends BasicConfirmationParam {
  txHash: string
  timestamp: number
-  signature?: string
 }

 export interface ExecutionData {
@@ -57,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>({
@@ -84,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,
@@ -238,9 +261,9 @@ export const useMessageConfirmations = ({
        setConfirmations,
        requiredSignatures,
        setSignatureCollected,
-        waitingBlocksResolved,
-        subscriptions,
-        timestamp,
+        id => (timeoutId = id),
+        () => isCancelled,
+        homeStartBlock,
        getValidatorFailedTransactionsForMessage,
        setFailedConfirmations,
        getValidatorPendingTransactionsForMessage,
@@ -249,7 +272,8 @@ export const useMessageConfirmations = ({
      )

      return () => {
-        unsubscribe()
+        clearTimeout(timeoutId)
+        isCancelled = true
      }
    },
    [
@@ -260,8 +284,7 @@ export const useMessageConfirmations = ({
      home.bridgeContract,
      requiredSignatures,
      waitingBlocksResolved,
-      timestamp,
-      setConfirmations
+      homeStartBlock
    ]
  )

@@ -272,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,
@@ -304,7 +321,8 @@ export const useMessageConfirmations = ({
      )

      return () => {
-        unsubscribe()
+        clearTimeout(timeoutId)
+        isCancelled = true
      }
    },
    [
@@ -316,8 +334,9 @@ export const useMessageConfirmations = ({
      home.web3,
      waitingBlocksResolved,
      waitingBlocksForExecutionResolved,
-      timestamp,
-      collectedSignaturesEvent
+      collectedSignaturesEvent,
+      foreignStartBlock,
+      homeStartBlock
    ]
  )

@@ -329,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) {
--- a/alm/src/hooks/useTransactionFinder.ts
+++ b/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]
  )
--- a/alm/src/hooks/useTransactionStatus.ts
+++ b/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,
--- a/alm/src/hooks/useValidatorContract.ts
+++ b/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 {
--- a/alm/src/services/BlockNumberProvider.ts
+++ b/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)
--- a/alm/src/utils/tests/contracts.test.ts
+++ b/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 [
            {
--- a/alm/src/utils/tests/explorer.test.ts
+++ b/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
    )
--- a/alm/src/utils/tests/getConfirmationsForTx.test.ts
+++ b/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,
@@ -110,8 +110,9 @@ describe('getConfirmationsForTx', () => {
    expect(setResult).toBeCalledTimes(2)
    expect(getValidatorConfirmation).toBeCalledTimes(1)
    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
-    expect(setSignatureCollected).toBeCalledTimes(1)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual([signature, signature])
+    expect(setSignatureCollected).toBeCalledTimes(2)
+    expect(setSignatureCollected.mock.calls[0][0]).toEqual(true)
+    expect(setSignatureCollected.mock.calls[1][0]).toEqual([signature, signature])

    expect(getValidatorFailedTransaction).toBeCalledTimes(1)
    expect(setFailedConfirmations).toBeCalledTimes(1)
@@ -121,14 +122,16 @@ describe('getConfirmationsForTx', () => {
    expect(setPendingConfirmations).toBeCalledTimes(1)
    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(false)

-    expect(setResult.mock.calls[0][0]()).toEqual(
+    const res1 = setResult.mock.calls[0][0]()
+    const res2 = setResult.mock.calls[1][0](res1)
+    expect(res1).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.NOT_REQUIRED }
+        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
      ])
    )
-    expect(setResult.mock.calls[1][0]).toEqual(
+    expect(res2).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
@@ -174,8 +177,8 @@ describe('getConfirmationsForTx', () => {
      setResult,
      requiredSignatures,
      setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
      timestamp,
      getFailedTransactions,
      setFailedConfirmations,
@@ -186,7 +189,7 @@ describe('getConfirmationsForTx', () => {

    unsubscribe()

-    expect(setResult).toBeCalledTimes(2)
+    expect(setResult).toBeCalledTimes(1)
    expect(getValidatorConfirmation).toBeCalledTimes(1)
    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
    expect(setSignatureCollected).toBeCalledTimes(1)
@@ -238,8 +241,8 @@ describe('getConfirmationsForTx', () => {
      setResult,
      requiredSignatures,
      setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
      timestamp,
      getFailedTransactions,
      setFailedConfirmations,
@@ -251,11 +254,12 @@ describe('getConfirmationsForTx', () => {
    unsubscribe()

    expect(subscriptions.length).toEqual(0)
-    expect(setResult).toBeCalledTimes(2)
+    expect(setResult).toBeCalledTimes(3)
    expect(getValidatorConfirmation).toBeCalledTimes(1)
    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
-    expect(setSignatureCollected).toBeCalledTimes(1)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual([signature, signature])
+    expect(setSignatureCollected).toBeCalledTimes(2)
+    expect(setSignatureCollected.mock.calls[0][0]).toEqual(true)
+    expect(setSignatureCollected.mock.calls[1][0]).toEqual([signature, signature])

    expect(getValidatorFailedTransaction).toBeCalledTimes(1)
    expect(setFailedConfirmations).toBeCalledTimes(1)
@@ -265,14 +269,24 @@ describe('getConfirmationsForTx', () => {
    expect(setPendingConfirmations).toBeCalledTimes(1)
    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(false)

-    expect(setResult.mock.calls[0][0]()).toEqual(
+    const res1 = setResult.mock.calls[0][0]()
+    const res2 = setResult.mock.calls[1][0](res1)
+    const res3 = setResult.mock.calls[2][0](res2)
+    expect(res1).toEqual(
+      expect.arrayContaining([
+        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
+      ])
+    )
+    expect(res2).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.NOT_REQUIRED }
      ])
    )
-    expect(setResult.mock.calls[1][0]).toEqual(
+    expect(res3).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
@@ -326,8 +340,8 @@ describe('getConfirmationsForTx', () => {
      setResult,
      requiredSignatures,
      setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
      timestamp,
      getFailedTransactions,
      setFailedConfirmations,
@@ -339,11 +353,12 @@ describe('getConfirmationsForTx', () => {
    unsubscribe()

    expect(subscriptions.length).toEqual(0)
-    expect(setResult).toBeCalledTimes(2)
+    expect(setResult).toBeCalledTimes(4)
    expect(getValidatorConfirmation).toBeCalledTimes(1)
    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
-    expect(setSignatureCollected).toBeCalledTimes(1)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual([signature, signature])
+    expect(setSignatureCollected).toBeCalledTimes(2)
+    expect(setSignatureCollected.mock.calls[0][0]).toEqual(true)
+    expect(setSignatureCollected.mock.calls[1][0]).toEqual([signature, signature])

    expect(getValidatorFailedTransaction).toBeCalledTimes(1)
    expect(setFailedConfirmations).toBeCalledTimes(1)
@@ -353,7 +368,27 @@ describe('getConfirmationsForTx', () => {
    expect(setPendingConfirmations).toBeCalledTimes(1)
    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(false)

-    expect(setResult.mock.calls[0][0]()).toEqual(
+    const res1 = setResult.mock.calls[0][0]()
+    const res2 = setResult.mock.calls[1][0](res1)
+    const res3 = setResult.mock.calls[2][0](res2)
+    const res4 = setResult.mock.calls[3][0](res3)
+    expect(res1).toEqual(
+      expect.arrayContaining([
+        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
+        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
+      ])
+    )
+    expect(res2).toEqual(
+      expect.arrayContaining([
+        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 },
+        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
+      ])
+    )
+    expect(res3).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
@@ -361,7 +396,7 @@ describe('getConfirmationsForTx', () => {
        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.NOT_REQUIRED }
      ])
    )
-    expect(setResult.mock.calls[1][0]).toEqual(
+    expect(res4).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
@@ -418,8 +453,8 @@ describe('getConfirmationsForTx', () => {
      setResult,
      requiredSignatures,
      setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
      timestamp,
      getFailedTransactions,
      setFailedConfirmations,
@@ -430,7 +465,7 @@ describe('getConfirmationsForTx', () => {

    unsubscribe()

-    expect(setResult).toBeCalledTimes(2)
+    expect(setResult).toBeCalledTimes(4)
    expect(getValidatorConfirmation).toBeCalledTimes(1)
    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
    expect(setSignatureCollected).toBeCalledTimes(1)
@@ -444,14 +479,32 @@ describe('getConfirmationsForTx', () => {
    expect(setPendingConfirmations).toBeCalledTimes(1)
    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(true)

-    expect(setResult.mock.calls[0][0]()).toEqual(
+    const res1 = setResult.mock.calls[0][0]()
+    const res2 = setResult.mock.calls[1][0](res1)
+    const res3 = setResult.mock.calls[2][0](res2)
+    const res4 = setResult.mock.calls[3][0](res3)
+    expect(res1).toEqual(
+      expect.arrayContaining([
+        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
+        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
+      ])
+    )
+    expect(res2).toEqual(
+      expect.arrayContaining([
+        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
+        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.PENDING, txHash: '0x123', timestamp: 123 }
+      ])
+    )
+    expect(res3).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 },
        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.PENDING, txHash: '0x123', timestamp: 123 }
      ])
    )
-    expect(setResult.mock.calls[1][0]).toEqual(
+    expect(res4).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 },
@@ -504,8 +557,8 @@ describe('getConfirmationsForTx', () => {
      setResult,
      requiredSignatures,
      setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
      timestamp,
      getFailedTransactions,
      setFailedConfirmations,
@@ -517,7 +570,7 @@ describe('getConfirmationsForTx', () => {
    unsubscribe()

    expect(subscriptions.length).toEqual(0)
-    expect(setResult).toBeCalledTimes(2)
+    expect(setResult).toBeCalledTimes(3)
    expect(getValidatorConfirmation).toBeCalledTimes(1)
    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
    expect(setSignatureCollected).toBeCalledTimes(1)
@@ -531,14 +584,24 @@ describe('getConfirmationsForTx', () => {
    expect(setPendingConfirmations).toBeCalledTimes(1)
    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(false)

-    expect(setResult.mock.calls[0][0]()).toEqual(
+    const res1 = setResult.mock.calls[0][0]()
+    const res2 = setResult.mock.calls[1][0](res1)
+    const res3 = setResult.mock.calls[2][0](res2)
+    expect(res1).toEqual(
+      expect.arrayContaining([
+        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
+        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
+      ])
+    )
+    expect(res2).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 },
        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 }
      ])
    )
-    expect(setResult.mock.calls[1][0]).toEqual(
+    expect(res3).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 },
@@ -615,8 +678,8 @@ describe('getConfirmationsForTx', () => {
      setResult,
      requiredSignatures,
      setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
      timestamp,
      getFailedTransactions,
      setFailedConfirmations,
@@ -627,7 +690,7 @@ describe('getConfirmationsForTx', () => {

    unsubscribe()

-    expect(setResult).toBeCalledTimes(2)
+    expect(setResult).toBeCalledTimes(4)
    expect(getValidatorConfirmation).toBeCalledTimes(1)
    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
    expect(setSignatureCollected).toBeCalledTimes(1)
@@ -641,14 +704,32 @@ describe('getConfirmationsForTx', () => {
    expect(setPendingConfirmations).toBeCalledTimes(1)
    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(true)

-    expect(setResult.mock.calls[0][0]()).toEqual(
+    const res1 = setResult.mock.calls[0][0]()
+    const res2 = setResult.mock.calls[1][0](res1)
+    const res3 = setResult.mock.calls[2][0](res2)
+    const res4 = setResult.mock.calls[3][0](res3)
+    expect(res1).toEqual(
+      expect.arrayContaining([
+        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
+        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
+      ])
+    )
+    expect(res2).toEqual(
+      expect.arrayContaining([
+        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
+        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.PENDING, txHash: '0x123', timestamp: 123 }
+      ])
+    )
+    expect(res3).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 },
        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.PENDING, txHash: '0x123', timestamp: 123 }
      ])
    )
-    expect(setResult.mock.calls[1][0]).toEqual(
+    expect(res4).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 },
@@ -665,8 +746,8 @@ describe('getConfirmationsForTx', () => {
      setResult,
      requiredSignatures,
      setSignatureCollected,
-      waitingBlocksResolved,
-      subscriptions,
+      subscriptions.push.bind(subscriptions),
+      isCancelled,
      timestamp,
      getFailedTransactions,
      setFailedConfirmations,
@@ -677,12 +758,13 @@ describe('getConfirmationsForTx', () => {

    unsubscribe()

-    expect(setResult).toBeCalledTimes(4)
+    expect(setResult).toBeCalledTimes(7)
    expect(getValidatorConfirmation).toBeCalledTimes(2)
    expect(getSuccessExecutionTransaction).toBeCalledTimes(2)
-    expect(setSignatureCollected).toBeCalledTimes(2)
+    expect(setSignatureCollected).toBeCalledTimes(3)
    expect(setSignatureCollected.mock.calls[0][0]).toEqual(false)
-    expect(setSignatureCollected.mock.calls[1][0]).toEqual([signature, signature])
+    expect(setSignatureCollected.mock.calls[1][0]).toEqual(true)
+    expect(setSignatureCollected.mock.calls[2][0]).toEqual([signature, signature])

    expect(getValidatorFailedTransaction).toBeCalledTimes(2)
    expect(setFailedConfirmations).toBeCalledTimes(2)
@@ -694,14 +776,24 @@ describe('getConfirmationsForTx', () => {
    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(true)
    expect(setPendingConfirmations.mock.calls[1][0]).toEqual(false)

-    expect(setResult.mock.calls[2][0]()).toEqual(
+    const res5 = setResult.mock.calls[4][0](res4)
+    const res6 = setResult.mock.calls[5][0](res5)
+    const res7 = setResult.mock.calls[6][0](res6)
+    expect(res5).toEqual(
      expect.arrayContaining([
-        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS },
+        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 },
        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS }
      ])
    )
-    expect(setResult.mock.calls[3][0]).toEqual(
+    expect(res6).toEqual(
+      expect.arrayContaining([
+        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
+        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 },
+        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS }
+      ])
+    )
+    expect(res7).toEqual(
      expect.arrayContaining([
        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 },
--- a/alm/src/utils/tests/getFinalizationEvent.test.ts
+++ b/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,
--- a/alm/src/utils/contract.ts
+++ b/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
    })
  ])
--- a/alm/src/utils/executionWaitingForBlocks.ts
+++ b/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)
-  }
-}
--- a/alm/src/utils/explorer.ts
+++ b/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))
--- a/alm/src/utils/getCollectedSignaturesEvent.ts
+++ b/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)
-  }
-}
--- a/alm/src/utils/getConfirmationsForTx.ts
+++ b/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,
@@ -14,72 +9,83 @@ import {
  getValidatorPendingTransaction,
  getSuccessExecutionTransaction
 } from './validatorConfirmationHelpers'
-import { ConfirmationParam } from '../hooks/useMessageConfirmations'
+import { BasicConfirmationParam, ConfirmationParam } from '../hooks/useMessageConfirmations'
+
+const mergeConfirmations = (oldConfirmations: BasicConfirmationParam[], newConfirmations: BasicConfirmationParam[]) => {
+  const confirmations = [...oldConfirmations]
+  newConfirmations.forEach(validatorData => {
+    const index = confirmations.findIndex(e => e.validator === validatorData.validator)
+    const currentStatus = confirmations[index].status
+    const newStatus = validatorData.status
+    if (
+      (validatorData as ConfirmationParam).txHash ||
+      (newStatus !== currentStatus && newStatus !== VALIDATOR_CONFIRMATION_STATUS.UNDEFINED)
+    ) {
+      confirmations[index] = validatorData
+    }
+  })
+  return confirmations
+}

 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

-  // If all the information was not collected, then it should retry
-  let shouldRetry = false
  const hashMsg = web3.utils.soliditySha3Raw(messageData)
  let validatorConfirmations = await Promise.all(
    validatorList.map(getValidatorConfirmation(web3, hashMsg, bridgeContract, confirmationContractMethod))
  )

-  const successConfirmations = validatorConfirmations.filter(c => c.status === VALIDATOR_CONFIRMATION_STATUS.SUCCESS)
-
-  setResult((prevConfirmations: ConfirmationParam[]) => {
-    if (prevConfirmations && prevConfirmations.length) {
-      successConfirmations.forEach(validatorData => {
-        const index = prevConfirmations.findIndex(e => e.validator === validatorData.validator)
-        validatorConfirmations[index] = validatorData
-      })
-      return prevConfirmations
-    } else {
-      return validatorConfirmations
+  const updateConfirmations = (confirmations: BasicConfirmationParam[]) => {
+    if (confirmations.length === 0) {
+      return
    }
-  })
+    validatorConfirmations = mergeConfirmations(validatorConfirmations, confirmations)
+    setResult((currentConfirmations: BasicConfirmationParam[]) => {
+      if (currentConfirmations && currentConfirmations.length) {
+        return mergeConfirmations(currentConfirmations, confirmations)
+      }
+      return confirmations
+    })
+  }

+  const successConfirmations = validatorConfirmations.filter(c => c.status === VALIDATOR_CONFIRMATION_STATUS.SUCCESS)
  const notSuccessConfirmations = validatorConfirmations.filter(c => c.status !== VALIDATOR_CONFIRMATION_STATUS.SUCCESS)
+  const hasEnoughSignatures = successConfirmations.length === requiredSignatures
+
+  updateConfirmations(validatorConfirmations)
+  setSignatureCollected(hasEnoughSignatures)

  // If signatures not collected, look for pending transactions
-  let pendingConfirmationsResult = false
-  if (successConfirmations.length !== requiredSignatures) {
+  if (!hasEnoughSignatures) {
    // Check if confirmation is pending
    const validatorPendingConfirmationsChecks = await Promise.all(
      notSuccessConfirmations.map(getValidatorPendingTransaction(bridgeContract, messageData, getPendingTransactions))
    )
+
    const validatorPendingConfirmations = validatorPendingConfirmationsChecks.filter(
      c => c.status === VALIDATOR_CONFIRMATION_STATUS.PENDING
    )
-
-    validatorPendingConfirmations.forEach(validatorData => {
-      const index = validatorConfirmations.findIndex(e => e.validator === validatorData.validator)
-      validatorConfirmations[index] = validatorData
-    })
-
-    if (validatorPendingConfirmations.length > 0) {
-      pendingConfirmationsResult = true
-    }
+    updateConfirmations(validatorPendingConfirmations)
+    setPendingConfirmations(validatorPendingConfirmations.length > 0)
+  } else {
+    setPendingConfirmations(false)
  }

  const undefinedConfirmations = validatorConfirmations.filter(
@@ -87,107 +93,79 @@ export const getConfirmationsForTx = async (
  )

  // Check if confirmation failed
-  let failedConfirmationsResult = false
  const validatorFailedConfirmationsChecks = await Promise.all(
    undefinedConfirmations.map(
-      getValidatorFailedTransaction(bridgeContract, messageData, timestamp, getFailedTransactions)
+      getValidatorFailedTransaction(bridgeContract, messageData, startBlock, getFailedTransactions)
    )
  )
  const validatorFailedConfirmations = validatorFailedConfirmationsChecks.filter(
    c => c.status === VALIDATOR_CONFIRMATION_STATUS.FAILED
  )
-  validatorFailedConfirmations.forEach(validatorData => {
-    const index = validatorConfirmations.findIndex(e => e.validator === validatorData.validator)
-    validatorConfirmations[index] = validatorData
-  })
-  const messageConfirmationsFailed = validatorFailedConfirmations.length > validatorList.length - requiredSignatures
-  if (messageConfirmationsFailed) {
-    failedConfirmationsResult = true
-  }
+  setFailedConfirmations(validatorFailedConfirmations.length > validatorList.length - requiredSignatures)
+  updateConfirmations(validatorFailedConfirmations)

  const missingConfirmations = validatorConfirmations.filter(
    c => c.status === VALIDATOR_CONFIRMATION_STATUS.UNDEFINED || c.status === VALIDATOR_CONFIRMATION_STATUS.PENDING
  )

-  if (successConfirmations.length !== requiredSignatures && missingConfirmations.length > 0) {
-    shouldRetry = true
-  }
-
-  let signatureCollectedResult: boolean | string[] = false
-  if (successConfirmations.length === requiredSignatures) {
+  if (hasEnoughSignatures) {
    // If signatures collected, it should set other signatures not found as not required
    const notRequiredConfirmations = missingConfirmations.map(c => ({
      validator: c.validator,
      status: VALIDATOR_CONFIRMATION_STATUS.NOT_REQUIRED
    }))
-
-    notRequiredConfirmations.forEach(validatorData => {
-      const index = validatorConfirmations.findIndex(e => e.validator === validatorData.validator)
-      validatorConfirmations[index] = validatorData
-    })
-    signatureCollectedResult = true
+    updateConfirmations(notRequiredConfirmations)

    if (fromHome) {
-      signatureCollectedResult = await Promise.all(
-        Array.from(Array(requiredSignatures).keys()).map(i => bridgeContract.methods.signature(hashMsg, i).call())
+      // fetch collected signatures for possible manual processing
+      setSignatureCollected(
+        await Promise.all(
+          Array.from(Array(requiredSignatures).keys()).map(i => bridgeContract.methods.signature(hashMsg, i).call())
+        )
      )
    }
  }

  // get transactions from success signatures
  const successConfirmationWithData = await Promise.all(
-    validatorConfirmations
-      .filter(c => c.status === VALIDATOR_CONFIRMATION_STATUS.SUCCESS)
-      .map(
-        getSuccessExecutionTransaction(web3, bridgeContract, fromHome, messageData, timestamp, getSuccessTransactions)
-      )
+    successConfirmations.map(
+      getSuccessExecutionTransaction(web3, bridgeContract, fromHome, messageData, startBlock, getSuccessTransactions)
+    )
  )

  const successConfirmationWithTxFound = successConfirmationWithData.filter(v => v.txHash !== '')
+  updateConfirmations(successConfirmationWithTxFound)

-  const updatedValidatorConfirmations = [...validatorConfirmations]
-
-  if (successConfirmationWithTxFound.length > 0) {
-    successConfirmationWithTxFound.forEach(validatorData => {
-      const index = updatedValidatorConfirmations.findIndex(e => e.validator === validatorData.validator)
-      updatedValidatorConfirmations[index] = validatorData
-    })
-  }
-
-  // Set results
-  setResult(updatedValidatorConfirmations)
-  setFailedConfirmations(failedConfirmationsResult)
-  setPendingConfirmations(pendingConfirmationsResult)
-  setSignatureCollected(signatureCollectedResult)
-
-  // Retry if not all transaction were found for validator confirmations
-  if (successConfirmationWithTxFound.length < successConfirmationWithData.length) {
-    shouldRetry = true
-  }
-
-  if (shouldRetry) {
-    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)
+  // retry if not all signatures are collected and some confirmations are still missing
+  // or some success transactions were not fetched successfully
+  if (
+    (!hasEnoughSignatures && missingConfirmations.length > 0) ||
+    successConfirmationWithTxFound.length < successConfirmationWithData.length
+  ) {
+    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)
+    }
  }
 }
--- a/alm/src/utils/getFinalizationEvent.ts
+++ b/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)
+    }
  }
 }
--- a/alm/src/utils/signatureWaitingForBlocks.ts
+++ b/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)
-  }
-}
--- a/alm/src/utils/validatorConfirmationHelpers.ts
+++ b/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
--- a/commons/abis.js
+++ b/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',
--- a/deployment/roles/common/tasks/dependencies.yml
+++ b/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
--- a/monitor/.env.example
+++ b/monitor/.env.example
@@ -25,3 +25,9 @@ MONITOR_CACHE_EVENTS=true

 MONITOR_HOME_TO_FOREIGN_ALLOWANCE_LIST=
 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
--- a/monitor/alerts.js
+++ b/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(
--- a/monitor/checkWorker.js
+++ b/monitor/checkWorker.js
@@ -12,10 +12,6 @@ const { web3Home } = require('./utils/web3')

 const { COMMON_HOME_BRIDGE_ADDRESS, MONITOR_BRIDGE_NAME } = process.env

-const MONITOR_VALIDATOR_HOME_TX_LIMIT = Number(process.env.MONITOR_VALIDATOR_HOME_TX_LIMIT) || 0
-const MONITOR_VALIDATOR_FOREIGN_TX_LIMIT = Number(process.env.MONITOR_VALIDATOR_FOREIGN_TX_LIMIT) || 0
-const MONITOR_TX_NUMBER_THRESHOLD = Number(process.env.MONITOR_TX_NUMBER_THRESHOLD) || 100
-
 const { HOME_ERC_TO_ERC_ABI } = require('../commons')

 async function checkWorker() {
@@ -45,27 +41,6 @@ async function checkWorker() {
    const vBalances = await validators(bridgeMode)
    if (!vBalances) throw new Error('vBalances is empty: ' + JSON.stringify(vBalances))

-    vBalances.homeOk = true
-    vBalances.foreignOk = true
-
-    if (MONITOR_VALIDATOR_HOME_TX_LIMIT) {
-      for (const hv in vBalances.home.validators) {
-        if (vBalances.home.validators[hv].leftTx < MONITOR_TX_NUMBER_THRESHOLD) {
-          vBalances.homeOk = false
-          break
-        }
-      }
-    }
-
-    if (MONITOR_VALIDATOR_FOREIGN_TX_LIMIT) {
-      for (const hv in vBalances.foreign.validators) {
-        if (vBalances.foreign.validators[hv].leftTx < MONITOR_TX_NUMBER_THRESHOLD) {
-          vBalances.foreignOk = false
-          break
-        }
-      }
-    }
-
    vBalances.ok = vBalances.homeOk && vBalances.foreignOk
    vBalances.health = true
    writeFile(`/responses/${MONITOR_BRIDGE_NAME}/validators.json`, vBalances)
--- a/monitor/checkWorker2.js
+++ b/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
--- a/monitor/checkWorker3.js
+++ b/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')
    }
--- a/monitor/detectFailures.js
+++ b/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
--- a/monitor/detectMediators.js
+++ b/monitor/detectMediators.js
@@ -141,7 +141,8 @@ async function main(mode) {
    permanentMediators,
    floatingMediators,
    remotelyControlledMediators,
-    unknown
+    unknown,
+    lastChecked: Math.floor(Date.now() / 1000)
  }
 }
 module.exports = main
--- a/monitor/eventsStats.js
+++ b/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 {
--- a/monitor/getBalances.js
+++ b/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 {
--- a/monitor/index.js
+++ b/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,39 +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('/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)
  }
--- a/monitor/metricsWorker.js
+++ b/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()
--- a/monitor/package.json
+++ b/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",
--- a/monitor/prometheusMetrics.js
+++ b/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
--- a/monitor/utils/events.js
+++ b/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
 }
--- a/monitor/utils/file.js
+++ b/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) {
--- a/monitor/utils/web3Cache.js
+++ b/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(
--- a/monitor/validators.js
+++ b/monitor/validators.js
@@ -16,10 +16,13 @@ const {
  COMMON_FOREIGN_GAS_PRICE_SUPPLIER_URL,
  COMMON_FOREIGN_GAS_PRICE_SPEED_TYPE,
  COMMON_FOREIGN_GAS_PRICE_FALLBACK,
-  COMMON_FOREIGN_GAS_PRICE_FACTOR
+  COMMON_FOREIGN_GAS_PRICE_FACTOR,
+  MONITOR_FOREIGN_VALIDATORS_BALANCE_ENABLE,
+  MONITOR_HOME_VALIDATORS_BALANCE_ENABLE
 } = process.env
 const MONITOR_VALIDATOR_HOME_TX_LIMIT = Number(process.env.MONITOR_VALIDATOR_HOME_TX_LIMIT) || 0
 const MONITOR_VALIDATOR_FOREIGN_TX_LIMIT = Number(process.env.MONITOR_VALIDATOR_FOREIGN_TX_LIMIT) || 0
+const MONITOR_TX_NUMBER_THRESHOLD = Number(process.env.MONITOR_TX_NUMBER_THRESHOLD) || 100

 const homeGasPriceSupplierOpts = {
  speedType: COMMON_HOME_GAS_PRICE_SPEED_TYPE,
@@ -33,12 +36,6 @@ const foreignGasPriceSupplierOpts = {
  logger
 }

-const asyncForEach = async (array, callback) => {
-  for (let index = 0; index < array.length; index++) {
-    await callback(array[index], index, array)
-  }
-}
-
 async function main(bridgeMode) {
  const { HOME_ABI, FOREIGN_ABI } = getBridgeABIs(bridgeMode)
  const homeBridge = new web3Home.eth.Contract(HOME_ABI, COMMON_HOME_BRIDGE_ADDRESS)
@@ -109,53 +106,61 @@ async function main(bridgeMode) {
  }

  let validatorsMatch = true
-  logger.debug('calling asyncForEach foreignValidators foreignVBalances')
-  await asyncForEach(foreignValidators, async v => {
-    const balance = await web3Foreign.eth.getBalance(v)
-    if (MONITOR_VALIDATOR_FOREIGN_TX_LIMIT) {
-      const leftTx = Web3Utils.toBN(balance)
-        .div(foreignTxCost)
-        .toString(10)
-      foreignVBalances[v] = {
-        balance: Web3Utils.fromWei(balance),
-        leftTx: Number(leftTx),
-        gasPrice: Number(foreignGasPriceGwei)
+  const foreignValidatorsWithBalanceCheck =
+    typeof MONITOR_FOREIGN_VALIDATORS_BALANCE_ENABLE === 'string'
+      ? MONITOR_FOREIGN_VALIDATORS_BALANCE_ENABLE.split(' ')
+      : foreignValidators
+  logger.debug('getting foreignValidators balances')
+  await Promise.all(
+    foreignValidators.map(async v => {
+      foreignVBalances[v] = {}
+      if (foreignValidatorsWithBalanceCheck.includes(v)) {
+        const balance = await web3Foreign.eth.getBalance(v)
+        foreignVBalances[v].balance = Web3Utils.fromWei(balance)
+        if (MONITOR_VALIDATOR_FOREIGN_TX_LIMIT) {
+          foreignVBalances[v].leftTx = Number(
+            Web3Utils.toBN(balance)
+              .div(foreignTxCost)
+              .toString(10)
+          )
+          foreignVBalances[v].gasPrice = parseFloat(foreignGasPriceGwei)
+        }
      }
-    } else {
-      foreignVBalances[v] = {
-        balance: Web3Utils.fromWei(balance)
-      }
-    }

-    if (!homeValidators.includes(v)) {
-      validatorsMatch = false
-      foreignVBalances[v].onlyOnForeign = true
-    }
-  })
-
-  logger.debug('calling asyncForEach homeValidators homeVBalances')
-  await asyncForEach(homeValidators, async v => {
-    const balance = await web3Home.eth.getBalance(v)
-    if (MONITOR_VALIDATOR_HOME_TX_LIMIT) {
-      const leftTx = Web3Utils.toBN(balance)
-        .div(homeTxCost)
-        .toString(10)
-      homeVBalances[v] = {
-        balance: Web3Utils.fromWei(balance),
-        leftTx: Number(leftTx),
-        gasPrice: Number(homeGasPriceGwei)
+      if (!homeValidators.includes(v)) {
+        validatorsMatch = false
+        foreignVBalances[v].onlyOnForeign = true
      }
-    } else {
-      homeVBalances[v] = {
-        balance: Web3Utils.fromWei(balance)
-      }
-    }
+    })
+  )

-    if (!foreignValidators.includes(v)) {
-      validatorsMatch = false
-      homeVBalances[v].onlyOnHome = true
-    }
-  })
+  const homeValidatorsWithBalanceCheck =
+    typeof MONITOR_HOME_VALIDATORS_BALANCE_ENABLE === 'string'
+      ? MONITOR_HOME_VALIDATORS_BALANCE_ENABLE.split(' ')
+      : homeValidators
+  logger.debug('calling homeValidators balances')
+  await Promise.all(
+    homeValidators.map(async v => {
+      homeVBalances[v] = {}
+      if (homeValidatorsWithBalanceCheck.includes(v)) {
+        const balance = await web3Home.eth.getBalance(v)
+        homeVBalances[v].balance = Web3Utils.fromWei(balance)
+        if (MONITOR_VALIDATOR_HOME_TX_LIMIT) {
+          homeVBalances[v].leftTx = Number(
+            Web3Utils.toBN(balance)
+              .div(homeTxCost)
+              .toString(10)
+          )
+          homeVBalances[v].gasPrice = parseFloat(homeGasPriceGwei)
+        }
+      }
+
+      if (!foreignValidators.includes(v)) {
+        validatorsMatch = false
+        homeVBalances[v].onlyOnHome = true
+      }
+    })
+  )

  logger.debug('calling homeBridgeValidators.methods.requiredSignatures().call()')
  const reqSigHome = await homeBridgeValidators.methods.requiredSignatures().call()
@@ -164,20 +169,22 @@ async function main(bridgeMode) {
  logger.debug('Done')
  return {
    home: {
-      validators: {
-        ...homeVBalances
-      },
+      validators: homeVBalances,
      requiredSignatures: Number(reqSigHome)
    },
    foreign: {
-      validators: {
-        ...foreignVBalances
-      },
+      validators: foreignVBalances,
      requiredSignatures: Number(reqSigForeign)
    },
    requiredSignaturesMatch: reqSigHome === reqSigForeign,
    validatorsMatch,
-    lastChecked: Math.floor(Date.now() / 1000)
+    lastChecked: Math.floor(Date.now() / 1000),
+    homeOk: Object.values(homeVBalances)
+      .filter(vb => typeof vb.leftTx === 'number')
+      .every(vb => vb.leftTx >= MONITOR_TX_NUMBER_THRESHOLD),
+    foreignOk: Object.values(foreignVBalances)
+      .filter(vb => typeof vb.leftTx === 'number')
+      .every(vb => vb.leftTx >= MONITOR_TX_NUMBER_THRESHOLD)
  }
 }

--- a/oracle/.env.example
+++ b/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
--- a/oracle/config/foreign-sender.config.js
+++ b/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
 }
--- a/oracle/config/home-sender.config.js
+++ b/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
 }
--- a/oracle/src/sender.js
+++ b/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)
--- a/oracle/src/services/amqpClient.js
+++ b/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, {
--- a/oracle/src/utils/constants.js
+++ b/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,
--- a/yarn.lock
+++ b/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"
Author	SHA1	Message	Date
Leonid	c94fd93c2d	Fix BSC RPC exceed maximum block range	2021-04-11 18:30:39 +03:00
Leonid Tyurin	ae83c76be9	Fix monitor metrics (#533 )	2021-04-02 03:59:49 -06:00
Kirill Fedoseev	dc3026e584	Fix undefined is not an object exception (#535 )	2021-03-26 12:16:23 -06:00
Kirill Fedoseev	b6ba0744b9	Fix ALM react subscriptions leading to duplicated RPC requests (#534 )	2021-03-18 00:04:33 -06:00
Kirill Fedoseev	4dba9a50e8	Extract tx resend intervals in env variables (#532 )	2021-03-17 21:48:40 -06:00
Kirill Fedoseev	818bc4675d	Fallback eth_getLogs to explorer API for BSC (#530 )	2021-03-14 07:39:23 -06:00
Alexander Kolotov	f93ab330cc	Merge the develop branch to the master branch, preparation to v2.7.0-rc0 (#515 ) 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)	2021-02-25 20:42:51 -06:00
Leonid Tyurin	f64f8b1c91	Add /metrics endpoint for prometheus support (#512 )	2021-02-25 20:39:48 -06:00
Kirill Fedoseev	9fd3f6ab82	Improve performance of BS requests in ALM (#516 )	2021-02-25 20:38:13 -06:00
Kirill Fedoseev	626f9376b2	Fix resend of stuck pending transactions (#514 )	2021-02-24 16:11:28 -06:00
Kirill Fedoseev	894134ba26	Add monitor script for detecting failed AMB messages (#513 )	2021-02-18 19:26:07 -06:00
Kirill Fedoseev	e1536755f4	Add pretty error messages for manual execution transaction reverts (#511 )	2021-02-18 19:25:01 -06:00
Alexander Kolotov	0451d6e373	Merge the develop branch to the master branch, preparation to v2.6.0	2021-01-11 20:17:53 -06:00
Kirill Fedoseev	409044b8a5	Add env variables for selective validator balance checks (#507 )	2021-01-10 20:18:06 -06:00
Kirill Fedoseev	5fc52f42d7	ALM: fix blocking Blockscout/Etherscan requests (#505 )	2021-01-07 13:35:23 -06:00
Alexander Kolotov	8a0d9f38b0	Added mediator endpoint in the monitor web service (#503 )	2020-12-24 19:15:51 +03:00