Use UserRequestForInformation as starting block for InformationRetrieved search

.github/workflows/main.yml

@@ -77,7 +77,7 @@ jobs:
       - name: Rebuild and push updated images
         run: |
           function check_if_image_exists() {
-            curl -fsSlL "https://${{ github.actor }}:${{ github.token }}@${DOCKER_REGISTRY}/v2/${DOCKER_REPO}/tokenbridge-e2e-$1/manifests/$2" > /dev/null
+            curl -fsSlL -H 'Authorization: bearer ${{ github.token }}' "https://${DOCKER_REGISTRY}/v2/${DOCKER_REPO}/tokenbridge-e2e-$1/manifests/$2" > /dev/null
           }
           updated=()
           if ! check_if_image_exists e2e ${E2E_TAG};         then updated+=("e2e"); fi
@@ -104,7 +104,7 @@ jobs:
       - name: Rebuild and push molecule runner e2e image
         run: |
           function check_if_image_exists() {
-            curl -fsSlL "https://${{ github.actor }}:${{ github.token }}@${DOCKER_REGISTRY}/v2/${DOCKER_REPO}/tokenbridge-e2e-$1/manifests/$2" > /dev/null
+            curl -fsSlL -H 'Authorization: bearer ${{ github.token }}' "https://${DOCKER_REGISTRY}/v2/${DOCKER_REPO}/tokenbridge-e2e-$1/manifests/$2" > /dev/null
           }
           if check_if_image_exists molecule_runner ${MOLECULE_RUNNER_TAG}; then
             echo "Image already exists"

CONFIGURATION.md

@@ -52,7 +52,6 @@ ORACLE_SHUTDOWN_CONTRACT_ADDRESS | Optional contract address in the side chain a
 ORACLE_SHUTDOWN_CONTRACT_METHOD | Method signature to be used in the side chain to identify the current shutdown status. Method should return boolean. Default value is `isShutdown()`. | `function signature`
 ORACLE_FOREIGN_RPC_BLOCK_POLLING_LIMIT | Max length for the block range used in `eth_getLogs` requests for polling contract events for the Foreign chain. Infinite, if not provided. | `integer`
 ORACLE_HOME_RPC_BLOCK_POLLING_LIMIT | Max length for the block range used in `eth_getLogs` requests for polling contract events for the Home chain. Infinite, if not provided. | `integer`
-ORACLE_JSONRPC_ERROR_CODES | Override default JSON rpc error codes that can trigger RPC fallback to the next URL from the list (or a retry in case of a single RPC URL). Default is `-32603,-32002,-32005`. Should be a comma-separated list of negative integers. | `string`
 
 
 ## Monitor configuration

Dockerfile.e2e

@@ -19,7 +19,6 @@ COPY --from=contracts /mono/contracts/build ./contracts/build
 COPY commons/package.json ./commons/
 COPY oracle-e2e/package.json ./oracle-e2e/
 COPY monitor-e2e/package.json ./monitor-e2e/
-COPY oracle/src/utils/constants.js ./oracle/src/utils/constants.js
 
 COPY yarn.lock .
 RUN NOYARNPOSTINSTALL=1 yarn install --frozen-lockfile --production

commons/abis.js

@@ -1,5 +1,5 @@
 const HOME_ERC_TO_NATIVE_ABI = require('../contracts/build/contracts/HomeBridgeErcToNative').abi
-const FOREIGN_ERC_TO_NATIVE_ABI = require('../contracts/build/contracts/XDaiForeignBridge.json').abi
+const FOREIGN_ERC_TO_NATIVE_ABI = require('../contracts/build/contracts/ForeignBridgeErcToNative').abi
 const ERC20_ABI = require('../contracts/build/contracts/ERC20').abi
 const BLOCK_REWARD_ABI = require('../contracts/build/contracts/BlockRewardMock').abi
 const BRIDGE_VALIDATORS_ABI = require('../contracts/build/contracts/BridgeValidators').abi

deployment/roles/common/templates/docker-logs.j2

@@ -1,6 +1,6 @@
 /var/log/docker/*/docker.log {
   rotate 5
-  size 100M
+  size 1G
   compress
   missingok
   delaycompress
@@ -8,7 +8,7 @@
 }
 /var/log/docker/*.log {
   rotate 5
-  size 100M
+  size 1G
   compress
   missingok
   delaycompress

deployment/roles/oracle/tasks/logging.yml

@@ -7,7 +7,7 @@
   loop_control:
     loop_var: file
 
-- name: Set the oracle's containers local logs configuration file
+- name: Set the local container logs configuration file
   template:
     src: 31-oracle-docker.conf.j2
     dest: /etc/rsyslog.d/31-oracle-docker.conf
@@ -15,22 +15,6 @@
     group: root
     mode: 0644
 
-- name: Set the redis container local logs configuration file
-  template:
-    src: 32-redis-docker.conf.j2
-    dest: /etc/rsyslog.d/32-redis-docker.conf
-    owner: root
-    group: root
-    mode: 0644
-
-- name: Set the rabbit MQ container local logs configuration file
-  template:
-    src: 33-rabbit-docker.conf.j2
-    dest: /etc/rsyslog.d/33-rabbit-docker.conf
-    owner: root
-    group: root
-    mode: 0644
-
 - name: Set the log configuration file to send container logs to remote server
   template:
     src: 36-oracle-remote-logging.conf.j2

deployment/roles/oracle/templates/.env.j2

@@ -11,16 +11,9 @@ ORACLE_HOME_RPC_POLLING_INTERVAL={{ ORACLE_HOME_RPC_POLLING_INTERVAL }}
 
 ## Foreign contract
 COMMON_FOREIGN_RPC_URL={{ COMMON_FOREIGN_RPC_URL }}
-{% if ORACLE_FOREIGN_ARCHIVE_RPC_URL | default('') != '' %}
-ORACLE_FOREIGN_ARCHIVE_RPC_URL={{ ORACLE_FOREIGN_ARCHIVE_RPC_URL }}
-{% endif %}
 COMMON_FOREIGN_BRIDGE_ADDRESS={{ COMMON_FOREIGN_BRIDGE_ADDRESS }}
 ORACLE_FOREIGN_RPC_POLLING_INTERVAL={{ ORACLE_FOREIGN_RPC_POLLING_INTERVAL }}
 
-{% if ORACLE_TX_REDUNDANCY | default('') != '' %}
-ORACLE_TX_REDUNDANCY={{ ORACLE_TX_REDUNDANCY }}
-{% endif %}
-
 ## Gasprice
 {% if COMMON_HOME_GAS_PRICE_SUPPLIER_URL | default('') != '' %}
 COMMON_HOME_GAS_PRICE_SUPPLIER_URL={{ COMMON_HOME_GAS_PRICE_SUPPLIER_URL }}
@@ -54,28 +47,8 @@ COMMON_FOREIGN_GAS_PRICE_FACTOR={{ COMMON_FOREIGN_GAS_PRICE_FACTOR }}
 ORACLE_ALLOW_HTTP_FOR_RPC={{ "yes" if ORACLE_ALLOW_HTTP_FOR_RPC else "no" }}
 ORACLE_QUEUE_URL={{ ORACLE_QUEUE_URL }}
 ORACLE_REDIS_URL={{ ORACLE_REDIS_URL }}
-{% if ORACLE_FOREIGN_TX_RESEND_INTERVAL | default('') != '' %}
-ORACLE_FOREIGN_TX_RESEND_INTERVAL={{ ORACLE_FOREIGN_TX_RESEND_INTERVAL }}
-{% endif %}
-{% if ORACLE_HOME_TX_RESEND_INTERVAL | default('') != '' %}
-ORACLE_HOME_TX_RESEND_INTERVAL={{ ORACLE_HOME_TX_RESEND_INTERVAL }}
-{% endif %}
-
-## Emergency shutdown configuration
-{% if ORACLE_SHUTDOWN_SERVICE_URL | default('') != '' %}
-ORACLE_SHUTDOWN_SERVICE_URL={{ ORACLE_SHUTDOWN_SERVICE_URL }}
-{% endif %}
-{% if ORACLE_SHUTDOWN_SERVICE_POLLING_INTERVAL | default('') != '' %}
-ORACLE_SHUTDOWN_SERVICE_POLLING_INTERVAL={{ ORACLE_SHUTDOWN_SERVICE_POLLING_INTERVAL }}
-{% endif %}
-{% if ORACLE_SIDE_RPC_URL | default('') != '' %}
-ORACLE_SIDE_RPC_URL={{ ORACLE_SIDE_RPC_URL }}
-{% endif %}
-{% if ORACLE_SHUTDOWN_CONTRACT_ADDRESS | default('') != '' %}
-ORACLE_SHUTDOWN_CONTRACT_ADDRESS={{ ORACLE_SHUTDOWN_CONTRACT_ADDRESS }}
-{% endif %}
-{% if ORACLE_SHUTDOWN_CONTRACT_METHOD | default('') != '' %}
-ORACLE_SHUTDOWN_CONTRACT_METHOD={{ ORACLE_SHUTDOWN_CONTRACT_METHOD }}
+{% if ORACLE_TX_REDUNDANCY | default('') != '' %}
+ORACLE_TX_REDUNDANCY={{ ORACLE_TX_REDUNDANCY }}
 {% endif %}
 
 {% if ORACLE_HOME_START_BLOCK | default('') != '' %}

deployment/roles/oracle/templates/32-redis-docker.conf.j2

@@ -1,11 +0,0 @@
-$FileCreateMode 0644
-template(name="DockerLogFileName_Redis" type="list") {
-   constant(value="/var/log/docker/")
-   property(name="syslogtag" securepath="replace" regex.type="ERE" regex.submatch="1" regex.expression="oracle_(.*redis.*)\\/[a-zA-Z0-9]+\\[")
-   constant(value="/docker.log")
-}
-
-if $programname contains 'oracle' and $programname contains 'redis' then \
-  ?DockerLogFileName_Redis
-
-$FileCreateMode 0600

deployment/roles/oracle/templates/33-rabbit-docker.conf.j2

@@ -1,11 +0,0 @@
-$FileCreateMode 0644
-template(name="DockerLogFileName_Rabbit" type="list") {
-   constant(value="/var/log/docker/")
-   property(name="syslogtag" securepath="replace" regex.type="ERE" regex.submatch="1" regex.expression="oracle_(.*rabbit.*)\\/[a-zA-Z0-9]+\\[")
-   constant(value="/docker.log")
-}
-
-if $programname contains 'oracle' and $programname contains 'rabbit' then \
-  ?DockerLogFileName_Rabbit
-
-$FileCreateMode 0600

e2e-commons/constants.json

@@ -38,7 +38,7 @@
   "ercToNativeBridge": {
     "home": "0x5118AC62AE912Dd5B51EEfF7338c4fcb0248Ba8c",
     "foreign": "0x32198D570fffC7033641F8A9094FFDCaAEF42624",
-    "foreignToken": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+    "foreignToken": "0x7cc4b1851c35959d34e635a470f6b5c43ba3c9c9",
     "monitor": "http://monitor-erc20-native:3012/bridge"
   },
   "amb": {

e2e-commons/contracts-envs/erc-to-native.env

@@ -32,7 +32,7 @@ FOREIGN_GAS_PRICE=10000000000
 FOREIGN_REWARDABLE=false
 
 BLOCK_REWARD_ADDRESS=0xdbeE25CbE97e4A5CC6c499875774dc7067E9426B
-ERC20_TOKEN_ADDRESS=0x6B175474E89094C44Da98b954EedeAC495271d0F
+ERC20_TOKEN_ADDRESS=0x7cc4b1851c35959d34e635a470f6b5c43ba3c9c9
 
 REQUIRED_NUMBER_OF_VALIDATORS=1
 VALIDATORS="0xaaB52d66283F7A1D5978bcFcB55721ACB467384b 0xdCC784657C78054aa61FbcFFd2605F32374816A4 0xDcef88209a20D52165230104B245803C3269454d"

monitor/getBalances.js

@@ -46,6 +46,24 @@ async function main(bridgeMode, eventsInfo) {
     const foreignBridge = new web3Foreign.eth.Contract(FOREIGN_ERC_TO_NATIVE_ABI, COMMON_FOREIGN_BRIDGE_ADDRESS)
     const erc20Address = await foreignBridge.methods.erc20token().call()
     const erc20Contract = new web3Foreign.eth.Contract(ERC20_ABI, erc20Address)
+    let investedAmountInDai = 0
+    let bridgeDsrBalance = 0
+    let displayChaiToken = false
+
+    try {
+      logger.debug('calling foreignBridge.methods.isChaiTokenEnabled')
+      if (await foreignBridge.methods.isChaiTokenEnabled().call()) {
+        displayChaiToken = true
+        logger.debug('calling foreignBridge.methods.investedAmountInDai')
+        investedAmountInDai = await foreignBridge.methods.investedAmountInDai().call()
+        logger.debug('calling foreignBridge.methods.dsrBalance')
+        bridgeDsrBalance = await foreignBridge.methods.dsrBalance().call()
+      } else {
+        logger.debug('Chai token is currently disabled')
+      }
+    } catch (e) {
+      logger.debug('Methods for chai token are not present')
+    }
 
     logger.debug('calling erc20Contract.methods.balanceOf')
     const foreignErc20Balance = await erc20Contract.methods
@@ -67,16 +85,29 @@ async function main(bridgeMode, eventsInfo) {
     const burntCoinsBN = new BN(burntCoins)
     const totalSupplyBN = mintedCoinsBN.minus(burntCoinsBN)
     const foreignErc20BalanceBN = new BN(foreignErc20Balance).plus(lateForeignConfirmationsTotalValue)
+    const investedAmountInDaiBN = new BN(investedAmountInDai)
+    const bridgeDsrBalanceBN = new BN(bridgeDsrBalance)
+
+    const diff = foreignErc20BalanceBN
+      .plus(investedAmountInDaiBN)
+      .minus(totalSupplyBN)
+      .toFixed()
+
+    const foreign = {
+      erc20Balance: Web3Utils.fromWei(foreignErc20Balance)
+    }
+
+    if (displayChaiToken) {
+      foreign.investedErc20Balance = Web3Utils.fromWei(investedAmountInDai)
+      foreign.accumulatedInterest = Web3Utils.fromWei(bridgeDsrBalanceBN.minus(investedAmountInDaiBN).toString(10))
+    }
 
-    const diff = foreignErc20BalanceBN.minus(totalSupplyBN).toFixed()
     logger.debug('Done')
     return {
       home: {
         totalSupply: Web3Utils.fromWei(totalSupplyBN.toFixed())
       },
-      foreign: {
-        erc20Balance: Web3Utils.fromWei(foreignErc20Balance)
-      },
+      foreign,
       balanceDiff: Number(Web3Utils.fromWei(diff)),
       ...blockRanges,
       lastChecked: Math.floor(Date.now() / 1000)

monitor/utils/events.js

@@ -11,6 +11,7 @@ const {
   OLD_AMB_USER_REQUEST_FOR_AFFIRMATION_ABI
 } = require('../../commons')
 const { normalizeEventInformation } = require('./message')
+const { filterTransferBeforeES } = require('./tokenUtils')
 const { writeFile, readCacheFile } = require('./file')
 const { web3Home, web3Foreign, getHomeBlockNumber, getForeignBlockNumber } = require('./web3')
 const { getPastEvents } = require('./web3Cache')
@@ -159,32 +160,80 @@ async function main(mode) {
         filter: { to: COMMON_FOREIGN_BRIDGE_ADDRESS }
       },
       chain: 'foreign'
-    }))
-      .map(normalizeEvent)
-      .filter(e => e.recipient !== ZERO_ADDRESS) // filter mint operation during SCD-to-MCD swaps
-      .filter(e => e.recipient.toLowerCase() !== '0x5d3a536e4d6dbd6114cc1ead35777bab948e3643') // filter cDai withdraws during compounding
-
-    // Get transfer events for each previously used Sai token
-    const saiTokenAddress = '0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359'
-    const halfDuplexTokenContract = new web3Foreign.eth.Contract(ERC20_ABI, saiTokenAddress)
-    logger.debug('Half duplex token:', saiTokenAddress)
-    logger.debug("calling halfDuplexTokenContract.getPastEvents('Transfer')")
-    // https://etherscan.io/tx/0xd0c3c92c94e05bc71256055ce8c4c993e047f04e04f3283a04e4cb077b71f6c6
-    const blockNumberHalfDuplexDisabled = 9884448
-    const halfDuplexTransferEvents = (await getPastEvents(halfDuplexTokenContract, {
-      event: 'Transfer',
-      fromBlock: MONITOR_FOREIGN_START_BLOCK,
-      toBlock: Math.min(blockNumberHalfDuplexDisabled, foreignDelayedBlockNumber),
-      options: {
-        filter: { to: COMMON_FOREIGN_BRIDGE_ADDRESS }
-      },
-      chain: 'foreign'
     })).map(normalizeEvent)
 
-    transferEvents = [...halfDuplexTransferEvents, ...transferEvents]
+    let directTransfers = transferEvents
+    const tokensSwappedAbiExists = FOREIGN_ABI.filter(e => e.type === 'event' && e.name === 'TokensSwapped')[0]
+    if (tokensSwappedAbiExists) {
+      logger.debug('collecting half duplex tokens participated in the bridge balance')
+      logger.debug("calling foreignBridge.getPastEvents('TokensSwapped')")
+      const tokensSwappedEvents = await getPastEvents(foreignBridge, {
+        event: 'TokensSwapped',
+        fromBlock: MONITOR_FOREIGN_START_BLOCK,
+        toBlock: foreignBlockNumber,
+        chain: 'foreign',
+        safeToBlock: foreignDelayedBlockNumber
+      })
+
+      // Get token swap events emitted by foreign bridge
+      const bridgeTokensSwappedEvents = tokensSwappedEvents.filter(e => e.address === COMMON_FOREIGN_BRIDGE_ADDRESS)
+
+      // Get transfer events for each previous erc20
+      const uniqueTokenAddressesSet = new Set(bridgeTokensSwappedEvents.map(e => e.returnValues.from))
+
+      // Exclude chai token from previous erc20
+      try {
+        logger.debug('calling foreignBridge.chaiToken() to remove it from half duplex tokens list')
+        const chaiToken = await foreignBridge.methods.chaiToken().call()
+        uniqueTokenAddressesSet.delete(chaiToken)
+      } catch (e) {
+        logger.debug('call to foreignBridge.chaiToken() failed')
+      }
+      // Exclude dai token from previous erc20
+      try {
+        logger.debug('calling foreignBridge.erc20token()  to remove it from half duplex tokens list')
+        const daiToken = await foreignBridge.methods.erc20token().call()
+        uniqueTokenAddressesSet.delete(daiToken)
+      } catch (e) {
+        logger.debug('call to foreignBridge.erc20token() failed')
+      }
+
+      const uniqueTokenAddresses = [...uniqueTokenAddressesSet]
+      await Promise.all(
+        uniqueTokenAddresses.map(async tokenAddress => {
+          const halfDuplexTokenContract = new web3Foreign.eth.Contract(ERC20_ABI, tokenAddress)
+
+          logger.debug('Half duplex token:', tokenAddress)
+          logger.debug("calling halfDuplexTokenContract.getPastEvents('Transfer')")
+          const halfDuplexTransferEvents = (await getPastEvents(halfDuplexTokenContract, {
+            event: 'Transfer',
+            fromBlock: MONITOR_FOREIGN_START_BLOCK,
+            toBlock: foreignDelayedBlockNumber,
+            options: {
+              filter: { to: COMMON_FOREIGN_BRIDGE_ADDRESS }
+            },
+            chain: 'foreign'
+          })).map(normalizeEvent)
+
+          // Remove events after the ES
+          logger.debug('filtering half duplex transfers happened before ES')
+          const validHalfDuplexTransfers = await filterTransferBeforeES(halfDuplexTransferEvents)
+
+          transferEvents = [...validHalfDuplexTransfers, ...transferEvents]
+        })
+      )
+
+      // filter transfer that is part of a token swap
+      directTransfers = transferEvents.filter(
+        e =>
+          bridgeTokensSwappedEvents.findIndex(
+            t => t.transactionHash === e.referenceTx && e.recipient === ZERO_ADDRESS
+          ) === -1
+      )
+    }
 
     // Get transfer events that didn't have a UserRequestForAffirmation event in the same transaction
-    const directTransfers = transferEvents.filter(
+    directTransfers = directTransfers.filter(
       e => foreignToHomeRequests.findIndex(t => t.referenceTx === e.referenceTx) === -1
     )
 

monitor/utils/tokenUtils.js

@@ -0,0 +1,27 @@
+// https://etherscan.io/tx/0xd0c3c92c94e05bc71256055ce8c4c993e047f04e04f3283a04e4cb077b71f6c6
+const blockNumberHalfDuplexDisabled = 9884448
+
+/**
+ * Returns true if the event was before the bridge stopped supporting half duplex transfers.
+ */
+async function transferBeforeES(event) {
+  return event.blockNumber < blockNumberHalfDuplexDisabled
+}
+
+async function filterTransferBeforeES(array) {
+  const newArray = []
+  // Iterate events from newer to older
+  for (let i = array.length - 1; i >= 0; i--) {
+    const beforeES = await transferBeforeES(array[i])
+    if (beforeES) {
+      // add element to first position so the new array will have the same order
+      newArray.unshift(array[i])
+    }
+  }
+  return newArray
+}
+
+module.exports = {
+  filterTransferBeforeES,
+  blockNumberHalfDuplexDisabled
+}

oracle-e2e/test/amb.js

@@ -1,6 +1,5 @@
 const Web3 = require('web3')
 const assert = require('assert')
-const { ASYNC_CALL_ERRORS } = require('../../oracle/src/utils/constants')
 const { user, homeRPC, foreignRPC, amb, validator } = require('../../e2e-commons/constants.json')
 const { uniformRetry } = require('../../e2e-commons/utils')
 const { BOX_ABI, HOME_AMB_ABI, FOREIGN_AMB_ABI, ambInformationSignatures } = require('../../commons')
@@ -304,7 +303,7 @@ describe('arbitrary message bridging', () => {
       await makeAsyncCall(selector, data2)
 
       assert(!(await homeBox.methods.status().call()), 'status is true')
-      assert.strictEqual(await homeBox.methods.data().call(), ASYNC_CALL_ERRORS.REVERT, 'returned data is incorrect')
+      assert.strictEqual(await homeBox.methods.data().call(), null, 'returned data is incorrect')
 
       const data3 = homeWeb3.eth.abi.encodeParameters(
         ['address', 'address', 'uint256', 'bytes'],
@@ -314,7 +313,7 @@ describe('arbitrary message bridging', () => {
       await makeAsyncCall(selector, data3)
 
       assert(!(await homeBox.methods.status().call()), 'status is true')
-      assert.strictEqual(await homeBox.methods.data().call(), ASYNC_CALL_ERRORS.REVERT, 'returned data is incorrect')
+      assert.strictEqual(await homeBox.methods.data().call(), null, 'returned data is incorrect')
     })
 
     it('should make async eth_call for specific block', async () => {
@@ -355,11 +354,6 @@ describe('arbitrary message bridging', () => {
       await makeAsyncCall(selector, data3)
 
       assert(!(await homeBox.methods.status().call()), 'status is true')
-      assert.strictEqual(
-        await homeBox.methods.data().call(),
-        ASYNC_CALL_ERRORS.BLOCK_IS_IN_THE_FUTURE,
-        'returned data is incorrect'
-      )
     })
 
     it('should make async eth_blockNumber', async () => {

oracle-e2e/test/ercToNative.js

@@ -33,10 +33,6 @@ const homeBridge = new homeWeb3.eth.Contract(HOME_ERC_TO_NATIVE_ABI, COMMON_HOME
 
 describe('erc to native', () => {
   before(async () => {
-    console.log('Initializing interest')
-    await foreignBridge.methods
-      .initializeInterest(ercToNativeBridge.foreignToken, 1, 1, validator.address)
-      .send({ from: validator.address, gas: '4000000' })
     if (process.env.ULTIMATE === 'true') {
       return
     }
@@ -116,7 +112,6 @@ describe('erc to native', () => {
       .catch(e => {
         console.error(e)
       })
-    await foreignBridge.methods.investDai().send({ from: validator.address, gas: '4000000' })
 
     // check that balance increases
     await uniformRetry(async retry => {

oracle/src/confirmRelay.js

@@ -6,7 +6,6 @@ const logger = require('./services/logger')
 const GasPrice = require('./services/gasPrice')
 const { getNonce, getChainId, getEventsFromTx } = require('./tx/web3')
 const { sendTx } = require('./tx/sendTx')
-const { getTokensState } = require('./utils/tokenState')
 const { checkHTTPS, watchdog, syncForEach, addExtraGas } = require('./utils/utils')
 const { EXIT_CODES, EXTRA_GAS_PERCENTAGE, MAX_GAS_LIMIT } = require('./utils/constants')
 
@@ -18,7 +17,7 @@ if (process.argv.length < 4) {
 }
 
 const config = require(path.join('../config/', process.argv[2]))
-const { web3, eventContract, chain, bridgeContract } = config.main
+const { web3, eventContract, chain } = config.main
 
 const isTxHash = txHash => txHash.length === 66 && web3.utils.isHexStrict(txHash)
 function readTxHashes(filePath) {
@@ -50,7 +49,7 @@ async function initialize() {
   try {
     const checkHttps = checkHTTPS(ORACLE_ALLOW_HTTP_FOR_RPC, logger)
 
-    web3.currentProvider.urls.forEach(checkHttps(chain))
+    web3.currentProvider.subProvider.urls.forEach(checkHttps(chain))
 
     attached = await isAttached()
     if (attached) {
@@ -115,12 +114,6 @@ function processEvents(events) {
 }
 
 async function main({ sendJob, txHashes }) {
-  if (config.id === 'erc-native-transfer') {
-    logger.debug('Getting token address to listen Transfer events')
-    const state = await getTokensState(bridgeContract, logger)
-    eventContract.options.address = state.bridgeableTokenAddress
-  }
-
   logger.info(`Processing ${txHashes.length} input transactions`)
   for (const txHash of txHashes) {
     try {

oracle/src/events/processAMBInformationRequests/calls/ethCall.js

@@ -1,7 +1,6 @@
 const { toBN } = require('web3').utils
 
-const { ASYNC_CALL_ERRORS, ASYNC_ETH_CALL_MAX_GAS_LIMIT } = require('../../../utils/constants')
-const { zipToObject, isRevertError } = require('../../../utils/utils')
+const { zipToObject } = require('../../../utils/utils')
 
 const argTypes = {
   to: 'address',
@@ -18,23 +17,14 @@ function makeCall(argNames) {
     const { blockNumber, ...opts } = zipToObject(argNames, args)
 
     if (blockNumber && toBN(blockNumber).gt(toBN(foreignBlock.number))) {
-      return [false, ASYNC_CALL_ERRORS.BLOCK_IS_IN_THE_FUTURE]
+      return [false, '0x']
     }
 
-    // different clients might use different default gas limits, so it makes sense to limit it by some large number
-    if (!opts.gas || toBN(opts.gas).gt(toBN(ASYNC_ETH_CALL_MAX_GAS_LIMIT))) {
-      opts.gas = ASYNC_ETH_CALL_MAX_GAS_LIMIT
-    }
-
-    return web3.eth
+    const [status, result] = await web3.eth
       .call(opts, blockNumber || foreignBlock.number)
-      .then(result => [true, web3.eth.abi.encodeParameter('bytes', result)])
-      .catch(e => {
-        if (isRevertError(e)) {
-          return [false, ASYNC_CALL_ERRORS.REVERT]
-        }
-        throw e
-      })
+      .then(result => [true, result], err => [false, err.data])
+
+    return [status, web3.eth.abi.encodeParameter('bytes', result)]
   }
 }
 

oracle/src/events/processAMBInformationRequests/calls/ethGetBalance.js

@@ -1,7 +1,5 @@
 const { toBN } = require('web3').utils
 
-const { ASYNC_CALL_ERRORS } = require('../../../utils/constants')
-
 async function call(web3, data, foreignBlock) {
   const address = web3.eth.abi.decodeParameter('address', data)
 
@@ -14,7 +12,7 @@ async function callArchive(web3, data, foreignBlock) {
   const { 0: address, 1: blockNumber } = web3.eth.abi.decodeParameters(['address', 'uint256'], data)
 
   if (toBN(blockNumber).gt(toBN(foreignBlock.number))) {
-    return [false, ASYNC_CALL_ERRORS.BLOCK_IS_IN_THE_FUTURE]
+    return [false, '0x']
   }
 
   const balance = await web3.eth.getBalance(address, blockNumber)

oracle/src/events/processAMBInformationRequests/calls/ethGetBlockByHash.js

@@ -1,4 +1,3 @@
-const { ASYNC_CALL_ERRORS } = require('../../../utils/constants')
 const { serializeBlock } = require('./serializers')
 
 async function call(web3, data, foreignBlock) {
@@ -7,7 +6,7 @@ async function call(web3, data, foreignBlock) {
   const block = await web3.eth.getBlock(blockHash)
 
   if (block === null || block.number > foreignBlock.number) {
-    return [false, ASYNC_CALL_ERRORS.NOT_FOUND]
+    return [false, '0x']
   }
 
   return [true, serializeBlock(web3, block)]

oracle/src/events/processAMBInformationRequests/calls/ethGetBlockByNumber.js

@@ -1,13 +1,12 @@
 const { toBN } = require('web3').utils
 
-const { ASYNC_CALL_ERRORS } = require('../../../utils/constants')
 const { serializeBlock } = require('./serializers')
 
 async function call(web3, data, foreignBlock) {
   const blockNumber = web3.eth.abi.decodeParameter('uint256', data)
 
   if (toBN(blockNumber).gt(toBN(foreignBlock.number))) {
-    return [false, ASYNC_CALL_ERRORS.BLOCK_IS_IN_THE_FUTURE]
+    return [false, '0x']
   }
 
   const block = await web3.eth.getBlock(blockNumber)

oracle/src/events/processAMBInformationRequests/calls/ethGetStorageAt.js

@@ -1,7 +1,5 @@
 const { toBN } = require('web3').utils
 
-const { ASYNC_CALL_ERRORS } = require('../../../utils/constants')
-
 async function call(web3, data, foreignBlock) {
   const { 0: address, 1: slot } = web3.eth.abi.decodeParameters(['address', 'bytes32'], data)
 
@@ -14,7 +12,7 @@ async function callArchive(web3, data, foreignBlock) {
   const { 0: address, 1: slot, 2: blockNumber } = web3.eth.abi.decodeParameters(['address', 'bytes32', 'uint256'], data)
 
   if (toBN(blockNumber).gt(toBN(foreignBlock.number))) {
-    return [false, ASYNC_CALL_ERRORS.BLOCK_IS_IN_THE_FUTURE]
+    return [false, '0x']
   }
 
   const value = await web3.eth.getStorageAt(address, slot, blockNumber)

oracle/src/events/processAMBInformationRequests/calls/ethGetTransactionByHash.js

@@ -1,4 +1,3 @@
-const { ASYNC_CALL_ERRORS } = require('../../../utils/constants')
 const { serializeTx } = require('./serializers')
 
 async function call(web3, data, foreignBlock) {
@@ -7,7 +6,7 @@ async function call(web3, data, foreignBlock) {
   const tx = await web3.eth.getTransaction(hash)
 
   if (tx === null || tx.blockNumber > foreignBlock.number) {
-    return [false, ASYNC_CALL_ERRORS.NOT_FOUND]
+    return [false, '0x']
   }
 
   return [true, serializeTx(web3, tx)]

oracle/src/events/processAMBInformationRequests/calls/ethGetTransactionCount.js

@@ -1,7 +1,5 @@
 const { toBN } = require('web3').utils
 
-const { ASYNC_CALL_ERRORS } = require('../../../utils/constants')
-
 async function call(web3, data, foreignBlock) {
   const address = web3.eth.abi.decodeParameter('address', data)
 
@@ -14,7 +12,7 @@ async function callArchive(web3, data, foreignBlock) {
   const { 0: address, 1: blockNumber } = web3.eth.abi.decodeParameters(['address', 'uint256'], data)
 
   if (toBN(blockNumber).gt(toBN(foreignBlock.number))) {
-    return [false, ASYNC_CALL_ERRORS.BLOCK_IS_IN_THE_FUTURE]
+    return [false, '0x']
   }
 
   const nonce = await web3.eth.getTransactionCount(address, blockNumber)

oracle/src/events/processAMBInformationRequests/calls/ethGetTransactionReceipt.js

@@ -1,4 +1,3 @@
-const { ASYNC_CALL_ERRORS } = require('../../../utils/constants')
 const { serializeReceipt } = require('./serializers')
 
 async function call(web3, data, foreignBlock) {
@@ -7,7 +6,7 @@ async function call(web3, data, foreignBlock) {
   const receipt = await web3.eth.getTransactionReceipt(hash)
 
   if (receipt === null || receipt.blockNumber > foreignBlock.number) {
-    return [false, ASYNC_CALL_ERRORS.NOT_FOUND]
+    return [false, '0x']
   }
 
   return [true, serializeReceipt(web3, receipt)]

oracle/src/events/processAMBInformationRequests/index.js

@@ -4,13 +4,7 @@ const { soliditySha3 } = require('web3').utils
 const { HttpListProviderError } = require('../../services/HttpListProvider')
 const rootLogger = require('../../services/logger')
 const makeBlockFinder = require('../../services/blockFinder')
-const {
-  EXIT_CODES,
-  MAX_CONCURRENT_EVENTS,
-  EXTRA_GAS_ABSOLUTE,
-  ASYNC_CALL_ERRORS,
-  MAX_ASYNC_CALL_RESULT_LENGTH
-} = require('../../utils/constants')
+const { EXIT_CODES, MAX_CONCURRENT_EVENTS, EXTRA_GAS_ABSOLUTE } = require('../../utils/constants')
 const estimateGas = require('./estimateGas')
 const { getValidatorContract, getBlock, getBlockNumber, getRequiredBlockConfirmations } = require('../../tx/web3')
 const { AlreadyProcessedError, AlreadySignedError, InvalidValidatorError } = require('../../utils/errors')
@@ -85,17 +79,12 @@ function processInformationRequestsBuilder(config) {
         logger.info({ requestSelector, method: asyncCallMethod, data }, 'Processing async request')
 
         const call = asyncCalls[asyncCallMethod]
-        let [status, result] = await call(web3ForeignArchive, data, foreignClosestBlock).catch(e => {
+        const [status, result] = await call(web3ForeignArchive, data, foreignClosestBlock).catch(e => {
           if (e instanceof HttpListProviderError) {
             throw e
           }
-          logger.error({ error: e.message }, 'Unknown error during async call execution')
-          throw e
+          return [false, '0x']
         })
-        if (result.length > 2 + MAX_ASYNC_CALL_RESULT_LENGTH * 2) {
-          status = false
-          result = ASYNC_CALL_ERRORS.RESULT_IS_TOO_LONG
-        }
         logger.info({ requestSelector, method: asyncCallMethod, status, result }, 'Request result obtained')
 
         let gasEstimate

oracle/src/events/processTransfers/index.js

@@ -13,25 +13,12 @@ const limit = promiseLimit(MAX_CONCURRENT_EVENTS)
 function processTransfersBuilder(config) {
   const { bridgeContract, web3 } = config.home
 
-  const userRequestForAffirmationHash = web3.eth.abi.encodeEventSignature('UserRequestForAffirmation(address,uint256)')
-  const redeemHash = web3.eth.abi.encodeEventSignature('Redeem(address,uint256,uint256)')
-  const transferHash = web3.eth.abi.encodeEventSignature('Transfer(address,address,uint256)')
-
-  const foreignBridgeAddress = config.foreign.bridgeAddress
-
-  const decodeAddress = data => web3.eth.abi.decodeParameter('address', data)
-
-  const isUserRequestForAffirmation = e =>
-    e.address.toLowerCase() === foreignBridgeAddress.toLowerCase() && e.topics[0] === userRequestForAffirmationHash
-  const isRedeem = cTokenAddress => e =>
-    e.address.toLowerCase() === cTokenAddress.toLowerCase() &&
-    e.topics[0] === redeemHash &&
-    decodeAddress(e.data.slice(0, 66)).toLowerCase() === foreignBridgeAddress.toLowerCase()
-  const isCTokenTransfer = cTokenAddress => e =>
-    e.address.toLowerCase() === cTokenAddress.toLowerCase() &&
-    e.topics[0] === transferHash &&
-    decodeAddress(e.topics[1]).toLowerCase() === foreignBridgeAddress.toLowerCase() &&
-    decodeAddress(e.topics[2]).toLowerCase() === cTokenAddress.toLowerCase()
+  const userRequestForAffirmationAbi = config.foreign.bridgeABI.find(
+    e => e.type === 'event' && e.name === 'UserRequestForAffirmation'
+  )
+  const tokensSwappedAbi = config.foreign.bridgeABI.find(e => e.type === 'event' && e.name === 'TokensSwapped')
+  const userRequestForAffirmationHash = web3.eth.abi.encodeEventSignature(userRequestForAffirmationAbi)
+  const tokensSwappedHash = tokensSwappedAbi ? web3.eth.abi.encodeEventSignature(tokensSwappedAbi) : '0x'
 
   let validatorContract = null
 
@@ -45,35 +32,37 @@ function processTransfersBuilder(config) {
     rootLogger.debug(`Processing ${transfers.length} Transfer events`)
     const callbacks = transfers
       .map(transfer => async () => {
-        const { from, to, value } = transfer.returnValues
+        const { from, value } = transfer.returnValues
 
         const logger = rootLogger.child({
-          eventTransactionHash: transfer.transactionHash,
-          from,
-          to,
-          value
+          eventTransactionHash: transfer.transactionHash
         })
 
-        logger.info('Processing transfer')
+        logger.info({ from, value }, `Processing transfer ${transfer.transactionHash}`)
 
         const receipt = await config.foreign.web3.eth.getTransactionReceipt(transfer.transactionHash)
 
-        if (receipt.logs.some(isUserRequestForAffirmation)) {
-          logger.info('Transfer event discarded because affirmation is detected in the same transaction')
+        const existsAffirmationEvent = receipt.logs.some(
+          e => e.address === config.foreign.bridgeAddress && e.topics[0] === userRequestForAffirmationHash
+        )
+
+        if (existsAffirmationEvent) {
+          logger.info(
+            `Transfer event discarded because a transaction with alternative receiver detected in transaction ${
+              transfer.transactionHash
+            }`
+          )
           return
         }
 
-        if (from === ZERO_ADDRESS) {
-          logger.info('Mint-like transfers from zero address are not processed')
-          return
-        }
+        const existsTokensSwappedEvent = tokensSwappedAbi
+          ? receipt.logs.some(e => e.address === config.foreign.bridgeAddress && e.topics[0] === tokensSwappedHash)
+          : false
 
-        // when bridge performs a withdrawal from Compound, the following three events occur
-        // * token.Transfer(from=cToken, to=bridge, amount=X)
-        // * cToken.Redeem(redeemer=bridge, amount=X, tokens=Y)
-        // * cToken.Transfer(from=bridge, to=cToken, amount=Y)
-        if (receipt.logs.some(isRedeem(from)) && receipt.logs.some(isCTokenTransfer(from))) {
-          logger.info('Transfer event discarded because cToken redeem is detected in the same transaction')
+        if (from === ZERO_ADDRESS && existsTokensSwappedEvent) {
+          logger.info(
+            `Transfer event discarded because token swap is detected in transaction ${transfer.transactionHash}`
+          )
           return
         }
 

oracle/src/sender.js

@@ -40,7 +40,7 @@ async function initialize() {
   try {
     const checkHttps = checkHTTPS(process.env.ORACLE_ALLOW_HTTP_FOR_RPC, logger)
 
-    web3.currentProvider.urls.forEach(checkHttps(config.id))
+    web3.currentProvider.subProvider.urls.forEach(checkHttps(config.id))
 
     GasPrice.start(config.id)
 

oracle/src/services/HttpListProvider.js

@@ -4,12 +4,8 @@ const { FALLBACK_RPC_URL_SWITCH_TIMEOUT } = require('../utils/constants')
 
 const { onInjected } = require('./injectedLogger')
 
-const { ORACLE_JSONRPC_ERROR_CODES } = process.env
-
 // From EIP-1474 and Infura documentation
-const JSONRPC_ERROR_CODES = ORACLE_JSONRPC_ERROR_CODES
-  ? ORACLE_JSONRPC_ERROR_CODES.split(',').map(s => parseInt(s, 10))
-  : [-32603, -32002, -32005]
+const JSONRPC_ERROR_CODES = [-32603, -32002, -32005]
 
 const defaultOptions = {
   name: 'main',
@@ -45,20 +41,6 @@ function HttpListProvider(urls, options = {}) {
   })
 }
 
-HttpListProvider.prototype.switchToFallbackRPC = function() {
-  if (this.urls.length < 2) {
-    return
-  }
-
-  const prevIndex = this.currentIndex
-  const newIndex = (prevIndex + 1) % this.urls.length
-  this.logger.info(
-    { index: newIndex, oldURL: this.urls[prevIndex], newURL: this.urls[newIndex] },
-    'Switching to fallback JSON-RPC URL'
-  )
-  this.currentIndex = newIndex
-}
-
 HttpListProvider.prototype.send = async function send(payload, callback) {
   // if fallback URL is being used for too long, switch back to the primary URL
   if (this.currentIndex > 0 && Date.now() - this.lastTimeUsedPrimary > FALLBACK_RPC_URL_SWITCH_TIMEOUT) {

oracle/src/services/SafeEthLogsProvider.js

@@ -1,35 +1,39 @@
 const { hexToNumber, isHexStrict } = require('web3').utils
 
+const { onInjected } = require('./injectedLogger')
+
 function SafeEthLogsProvider(provider) {
-  const oldSend = provider.send.bind(provider)
-  const newSend = function(payload, callback) {
-    if (payload.method === 'eth_getLogs' && isHexStrict(payload.params[0].toBlock)) {
-      this.logger.debug('Modifying eth_getLogs request to include batch eth_blockNumber request')
+  this.subProvider = provider
+  onInjected(logger => {
+    this.logger = logger.child({ module: 'SafeEthLogsProvider' })
+  })
+}
 
-      const newPayload = [payload, { jsonrpc: '2.0', id: payload.id + 1, method: 'eth_blockNumber', params: [] }]
-      oldSend(newPayload, (err, res) => {
-        if (err) {
-          callback(err, null)
+SafeEthLogsProvider.prototype.send = function send(payload, callback) {
+  if (payload.method === 'eth_getLogs' && isHexStrict(payload.params[0].toBlock)) {
+    this.logger.debug('Modifying eth_getLogs request to include batch eth_blockNumber request')
+
+    const newPayload = [payload, { jsonrpc: '2.0', id: payload.id + 1, method: 'eth_blockNumber', params: [] }]
+    this.subProvider.send(newPayload, (err, res) => {
+      if (err) {
+        callback(err, null)
+      } else {
+        const rawLogs = res.find(({ id }) => id === payload.id)
+        const rawBlockNumber = res.find(({ id }) => id === payload.id + 1)
+        const blockNumber = hexToNumber(rawBlockNumber.result)
+        const toBlock = hexToNumber(payload.params[0].toBlock)
+
+        if (blockNumber < toBlock) {
+          this.logger.warn({ toBlock, blockNumber }, 'Returned block number is less than the specified toBlock')
+          callback(new Error('block number too low'), null)
         } else {
-          const rawLogs = res.find(({ id }) => id === payload.id)
-          const rawBlockNumber = res.find(({ id }) => id === payload.id + 1)
-          const blockNumber = hexToNumber(rawBlockNumber.result)
-          const toBlock = hexToNumber(payload.params[0].toBlock)
-
-          if (blockNumber < toBlock) {
-            this.logger.warn({ toBlock, blockNumber }, 'Returned block number is less than the specified toBlock')
-            callback(new Error('block number too low'), null)
-          } else {
-            callback(null, rawLogs)
-          }
+          callback(null, rawLogs)
         }
-      })
-    } else {
-      oldSend(payload, callback)
-    }
+      }
+    })
+  } else {
+    this.subProvider.send(payload, callback)
   }
-  provider.send = newSend.bind(provider)
-  return provider
 }
 
 module.exports = {

oracle/src/services/web3.js

@@ -38,10 +38,10 @@ const foreignOptions = {
   retry: RETRY_CONFIG
 }
 
-const homeProvider = SafeEthLogsProvider(new HttpListProvider(homeUrls, homeOptions))
+const homeProvider = new SafeEthLogsProvider(new HttpListProvider(homeUrls, homeOptions))
 const web3Home = new Web3(homeProvider)
 
-const foreignProvider = SafeEthLogsProvider(new HttpListProvider(foreignUrls, foreignOptions))
+const foreignProvider = new SafeEthLogsProvider(new HttpListProvider(foreignUrls, foreignOptions))
 const web3Foreign = new Web3(foreignProvider)
 
 let web3ForeignArchive = null

oracle/src/utils/constants.js

@@ -25,20 +25,7 @@ module.exports = {
   },
   DEFAULT_TRANSACTION_RESEND_INTERVAL: 20 * 60 * 1000,
   FALLBACK_RPC_URL_SWITCH_TIMEOUT: 60 * 60 * 1000,
-  BLOCK_NUMBER_PROGRESS_ITERATIONS_LIMIT: 10,
   SENDER_QUEUE_MAX_PRIORITY: 10,
   SENDER_QUEUE_SEND_PRIORITY: 5,
-  SENDER_QUEUE_CHECK_STATUS_PRIORITY: 1,
-  ASYNC_CALL_ERRORS: {
-    // requested transaction/block/receipt does not exist
-    NOT_FOUND: '0x0000000000000000000000000000000000000000000000000000000000000000',
-    // requested custom block does not exist yet or its timestamp is greater than the home block timestamp
-    BLOCK_IS_IN_THE_FUTURE: '0x0000000000000000000000000000000000000000000000000000000000000001',
-    // eth_call has reverted or finished with OOG error
-    REVERT: '0x0000000000000000000000000000000000000000000000000000000000000002',
-    // evaluated output length exceeds allowed length of 64 KB
-    RESULT_IS_TOO_LONG: '0x0000000000000000000000000000000000000000000000000000000000000003'
-  },
-  MAX_ASYNC_CALL_RESULT_LENGTH: 64 * 1024,
-  ASYNC_ETH_CALL_MAX_GAS_LIMIT: 100000000
+  SENDER_QUEUE_CHECK_STATUS_PRIORITY: 1
 }

oracle/src/utils/utils.js

@@ -106,11 +106,7 @@ function isGasPriceError(e) {
 
 function isSameTransactionError(e) {
   const message = e.message.toLowerCase()
-  return (
-    message.includes('transaction with the same hash was already imported') ||
-    message.includes('already known') ||
-    message.includes('alreadyknown')
-  )
+  return message.includes('transaction with the same hash was already imported') || message.includes('already known')
 }
 
 function isInsufficientBalanceError(e) {
@@ -123,20 +119,7 @@ function isNonceError(e) {
   return (
     message.includes('transaction nonce is too low') ||
     message.includes('nonce too low') ||
-    message.includes('transaction with same nonce in the queue') ||
-    message.includes('oldnonce')
-  )
-}
-
-function isRevertError(e) {
-  const message = e.message.toLowerCase()
-  // OE and NE returns "VM execution error"/"Transaction execution error"
-  // Geth returns "out of gas"/"intrinsic gas too low"/"execution reverted"
-  return (
-    message.includes('execution error') ||
-    message.includes('intrinsic gas too low') ||
-    message.includes('out of gas') ||
-    message.includes('execution reverted')
+    message.includes('transaction with same nonce in the queue')
   )
 }
 
@@ -191,7 +174,6 @@ module.exports = {
   isSameTransactionError,
   isInsufficientBalanceError,
   isNonceError,
-  isRevertError,
   getRetrySequence,
   promiseAny,
   readAccessListFile,

oracle/src/watcher.js

@@ -6,7 +6,7 @@ const logger = require('./services/logger')
 const { getShutdownFlag } = require('./services/shutdownState')
 const { getBlockNumber, getRequiredBlockConfirmations, getEvents } = require('./tx/web3')
 const { checkHTTPS, watchdog } = require('./utils/utils')
-const { EXIT_CODES, BLOCK_NUMBER_PROGRESS_ITERATIONS_LIMIT } = require('./utils/constants')
+const { EXIT_CODES } = require('./utils/constants')
 
 if (process.argv.length < 3) {
   logger.error('Please check the number of arguments, config file was not provided')
@@ -29,14 +29,12 @@ const { getTokensState } = require('./utils/tokenState')
 const { web3, bridgeContract, eventContract, startBlock, pollingInterval, chain } = config.main
 const lastBlockRedisKey = `${config.id}:lastProcessedBlock`
 let lastProcessedBlock = Math.max(startBlock - 1, 0)
-let lastSeenBlockNumber = 0
-let sameBlockNumberCounter = 0
 
 async function initialize() {
   try {
     const checkHttps = checkHTTPS(process.env.ORACLE_ALLOW_HTTP_FOR_RPC, logger)
 
-    web3.currentProvider.urls.forEach(checkHttps(chain))
+    web3.currentProvider.subProvider.urls.forEach(checkHttps(chain))
 
     await getLastProcessedBlock()
     connectWatcherToQueue({
@@ -119,28 +117,6 @@ async function getLastBlockToProcess(web3, bridgeContract) {
     getBlockNumber(web3),
     getRequiredBlockConfirmations(bridgeContract)
   ])
-
-  if (lastBlockNumber < lastSeenBlockNumber) {
-    sameBlockNumberCounter = 0
-    logger.warn({ lastBlockNumber, lastSeenBlockNumber }, 'Received block number less than already seen block')
-    web3.currentProvider.switchToFallbackRPC()
-  } else if (lastBlockNumber === lastSeenBlockNumber) {
-    sameBlockNumberCounter++
-    if (sameBlockNumberCounter > 1) {
-      logger.info({ lastBlockNumber, sameBlockNumberCounter }, 'Received the same block number more than twice')
-      if (sameBlockNumberCounter >= BLOCK_NUMBER_PROGRESS_ITERATIONS_LIMIT) {
-        sameBlockNumberCounter = 0
-        logger.warn(
-          { lastBlockNumber, n: BLOCK_NUMBER_PROGRESS_ITERATIONS_LIMIT },
-          'Received the same block number for too many times. Probably node is not synced anymore'
-        )
-        web3.currentProvider.switchToFallbackRPC()
-      }
-    }
-  } else {
-    sameBlockNumberCounter = 0
-    lastSeenBlockNumber = lastBlockNumber
-  }
   return lastBlockNumber - requiredBlockConfirmations
 }
 
@@ -156,6 +132,8 @@ async function main({ sendToQueue }) {
       logger.info(`Oracle watcher was unsuspended.`)
     }
 
+    await checkConditions()
+
     const lastBlockToProcess = await getLastBlockToProcess(web3, bridgeContract)
 
     if (lastBlockToProcess <= lastProcessedBlock) {
@@ -163,8 +141,6 @@ async function main({ sendToQueue }) {
       return
     }
 
-    await checkConditions()
-
     const fromBlock = lastProcessedBlock + 1
     const rangeEndBlock = config.blockPollingLimit ? fromBlock + config.blockPollingLimit : lastBlockToProcess
     let toBlock = Math.min(lastBlockToProcess, rangeEndBlock)

parity/foreign_mocks/cDAIMock.sol

@@ -1,33 +0,0 @@
-pragma solidity 0.4.24;
-
-interface IERC20 {
-  function transferFrom(address from,address to,uint256 value) external;
-  function transfer(address to,uint256 value) external;
-}
-
-contract cDaiMock {
-  IERC20 daiToken;
-
-  event Transfer(address indexed from, address indexed to, uint amount);
-  event Mint(address minter, uint mintAmount, uint mintTokens);
-  event Redeem(address redeemer, uint redeemAmount, uint redeemTokens);
-
-
-  function mint(uint256 mintAmount) external returns (uint256) {
-    daiToken.transferFrom(msg.sender, address(this), mintAmount);
-
-    emit Mint(msg.sender, mintAmount, mintAmount);
-    emit Transfer(address(this), msg.sender, mintAmount);
-
-    return 0;
-  }
-
-  function redeemUnderlying(uint256 redeemAmount) external returns (uint256) {
-    daiToken.transfer(msg.sender, redeemAmount);
-
-    emit Transfer(msg.sender, address(this), redeemAmount);
-    emit Redeem(msg.sender, redeemAmount, redeemAmount);
-
-    return 0;
-  }
-}