.circleci/config.yml

@@ -0,0 +1,321 @@
+version: 2.1
+
+orbs:
+  tokenbridge-orb:
+    commands:
+      install-chrome:
+        steps:
+          - run:
+              name: Update dpkg
+              command: |
+                sudo apt-get clean
+                sudo apt-get update
+                sudo apt-get install dpkg
+          - run:
+              name: Install Chrome
+              command: |
+                wget -O chrome.deb https://dl.google.com/linux/chrome/deb/pool/main/g/google-chrome-stable/google-chrome-stable_77.0.3865.120-1_amd64.deb
+                sudo dpkg -i chrome.deb
+      install-node:
+        steps:
+          - run:
+              name: Install Node
+              command: |
+                export NVM_DIR="/opt/circleci/.nvm"
+                [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
+
+                nvm install 10.16.3 && nvm alias default 10.16.3
+
+                echo 'export NVM_DIR="/opt/circleci/.nvm"' >> $BASH_ENV
+                echo ' [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"' >> $BASH_ENV
+      install-yarn:
+        steps:
+          - run:
+              name: Install Yarn
+              command: |
+                curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
+                echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
+                sudo apt-get update && sudo apt-get -y install yarn
+      yarn-install-cached-on-machine:
+        steps:
+          - restore_cache:
+              name: Restore Machine Yarn Package Cache
+              keys:
+                - yarn-machine-{{ checksum "package.json" }}-{{ checksum "yarn.lock" }}
+          - run:
+              name: Install npm dependencies using Yarn
+              command: nvm use default; yarn install --frozen-lockfile
+          - save_cache:
+              name: Save Machine Yarn Package Cache
+              key: yarn-machine-{{ checksum "package.json" }}-{{ checksum "yarn.lock" }}
+              paths:
+                - ~/.cache/yarn
+      wait-for-oracle:
+        parameters:
+          redis-key:
+            type: string
+        steps:
+          - run:
+              name: Install redis tools
+              command: sudo apt-get install -y redis-tools
+          - run:
+              name: Wait for the Oracle to start
+              command: |
+                set +e
+                i=0
+                while [[ $(redis-cli GET << parameters.redis-key >> ) ]]; do
+                  ((i++))
+                  if [ "$i" -gt 30 ]
+                  then
+                    exit -1
+                  fi
+
+                  echo "Sleeping..."
+                  sleep 3
+                done
+    executors:
+      docker-node:
+        docker:
+          - image: circleci/node:10.15
+      machine-with-docker-caching:
+        machine:
+          image: circleci/classic:latest
+          docker_layer_caching: true
+
+jobs:
+  initialize:
+    executor: tokenbridge-orb/docker-node
+    steps:
+      - checkout
+      - run: git submodule update --init
+      - restore_cache:
+          name: Restore Yarn Package Cache
+          keys:
+            - yarn-{{ checksum "package.json" }}-{{ checksum "yarn.lock" }}
+      - run: git submodule status > submodule.status
+      - restore_cache:
+          name: Restore contracts submodule with compiled contracts
+          keys:
+            - contracts-{{ checksum "submodule.status" }}
+      - run: yarn install --frozen-lockfile
+      - save_cache:
+          name: Save Yarn Package Cache
+          key: yarn-{{ checksum "package.json" }}-{{ checksum "yarn.lock" }}
+          paths:
+            - ~/.cache/yarn
+      - run: touch install_deploy.log; test -d contracts/build/contracts || yarn install:deploy &> install_deploy.log
+      - store_artifacts:
+          path: install_deploy.log
+      - run: test -d contracts/build/contracts || yarn compile:contracts
+      - save_cache:
+          name: Save contracts submodule with compiled contracts
+          key: contracts-{{ checksum "submodule.status" }}
+          paths:
+            - contracts
+      - save_cache:
+          name: Save initialized project for subsequent jobs
+          key: initialize-{{ .Environment.CIRCLE_SHA1 }}
+          paths:
+            - ~/project
+  initialize-root:
+    executor: tokenbridge-orb/docker-node
+    steps:
+      - checkout
+      - run: sudo su - -c 'export CI=true && cd /home/circleci/project && yarn initialize && yarn test'
+  build:
+    executor: tokenbridge-orb/docker-node
+    steps:
+      - restore_cache:
+          key: initialize-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn run build
+  lint:
+    executor: tokenbridge-orb/docker-node
+    steps:
+      - restore_cache:
+          key: initialize-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn run lint
+  test:
+    executor: tokenbridge-orb/docker-node
+    steps:
+      - restore_cache:
+          key: initialize-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn run test
+  oracle-e2e:
+    executor: tokenbridge-orb/docker-node
+    steps:
+      - checkout
+      - run: git submodule update --init
+      - setup_remote_docker:
+          docker_layer_caching: true
+      - run: yarn run oracle-e2e
+  ui-e2e:
+    executor: tokenbridge-orb/machine-with-docker-caching
+    steps:
+      - checkout
+      - tokenbridge-orb/install-node
+      - tokenbridge-orb/install-yarn
+      - tokenbridge-orb/install-chrome
+      - run: git submodule update --init
+      - tokenbridge-orb/yarn-install-cached-on-machine
+      - run: yarn run ui-e2e
+  monitor-e2e:
+    executor: tokenbridge-orb/machine-with-docker-caching
+    steps:
+      - checkout
+      - run: git submodule update --init
+      - run: ./monitor-e2e/run-tests.sh
+  cover:
+    executor: tokenbridge-orb/docker-node
+    steps:
+      - restore_cache:
+          key: initialize-{{ .Environment.CIRCLE_SHA1 }}
+      - run: yarn workspace ui run coverage
+      - run: yarn workspace ui run coveralls
+  deployment-oracle:
+    executor: tokenbridge-orb/machine-with-docker-caching
+    steps:
+      - checkout
+      - run: git submodule update --init
+      - run:
+          name: Run the scenario
+          command: deployment-e2e/molecule.sh oracle
+          no_output_timeout: 40m
+  deployment-ui:
+    executor: tokenbridge-orb/machine-with-docker-caching
+    steps:
+      - checkout
+      - run: git submodule update --init
+      - run:
+          name: Run the scenario
+          command: deployment-e2e/molecule.sh ui
+          no_output_timeout: 40m
+  deployment-monitor:
+    executor: tokenbridge-orb/machine-with-docker-caching
+    steps:
+      - checkout
+      - run: git submodule update --init
+      - run:
+          name: Run the scenario
+          command: deployment-e2e/molecule.sh monitor
+          no_output_timeout: 40m
+  deployment-repo:
+    executor: tokenbridge-orb/machine-with-docker-caching
+    steps:
+      - checkout
+      - run: git submodule update --init
+      - tokenbridge-orb/install-node
+      - tokenbridge-orb/install-yarn
+      - tokenbridge-orb/yarn-install-cached-on-machine
+      - run:
+          name: Run the scenario
+          command: deployment-e2e/molecule.sh repo
+          no_output_timeout: 40m
+  deployment-multiple:
+    executor: tokenbridge-orb/machine-with-docker-caching
+    steps:
+      - checkout
+      - run: git submodule update --init
+      - run:
+          name: Run the scenario
+          command: deployment-e2e/molecule.sh multiple
+          no_output_timeout: 40m
+  ultimate:
+    executor: tokenbridge-orb/machine-with-docker-caching
+    parameters:
+      scenario-name:
+        description: "Molecule scenario name used to create the infrastructure"
+        type: string
+      redis-key:
+        description: "Redis key checked for non-emptiness to assert if Oracle is running"
+        type: string
+      ui-e2e-grep:
+        description: "Mocha grep string used to run ui-e2e tests specific to given type of bridge"
+        default: ''
+        type: string
+      oracle-e2e-script:
+        description: "Yarn script string used to run oracle-e2e tests specific to given type of bridge"
+        default: ''
+        type: string
+    steps:
+      - checkout
+      - run: git submodule update --init
+      - tokenbridge-orb/install-node
+      - tokenbridge-orb/install-chrome
+      - tokenbridge-orb/install-yarn
+      - tokenbridge-orb/yarn-install-cached-on-machine
+      - run:
+          name: Prepare the infrastructure
+          command: e2e-commons/up.sh deploy << parameters.scenario-name >> blocks
+          no_output_timeout: 50m
+      - tokenbridge-orb/wait-for-oracle:
+          redis-key: << parameters.redis-key >>
+      - when:
+          condition: << parameters.ui-e2e-grep >>
+          steps:
+            - run:
+                name: Run the ui-e2e tests
+                command: |
+                  nvm use default;
+                  cd ui-e2e; yarn mocha -g "<< parameters.ui-e2e-grep >>" -b ./test.js
+      - when:
+          condition: << parameters.oracle-e2e-script >>
+          steps:
+            - run:
+                name: Run the oracle-e2e tests
+                command: cd e2e-commons && docker-compose run e2e yarn workspace oracle-e2e run << parameters.oracle-e2e-script >>
+workflows:
+  tokenbridge:
+    jobs:
+      - initialize
+      - initialize-root:
+          filters:
+            branches:
+              only: master
+      - build:
+          requires:
+            - initialize
+      - lint:
+          requires:
+            - initialize
+      - test:
+          requires:
+            - initialize
+      - cover:
+          requires:
+            - initialize
+          filters:
+            branches:
+              only: master
+      - oracle-e2e
+      - ui-e2e
+      - monitor-e2e
+      - deployment-oracle
+      - deployment-ui
+      - deployment-monitor
+      - deployment-repo
+      - deployment-multiple
+      - ultimate:
+          name: "ultimate: native to erc"
+          scenario-name: native-to-erc
+          redis-key: native-erc-collected-signatures:lastProcessedBlock
+          ui-e2e-grep: "NATIVE TO ERC"
+      - ultimate:
+          name: "ultimate: erc to native"
+          scenario-name: erc-to-native
+          redis-key: erc-native-collected-signatures:lastProcessedBlock
+          ui-e2e-grep: "ERC TO NATIVE"
+      - ultimate:
+          name: "ultimate: erc to erc"
+          scenario-name: erc-to-erc
+          redis-key: erc-erc-collected-signatures:lastProcessedBlock
+          ui-e2e-grep: "ERC TO ERC"
+      - ultimate:
+          name: "ultimate: amb"
+          scenario-name: amb
+          redis-key: amb-collected-signatures:lastProcessedBlock
+          oracle-e2e-script: "amb"
+      - ultimate:
+          name: "ultimate: amb stake erc to erc"
+          scenario-name: ultimate-amb-stake-erc-to-erc
+          redis-key: amb-collected-signatures:lastProcessedBlock
+          ui-e2e-grep: "AMB-STAKE-ERC-TO-ERC"

.dockerignore

@@ -8,17 +8,9 @@
 **/docs
 **/*.md
 
-monitor/**/*.env*
-oracle/**/*.env*
-!**/.env.example
-
 contracts/test
 contracts/build
 oracle/test
-monitor/test
-monitor/responses
-monitor/cache/*
-commons/test
 oracle/**/*.png
 oracle/**/*.jpg
 audit

.github/workflows/main.yml

@@ -1,227 +0,0 @@
-name: tokenbridge
-
-on: [push]
-
-env:
-  DOCKER_REGISTRY: docker.pkg.github.com
-  DOCKER_REPO: poanetwork/tokenbridge
-  DOCKER_IMAGE_BASE: docker.pkg.github.com/poanetwork/tokenbridge
-
-jobs:
-  initialize:
-    runs-on: ubuntu-latest
-    outputs:
-      cache_key: ${{ steps.get_cache_key.outputs.cache_key }}
-    steps:
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Set cache key
-        id: get_cache_key
-        run: |
-          git submodule status > submodule.status
-          echo "::set-output name=cache_key::cache-repo-${{ hashFiles('yarn.lock', 'package.json', 'submodule.status') }}"
-      - uses: actions/cache@v2
-        id: cache-repo
-        with:
-          path: |
-            **/node_modules
-            contracts/build
-          key: ${{ steps.get_cache_key.outputs.cache_key }}
-      - name: Install dependencies and compile contracts
-        if: ${{ !steps.cache-repo.outputs.cache-hit }}
-        run: |
-          yarn install --frozen-lockfile
-          yarn run install:deploy
-          yarn run compile:contracts
-  validate:
-    runs-on: ubuntu-latest
-    needs:
-      - initialize
-    strategy:
-      fail-fast: false
-      matrix:
-        task: [build, lint, test]
-    steps:
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - uses: actions/cache@v2
-        id: cache-repo
-        with:
-          path: |
-            **/node_modules
-            contracts/build
-          key: ${{ needs.initialize.outputs.cache_key }}
-      - name: yarn run ${{ matrix.task }}
-        run: ${{ steps.cache-repo.outputs.cache-hit }} && yarn run ${{ matrix.task }}
-  build-e2e-images:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Evaluate e2e docker images tags
-        run: |
-          git submodule status > submodule.status
-          echo "E2E_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'Dockerfile.e2e', 'commons', 'oracle-e2e', 'monitor-e2e', 'e2e-commons') }}" >> $GITHUB_ENV
-          echo "ORACLE_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'commons', 'oracle') }}" >> $GITHUB_ENV
-          echo "MONITOR_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'commons', 'monitor') }}" >> $GITHUB_ENV
-          echo "ALM_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'commons', 'alm') }}" >> $GITHUB_ENV
-      - 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
-          }
-          updated=()
-          if ! check_if_image_exists e2e ${E2E_TAG};         then updated+=("e2e"); fi
-          if ! check_if_image_exists oracle ${ORACLE_TAG};   then updated+=("oracle-amb"); fi
-          if ! check_if_image_exists monitor ${MONITOR_TAG}; then updated+=("monitor-amb"); fi
-          if ! check_if_image_exists alm ${ALM_TAG};         then updated+=("alm"); fi
-          if [ ${#updated[@]} -gt 0 ]; then
-            echo "Updated services: ${updated[@]}"
-            cd e2e-commons
-            docker login ${DOCKER_REGISTRY} -u ${{ github.actor }} -p ${{ github.token }}
-            docker-compose build ${updated[@]}
-            docker-compose push ${updated[@]}
-          else
-            echo "Nothing relevant was changed in the source"
-          fi
-  build-molecule-runner:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Evaluate e2e molecule runner tag
-        run: echo "MOLECULE_RUNNER_TAG=${{ hashFiles('./deployment-e2e/Dockerfile') }}" >> $GITHUB_ENV
-      - 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
-          }
-          if check_if_image_exists molecule_runner ${MOLECULE_RUNNER_TAG}; then
-            echo "Image already exists"
-          else
-            cd e2e-commons
-            docker login ${DOCKER_REGISTRY} -u ${{ github.actor }} -p ${{ github.token }}
-            docker-compose build molecule_runner
-            docker-compose push molecule_runner
-          fi
-  e2e:
-    runs-on: ubuntu-latest
-    needs:
-      - initialize
-      - build-e2e-images
-    strategy:
-      fail-fast: false
-      matrix:
-        task: [oracle-e2e, monitor-e2e, alm-e2e]
-        include:
-          - task: alm-e2e
-            use-cache: true
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Evaluate e2e docker images tags
-        run: |
-          git submodule status > submodule.status
-          echo "E2E_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'Dockerfile.e2e', 'commons', 'oracle-e2e', 'monitor-e2e', 'e2e-commons') }}" >> $GITHUB_ENV
-          echo "ORACLE_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'commons', 'oracle') }}" >> $GITHUB_ENV
-          echo "MONITOR_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'commons', 'monitor') }}" >> $GITHUB_ENV
-          echo "ALM_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'commons', 'alm') }}" >> $GITHUB_ENV
-      - if: ${{ matrix.use-cache }}
-        uses: actions/cache@v2
-        id: cache-repo
-        with:
-          path: |
-            **/node_modules
-            contracts/build
-          key: ${{ needs.initialize.outputs.cache_key }}
-      - name: Login to docker registry
-        run: docker login ${DOCKER_REGISTRY} -u ${{ github.actor }} -p ${{ github.token }}
-      - name: yarn run ${{ matrix.task }}
-        run: ${{ !matrix.use-cache || steps.cache-repo.outputs.cache-hit }} && yarn run ${{ matrix.task }}
-      - name: Upload logs
-        if: always()
-        uses: actions/upload-artifact@v2
-        with:
-          name: logs-${{ matrix.task }}
-          path: e2e-commons/logs
-  deployment:
-    runs-on: ubuntu-latest
-    needs:
-      - build-e2e-images
-      - build-molecule-runner
-    strategy:
-      fail-fast: false
-      matrix:
-        task: [oracle, monitor, multiple, repo]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Evaluate e2e molecule runner tag
-        run: echo "MOLECULE_RUNNER_TAG=${{ hashFiles('./deployment-e2e/Dockerfile') }}" >> $GITHUB_ENV
-      - name: Login to docker registry
-        run: docker login ${DOCKER_REGISTRY} -u ${{ github.actor }} -p ${{ github.token }}
-      - run: deployment-e2e/molecule.sh ${{ matrix.task }}
-  ultimate:
-    if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/develop' || startsWith(github.ref, 'refs/tags') || contains(github.event.head_commit.message, 'ultimate')
-    runs-on: ubuntu-latest
-    needs:
-      - initialize
-      - build-e2e-images
-    strategy:
-      fail-fast: false
-      matrix:
-        task: [amb, erc-to-native]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Evaluate e2e docker images tags
-        run: |
-          git submodule status > submodule.status
-          echo "E2E_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'Dockerfile.e2e', 'commons', 'oracle-e2e', 'monitor-e2e', 'e2e-commons') }}" >> $GITHUB_ENV
-          echo "ORACLE_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'commons', 'oracle') }}" >> $GITHUB_ENV
-          echo "MONITOR_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'commons', 'monitor') }}" >> $GITHUB_ENV
-          echo "ALM_TAG=${{ hashFiles('yarn.lock', 'package.json', 'submodule.status', 'commons', 'alm') }}" >> $GITHUB_ENV
-          echo "MOLECULE_RUNNER_TAG=${{ hashFiles('./deployment-e2e/Dockerfile') }}" >> $GITHUB_ENV
-      - uses: actions/cache@v2
-        id: cache-repo
-        with:
-          path: |
-            **/node_modules
-            contracts/build
-          key: ${{ needs.initialize.outputs.cache_key }}
-      - name: Login to docker registry
-        run: docker login ${DOCKER_REGISTRY} -u ${{ github.actor }} -p ${{ github.token }}
-      - name: Deploy contracts
-        run: ${{ steps.cache-repo.outputs.cache-hit }} && e2e-commons/up.sh deploy generate-amb-tx blocks
-      - name: Pull e2e oracle image
-        run: |
-         docker-compose -f ./e2e-commons/docker-compose.yml pull oracle-amb
-         docker tag ${DOCKER_IMAGE_BASE}/tokenbridge-e2e-oracle:${ORACLE_TAG} poanetwork/tokenbridge-oracle:latest
-      - name: Deploy oracle
-        run: deployment-e2e/molecule.sh ultimate-${{ matrix.task }}
-      - name: Reset docker socket permissions
-        run: sudo chown -R $USER:docker /var/run/docker.sock
-      - name: Run oracle e2e tests
-        run: docker-compose -f ./e2e-commons/docker-compose.yml run -e ULTIMATE=true e2e yarn workspace oracle-e2e run ${{ matrix.task }}
-      - name: Save logs
-        if: always()
-        run: e2e-commons/down.sh
-      - name: Upload logs
-        if: always()
-        uses: actions/upload-artifact@v2
-        with:
-          name: logs-ultimate-${{ matrix.task }}
-          path: e2e-commons/logs

.gitignore

@@ -10,8 +10,11 @@ dist
 
 # misc
 .DS_Store
-*.env*
-!.env.example
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
 .idea
 .nyc_output
 logs/
@@ -46,9 +49,5 @@ __pycache__
 
 #monitor
 monitor/responses/*
-monitor/cache/*
-!monitor/cache/.gitkeep
+monitor/configs/*.env
 !monitor/.gitkeep
-
-# Local Netlify folder
-.netlify

.nvmrc

@@ -1 +1 @@
-12.22
+10.16

CONFIGURATION.md

@@ -8,11 +8,11 @@ COMMON_HOME_RPC_URL | The HTTPS URL(s) used to communicate to the RPC nodes in t
 COMMON_FOREIGN_RPC_URL | The HTTPS URL(s) used to communicate to the RPC nodes in the Foreign network. Several URLs can be specified, delimited by spaces. If the connection to one of these nodes is lost the next URL is used for connection. | URL(s)
 COMMON_HOME_BRIDGE_ADDRESS | The address of the bridge contract address in the Home network. It is used to listen to events from and send validators' transactions to the Home network. | hexidecimal beginning with "0x"
 COMMON_FOREIGN_BRIDGE_ADDRESS | The  address of the bridge contract address in the Foreign network. It is used to listen to events from and send validators' transactions to the Foreign network. | hexidecimal beginning with "0x"
-COMMON_HOME_GAS_PRICE_SUPPLIER_URL | The URL used to get a JSON response from the gas price prediction oracle for the Home network. The gas price provided by the oracle is used to send the validator's transactions to the RPC node. Since it is assumed that the Home network has a predefined gas price (e.g. the gas price in the Core of POA.Network is `1 GWei`), the gas price oracle parameter can be omitted for such networks. Set to `eip1559-gas-estimation` if you want to use EIP1559 RPC-based gas estimation. | URL
+COMMON_HOME_GAS_PRICE_SUPPLIER_URL | The URL used to get a JSON response from the gas price prediction oracle for the Home network. The gas price provided by the oracle is used to send the validator's transactions to the RPC node. Since it is assumed that the Home network has a predefined gas price (e.g. the gas price in the Core of POA.Network is `1 GWei`), the gas price oracle parameter can be omitted for such networks. | URL
 COMMON_HOME_GAS_PRICE_SPEED_TYPE | Assuming the gas price oracle responds with the following JSON structure: `{"fast": 20.0, "block_time": 12.834, "health": true, "standard": 6.0, "block_number": 6470469, "instant": 71.0, "slow": 1.889}`, this parameter specifies the desirable transaction speed. The speed type can be omitted when `COMMON_HOME_GAS_PRICE_SUPPLIER_URL` is not used. | `instant` / `fast` / `standard` / `slow`
 COMMON_HOME_GAS_PRICE_FALLBACK | The gas price (in Wei) that is used if both the oracle and the fall back gas price specified in the Home Bridge contract are not available. | integer
 COMMON_HOME_GAS_PRICE_FACTOR | A value that will multiply the gas price of the oracle to convert it to gwei. If the oracle API returns gas prices in gwei then this can be set to `1`. Also, it could be used to intentionally pay more gas than suggested by the oracle to guarantee the transaction verification. E.g. `1.25` or `1.5`. | integer
-COMMON_FOREIGN_GAS_PRICE_SUPPLIER_URL | The URL used to get a JSON response from the gas price prediction oracle for the Foreign network. The provided gas price is used to send the validator's transactions to the RPC node. If the Foreign network is Ethereum Foundation mainnet, the oracle URL can be: https://gasprice.poa.network. Otherwise this parameter can be omitted. Set to `gas-price-oracle` if you want to use npm `gas-price-oracle` package for retrieving gas price from multiple sources. Set to `eip1559-gas-estimation` if you want to use EIP1559 RPC-based gas estimation. | URL
+COMMON_FOREIGN_GAS_PRICE_SUPPLIER_URL | The URL used to get a JSON response from the gas price prediction oracle for the Foreign network. The provided gas price is used to send the validator's transactions to the RPC node. If the Foreign network is Ethereum Foundation mainnet, the oracle URL can be: https://gasprice.poa.network. Otherwise this parameter can be omitted. | URL
 COMMON_FOREIGN_GAS_PRICE_SPEED_TYPE | Assuming the gas price oracle responds with the following JSON structure: `{"fast": 20.0, "block_time": 12.834, "health": true, "standard": 6.0, "block_number": 6470469, "instant": 71.0, "slow": 1.889}`, this parameter specifies the desirable transaction speed. The speed type can be omitted when `COMMON_FOREIGN_GAS_PRICE_SUPPLIER_URL`is not used. | `instant` / `fast` / `standard` / `slow`
 COMMON_FOREIGN_GAS_PRICE_FALLBACK | The gas price (in Wei) used if both the oracle and fall back gas price specified in the Foreign Bridge contract are not available. | integer
 COMMON_FOREIGN_GAS_PRICE_FACTOR | A value that will multiply the gas price of the oracle to convert it to gwei. If the oracle API returns gas prices in gwei then this can be set to `1`. Also, it could be used to intentionally pay more gas than suggested by the oracle to guarantee the transaction verification. E.g. `1.25` or `1.5`. | integer
@@ -22,7 +22,7 @@ COMMON_FOREIGN_GAS_PRICE_FACTOR | A value that will multiply the gas price of th
 
 name | description | value
 --- | --- | ---
-ORACLE_BRIDGE_MODE | The bridge mode. The bridge starts listening to a different set of events based on this parameter. | ERC_TO_NATIVE / ARBITRARY_MESSAGE
+ORACLE_BRIDGE_MODE | The bridge mode. The bridge starts listening to a different set of events based on this parameter. | NATIVE_TO_ERC / ERC_TO_ERC / ERC_TO_NATIVE
 ORACLE_ALLOW_HTTP_FOR_RPC | **Only use in test environments - must be omitted in production environments.**. If this parameter is specified and set to `yes`, RPC URLs can be specified in form of HTTP links. A warning that the connection is insecure will be written to the logs. | `yes` / `no`
 ORACLE_HOME_RPC_POLLING_INTERVAL | The interval in milliseconds used to request the RPC node in the Home network for new blocks. The interval should match the average production time for a new block. | integer
 ORACLE_FOREIGN_RPC_POLLING_INTERVAL | The interval in milliseconds used to request the RPC node in the Foreign network for new blocks. The interval should match the average production time for a new block. | integer
@@ -36,31 +36,29 @@ ORACLE_LOG_LEVEL | Set the level of details in the logs. | `trace` / `debug` / `
 ORACLE_MAX_PROCESSING_TIME | The workers processes will be killed if this amount of time (in milliseconds) is elapsed before they finish processing. It is recommended to set this value to 4 times the value of the longest polling time (set with the `HOME_POLLING_INTERVAL` and `FOREIGN_POLLING_INTERVAL` variables). To disable this, set the time to 0. | integer
 ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY | The private key of the bridge validator used to sign confirmations before sending transactions to the bridge contracts. The validator account is calculated automatically from the private key. Every bridge instance (set of watchers and senders) must have its own unique private key. The specified private key is used to sign transactions on both sides of the bridge. | hexidecimal without "0x"
 ORACLE_VALIDATOR_ADDRESS | The public address of the bridge validator | hexidecimal with "0x"
-ORACLE_TX_REDUNDANCY | If set to `true`, instructs oracle to send `eth_sendRawTransaction` requests through all available RPC urls defined in `COMMON_HOME_RPC_URL` and `COMMON_FOREIGN_RPC_URL` variables instead of using first available one
-ORACLE_HOME_TO_FOREIGN_ALLOWANCE_LIST | Filename with a list of addresses, separated by newlines. If set, determines the privileged set of accounts whose requests will be automatically processed by the CollectedSignatures watcher. | string
-ORACLE_HOME_TO_FOREIGN_BLOCK_LIST | Filename with a list of addresses, separated by newlines. If set, determines the blocked set of accounts whose requests will not be automatically processed by the CollectedSignatures watcher. Has a lower priority than the `ORACLE_HOME_TO_FOREIGN_ALLOWANCE_LIST` | string
-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  
-ORACLE_SHUTDOWN_SERVICE_URL | Optional external URL to some other service/monitor/configuration manager that controls the remote shutdown process. GET request should return `application/json` message with the following schema: `{ shutdown: true/false }`. | URL
-ORACLE_SHUTDOWN_SERVICE_POLLING_INTERVAL | Optional interval in milliseconds used to request the side RPC node or external shutdown service. Default is 120000. | integer
-ORACLE_SIDE_RPC_URL | Optional HTTPS URL(s) for communication with the external shutdown service or side RPC nodes, used for shutdown manager activities. Several URLs can be specified, delimited by spaces. If the connection to one of these nodes is lost the next URL is used for connection. | URL(s)
-ORACLE_FOREIGN_ARCHIVE_RPC_URL | Optional HTTPS URL(s) for communication with the archive nodes on the foreign network. Only used in AMB bridge mode for async information request processing. Several URLs can be specified, delimited by spaces. If the connection to one of these nodes is lost the next URL is used for connection. | URL(s)
-ORACLE_SHUTDOWN_CONTRACT_ADDRESS | Optional contract address in the side chain accessible through `ORACLE_SIDE_RPC_URL`, where the method passed in `ORACLE_SHUTDOWN_CONTRACT_METHOD` is implemented. | `address`
-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`
-ORACLE_HOME_EVENTS_REPROCESSING | If set to `true`, home events happened in the past will be refetched and processed once again, to ensure that nothing was missed on the first pass. | `bool`
-ORACLE_HOME_EVENTS_REPROCESSING_BATCH_SIZE | Batch size for one `eth_getLogs` request when reprocessing old logs in the home chain. Defaults to `1000` | `integer`
-ORACLE_HOME_EVENTS_REPROCESSING_BLOCK_DELAY | Block confirmations number, after which old logs are being reprocessed in the home chain. Defaults to `500` | `integer`
-ORACLE_HOME_RPC_SYNC_STATE_CHECK_INTERVAL | Interval for checking JSON RPC sync state, by requesting the latest block number. Oracle will switch to the fallback JSON RPC in case sync process is stuck | `integer`
-ORACLE_FOREIGN_EVENTS_REPROCESSING  | If set to `true`, foreign events happened in the past will be refetched and processed once again, to ensure that nothing was missed on the first pass. | `bool`
-ORACLE_FOREIGN_EVENTS_REPROCESSING_BATCH_SIZE | Batch size for one `eth_getLogs` request when reprocessing old logs in the foreign chain. Defaults to `500` | `integer`
-ORACLE_FOREIGN_EVENTS_REPROCESSING_BLOCK_DELAY | Block confirmations number, after which old logs are being reprocessed in the foreign chain. Defaults to `250` | `integer`
-ORACLE_FOREIGN_RPC_SYNC_STATE_CHECK_INTERVAL | Interval for checking JSON RPC sync state, by requesting the latest block number. Oracle will switch to the fallback JSON RPC in case sync process is stuck | `integer`
+
+
+## UI configuration
+
+name | description | value
+--- | --- | ---
+UI_TITLE | The title for the bridge UI page. `%c` will be replaced by the name of the network. | string
+UI_OG_TITLE | The meta title for the deployed bridge page. | string
+UI_DESCRIPTION | The meta description for the deployed bridge page. | string
+UI_NATIVE_TOKEN_DISPLAY_NAME | name of the home native coin | string
+UI_HOME_NETWORK_DISPLAY_NAME | name to be displayed for home network | string
+UI_FOREIGN_NETWORK_DISPLAY_NAME | name to be displayed for foreign network | string
+UI_HOME_WITHOUT_EVENTS | `true` if home network doesn't support events | true/false
+UI_FOREIGN_WITHOUT_EVENTS | `true` if foreign network doesn't support events | true/false
+UI_HOME_EXPLORER_TX_TEMPLATE | template link to transaction on home explorer. `%s` will be replaced by transaction hash | URL template
+UI_FOREIGN_EXPLORER_TX_TEMPLATE | template link to transaction on foreign explorer. `%s` will be replaced by transaction hash | URL template
+UI_HOME_EXPLORER_ADDRESS_TEMPLATE | template link to address on home explorer. `%s` will be replaced by address | URL template
+UI_FOREIGN_EXPLORER_ADDRESS_TEMPLATE | template link to address on foreign explorer. `%s` will be replaced by address | URL template
+UI_HOME_GAS_PRICE_UPDATE_INTERVAL | An interval in milliseconds used to get the updated gas price value either from the oracle or from the Home Bridge contract. | integer
+UI_FOREIGN_GAS_PRICE_UPDATE_INTERVAL | An interval in milliseconds used to get the updated gas price value either from the oracle or from the Foreign Bridge contract. | integer
+UI_PORT | The port for the UI app. | integer
+UI_STYLES | The set of styles to render the bridge UI page. | core/classic/stake
+UI_PUBLIC_URL | The public url for the deployed bridge page | string
 
 
 ## Monitor configuration
@@ -74,9 +72,4 @@ MONITOR_VALIDATOR_FOREIGN_TX_LIMIT | Average gas usage of a transaction sent by
 MONITOR_TX_NUMBER_THRESHOLD | If estimated number of transaction is equal to or below this value, the monitor will report that the validator has less funds than it is required. | integer
 MONITOR_PORT | The port for the Monitor. | integer
 MONITOR_BRIDGE_NAME | The name to be used in the url path for the bridge | string
-MONITOR_CACHE_EVENTS | If set to true, monitor will cache obtained events for other workers runs | `true` / `false`
-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_CACHE_EVENTS | If set to true, monitor will cache obtained events for other workers runs

Dockerfile.e2e

@@ -1,33 +1,15 @@
-FROM node:12 as contracts
-
-WORKDIR /mono
-
-COPY contracts/package.json contracts/package-lock.json ./contracts/
-
-WORKDIR /mono/contracts
-RUN npm install --only=prod
-
-COPY ./contracts/truffle-config.js ./
-COPY ./contracts/contracts ./contracts
-RUN npm run compile
-
-FROM node:12
+FROM node:10
 
 WORKDIR /mono
 COPY package.json .
-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 contracts/package.json ./contracts/
 
 COPY yarn.lock .
-RUN NOYARNPOSTINSTALL=1 yarn install --frozen-lockfile --production
-
-COPY ./contracts/deploy ./contracts/deploy
+RUN yarn install --frozen-lockfile
+COPY ./contracts ./contracts
 RUN yarn install:deploy
+RUN yarn compile:contracts
 
-COPY commons/ ./commons/
-COPY oracle-e2e/ ./oracle-e2e/
-COPY monitor-e2e/ ./monitor-e2e/
-COPY e2e-commons/ ./e2e-commons/
+COPY . .

README.md

@@ -1,4 +1,4 @@
-![tokenbridge](https://github.com/poanetwork/tokenbridge/workflows/tokenbridge/badge.svg?branch=master)
+[![CircleCI](https://circleci.com/gh/poanetwork/tokenbridge.svg?style=svg)](https://circleci.com/gh/poanetwork/tokenbridge)
 [![Gitter](https://badges.gitter.im/poanetwork/poa-bridge.svg)](https://gitter.im/poanetwork/poa-bridge?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![License: LGPL v3.0](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
 
@@ -19,11 +19,13 @@ Sub-repositories maintained within this monorepo are listed below.
 
 | Sub-repository | Description |
 | --- | --- |
-| [Oracle](oracle/README.md) | Responsible for listening to bridge related events and authorizing asset transfers. |
+| [Oracle](oracle/README.md) | Oracle responsible for listening to bridge related events and authorizing asset transfers. |
+| [UI](ui/README.md) | DApp interface to transfer tokens and coins between chains. |
 | [Monitor](monitor/README.md) | Tool for checking balances and unprocessed events in bridged networks. |
 | [Deployment](deployment/README.md) | Ansible playbooks for deploying cross-chain bridges. |
 | [Oracle-E2E](oracle-e2e/README.md) | End to end tests for the Oracle |
 | [Monitor-E2E](monitor-e2e/README.md) | End to end tests for the Monitor |
+| [UI-E2E](ui-e2e/README.md) | End to end tests for the UI |
 | [Deployment-E2E](deployment-e2e/README.md) | End to end tests for the Deployment |
 | [Commons](commons/README.md) | Interfaces, constants and utilities shared between the sub-repositories |
 | [E2E-Commons](e2e-commons/README.md) | Common utilities and configuration used in end to end tests |
@@ -54,6 +56,8 @@ Additionally there are [Smart Contracts](https://github.com/poanetwork/tokenbrid
 
 The POA TokenBridge provides four operational modes:
 
+- [x] `Native-to-ERC20` **Coins** on a Home network can be converted to ERC20-compatible **tokens** on a Foreign network. Coins are locked on the Home side and the corresponding amount of ERC20 tokens are minted on the Foreign side. When the operation is reversed, tokens are burnt on the Foreign side and unlocked in the Home network. **More Information: [POA-to-POA20 Bridge](https://medium.com/poa-network/introducing-poa-bridge-and-poa20-55d8b78058ac)**
+- [x] `ERC20-to-ERC20` ERC20-compatible tokens on the Foreign network are locked and minted as ERC20-compatible tokens (ERC677 tokens) on the Home network. When transferred from Home to Foreign, they are burnt on the Home side and unlocked in the Foreign network. This can be considered a form of atomic swap when a user swaps the token "X" in network "A" to the token "Y" in network "B". **More Information: [ERC20-to-ERC20](https://medium.com/poa-network/introducing-the-erc20-to-erc20-tokenbridge-ce266cc1a2d0)**
 - [x] `ERC20-to-Native`: Pre-existing **tokens** in the Foreign network are locked and **coins** are minted in the `Home` network. In this mode, the Home network consensus engine invokes [Parity's Block Reward contract](https://wiki.parity.io/Block-Reward-Contract.html) to mint coins per the bridge contract request. **More Information: [xDai Chain](https://medium.com/poa-network/poa-network-partners-with-makerdao-on-xdai-chain-the-first-ever-usd-stable-blockchain-65a078c41e6a)**
 - [x] `Arbitrary-Message`: Transfer arbitrary data between two networks as so the data could be interpreted as an arbitrary contract method invocation.
 
@@ -64,7 +68,7 @@ Clone the repository:
 git clone https://github.com/poanetwork/tokenbridge
 ```
 
-If there is no need to build docker images for the TokenBridge components (oracle, monitor), initialize submodules, install dependencies, compile the Smart Contracts:
+If there is no need to build docker images for the TokenBridge components (oracle, monitor, UI), initialize submodules, install dependencies, compile the Smart Contracts:
 ```
 yarn initialize
 ```
@@ -87,7 +91,7 @@ Running tests for all projects:
 yarn test
 ```
 
-Additionally there are end-to-end tests for [Oracle](oracle-e2e/README.md) and [Monitor](monitor-e2e/README.md).
+Additionally there are end-to-end tests for [Oracle](oracle-e2e/README.md) and [UI](ui-e2e/README.md).
 
 For details on building, running and developing please refer to respective READMEs in sub-repositories.
 
@@ -106,4 +110,4 @@ This project is licensed under the GNU Lesser General Public License v3.0. See t
 
 ## References
 
-* [TokenBridge Documentation](https://docs.tokenbridge.net/)
+* [TokenBridge Documentation](http://www.tokenbridge.net/)

alm-e2e/.eslintrc

@@ -1,15 +0,0 @@
-{
-  "extends": [
-    "plugin:node/recommended",
-    "airbnb-base",
-    "../.eslintrc"
-  ],
-  "plugins": ["node", "jest"],
-  "env": {
-    "jest/globals": true
-  },
-  "globals": {
-    "page": true,
-    "browser": true
-  }
-}

alm-e2e/package.json

@@ -1,24 +0,0 @@
-{
-  "name": "alm-e2e",
-  "version": "0.0.1",
-  "private": true,
-  "scripts": {
-    "test": "jest --detectOpenHandles",
-    "lint": "eslint . --ignore-path ../.eslintignore",
-    "lint:fix": "eslint . --fix"
-  },
-  "dependencies": {
-    "jest": "24.7.1",
-    "jest-puppeteer": "^4.4.0",
-    "puppeteer": "^5.2.1"
-  },
-  "jest": {
-    "preset": "jest-puppeteer"
-  },
-  "devDependencies": {
-    "eslint-plugin-jest": "^23.18.0"
-  },
-  "engines": {
-    "node": ">= 12.22"
-  }
-}

alm-e2e/run-tests.sh

@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-cd $(dirname $0)
-
-../e2e-commons/up.sh deploy generate-amb-tx blocks alm alm-e2e
-
-# run oracle amb e2e tests to generate transactions for alm
-docker-compose -f ../e2e-commons/docker-compose.yml run e2e yarn workspace oracle-e2e run alm
-
-yarn test
-rc=$?
-
-../e2e-commons/down.sh
-exit $rc

alm-e2e/src/test.js

@@ -1,50 +0,0 @@
-const puppeteer = require('puppeteer')
-const { waitUntil } = require('./utils/utils')
-
-jest.setTimeout(60000)
-
-const statusText = 'Success'
-const statusSelector = 'label[data-id="status"]'
-
-const homeToForeignTxURL = 'http://localhost:3004/77/0x295efbe6ae98937ef35d939376c9bd752b4dc6f6899a9d5ddd6a57cea3d76c89'
-const foreignToHomeTxURL = 'http://localhost:3004/42/0x7262f7dbe6c30599edded2137fbbe93c271b37f5c54dd27f713f0cf510e3b4dd'
-
-describe('ALM', () => {
-  let browser
-  let page
-
-  beforeAll(async () => {
-    browser = await puppeteer.launch()
-    page = await browser.newPage()
-  })
-
-  afterAll(async () => {
-    await browser.close()
-  })
-
-  it('should be titled "AMB Live Monitoring"', async () => {
-    await page.goto(foreignToHomeTxURL)
-
-    await expect(page.title()).resolves.toMatch('AMB Live Monitoring')
-  })
-  it('should display information of foreign to home transaction', async () => {
-    await page.goto(foreignToHomeTxURL)
-
-    await page.waitForSelector(statusSelector)
-    await waitUntil(async () => {
-      const element = await page.$(statusSelector)
-      const text = await page.evaluate(element => element.textContent, element)
-      return text === statusText
-    })
-  })
-  it('should display information of home to foreign transaction', async () => {
-    await page.goto(homeToForeignTxURL)
-
-    await page.waitForSelector(statusSelector)
-    await waitUntil(async () => {
-      const element = await page.$(statusSelector)
-      const text = await page.evaluate(element => element.textContent, element)
-      return text === statusText
-    })
-  })
-})

alm-e2e/src/utils/utils.js

@@ -1,15 +0,0 @@
-const waitUntil = async (predicate, step = 100, timeout = 20000) => {
-  const stopTime = Date.now() + timeout
-  while (Date.now() <= stopTime) {
-    const result = await predicate()
-    if (result) {
-      return result
-    }
-    await new Promise(resolve => setTimeout(resolve, step)) // sleep
-  }
-  throw new Error(`waitUntil timed out after ${timeout} ms`)
-}
-
-module.exports = {
-  waitUntil
-}

alm/.gitignore

@@ -1,7 +1,5 @@
 # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 
-src/snapshots/*.json
-
 # dependencies
 /node_modules
 /.pnp

alm/Dockerfile

@@ -1,29 +1,20 @@
-FROM node:12 as contracts
-
-WORKDIR /mono
-
-COPY contracts/package.json contracts/package-lock.json ./contracts/
-
-WORKDIR /mono/contracts
-RUN npm install --only=prod
-
-COPY ./contracts/truffle-config.js ./
-COPY ./contracts/contracts ./contracts
-RUN npm run compile
-
 FROM node:12 as alm-builder
 
 WORKDIR /mono
 COPY package.json .
-COPY --from=contracts /mono/contracts/build ./contracts/build
+COPY contracts/package.json ./contracts/
 COPY commons/package.json ./commons/
 COPY alm/package.json ./alm/
 COPY yarn.lock .
-RUN NOYARNPOSTINSTALL=1 yarn install --frozen-lockfile
+RUN yarn install --production --frozen-lockfile
+
+COPY ./contracts ./contracts
+RUN yarn run compile:contracts
+RUN mv ./contracts/build ./ && rm -rf ./contracts/* ./contracts/.[!.]* && mv ./build ./contracts/
 
 COPY ./commons ./commons
-COPY ./alm ./alm
 
+COPY ./alm ./alm
 ARG DOT_ENV_PATH=./alm/.env
 COPY ${DOT_ENV_PATH} ./alm/.env
 

alm/package.json

@@ -3,7 +3,6 @@
   "version": "0.1.0",
   "private": true,
   "dependencies": {
-    "@ethersproject/bignumber": ">=5.0.0-beta.130",
     "@react-hook/window-size": "^3.0.6",
     "@testing-library/jest-dom": "^4.2.4",
     "@testing-library/react": "^9.3.2",
@@ -16,11 +15,8 @@
     "@types/react-router-dom": "^5.1.5",
     "@types/styled-components": "^5.1.0",
     "@use-it/interval": "^0.1.3",
-    "@web3-react/core": "^6.1.1",
-    "@web3-react/injected-connector": "^6.0.7",
     "customize-cra": "^1.0.0",
     "date-fns": "^2.14.0",
-    "dotenv": "^8.2.0",
     "fast-memoize": "^2.5.2",
     "promise-retry": "^2.0.1",
     "react": "^16.13.1",
@@ -30,17 +26,15 @@
     "react-scripts": "3.0.1",
     "styled-components": "^5.1.1",
     "typescript": "^3.5.2",
-    "web3": "1.2.11",
-    "web3-eth-contract": "1.2.11",
-    "web3-utils": "1.2.11"
+    "web3": "1.2.7",
+    "web3-eth-contract": "1.2.7"
   },
   "scripts": {
-    "start": "yarn createSnapshots && ./load-env.sh react-app-rewired start",
-    "build": "yarn createSnapshots && ./load-env.sh react-app-rewired build",
+    "start": "./load-env.sh react-app-rewired start",
+    "build": "./load-env.sh react-app-rewired build",
     "test": "react-app-rewired test",
     "eject": "react-app-rewired eject",
-    "lint": "eslint '*/**/*.{js,ts,tsx}' --ignore-path ../.eslintignore",
-    "createSnapshots": "node scripts/createSnapshots.js"
+    "lint": "eslint '*/**/*.{js,ts,tsx}' --ignore-path ../.eslintignore"
   },
   "eslintConfig": {
     "extends": "react-app"
@@ -58,7 +52,6 @@
     ]
   },
   "devDependencies": {
-    "eslint-plugin-prettier": "^3.1.3",
-    "node-fetch": "^2.6.1"
+    "eslint-plugin-prettier": "^3.1.3"
   }
 }

alm/public/_redirects

@@ -1 +0,0 @@
-/*  /index.html  200

alm/scripts/createSnapshots.js

@@ -1,155 +0,0 @@
-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')
-
-const {
-  COMMON_HOME_RPC_URL,
-  COMMON_HOME_BRIDGE_ADDRESS,
-  COMMON_FOREIGN_RPC_URL,
-  COMMON_FOREIGN_BRIDGE_ADDRESS,
-  ALM_FOREIGN_EXPLORER_API,
-  ALM_HOME_EXPLORER_API
-} = process.env
-
-const generateSnapshot = async (side, url, bridgeAddress) => {
-  const snapshotPath = `../src/snapshots/${side}.json`
-  const snapshotFullPath = path.join(__dirname, snapshotPath)
-  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
-
-  // Save chainId
-  snapshot.chainId = await web3.eth.getChainId()
-
-  const bridgeContract = new web3.eth.Contract(HOME_AMB_ABI, bridgeAddress)
-
-  // Save RequiredBlockConfirmationChanged events
-  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
-  if (requiredBlockConfirmationChangedEvents.length === 0) {
-    const deployedAtBlock = await bridgeContract.methods.deployedAtBlock().call()
-    const blockConfirmations = await bridgeContract.methods.requiredBlockConfirmations().call()
-
-    requiredBlockConfirmationChangedEvents.push({
-      blockNumber: parseInt(deployedAtBlock),
-      returnValues: {
-        requiredBlockConfirmations: blockConfirmations
-      }
-    })
-  }
-
-  snapshot.RequiredBlockConfirmationChanged = requiredBlockConfirmationChangedEvents.map(e => ({
-    blockNumber: e.blockNumber,
-    returnValues: {
-      requiredBlockConfirmations: e.returnValues.requiredBlockConfirmations
-    }
-  }))
-
-  const validatorAddress = await bridgeContract.methods.validatorContract().call()
-  const validatorContract = new web3.eth.Contract(BRIDGE_VALIDATORS_ABI, validatorAddress)
-
-  // Save RequiredSignaturesChanged events
-  const RequiredSignaturesChangedEvents = await getPastEventsWithFallback(
-    validatorContract,
-    'RequiredSignaturesChanged',
-    {
-      fromBlock: 0,
-      toBlock: currentBlockNumber
-    }
-  )
-  snapshot.RequiredSignaturesChanged = RequiredSignaturesChangedEvents.map(e => ({
-    blockNumber: e.blockNumber,
-    returnValues: {
-      requiredSignatures: e.returnValues.requiredSignatures
-    }
-  }))
-
-  // Save ValidatorAdded events
-  const validatorAddedEvents = await getPastEventsWithFallback(validatorContract, 'ValidatorAdded', {
-    fromBlock: 0,
-    toBlock: currentBlockNumber
-  })
-
-  snapshot.ValidatorAdded = validatorAddedEvents.map(e => ({
-    blockNumber: e.blockNumber,
-    returnValues: {
-      validator: e.returnValues.validator
-    },
-    event: 'ValidatorAdded'
-  }))
-
-  // Save ValidatorRemoved events
-  const validatorRemovedEvents = await getPastEventsWithFallback(validatorContract, 'ValidatorRemoved', {
-    fromBlock: 0,
-    toBlock: currentBlockNumber
-  })
-
-  snapshot.ValidatorRemoved = validatorRemovedEvents.map(e => ({
-    blockNumber: e.blockNumber,
-    returnValues: {
-      validator: e.returnValues.validator
-    },
-    event: 'ValidatorRemoved'
-  }))
-
-  // Write snapshot
-  fs.writeFileSync(snapshotFullPath, JSON.stringify(snapshot, null, 2))
-}
-
-const main = async () => {
-  await Promise.all([
-    generateSnapshot('home', COMMON_HOME_RPC_URL, COMMON_HOME_BRIDGE_ADDRESS),
-    generateSnapshot('foreign', COMMON_FOREIGN_RPC_URL, COMMON_FOREIGN_BRIDGE_ADDRESS)
-  ])
-}
-
-main()
-  .then(() => process.exit(0))
-  .catch(error => {
-    console.log('Error while creating snapshots')
-    console.error(error)
-    process.exit(0)
-  })

alm/src/App.test.tsx

@@ -0,0 +1,5 @@
+import React from 'react'
+
+test('renders learn react link', () => {
+  // Removed basic test from setup. Keeping this so CI passes until we add unit tests.
+})

alm/src/App.tsx

@@ -1,18 +1,14 @@
 import React from 'react'
 import { BrowserRouter } from 'react-router-dom'
-import { Web3ReactProvider } from '@web3-react/core'
-import Web3 from 'web3'
 import { MainPage } from './components/MainPage'
 import { StateProvider } from './state/StateProvider'
 
 function App() {
   return (
     <BrowserRouter>
-      <Web3ReactProvider getLibrary={provider => new Web3(provider)}>
-        <StateProvider>
-          <MainPage />
-        </StateProvider>
-      </Web3ReactProvider>
+      <StateProvider>
+        <MainPage />
+      </StateProvider>
     </BrowserRouter>
   )
 }

alm/src/abis/ForeignAMB.ts

@@ -123,24 +123,6 @@ const abi: AbiItem[] = [
     stateMutability: 'nonpayable',
     type: 'function'
   },
-  {
-    constant: false,
-    inputs: [
-      {
-        name: '_data',
-        type: 'bytes'
-      },
-      {
-        name: '_signatures',
-        type: 'bytes'
-      }
-    ],
-    name: 'safeExecuteSignaturesWithAutoGasLimit',
-    outputs: [],
-    payable: false,
-    stateMutability: 'nonpayable',
-    type: 'function'
-  },
   {
     constant: true,
     inputs: [

alm/src/components/ConfirmationsContainer.tsx

@@ -1,10 +1,10 @@
-import React, { useEffect, useState } from 'react'
+import React from 'react'
 import { TransactionReceipt } from 'web3-eth'
 import { useMessageConfirmations } from '../hooks/useMessageConfirmations'
 import { MessageObject } from '../utils/web3'
 import styled from 'styled-components'
-import { CONFIRMATIONS_STATUS, VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
-import { CONFIRMATIONS_STATUS_LABEL, CONFIRMATIONS_STATUS_LABEL_HOME } from '../config/descriptions'
+import { CONFIRMATIONS_STATUS } from '../config/constants'
+import { CONFIRMATIONS_STATUS_LABEL } from '../config/descriptions'
 import { SimpleLoading } from './commons/Loading'
 import { ValidatorsConfirmations } from './ValidatorsConfirmations'
 import { getConfirmationsStatusDescription } from '../utils/networks'
@@ -12,8 +12,6 @@ import { useStateProvider } from '../state/StateProvider'
 import { ExecutionConfirmation } from './ExecutionConfirmation'
 import { useValidatorContract } from '../hooks/useValidatorContract'
 import { useBlockConfirmations } from '../hooks/useBlockConfirmations'
-import { MultiLine } from './commons/MultiLine'
-import { ExplorerTxLink } from './commons/ExplorerTxLink'
 
 const StatusLabel = styled.label`
   font-weight: bold;
@@ -39,111 +37,48 @@ export interface ConfirmationsContainerParams {
   message: MessageObject
   receipt: Maybe<TransactionReceipt>
   fromHome: boolean
-  homeStartBlock: Maybe<number>
-  foreignStartBlock: Maybe<number>
+  timestamp: number
 }
 
-export const ConfirmationsContainer = ({
-  message,
-  receipt,
-  fromHome,
-  homeStartBlock,
-  foreignStartBlock
-}: ConfirmationsContainerParams) => {
+export const ConfirmationsContainer = ({ message, receipt, fromHome, timestamp }: ConfirmationsContainerParams) => {
   const {
     home: { name: homeName },
     foreign: { name: foreignName }
   } = useStateProvider()
-  const src = useValidatorContract(fromHome, receipt ? receipt.blockNumber : 0)
-  const [executionBlockNumber, setExecutionBlockNumber] = useState(0)
-  const dst = useValidatorContract(!fromHome, executionBlockNumber || 'latest')
+  const { requiredSignatures, validatorList } = useValidatorContract({ fromHome, receipt })
   const { blockConfirmations } = useBlockConfirmations({ fromHome, receipt })
-  const {
-    confirmations,
-    status,
-    executionData,
-    signatureCollected,
-    waitingBlocksResolved,
-    setExecutionData,
-    executionEventsFetched,
-    setPendingExecution
-  } = useMessageConfirmations({
+  const { confirmations, status, executionData, signatureCollected } = useMessageConfirmations({
     message,
     receipt,
     fromHome,
-    homeStartBlock,
-    foreignStartBlock,
-    requiredSignatures: src.requiredSignatures,
-    validatorList: src.validatorList,
-    targetValidatorList: dst.validatorList,
+    timestamp,
+    requiredSignatures,
+    validatorList,
     blockConfirmations
   })
 
-  useEffect(
-    () => {
-      if (executionBlockNumber || executionData.status !== VALIDATOR_CONFIRMATION_STATUS.EXECUTION_SUCCESS) return
-
-      setExecutionBlockNumber(executionData.blockNumber)
-    },
-    [executionData.status, executionBlockNumber, executionData.blockNumber]
-  )
-
-  const statusLabel = fromHome ? CONFIRMATIONS_STATUS_LABEL_HOME : CONFIRMATIONS_STATUS_LABEL
-
-  const parseDescription = () => {
-    let description = getConfirmationsStatusDescription(status, homeName, foreignName, fromHome)
-    let link
-    const descArray = description.split('%link')
-    if (descArray.length > 1) {
-      description = descArray[0]
-      link = (
-        <ExplorerTxLink href={descArray[1]} target="_blank" rel="noopener noreferrer">
-          {descArray[1]}
-        </ExplorerTxLink>
-      )
-    }
-
-    return (
-      <div>
-        {description}
-        {link}
-      </div>
-    )
-  }
-
   return (
     <div className="row is-center">
       <StyledConfirmationContainer className="col-9">
         <div className="row is-center">
           <StatusLabel>Status:</StatusLabel>
-          <StatusResultLabel data-id="status">
-            {status !== CONFIRMATIONS_STATUS.UNDEFINED ? statusLabel[status] : <SimpleLoading />}
+          <StatusResultLabel>
+            {status !== CONFIRMATIONS_STATUS.UNDEFINED ? CONFIRMATIONS_STATUS_LABEL[status] : <SimpleLoading />}
           </StatusResultLabel>
         </div>
         <StatusDescription className="row is-center">
-          <MultiLine className="col-10">
-            {status !== CONFIRMATIONS_STATUS.UNDEFINED ? parseDescription() : ''}
-          </MultiLine>
+          <p className="col-10">
+            {status !== CONFIRMATIONS_STATUS.UNDEFINED
+              ? getConfirmationsStatusDescription(status, homeName, foreignName)
+              : ''}
+          </p>
         </StatusDescription>
         <ValidatorsConfirmations
-          confirmations={fromHome ? confirmations.filter(c => dst.validatorList.includes(c.validator)) : confirmations}
-          requiredSignatures={dst.requiredSignatures}
-          validatorList={dst.validatorList}
-          waitingBlocksResolved={waitingBlocksResolved}
+          confirmations={confirmations}
+          requiredSignatures={requiredSignatures}
+          validatorList={validatorList}
         />
-        {signatureCollected && (
-          <ExecutionConfirmation
-            message={message}
-            executionData={executionData}
-            isHome={!fromHome}
-            confirmations={confirmations}
-            setExecutionData={setExecutionData}
-            executionEventsFetched={executionEventsFetched}
-            setPendingExecution={setPendingExecution}
-            dstRequiredSignatures={dst.requiredSignatures}
-            dstValidatorList={dst.validatorList}
-          />
-        )}
+        {signatureCollected && <ExecutionConfirmation executionData={executionData} isHome={!fromHome} />}
       </StyledConfirmationContainer>
     </div>
   )

alm/src/components/ExecutionConfirmation.tsx

@@ -1,102 +1,36 @@
-import React, { useEffect, useState } from 'react'
+import React from 'react'
 import { formatTimestamp, formatTxHash, getExplorerTxUrl } from '../utils/networks'
 import { useWindowWidth } from '@react-hook/window-size'
-import { SEARCHING_TX, VALIDATOR_CONFIRMATION_STATUS, ALM_HOME_TO_FOREIGN_MANUAL_EXECUTION } from '../config/constants'
+import { VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
 import { SimpleLoading } from './commons/Loading'
 import styled from 'styled-components'
-import { ConfirmationParam, ExecutionData } from '../hooks/useMessageConfirmations'
+import { ExecutionData } from '../hooks/useMessageConfirmations'
 import { GreyLabel, RedLabel, SuccessLabel } from './commons/Labels'
 import { ExplorerTxLink } from './commons/ExplorerTxLink'
-import { Thead, AgeTd, StatusTd } from './commons/Table'
-import { ManualExecutionButton } from './ManualExecutionButton'
-import { useStateProvider } from '../state/StateProvider'
-import { matchesRule, MessageObject, WarnRule } from '../utils/web3'
-import { WarningAlert } from './commons/WarningAlert'
-import { ErrorAlert } from './commons/ErrorAlert'
+
+const Thead = styled.thead`
+  border-bottom: 2px solid #9e9e9e;
+`
 
 const StyledExecutionConfirmation = styled.div`
   margin-top: 30px;
 `
 
 export interface ExecutionConfirmationParams {
-  message: MessageObject
   executionData: ExecutionData
-  setExecutionData: Function
-  confirmations: ConfirmationParam[]
   isHome: boolean
-  executionEventsFetched: boolean
-  setPendingExecution: Function
-  dstRequiredSignatures: number
-  dstValidatorList: string[]
 }
 
-export const ExecutionConfirmation = ({
-  message,
-  executionData,
-  setExecutionData,
-  confirmations,
-  isHome,
-  executionEventsFetched,
-  setPendingExecution,
-  dstRequiredSignatures,
-  dstValidatorList
-}: ExecutionConfirmationParams) => {
-  const { foreign } = useStateProvider()
-  const [safeExecutionAvailable, setSafeExecutionAvailable] = useState(false)
-  const [error, setError] = useState('')
-  const [warning, setWarning] = useState('')
-  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
+export const ExecutionConfirmation = ({ executionData, isHome }: ExecutionConfirmationParams) => {
   const windowWidth = useWindowWidth()
 
   const txExplorerLink = getExplorerTxUrl(executionData.txHash, isHome)
   const formattedValidator =
     windowWidth < 850 && executionData.validator ? formatTxHash(executionData.validator) : executionData.validator
 
-  useEffect(
-    () => {
-      if (!availableManualExecution || !foreign.bridgeContract) return
-
-      const p = foreign.bridgeContract.methods.getBridgeInterfacesVersion().call()
-      p.then(({ major, minor }: any) => {
-        major = parseInt(major, 10)
-        minor = parseInt(minor, 10)
-        if (major < 5 || (major === 5 && minor < 7)) return
-
-        setSafeExecutionAvailable(true)
-      })
-    },
-    [availableManualExecution, foreign.bridgeContract]
-  )
-
-  useEffect(
-    () => {
-      if (!message.data || !executionData || !availableManualExecution) return
-
-      try {
-        const fileName = 'warnRules'
-        const rules: WarnRule[] = require(`../snapshots/${fileName}.json`)
-        for (let rule of rules) {
-          if (matchesRule(rule, message)) {
-            setWarning(rule.message)
-            return
-          }
-        }
-      } catch (e) {}
-    },
-    [availableManualExecution, executionData, message, message.data, setWarning]
-  )
-
   const getExecutionStatusElement = (validatorStatus = '') => {
     switch (validatorStatus) {
-      case VALIDATOR_CONFIRMATION_STATUS.EXECUTION_SUCCESS:
+      case VALIDATOR_CONFIRMATION_STATUS.SUCCESS:
         return <SuccessLabel>{validatorStatus}</SuccessLabel>
       case VALIDATOR_CONFIRMATION_STATUS.FAILED:
         return <RedLabel>{validatorStatus}</RedLabel>
@@ -104,66 +38,29 @@ export const ExecutionConfirmation = ({
       case VALIDATOR_CONFIRMATION_STATUS.WAITING:
         return <GreyLabel>{validatorStatus}</GreyLabel>
       default:
-        return executionData.validator ? (
-          <GreyLabel>{VALIDATOR_CONFIRMATION_STATUS.WAITING}</GreyLabel>
-        ) : (
-          <SimpleLoading />
-        )
+        return <SimpleLoading />
     }
   }
 
   return (
     <StyledExecutionConfirmation>
-      {error && <ErrorAlert onClick={() => setError('')} error={error} />}
-      {warning && <WarningAlert onClick={() => setWarning('')} error={warning} />}
       <table>
         <Thead>
           <tr>
-            <th>{requiredManualExecution ? 'Execution info' : 'Executed by'}</th>
+            <th>Executed by</th>
             <th className="text-center">Status</th>
-            {showAgeColumn && <th className="text-center">Age</th>}
-            {availableManualExecution && <th className="text-center">Actions</th>}
+            <th className="text-center">Age</th>
           </tr>
         </Thead>
         <tbody>
           <tr>
-            <td>
-              {requiredManualExecution ? (
-                'Manual user action is required to complete the operation'
-              ) : formattedValidator ? (
-                formattedValidator
-              ) : (
-                <SimpleLoading />
-              )}
+            <td>{formattedValidator ? formattedValidator : <SimpleLoading />}</td>
+            <td className="text-center">{getExecutionStatusElement(executionData.status)}</td>
+            <td className="text-center">
+              <ExplorerTxLink href={txExplorerLink} target="_blank">
+                {executionData.timestamp > 0 ? formatTimestamp(executionData.timestamp) : ''}
+              </ExplorerTxLink>
             </td>
-            <StatusTd className="text-center">{getExecutionStatusElement(executionData.status)}</StatusTd>
-            {showAgeColumn && (
-              <AgeTd className="text-center">
-                {executionData.timestamp > 0 ? (
-                  <ExplorerTxLink href={txExplorerLink} target="_blank">
-                    {formatTimestamp(executionData.timestamp)}
-                  </ExplorerTxLink>
-                ) : executionData.status === VALIDATOR_CONFIRMATION_STATUS.WAITING ? (
-                  ''
-                ) : (
-                  SEARCHING_TX
-                )}
-              </AgeTd>
-            )}
-            {availableManualExecution && (
-              <td>
-                <ManualExecutionButton
-                  safeExecutionAvailable={safeExecutionAvailable}
-                  messageData={message.data}
-                  setExecutionData={setExecutionData}
-                  confirmations={confirmations}
-                  setPendingExecution={setPendingExecution}
-                  setError={setError}
-                  requiredSignatures={dstRequiredSignatures}
-                  validatorList={dstValidatorList}
-                />
-              </td>
-            )}
           </tr>
         </tbody>
       </table>

alm/src/components/Form.tsx

@@ -35,13 +35,8 @@ export const Form = ({ onSubmit }: { onSubmit: ({ chainId, txHash, receipt }: Fo
     onSubmit({ chainId, txHash, receipt })
   }
 
-  const onBack = () => {
-    setTxHash('')
-    setSearchTx(false)
-  }
-
   if (searchTx) {
-    return <TransactionSelector txHash={txHash} onSelected={onSelected} onBack={onBack} />
+    return <TransactionSelector txHash={txHash} onSelected={onSelected} />
   }
 
   return (

alm/src/components/MainPage.tsx

@@ -1,13 +1,10 @@
-import React, { useEffect, useState, useCallback } from 'react'
+import React, { useState } from 'react'
 import styled from 'styled-components'
 import { Route, useHistory } from 'react-router-dom'
 import { Form } from './Form'
 import { StatusContainer } from './StatusContainer'
 import { useStateProvider } from '../state/StateProvider'
 import { TransactionReceipt } from 'web3-eth'
-import { InfoAlert } from './commons/InfoAlert'
-import { ExplorerTxLink } from './commons/ExplorerTxLink'
-import { FOREIGN_NETWORK_NAME, HOME_NETWORK_NAME } from '../config/constants'
 
 const StyledMainPage = styled.div`
   text-align: center;
@@ -35,14 +32,6 @@ const HeaderContainer = styled.header`
   }
 `
 
-const AlertP = styled.p`
-  align-items: start;
-  margin-bottom: 0;
-  @media (max-width: 600px) {
-    flex-direction: column;
-  }
-`
-
 export interface FormSubmitParams {
   chainId: number
   txHash: string
@@ -54,27 +43,6 @@ export const MainPage = () => {
   const { home, foreign } = useStateProvider()
   const [networkName, setNetworkName] = useState('')
   const [receipt, setReceipt] = useState<Maybe<TransactionReceipt>>(null)
-  const [showInfoAlert, setShowInfoAlert] = useState(false)
-
-  const loadFromStorage = useCallback(() => {
-    const hideAlert = window.localStorage.getItem('hideInfoAlert')
-    setShowInfoAlert(!hideAlert)
-  }, [])
-
-  useEffect(
-    () => {
-      loadFromStorage()
-    },
-    [loadFromStorage]
-  )
-
-  const onAlertClose = useCallback(
-    () => {
-      window.localStorage.setItem('hideInfoAlert', 'true')
-      loadFromStorage()
-    },
-    [loadFromStorage]
-  )
 
   const setNetworkData = (chainId: number) => {
     const network = chainId === home.chainId ? home.name : foreign.name
@@ -96,13 +64,6 @@ export const MainPage = () => {
     setNetworkData(chainId)
   }
 
-  useEffect(() => {
-    const w = window as any
-    if (w.ethereum) {
-      w.ethereum.autoRefreshOnNetworkChange = false
-    }
-  }, [])
-
   return (
     <StyledMainPage>
       <Header>
@@ -112,25 +73,6 @@ export const MainPage = () => {
         </HeaderContainer>
       </Header>
       <div className="container">
-        {showInfoAlert && (
-          <InfoAlert onClick={onAlertClose}>
-            <p className="is-left text-left">
-              The Arbitrary Message Bridge Live Monitoring application provides real-time status updates for messages
-              bridged between {HOME_NETWORK_NAME} and {FOREIGN_NETWORK_NAME}. You can check current tx status, view
-              validator info, and troubleshoot potential issues with bridge transfers.
-            </p>
-            <AlertP className="is-left text-left">
-              For more information refer to&nbsp;
-              <ExplorerTxLink
-                href="https://docs.tokenbridge.net/about-tokenbridge/components/amb-live-monitoring-application"
-                target="_blank"
-                rel="noopener noreferrer"
-              >
-                the ALM documentation
-              </ExplorerTxLink>
-            </AlertP>
-          </InfoAlert>
-        )}
         <Route exact path={['/']} children={<Form onSubmit={onFormSubmit} />} />
         <Route
           path={['/:chainId/:txHash/:messageIdParam', '/:chainId/:txHash']}

alm/src/components/ManualExecutionButton.tsx

@@ -1,231 +0,0 @@
-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 {
-  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'
-import { ConfirmationParam } from '../hooks/useMessageConfirmations'
-
-const ActionButton = styled.button`
-  color: var(--button-color);
-  border-color: var(--font-color);
-  margin-top: 10px;
-  min-width: 120px;
-  padding: 1rem;
-  &:focus {
-    outline: var(--button-color);
-  }
-`
-
-interface ManualExecutionButtonParams {
-  safeExecutionAvailable: boolean
-  messageData: string
-  setExecutionData: Function
-  confirmations: ConfirmationParam[]
-  setPendingExecution: Function
-  setError: Function
-  requiredSignatures: number
-  validatorList: string[]
-}
-
-export const ManualExecutionButton = ({
-  safeExecutionAvailable,
-  messageData,
-  setExecutionData,
-  confirmations,
-  setPendingExecution,
-  setError,
-  requiredSignatures,
-  validatorList
-}: ManualExecutionButtonParams) => {
-  const { foreign } = useStateProvider()
-  const { library, activate, account, active } = useWeb3React()
-  const [manualExecution, setManualExecution] = useState(false)
-  const [allowFailures, setAllowFailures] = useState(false)
-  const [ready, setReady] = useState(false)
-  const [title, setTitle] = useState('Loading')
-  const [validSignatures, setValidSignatures] = useState<string[]>([])
-
-  useEffect(
-    () => {
-      if (
-        !foreign.bridgeContract ||
-        !foreign.web3 ||
-        !confirmations ||
-        !confirmations.length ||
-        !requiredSignatures ||
-        !validatorList ||
-        !validatorList.length
-      )
-        return
-
-      const signatures = []
-      for (let i = 0; i < confirmations.length && signatures.length < requiredSignatures; i++) {
-        const sig = confirmations[i].signature
-        if (!sig) {
-          continue
-        }
-        const { v, r, s } = signatureToVRS(sig)
-        const signer = foreign.web3.eth.accounts.recover(messageData, `0x${v}`, `0x${r}`, `0x${s}`)
-        if (validatorList.includes(signer)) {
-          signatures.push(sig)
-        }
-      }
-
-      if (signatures.length >= requiredSignatures) {
-        setValidSignatures(signatures.slice(0, requiredSignatures))
-        setTitle('Execute')
-        setReady(true)
-      } else {
-        setTitle('Unavailable')
-      }
-    },
-    [
-      foreign.bridgeContract,
-      foreign.web3,
-      validatorList,
-      requiredSignatures,
-      messageData,
-      setValidSignatures,
-      confirmations
-    ]
-  )
-
-  useEffect(
-    () => {
-      if (!manualExecution || !foreign.chainId) return
-
-      if (!active) {
-        activate(new InjectedConnector({ supportedChainIds: [foreign.chainId] }), e => {
-          if (e.message.includes('Unsupported chain id')) {
-            setError(INCORRECT_CHAIN_ERROR)
-            const { ethereum } = window as any
-
-            // remove the error message after chain is correctly changed to the foreign one
-            const listener = (chainId: string) => {
-              if (parseInt(chainId.slice(2), 16) === foreign.chainId) {
-                ethereum.removeListener('chainChanged', listener)
-                setError((error: string) => (error === INCORRECT_CHAIN_ERROR ? '' : error))
-              }
-            }
-            ethereum.on('chainChanged', listener)
-          } else {
-            setError(e.message)
-          }
-          setManualExecution(false)
-        })
-        return
-      }
-
-      if (!library || !foreign.bridgeContract || !foreign.web3 || !validSignatures || !validSignatures.length) return
-
-      const signatures = packSignatures(validSignatures.map(signatureToVRS))
-      const messageId = messageData.slice(0, 66)
-      const bridge = foreign.bridgeContract
-      const executeMethod =
-        safeExecutionAvailable && !allowFailures
-          ? bridge.methods.safeExecuteSignaturesWithAutoGasLimit
-          : bridge.methods.executeSignatures
-      const data = executeMethod(messageData, signatures).encodeABI()
-      setManualExecution(false)
-
-      library.eth
-        .sendTransaction({
-          from: account,
-          to: foreign.bridgeAddress,
-          data
-        })
-        .on('transactionHash', (txHash: string) => {
-          setExecutionData({
-            status: VALIDATOR_CONFIRMATION_STATUS.PENDING,
-            validator: account,
-            txHash,
-            timestamp: Math.floor(new Date().getTime() / 1000.0),
-            executionResult: false
-          })
-          setPendingExecution(true)
-        })
-        .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,
-      library,
-      activate,
-      active,
-      account,
-      foreign.chainId,
-      foreign.bridgeAddress,
-      foreign.bridgeContract,
-      setError,
-      messageData,
-      setExecutionData,
-      setPendingExecution,
-      safeExecutionAvailable,
-      allowFailures,
-      foreign.web3,
-      validSignatures
-    ]
-  )
-
-  return (
-    <div>
-      <div className="is-center">
-        <ActionButton disabled={!ready} className="button outline" onClick={() => setManualExecution(true)}>
-          {title}
-        </ActionButton>
-      </div>
-      {safeExecutionAvailable && (
-        <div
-          title="Allow executed message to fail and record its failure on-chain without reverting the whole transaction.
-          Use fixed gas limit for execution."
-          className="is-center"
-          style={{ paddingTop: 10 }}
-        >
-          <input
-            type="checkbox"
-            id="allow-failures"
-            checked={allowFailures}
-            onChange={e => setAllowFailures(e.target.checked)}
-          />
-          <label htmlFor="allow-failures">Unsafe mode</label>
-        </div>
-      )}
-    </div>
-  )
-}

alm/src/components/StatusContainer.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect } from 'react'
-import { useHistory, useParams } from 'react-router-dom'
+import { Link, useHistory, useParams } from 'react-router-dom'
 import { useTransactionStatus } from '../hooks/useTransactionStatus'
 import { formatTxHash, getExplorerTxUrl, getTransactionStatusDescription, validTxHash } from '../utils/networks'
 import { TRANSACTION_STATUS } from '../config/constants'
@@ -8,9 +8,23 @@ import { Loading } from './commons/Loading'
 import { useStateProvider } from '../state/StateProvider'
 import { ExplorerTxLink } from './commons/ExplorerTxLink'
 import { ConfirmationsContainer } from './ConfirmationsContainer'
+import { LeftArrow } from './commons/LeftArrow'
+import styled from 'styled-components'
 import { TransactionReceipt } from 'web3-eth'
-import { BackButton } from './commons/BackButton'
-import { useClosestBlock } from '../hooks/useClosestBlock'
+
+const BackButton = styled.button`
+  color: var(--button-color);
+  border-color: var(--font-color);
+  margin-top: 10px;
+  &:focus {
+    outline: var(--button-color);
+  }
+`
+
+const BackLabel = styled.label`
+  margin-left: 5px;
+  cursor: pointer;
+`
 
 export interface StatusContainerParam {
   onBackToMain: () => void
@@ -24,15 +38,12 @@ 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
 
@@ -68,51 +79,44 @@ export const StatusContainer = ({ onBackToMain, setNetworkFromParams, receiptPar
   const displayReference = multiMessageSelected ? messages[selectedMessageId].id : txHash
   const formattedMessageId = formatTxHash(displayReference)
 
+  const displayedDescription = multiMessageSelected
+    ? getTransactionStatusDescription(TRANSACTION_STATUS.SUCCESS_ONE_MESSAGE, timestamp)
+    : description
+
+  const isHome = chainId === home.chainId.toString()
   const txExplorerLink = getExplorerTxUrl(txHash, isHome)
   const displayExplorerLink = status !== TRANSACTION_STATUS.NOT_FOUND
 
   const displayConfirmations = status === TRANSACTION_STATUS.SUCCESS_ONE_MESSAGE || multiMessageSelected
   const messageToConfirm =
     messages.length > 1 ? messages[selectedMessageId] : messages.length > 0 ? messages[0] : { id: '', data: '' }
-
-  let displayedDescription: string = multiMessageSelected
-    ? getTransactionStatusDescription(TRANSACTION_STATUS.SUCCESS_ONE_MESSAGE, timestamp)
-    : description
-  let link
-  const descArray = displayedDescription.split('%link')
-  if (descArray.length > 1) {
-    displayedDescription = descArray[0]
-    link = (
-      <ExplorerTxLink href={descArray[1]} target="_blank" rel="noopener noreferrer">
-        {descArray[1]}
-      </ExplorerTxLink>
-    )
-  }
-
   return (
     <div>
       {status && (
         <p>
-          The transaction{' '}
+          The request{' '}
           {displayExplorerLink && (
-            <ExplorerTxLink href={txExplorerLink} target="_blank">
+            <ExplorerTxLink href={txExplorerLink} target="blank">
               {formattedMessageId}
             </ExplorerTxLink>
           )}
-          {!displayExplorerLink && <label>{formattedMessageId}</label>} {displayedDescription} {link}
+          {!displayExplorerLink && <label>{formattedMessageId}</label>} {displayedDescription}
         </p>
       )}
       {displayMessageSelector && <MessageSelector messages={messages} onMessageSelected={onMessageSelected} />}
       {displayConfirmations && (
-        <ConfirmationsContainer
-          message={messageToConfirm}
-          receipt={receipt}
-          fromHome={isHome}
-          homeStartBlock={homeStartBlock}
-          foreignStartBlock={foreignStartBlock}
-        />
+        <ConfirmationsContainer message={messageToConfirm} receipt={receipt} fromHome={isHome} timestamp={timestamp} />
       )}
-      <BackButton onBackToMain={onBackToMain} />
+      <div className="row is-center">
+        <div className="col-9">
+          <Link to="/" onClick={onBackToMain}>
+            <BackButton className="button outline is-left">
+              <LeftArrow />
+              <BackLabel>Search another transaction</BackLabel>
+            </BackButton>
+          </Link>
+        </div>
+      </div>
     </div>
   )
 }

alm/src/components/TransactionSelector.tsx

@@ -5,23 +5,13 @@ import { TRANSACTION_STATUS } from '../config/constants'
 import { TransactionReceipt } from 'web3-eth'
 import { Loading } from './commons/Loading'
 import { NetworkTransactionSelector } from './NetworkTransactionSelector'
-import { BackButton } from './commons/BackButton'
-import { TRANSACTION_STATUS_DESCRIPTION } from '../config/descriptions'
-import { MultiLine } from './commons/MultiLine'
-import styled from 'styled-components'
-
-const StyledMultiLine = styled(MultiLine)`
-  margin-bottom: 40px;
-`
 
 export const TransactionSelector = ({
   txHash,
-  onSelected,
-  onBack
+  onSelected
 }: {
   txHash: string
   onSelected: (chainId: number, receipt: TransactionReceipt) => void
-  onBack: () => void
 }) => {
   const { home, foreign } = useStateProvider()
   const { receipt: homeReceipt, status: homeStatus } = useTransactionFinder({ txHash, web3: home.web3 })
@@ -53,15 +43,5 @@ export const TransactionSelector = ({
     return <NetworkTransactionSelector onNetworkSelected={onSelectedNetwork} />
   }
 
-  if (foreignStatus === TRANSACTION_STATUS.NOT_FOUND && homeStatus === TRANSACTION_STATUS.NOT_FOUND) {
-    const message = TRANSACTION_STATUS_DESCRIPTION[TRANSACTION_STATUS.NOT_FOUND]
-    return (
-      <div>
-        <StyledMultiLine>{message}</StyledMultiLine>
-        <BackButton onBackToMain={onBack} />
-      </div>
-    )
-  }
-
   return <Loading />
 }

alm/src/components/ValidatorsConfirmations.tsx

@@ -1,13 +1,16 @@
 import React from 'react'
 import { formatTimestamp, formatTxHash, getExplorerTxUrl } from '../utils/networks'
 import { useWindowWidth } from '@react-hook/window-size'
-import { RECENT_AGE, SEARCHING_TX, VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
+import { VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
 import { SimpleLoading } from './commons/Loading'
 import styled from 'styled-components'
 import { ConfirmationParam } from '../hooks/useMessageConfirmations'
 import { GreyLabel, RedLabel, SuccessLabel } from './commons/Labels'
 import { ExplorerTxLink } from './commons/ExplorerTxLink'
-import { Thead, AgeTd, StatusTd } from './commons/Table'
+
+const Thead = styled.thead`
+  border-bottom: 2px solid #9e9e9e;
+`
 
 const RequiredConfirmations = styled.label`
   font-size: 14px;
@@ -17,23 +20,19 @@ export interface ValidatorsConfirmationsParams {
   confirmations: Array<ConfirmationParam>
   requiredSignatures: number
   validatorList: string[]
-  waitingBlocksResolved: boolean
 }
 
 export const ValidatorsConfirmations = ({
   confirmations,
   requiredSignatures,
-  validatorList,
-  waitingBlocksResolved
+  validatorList
 }: ValidatorsConfirmationsParams) => {
   const windowWidth = useWindowWidth()
 
   const getValidatorStatusElement = (validatorStatus = '') => {
     switch (validatorStatus) {
       case VALIDATOR_CONFIRMATION_STATUS.SUCCESS:
-      case VALIDATOR_CONFIRMATION_STATUS.MANUAL:
-      case VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID:
-        return <SuccessLabel>{VALIDATOR_CONFIRMATION_STATUS.SUCCESS}</SuccessLabel>
+        return <SuccessLabel>{validatorStatus}</SuccessLabel>
       case VALIDATOR_CONFIRMATION_STATUS.FAILED:
         return <RedLabel>{validatorStatus}</RedLabel>
       case VALIDATOR_CONFIRMATION_STATUS.PENDING:
@@ -41,11 +40,7 @@ export const ValidatorsConfirmations = ({
       case VALIDATOR_CONFIRMATION_STATUS.NOT_REQUIRED:
         return <GreyLabel>{validatorStatus}</GreyLabel>
       default:
-        return waitingBlocksResolved ? (
-          <GreyLabel>{VALIDATOR_CONFIRMATION_STATUS.WAITING}</GreyLabel>
-        ) : (
-          <SimpleLoading />
-        )
+        return <SimpleLoading />
     }
   }
 
@@ -60,45 +55,36 @@ export const ValidatorsConfirmations = ({
           </tr>
         </Thead>
         <tbody>
-          {confirmations.map((confirmation, i) => {
-            const displayedStatus = confirmation.status
-            const explorerLink = getExplorerTxUrl(confirmation.txHash, true)
-            let elementIfNoTimestamp: any = <SimpleLoading />
-            switch (displayedStatus) {
-              case '':
-              case VALIDATOR_CONFIRMATION_STATUS.UNDEFINED:
-                if (waitingBlocksResolved) {
-                  elementIfNoTimestamp = SEARCHING_TX
-                }
-                break
-              case VALIDATOR_CONFIRMATION_STATUS.WAITING:
-              case VALIDATOR_CONFIRMATION_STATUS.NOT_REQUIRED:
-                elementIfNoTimestamp = ''
-                break
-              case VALIDATOR_CONFIRMATION_STATUS.MANUAL:
-                elementIfNoTimestamp = RECENT_AGE
-                break
-            }
+          {validatorList.map((validator, i) => {
+            const filteredConfirmation = confirmations.filter(c => c.validator === validator)
+            const confirmation = filteredConfirmation.length > 0 ? filteredConfirmation[0] : null
+            const displayedStatus = confirmation && confirmation.status ? confirmation.status : ''
+            const explorerLink = confirmation && confirmation.txHash ? getExplorerTxUrl(confirmation.txHash, true) : ''
+            const elementIfNoTimestamp =
+              displayedStatus !== VALIDATOR_CONFIRMATION_STATUS.WAITING &&
+              displayedStatus !== VALIDATOR_CONFIRMATION_STATUS.NOT_REQUIRED ? (
+                <SimpleLoading />
+              ) : (
+                ''
+              )
             return (
               <tr key={i}>
-                <td>{windowWidth < 850 ? formatTxHash(confirmation.validator) : confirmation.validator}</td>
-                <StatusTd className="text-center">{getValidatorStatusElement(displayedStatus)}</StatusTd>
-                <AgeTd className="text-center">
-                  {confirmation && confirmation.timestamp > 0 ? (
-                    <ExplorerTxLink href={explorerLink} target="_blank">
-                      {formatTimestamp(confirmation.timestamp)}
-                    </ExplorerTxLink>
-                  ) : (
-                    elementIfNoTimestamp
-                  )}
-                </AgeTd>
+                <td>{windowWidth < 850 ? formatTxHash(validator) : validator}</td>
+                <td className="text-center">{getValidatorStatusElement(displayedStatus)}</td>
+                <td className="text-center">
+                  <ExplorerTxLink href={explorerLink} target="_blank">
+                    {confirmation && confirmation.timestamp > 0
+                      ? formatTimestamp(confirmation.timestamp)
+                      : elementIfNoTimestamp}
+                  </ExplorerTxLink>
+                </td>
               </tr>
             )
           })}
         </tbody>
       </table>
       <RequiredConfirmations>
-        At least <strong>{requiredSignatures}</strong> of <strong>{validatorList.length}</strong> confirmations required
+        {requiredSignatures} of {validatorList.length} confirmations required
       </RequiredConfirmations>
     </div>
   )

alm/src/components/commons/BackButton.tsx

@@ -1,35 +0,0 @@
-import { Link } from 'react-router-dom'
-import { LeftArrow } from './LeftArrow'
-import React from 'react'
-import styled from 'styled-components'
-
-const StyledButton = styled.button`
-  color: var(--button-color);
-  border-color: var(--font-color);
-  margin-top: 10px;
-  &:focus {
-    outline: var(--button-color);
-  }
-`
-
-const BackLabel = styled.label`
-  margin-left: 5px;
-  cursor: pointer;
-`
-
-export interface BackButtonParam {
-  onBackToMain: () => void
-}
-
-export const BackButton = ({ onBackToMain }: BackButtonParam) => (
-  <div className="row is-center">
-    <div className="col-9">
-      <Link to="/" onClick={onBackToMain}>
-        <StyledButton className="button outline is-left">
-          <LeftArrow />
-          <BackLabel>Search another transaction</BackLabel>
-        </StyledButton>
-      </Link>
-    </div>
-  </div>
-)

alm/src/components/commons/CloseIcon.tsx

@@ -1,18 +0,0 @@
-import React from 'react'
-
-export const CloseIcon = ({ color }: { color?: string }) => (
-  <svg
-    aria-hidden="true"
-    focusable="false"
-    data-prefix="fa"
-    data-icon="times"
-    className="svg-inline--fa fa-times fa-w-11 fa-lg "
-    role="img"
-    xmlns="http://www.w3.org/2000/svg"
-    viewBox="0 0 352 512"
-    fill={color || '#1890ff'}
-    height="1em"
-  >
-    <path d="M242.72 256l100.07-100.07c12.28-12.28 12.28-32.19 0-44.48l-22.24-22.24c-12.28-12.28-32.19-12.28-44.48 0L176 189.28 75.93 89.21c-12.28-12.28-32.19-12.28-44.48 0L9.21 111.45c-12.28 12.28-12.28 32.19 0 44.48L109.28 256 9.21 356.07c-12.28 12.28-12.28 32.19 0 44.48l22.24 22.24c12.28 12.28 32.2 12.28 44.48 0L176 322.72l100.07 100.07c12.28 12.28 32.2 12.28 44.48 0l22.24-22.24c12.28-12.28 12.28-32.19 0-44.48L242.72 256z" />
-  </svg>
-)

alm/src/components/commons/ErrorAlert.tsx

@@ -1,48 +0,0 @@
-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);
-  border-radius: 4px;
-  margin-bottom: 20px;
-  padding-top: 10px;
-`
-
-const CloseIconContainer = styled.div`
-  cursor: pointer;
-`
-
-const TextContainer = styled.div`
-  white-space: pre-wrap;
-  flex-direction: column;
-`
-
-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-12 is-vertical-align row">
-        <InfoIcon color="var(--failed-color)" />
-        <TextContainer className="col-10">
-          {text}
-          {link}
-        </TextContainer>
-        <CloseIconContainer className="col-1 is-vertical-align is-center" onClick={onClick}>
-          <CloseIcon color="var(--failed-color)" />
-        </CloseIconContainer>
-      </StyledErrorAlert>
-    </div>
-  )
-}

alm/src/components/commons/InfoAlert.tsx

@@ -1,31 +0,0 @@
-import React from 'react'
-import styled from 'styled-components'
-import { InfoIcon } from './InfoIcon'
-import { CloseIcon } from './CloseIcon'
-
-const StyledInfoAlert = styled.div`
-  border: 1px solid var(--button-color);
-  border-radius: 4px;
-  margin-bottom: 20px;
-  padding-top: 10px;
-`
-
-const CloseIconContainer = styled.div`
-  cursor: pointer;
-`
-
-const TextContainer = styled.div`
-  flex-direction: column;
-`
-
-export const InfoAlert = ({ onClick, children }: { onClick: () => void; children: React.ReactChild[] }) => (
-  <div className="row is-center">
-    <StyledInfoAlert className="col-10 is-vertical-align row">
-      <InfoIcon />
-      <TextContainer className="col-10">{children}</TextContainer>
-      <CloseIconContainer className="col-1 is-vertical-align is-center" onClick={onClick}>
-        <CloseIcon />
-      </CloseIconContainer>
-    </StyledInfoAlert>
-  </div>
-)

alm/src/components/commons/InfoIcon.tsx

@@ -1,16 +0,0 @@
-import React from 'react'
-
-export const InfoIcon = ({ color }: { color?: string }) => (
-  <svg
-    className="col-1 is-left"
-    viewBox="64 64 896 896"
-    focusable="false"
-    data-icon="info-circle"
-    width="1em"
-    height="1em"
-    fill={color || '#1890ff'}
-    aria-hidden="true"
-  >
-    <path d="M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm32 664c0 4.4-3.6 8-8 8h-48c-4.4 0-8-3.6-8-8V456c0-4.4 3.6-8 8-8h48c4.4 0 8 3.6 8 8v272zm-32-344a48.01 48.01 0 010-96 48.01 48.01 0 010 96z" />
-  </svg>
-)

alm/src/components/commons/MultiLine.tsx

@@ -1,5 +0,0 @@
-import styled from 'styled-components'
-
-export const MultiLine = styled.div`
-  white-space: pre-wrap;
-`

alm/src/components/commons/Table.tsx

@@ -1,13 +0,0 @@
-import styled from 'styled-components'
-
-export const Thead = styled.thead`
-  border-bottom: 2px solid #9e9e9e;
-`
-
-export const StatusTd = styled.td`
-  width: 150px;
-`
-
-export const AgeTd = styled.td`
-  width: 180px;
-`

alm/src/components/commons/WarningAlert.tsx

@@ -1,34 +0,0 @@
-import React from 'react'
-import styled from 'styled-components'
-import { InfoIcon } from './InfoIcon'
-import { CloseIcon } from './CloseIcon'
-
-const StyledErrorAlert = styled.div`
-  border: 1px solid var(--warning-color);
-  border-radius: 4px;
-  margin-bottom: 20px;
-  padding-top: 10px;
-`
-
-const CloseIconContainer = styled.div`
-  cursor: pointer;
-`
-
-const TextContainer = styled.div`
-  white-space: pre-wrap;
-  flex-direction: column;
-`
-
-export const WarningAlert = ({ onClick, error }: { onClick: () => void; error: string }) => {
-  return (
-    <div className="row is-center">
-      <StyledErrorAlert className="col-12 is-vertical-align row">
-        <InfoIcon color="var(--warning-color)" />
-        <TextContainer className="col-10">{error}</TextContainer>
-        <CloseIconContainer className="col-1 is-vertical-align is-center" onClick={onClick}>
-          <CloseIcon color="var(--warning-color)" />
-        </CloseIconContainer>
-      </StyledErrorAlert>
-    </div>
-  )
-}

alm/src/config/constants.ts

@@ -13,13 +13,11 @@ export const FOREIGN_EXPLORER_TX_TEMPLATE: string = process.env.REACT_APP_ALM_FO
 export const HOME_EXPLORER_API: string = process.env.REACT_APP_ALM_HOME_EXPLORER_API || ''
 export const FOREIGN_EXPLORER_API: string = process.env.REACT_APP_ALM_FOREIGN_EXPLORER_API || ''
 
-export const ALM_HOME_TO_FOREIGN_MANUAL_EXECUTION: boolean =
-  (process.env.REACT_APP_ALM_HOME_TO_FOREIGN_MANUAL_EXECUTION || '').toLowerCase() === 'true'
-
 export const HOME_RPC_POLLING_INTERVAL: number = 5000
 export const FOREIGN_RPC_POLLING_INTERVAL: number = 5000
-export const BLOCK_RANGE: number = 500
-export const MAX_TX_SEARCH_BLOCK_RANGE: number = 10000
+export const BLOCK_RANGE: number = 50
+export const ONE_DAY_TIMESTAMP: number = 86400
+export const THREE_DAYS_TIMESTAMP: number = 259200
 
 export const EXECUTE_AFFIRMATION_HASH = 'e7a2c01f'
 export const SUBMIT_SIGNATURE_HASH = '630cea8e'
@@ -47,35 +45,15 @@ export const CONFIRMATIONS_STATUS = {
   EXECUTION_WAITING: 'EXECUTION_WAITING',
   FAILED: 'FAILED',
   PENDING: 'PENDING',
-  SEARCHING: 'SEARCHING',
-  WAITING_VALIDATORS: 'WAITING_VALIDATORS',
-  WAITING_CHAIN: 'WAITING_CHAIN',
+  WAITING: 'WAITING',
   UNDEFINED: 'UNDEFINED'
 }
 
 export const VALIDATOR_CONFIRMATION_STATUS = {
-  SUCCESS: 'Confirmed',
-  MANUAL: 'Manual',
-  EXECUTION_SUCCESS: 'Executed',
+  SUCCESS: 'Success',
   FAILED: 'Failed',
-  FAILED_VALID: 'Failed valid',
   PENDING: 'Pending',
   WAITING: 'Waiting',
   NOT_REQUIRED: 'Not required',
   UNDEFINED: 'UNDEFINED'
 }
-
-export const RECENT_AGE = 'Recent'
-
-export const SEARCHING_TX = 'Searching Transaction...'
-
-export const INCORRECT_CHAIN_ERROR = `Incorrect chain chosen. Switch to ${FOREIGN_NETWORK_NAME} in the wallet.`
-
-export const DOUBLE_EXECUTION_ATTEMPT_ERROR = `Your execution transaction has been reverted.
-However, the execution completed successfully in the transaction sent by a different party.`
-
-export const EXECUTION_FAILED_ERROR = `Your execution transaction has been reverted.
-Please, contact the support by messaging on %linkhttps://forum.poa.network/c/support`
-
-export const EXECUTION_OUT_OF_GAS_ERROR = `Your execution transaction has been reverted due to Out-of-Gas error.
-Please, resend the transaction and provide more gas to it.`

alm/src/config/descriptions.ts

@@ -1,76 +1,36 @@
 // %t will be replaced by the time -> x minutes/hours/days ago
-import { ALM_HOME_TO_FOREIGN_MANUAL_EXECUTION } from './constants'
-
 export const TRANSACTION_STATUS_DESCRIPTION: { [key: string]: string } = {
   SUCCESS_MULTIPLE_MESSAGES: 'was initiated %t and contains several bridge messages. Specify one of them:',
   SUCCESS_ONE_MESSAGE: 'was initiated %t',
-  SUCCESS_NO_MESSAGES:
-    'successfully mined %t but it does not seem to contain any request to the bridge, \nso nothing needs to be confirmed by the validators. \nIf you are sure that the transaction should contain a request to the bridge,\ncontact to the validators by \nmessaging on %linkhttps://forum.poa.network/c/support',
+  SUCCESS_NO_MESSAGES: 'execution succeeded %t but it does not contain any bridge messages',
   FAILED: 'failed %t',
-  NOT_FOUND:
-    'Transaction not found. \n1. Check that the transaction hash is correct. \n2. Wait several blocks for the transaction to be\nmined, gas price affects mining speed.'
+  NOT_FOUND: 'was not found'
 }
 
 export const CONFIRMATIONS_STATUS_LABEL: { [key: string]: string } = {
-  SUCCESS: 'Success',
-  SUCCESS_MESSAGE_FAILED: 'Success',
-  FAILED: 'Failed',
-  PENDING: 'Pending',
-  WAITING_VALIDATORS: 'Waiting',
-  SEARCHING: 'Waiting',
-  WAITING_CHAIN: 'Waiting'
-}
-
-export const CONFIRMATIONS_STATUS_LABEL_HOME: { [key: string]: string } = {
   SUCCESS: 'Success',
   SUCCESS_MESSAGE_FAILED: 'Success',
   EXECUTION_FAILED: 'Execution failed',
   EXECUTION_PENDING: 'Execution pending',
-  EXECUTION_WAITING: ALM_HOME_TO_FOREIGN_MANUAL_EXECUTION ? 'Manual execution waiting' : 'Execution waiting',
-  FAILED: 'Confirmation Failed',
-  PENDING: 'Confirmation Pending',
-  WAITING_VALIDATORS: 'Confirmation Waiting',
-  SEARCHING: 'Confirmation Waiting',
-  WAITING_CHAIN: 'Confirmation Waiting'
+  EXECUTION_WAITING: 'Execution waiting',
+  FAILED: 'Failed',
+  PENDING: 'Pending',
+  WAITING: 'Waiting'
 }
 
-// use %link to identify a link
+// %homeChain will be replaced by the home network name
+// %foreignChain will be replaced by the foreign network name
 export const CONFIRMATIONS_STATUS_DESCRIPTION: { [key: string]: string } = {
   SUCCESS: '',
   SUCCESS_MESSAGE_FAILED:
-    'The specified transaction was included in a block,\nthe validators collected signatures and the cross-chain relay was executed correctly,\nbut the contained message execution failed.\nContact the support of the application you used to produce the transaction for the clarifications.',
-  FAILED:
-    'The specified transaction was included in a block,\nbut confirmations sent by a majority of validators\nfailed. The cross-chain relay request will not be\nprocessed. Contact to the validators by\nmessaging on %linkhttps://forum.poa.network/c/support',
-  PENDING:
-    'The specified transaction was included in a block. A\nmajority of validators sent confirmations which have\nnot yet been added to a block.',
-  WAITING_VALIDATORS:
-    'The specified transaction was included in a block.\nSome validators have sent confirmations, others are\nwaiting for chain finalization.\nCheck status again after a few blocks. If the issue still persists contact to the validators by messaging on %linkhttps://forum.poa.network/c/support',
-  SEARCHING:
-    'The specified transaction was included in a block. The app is looking for confirmations. Either\n1. Validators are waiting for chain finalization before sending their signatures.\n2. Validators are not active.\n3. The bridge was stopped.\nCheck status again after a few blocks. If the issue still persists contact to the validators by messaging on %linkhttps://forum.poa.network/c/support',
-  WAITING_CHAIN:
-    'The specified transaction was included in a block.\nValidators are waiting for chain finalization before\nsending their confirmations.'
-}
-
-// use %link to identify a link
-export const CONFIRMATIONS_STATUS_DESCRIPTION_HOME: { [key: string]: string } = {
-  SUCCESS: '',
-  SUCCESS_MESSAGE_FAILED:
-    'The specified transaction was included in a block,\nthe validators collected signatures and the cross-chain relay was executed correctly,\nbut the contained message execution failed.\nContact the support of the application you used to produce the transaction for the clarifications.',
+    'Signatures have been collected in the %homeChain and they were successfully sent to the %foreignChain but the contained message execution failed.',
   EXECUTION_FAILED:
-    'The specified transaction was included in a block\nand the validators collected signatures. The\n transaction with collected signatures was\nsent but did not succeed. Contact to the validators by messaging\non %linkhttps://forum.poa.network/c/support',
+    'Signatures have been collected in the %homeChain and they were sent to the %foreignChain but the transaction with signatures failed',
   EXECUTION_PENDING:
-    'The specified transaction was included in a block\nand the validators collected signatures. The\n transaction with collected signatures was\nsent but is not yet added to a block.',
-  EXECUTION_WAITING: ALM_HOME_TO_FOREIGN_MANUAL_EXECUTION
-    ? 'The specified transaction was included in a block\nand the validators collected signatures.\nNow the manual user action is required to complete message execution.\n Please, press the "Execute" button.'
-    : 'The specified transaction was included in a block\nand the validators collected signatures. Either\n1. One of the validators is waiting for chain finalization.\n2. A validator skipped its duty to relay signatures.\n3. The execution transaction is still pending (e.g. due to the gas price spike).\nCheck status again after a few blocks or force execution by pressing the "Execute" button.\nIf the issue still persists contact to the validators by messaging on %linkhttps://forum.poa.network/c/support',
+    'Signatures have been collected in the %homeChain and they were sent to the %foreignChain but the transaction is in the pending state (transactions congestion or low gas price)',
+  EXECUTION_WAITING: 'Execution waiting',
   FAILED:
-    'The specified transaction was included in a block,\nbut transactions with signatures sent by a majority of\nvalidators failed. The cross-chain relay request will\nnot be processed. Contact to the validators by\nmessaging on %linkhttps://forum.poa.network/c/support',
-  PENDING:
-    'The specified transaction was included in a block.\nA majority of validators sent signatures which have not\nyet been added to a block.',
-  WAITING_VALIDATORS:
-    'The specified transaction was included in a block.\nSome validators have sent signatures, others are\nwaiting for chain finalization.\nCheck status again after a few blocks. If the issue still persists contact to the validators by messaging on %linkhttps://forum.poa.network/c/support',
-  SEARCHING:
-    'The specified transaction was included in a block. The app is looking for confirmations. Either\n1. Validators are waiting for chain finalization before sending their signatures.\n2. Validators are not active.\n3. The bridge was stopped.\nCheck status again after a few blocks. If the issue still persists contact to the validators by messaging on %linkhttps://forum.poa.network/c/support',
-  WAITING_CHAIN:
-    'The specified transaction was included in a block.\nValidators are waiting for chain finalization\nbefore sending their signatures.'
+    'Some validators sent improper transactions as so they were failed, collected confirmations are not enough to execute the relay request',
+  PENDING: 'Some confirmations are in pending state',
+  WAITING: 'Validators are waiting for the chain finalization'
 }

alm/src/hooks/useBlockConfirmations.ts

@@ -3,9 +3,6 @@ import { TransactionReceipt } from 'web3-eth'
 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
@@ -20,25 +17,19 @@ export const useBlockConfirmations = ({ receipt, fromHome }: UseBlockConfirmatio
   const callRequireBlockConfirmations = async (
     contract: Contract,
     receipt: TransactionReceipt,
-    setResult: Function,
-    snapshotProvider: SnapshotProvider,
-    web3: Web3,
-    api: string
+    setResult: Function
   ) => {
-    const result = await getRequiredBlockConfirmations(contract, receipt.blockNumber, snapshotProvider, web3, api)
+    const result = await getRequiredBlockConfirmations(contract, receipt.blockNumber)
     setResult(result)
   }
 
   useEffect(
     () => {
       const bridgeContract = fromHome ? home.bridgeContract : foreign.bridgeContract
-      const snapshotProvider = fromHome ? homeSnapshotProvider : foreignSnapshotProvider
-      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)
+      if (!bridgeContract || !receipt) return
+      callRequireBlockConfirmations(bridgeContract, receipt, setBlockConfirmations)
     },
-    [home.bridgeContract, foreign.bridgeContract, receipt, fromHome, home.web3, foreign.web3]
+    [home.bridgeContract, foreign.bridgeContract, receipt, fromHome]
   )
 
   return {

alm/src/hooks/useClosestBlock.ts

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

alm/src/hooks/useMessageConfirmations.ts

@@ -3,6 +3,7 @@ import { TransactionReceipt } from 'web3-eth'
 import { MessageObject } from '../utils/web3'
 import { useEffect, useState } from 'react'
 import { EventData } from 'web3-eth-contract'
+import { getAffirmationsSigned, getMessagesSigned } from '../utils/contract'
 import {
   BLOCK_RANGE,
   CONFIRMATIONS_STATUS,
@@ -11,6 +12,9 @@ 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 {
@@ -25,20 +29,20 @@ export interface useMessageConfirmationsParams {
   message: MessageObject
   receipt: Maybe<TransactionReceipt>
   fromHome: boolean
-  homeStartBlock: Maybe<number>
-  foreignStartBlock: Maybe<number>
+  timestamp: number
   requiredSignatures: number
   validatorList: string[]
-  targetValidatorList: string[]
   blockConfirmations: number
 }
 
-export interface ConfirmationParam {
+export interface BasicConfirmationParam {
   validator: string
   status: string
+}
+
+export interface ConfirmationParam extends BasicConfirmationParam {
   txHash: string
   timestamp: number
-  signature?: string
 }
 
 export interface ExecutionData {
@@ -47,35 +51,30 @@ export interface ExecutionData {
   txHash: string
   timestamp: number
   executionResult: boolean
-  blockNumber: number
 }
 
 export const useMessageConfirmations = ({
   message,
   receipt,
   fromHome,
-  homeStartBlock,
-  foreignStartBlock,
+  timestamp,
   requiredSignatures,
   validatorList,
-  targetValidatorList,
   blockConfirmations
 }: useMessageConfirmationsParams) => {
   const { home, foreign } = useStateProvider()
-  const [confirmations, setConfirmations] = useState<ConfirmationParam[]>([])
+  const [confirmations, setConfirmations] = useState<Array<ConfirmationParam>>([])
   const [status, setStatus] = useState(CONFIRMATIONS_STATUS.UNDEFINED)
   const [waitingBlocks, setWaitingBlocks] = useState(false)
   const [waitingBlocksResolved, setWaitingBlocksResolved] = useState(false)
   const [signatureCollected, setSignatureCollected] = useState(false)
-  const [executionEventsFetched, setExecutionEventsFetched] = useState(false)
   const [collectedSignaturesEvent, setCollectedSignaturesEvent] = useState<Maybe<EventData>>(null)
   const [executionData, setExecutionData] = useState<ExecutionData>({
     status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
     validator: '',
     txHash: '',
     timestamp: 0,
-    executionResult: false,
-    blockNumber: 0
+    executionResult: false
   })
   const [waitingBlocksForExecution, setWaitingBlocksForExecution] = useState(false)
   const [waitingBlocksForExecutionResolved, setWaitingBlocksForExecutionResolved] = useState(false)
@@ -84,59 +83,43 @@ export const useMessageConfirmations = ({
   const [pendingConfirmations, setPendingConfirmations] = useState(false)
   const [pendingExecution, setPendingExecution] = useState(false)
 
-  const existsConfirmation = (confirmationArray: ConfirmationParam[]) =>
-    confirmationArray.some(
-      c => c.status !== VALIDATOR_CONFIRMATION_STATUS.UNDEFINED && c.status !== VALIDATOR_CONFIRMATION_STATUS.WAITING
-    )
-
-  // 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
+      if (!receipt || !blockConfirmations) return
 
-      let timeoutId: number
+      const subscriptions: Array<number> = []
+
+      const unsubscribe = () => {
+        subscriptions.forEach(s => {
+          clearTimeout(s)
+        })
+      }
 
       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
-      }))
 
-      const checkSignaturesWaitingForBLocks = () => {
-        const currentBlock = blockProvider.get()
+      checkSignaturesWaitingForBLocks(
+        targetBlock,
+        setWaitingBlocks,
+        setWaitingBlocksResolved,
+        validatorList,
+        setConfirmations,
+        blockProvider,
+        interval,
+        subscriptions
+      )
 
-        if (currentBlock && currentBlock >= targetBlock) {
-          setWaitingBlocksResolved(true)
-          setWaitingBlocks(false)
-        } else if (currentBlock) {
-          setWaitingBlocks(true)
-          setConfirmations(validatorsWaiting)
-          timeoutId = setTimeout(checkSignaturesWaitingForBLocks, interval)
-        } else {
-          timeoutId = setTimeout(checkSignaturesWaitingForBLocks, 500)
-        }
+      return () => {
+        unsubscribe()
+        blockProvider.stop()
       }
-
-      checkSignaturesWaitingForBLocks()
-
-      return () => clearTimeout(timeoutId)
     },
-    [blockConfirmations, fromHome, receipt, validatorList, waitingBlocksResolved]
+    [blockConfirmations, foreign.web3, fromHome, validatorList, home.web3, receipt]
   )
 
   // The collected signature event is only fetched once the signatures are collected on tx from home to foreign, to calculate if
@@ -144,40 +127,35 @@ export const useMessageConfirmations = ({
   // This is executed if the message is in Home to Foreign direction only
   useEffect(
     () => {
-      if (!fromHome || !receipt || !home.web3 || !home.bridgeContract || !signatureCollected) return
+      if (!fromHome || !receipt || !home.web3 || !signatureCollected) return
 
-      let timeoutId: number
-      let isCancelled = false
+      const subscriptions: Array<number> = []
 
-      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)
-        }
+      const unsubscribe = () => {
+        subscriptions.forEach(s => {
+          clearTimeout(s)
+        })
       }
 
-      getCollectedSignaturesEvent(receipt.blockNumber, receipt.blockNumber + BLOCK_RANGE)
+      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
+      )
 
       return () => {
-        clearTimeout(timeoutId)
-        isCancelled = true
+        unsubscribe()
+        homeBlockNumberProvider.stop()
       }
     },
     [fromHome, home.bridgeContract, home.web3, message.data, receipt, signatureCollected]
@@ -187,113 +165,66 @@ export const useMessageConfirmations = ({
   // This is executed if the message is in Home to Foreign direction only
   useEffect(
     () => {
-      if (!fromHome || !home.web3 || !collectedSignaturesEvent || !blockConfirmations) return
-      if (waitingBlocksForExecutionResolved) return
+      if (!fromHome || !home.web3 || !receipt || !collectedSignaturesEvent || !blockConfirmations) return
 
-      let timeoutId: number
+      const subscriptions: Array<number> = []
 
-      const targetBlock = collectedSignaturesEvent.blockNumber + blockConfirmations
-
-      const checkWaitingBlocksForExecution = () => {
-        const currentBlock = homeBlockNumberProvider.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)
-        } 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)
-        }
+      const unsubscribe = () => {
+        subscriptions.forEach(s => {
+          clearTimeout(s)
+        })
       }
 
-      checkWaitingBlocksForExecution()
+      homeBlockNumberProvider.start(home.web3)
+      const targetBlock = collectedSignaturesEvent.blockNumber + blockConfirmations
 
-      return () => clearTimeout(timeoutId)
+      checkWaitingBlocksForExecution(
+        homeBlockNumberProvider,
+        HOME_RPC_POLLING_INTERVAL,
+        targetBlock,
+        collectedSignaturesEvent,
+        setWaitingBlocksForExecution,
+        setWaitingBlocksForExecutionResolved,
+        setExecutionData,
+        subscriptions
+      )
+
+      return () => {
+        unsubscribe()
+        homeBlockNumberProvider.stop()
+      }
     },
-    [collectedSignaturesEvent, fromHome, blockConfirmations, home.web3, waitingBlocksForExecutionResolved]
+    [collectedSignaturesEvent, fromHome, blockConfirmations, home.web3, receipt]
   )
 
   // 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 || !homeStartBlock || !requiredSignatures || !home.web3 || !home.bridgeContract) return
-      if (!validatorList || !validatorList.length) return
+      if (!waitingBlocksResolved || !timestamp || !requiredSignatures) return
 
-      let timeoutId: number
-      let isCancelled = false
+      const subscriptions: Array<number> = []
 
-      if (fromHome) {
-        if (!targetValidatorList || !targetValidatorList.length) return
-        const msgHash = home.web3.utils.sha3(message.data)!
-        const allValidators = [...validatorList, ...targetValidatorList].filter((v, i, s) => s.indexOf(v) === i)
-        const manualConfirmations = []
-        for (let i = 0; i < allValidators.length; i++) {
-          try {
-            const overrideSignatures: {
-              [key: string]: string
-            } = require(`../snapshots/signatures_${allValidators[i]}.json`)
-            if (overrideSignatures[msgHash]) {
-              console.log(`Adding manual signature from ${allValidators[i]}`)
-              manualConfirmations.push({
-                status: VALIDATOR_CONFIRMATION_STATUS.MANUAL,
-                validator: allValidators[i],
-                timestamp: 0,
-                txHash: '',
-                signature: overrideSignatures[msgHash]
-              })
-            } else {
-              console.log(`No manual signature from ${allValidators[i]} was found`)
-            }
-          } catch (e) {
-            console.log(`Signatures overrides are not present for ${allValidators[i]}`)
-          }
-        }
-        setConfirmations(manualConfirmations)
+      const unsubscribe = () => {
+        subscriptions.forEach(s => {
+          clearTimeout(s)
+        })
       }
 
+      const confirmationContractMethod = fromHome ? getMessagesSigned : getAffirmationsSigned
+
       getConfirmationsForTx(
         message.data,
         home.web3,
         validatorList,
         home.bridgeContract,
-        fromHome,
+        confirmationContractMethod,
         setConfirmations,
         requiredSignatures,
         setSignatureCollected,
-        id => (timeoutId = id),
-        () => isCancelled,
-        homeStartBlock,
+        waitingBlocksResolved,
+        subscriptions,
+        timestamp,
         getValidatorFailedTransactionsForMessage,
         setFailedConfirmations,
         getValidatorPendingTransactionsForMessage,
@@ -302,8 +233,7 @@ export const useMessageConfirmations = ({
       )
 
       return () => {
-        clearTimeout(timeoutId)
-        isCancelled = true
+        unsubscribe()
       }
     },
     [
@@ -314,8 +244,7 @@ export const useMessageConfirmations = ({
       home.bridgeContract,
       requiredSignatures,
       waitingBlocksResolved,
-      homeStartBlock,
-      targetValidatorList
+      timestamp
     ]
   )
 
@@ -326,34 +255,38 @@ export const useMessageConfirmations = ({
     () => {
       if ((fromHome && !waitingBlocksForExecutionResolved) || (!fromHome && !waitingBlocksResolved)) return
 
-      const bridgeContract = fromHome ? foreign.bridgeContract : home.bridgeContract
-      const web3 = fromHome ? foreign.web3 : home.web3
-      const startBlock = fromHome ? foreignStartBlock : homeStartBlock
-      if (!startBlock || !bridgeContract || !web3) return
+      const subscriptions: Array<number> = []
 
-      let timeoutId: number
-      let isCancelled = false
+      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
 
       getFinalizationEvent(
-        fromHome,
         bridgeContract,
-        web3,
+        contractEvent,
+        providedWeb3,
         setExecutionData,
+        waitingBlocksResolved,
         message,
-        id => (timeoutId = id),
-        () => isCancelled,
-        startBlock,
+        interval,
+        subscriptions,
+        timestamp,
         collectedSignaturesEvent,
         getExecutionFailedTransactionForMessage,
         setFailedExecution,
         getExecutionPendingTransactionsForMessage,
-        setPendingExecution,
-        setExecutionEventsFetched
+        setPendingExecution
       )
 
       return () => {
-        clearTimeout(timeoutId)
-        isCancelled = true
+        unsubscribe()
       }
     },
     [
@@ -365,26 +298,19 @@ export const useMessageConfirmations = ({
       home.web3,
       waitingBlocksResolved,
       waitingBlocksForExecutionResolved,
-      collectedSignaturesEvent,
-      foreignStartBlock,
-      homeStartBlock
+      timestamp,
+      collectedSignaturesEvent
     ]
   )
 
   // Sets the message status based in the collected information
   useEffect(
     () => {
-      if (
-        executionData.status === VALIDATOR_CONFIRMATION_STATUS.EXECUTION_SUCCESS &&
-        existsConfirmation(confirmations)
-      ) {
+      if (executionData.status === VALIDATOR_CONFIRMATION_STATUS.SUCCESS) {
         const newStatus = executionData.executionResult
           ? CONFIRMATIONS_STATUS.SUCCESS
           : CONFIRMATIONS_STATUS.SUCCESS_MESSAGE_FAILED
         setStatus(newStatus)
-
-        foreignBlockNumberProvider.stop()
-        homeBlockNumberProvider.stop()
       } else if (signatureCollected) {
         if (fromHome) {
           if (waitingBlocksForExecution) {
@@ -393,24 +319,18 @@ export const useMessageConfirmations = ({
             setStatus(CONFIRMATIONS_STATUS.EXECUTION_FAILED)
           } else if (pendingExecution) {
             setStatus(CONFIRMATIONS_STATUS.EXECUTION_PENDING)
-          } else if (waitingBlocksForExecutionResolved) {
-            setStatus(CONFIRMATIONS_STATUS.EXECUTION_WAITING)
           } else {
-            setStatus(CONFIRMATIONS_STATUS.EXECUTION_WAITING)
+            setStatus(CONFIRMATIONS_STATUS.UNDEFINED)
           }
         } else {
           setStatus(CONFIRMATIONS_STATUS.UNDEFINED)
         }
       } else if (waitingBlocks) {
-        setStatus(CONFIRMATIONS_STATUS.WAITING_CHAIN)
+        setStatus(CONFIRMATIONS_STATUS.WAITING)
       } else if (failedConfirmations) {
         setStatus(CONFIRMATIONS_STATUS.FAILED)
       } else if (pendingConfirmations) {
         setStatus(CONFIRMATIONS_STATUS.PENDING)
-      } else if (waitingBlocksResolved && existsConfirmation(confirmations)) {
-        setStatus(CONFIRMATIONS_STATUS.WAITING_VALIDATORS)
-      } else if (waitingBlocksResolved) {
-        setStatus(CONFIRMATIONS_STATUS.SEARCHING)
       } else {
         setStatus(CONFIRMATIONS_STATUS.UNDEFINED)
       }
@@ -424,10 +344,7 @@ export const useMessageConfirmations = ({
       failedConfirmations,
       failedExecution,
       pendingConfirmations,
-      pendingExecution,
-      waitingBlocksResolved,
-      confirmations,
-      waitingBlocksForExecutionResolved
+      pendingExecution
     ]
   )
 
@@ -435,10 +352,6 @@ export const useMessageConfirmations = ({
     confirmations,
     status,
     signatureCollected,
-    executionData,
-    setExecutionData,
-    waitingBlocksResolved,
-    executionEventsFetched,
-    setPendingExecution
+    executionData
   }
 }

alm/src/hooks/useNetwork.ts

@@ -1,8 +1,7 @@
 import { useEffect, useState } from 'react'
-import { getChainId, getWeb3 } from '../utils/web3'
-import { SnapshotProvider } from '../services/SnapshotProvider'
+import { getWeb3 } from '../utils/web3'
 
-export const useNetwork = (url: string, snapshotProvider: SnapshotProvider) => {
+export const useNetwork = (url: string) => {
   const [loading, setLoading] = useState(true)
   const [chainId, setChainId] = useState(0)
   const web3 = getWeb3(url)
@@ -10,14 +9,14 @@ export const useNetwork = (url: string, snapshotProvider: SnapshotProvider) => {
   useEffect(
     () => {
       setLoading(true)
-      const getWeb3ChainId = async () => {
-        const id = await getChainId(web3, snapshotProvider)
+      const getChainId = async () => {
+        const id = await web3.eth.getChainId()
         setChainId(id)
         setLoading(false)
       }
-      getWeb3ChainId()
+      getChainId()
     },
-    [web3, snapshotProvider]
+    [web3.eth]
   )
 
   return {

alm/src/hooks/useTransactionFinder.ts

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

alm/src/hooks/useTransactionStatus.ts

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

alm/src/hooks/useValidatorContract.ts

@@ -4,13 +4,17 @@ import Web3 from 'web3'
 import { getRequiredSignatures, getValidatorAddress, getValidatorList } from '../utils/contract'
 import { BRIDGE_VALIDATORS_ABI } from '../abis'
 import { useStateProvider } from '../state/StateProvider'
-import { foreignSnapshotProvider, homeSnapshotProvider, SnapshotProvider } from '../services/SnapshotProvider'
-import { FOREIGN_EXPLORER_API, HOME_EXPLORER_API } from '../config/constants'
+import { TransactionReceipt } from 'web3-eth'
 
-export const useValidatorContract = (isHome: boolean, blockNumber: number | 'latest') => {
+export interface useValidatorContractParams {
+  fromHome: boolean
+  receipt: Maybe<TransactionReceipt>
+}
+
+export const useValidatorContract = ({ receipt, fromHome }: useValidatorContractParams) => {
   const [validatorContract, setValidatorContract] = useState<Maybe<Contract>>(null)
   const [requiredSignatures, setRequiredSignatures] = useState(0)
-  const [validatorList, setValidatorList] = useState<string[]>([])
+  const [validatorList, setValidatorList] = useState([])
 
   const { home, foreign } = useStateProvider()
 
@@ -23,50 +27,38 @@ export const useValidatorContract = (isHome: boolean, blockNumber: number | 'lat
 
   const callRequiredSignatures = async (
     contract: Maybe<Contract>,
-    blockNumber: number | 'latest',
-    setResult: Function,
-    snapshotProvider: SnapshotProvider,
-    web3: Web3,
-    api: string
+    receipt: TransactionReceipt,
+    setResult: Function
   ) => {
     if (!contract) return
-    const result = await getRequiredSignatures(contract, blockNumber, snapshotProvider, web3, api)
+    const result = await getRequiredSignatures(contract, receipt.blockNumber)
     setResult(result)
   }
 
-  const callValidatorList = async (
-    contract: Maybe<Contract>,
-    blockNumber: number | 'latest',
-    setResult: Function,
-    snapshotProvider: SnapshotProvider,
-    web3: Web3,
-    api: string
-  ) => {
+  const callValidatorList = async (contract: Maybe<Contract>, receipt: TransactionReceipt, setResult: Function) => {
     if (!contract) return
-    const result = await getValidatorList(contract, blockNumber, snapshotProvider, web3, api)
+    const result = await getValidatorList(contract, receipt.blockNumber)
     setResult(result)
   }
 
-  const web3 = isHome ? home.web3 : foreign.web3
-  const api = isHome ? HOME_EXPLORER_API : FOREIGN_EXPLORER_API
-  const bridgeContract = isHome ? home.bridgeContract : foreign.bridgeContract
-  const snapshotProvider = isHome ? 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)
     },
-    [web3, bridgeContract]
+    [home.web3, foreign.web3, home.bridgeContract, foreign.bridgeContract, fromHome]
   )
 
   useEffect(
     () => {
-      if (!web3 || !blockNumber) return
-      callRequiredSignatures(validatorContract, blockNumber, setRequiredSignatures, snapshotProvider, web3, api)
-      callValidatorList(validatorContract, blockNumber, setValidatorList, snapshotProvider, web3, api)
+      if (!receipt) return
+      callRequiredSignatures(validatorContract, receipt, setRequiredSignatures)
+      callValidatorList(validatorContract, receipt, setValidatorList)
     },
-    [validatorContract, blockNumber, web3, snapshotProvider, api]
+    [validatorContract, receipt]
   )
 
   return {

alm/src/services/BlockNumberProvider.ts

@@ -1,6 +1,6 @@
 import Web3 from 'web3'
 import differenceInMilliseconds from 'date-fns/differenceInMilliseconds'
-import { FOREIGN_RPC_POLLING_INTERVAL, HOME_RPC_POLLING_INTERVAL } from '../config/constants'
+import { HOME_RPC_POLLING_INTERVAL } from '../config/constants'
 
 export class BlockNumberProvider {
   private running: number
@@ -33,7 +33,7 @@ export class BlockNumberProvider {
   }
 
   stop() {
-    this.running = this.running > 0 ? this.running - 1 : 0
+    this.running = this.running - 1
 
     if (!this.running) {
       clearTimeout(this.ref)
@@ -61,4 +61,4 @@ export class BlockNumberProvider {
 }
 
 export const homeBlockNumberProvider = new BlockNumberProvider(HOME_RPC_POLLING_INTERVAL)
-export const foreignBlockNumberProvider = new BlockNumberProvider(FOREIGN_RPC_POLLING_INTERVAL)
+export const foreignBlockNumberProvider = new BlockNumberProvider(HOME_RPC_POLLING_INTERVAL)

alm/src/services/SnapshotProvider.ts

@@ -1,69 +0,0 @@
-const initialValue = {
-  chainId: 0,
-  RequiredBlockConfirmationChanged: [],
-  RequiredSignaturesChanged: [],
-  ValidatorAdded: [],
-  ValidatorRemoved: [],
-  snapshotBlockNumber: 0
-}
-
-export interface SnapshotEvent {
-  blockNumber: number
-  returnValues: any
-}
-
-export interface SnapshotValidatorEvent {
-  blockNumber: number
-  returnValues: any
-  event: string
-}
-
-export interface Snapshot {
-  chainId: number
-  RequiredBlockConfirmationChanged: SnapshotEvent[]
-  RequiredSignaturesChanged: SnapshotEvent[]
-  ValidatorAdded: SnapshotValidatorEvent[]
-  ValidatorRemoved: SnapshotValidatorEvent[]
-  snapshotBlockNumber: number
-}
-
-export class SnapshotProvider {
-  private data: Snapshot
-
-  constructor(side: string) {
-    let data = initialValue
-    try {
-      data = require(`../snapshots/${side}.json`)
-    } catch (e) {
-      console.log('Snapshot not found')
-    }
-    this.data = data
-  }
-
-  chainId() {
-    return this.data.chainId
-  }
-
-  snapshotBlockNumber() {
-    return this.data.snapshotBlockNumber
-  }
-
-  requiredBlockConfirmationEvents(toBlock: number) {
-    return this.data.RequiredBlockConfirmationChanged.filter(e => e.blockNumber <= toBlock)
-  }
-
-  requiredSignaturesEvents(toBlock: number) {
-    return this.data.RequiredSignaturesChanged.filter(e => e.blockNumber <= toBlock)
-  }
-
-  validatorAddedEvents(fromBlock: number) {
-    return this.data.ValidatorAdded.filter(e => e.blockNumber >= fromBlock)
-  }
-
-  validatorRemovedEvents(fromBlock: number) {
-    return this.data.ValidatorRemoved.filter(e => e.blockNumber >= fromBlock)
-  }
-}
-
-export const homeSnapshotProvider = new SnapshotProvider('home')
-export const foreignSnapshotProvider = new SnapshotProvider('foreign')

alm/src/state/StateProvider.tsx

@@ -11,7 +11,6 @@ import {
 import Web3 from 'web3'
 import { useBridgeContracts } from '../hooks/useBridgeContracts'
 import { Contract } from 'web3-eth-contract'
-import { foreignSnapshotProvider, homeSnapshotProvider } from '../services/SnapshotProvider'
 
 export interface BaseNetworkParams {
   chainId: number
@@ -48,8 +47,8 @@ const initialState = {
 const StateContext = createContext<StateContext>(initialState)
 
 export const StateProvider = ({ children }: { children: ReactNode }) => {
-  const homeNetwork = useNetwork(HOME_RPC_URL, homeSnapshotProvider)
-  const foreignNetwork = useNetwork(FOREIGN_RPC_URL, foreignSnapshotProvider)
+  const homeNetwork = useNetwork(HOME_RPC_URL)
+  const foreignNetwork = useNetwork(FOREIGN_RPC_URL)
   const { homeBridge, foreignBridge } = useBridgeContracts({
     homeWeb3: homeNetwork.web3,
     foreignWeb3: foreignNetwork.web3

alm/src/themes/GlobalStyle.tsx

@@ -28,7 +28,5 @@ export const GlobalStyle = createGlobalStyle<{ theme: ThemeType }>`
     --not-required-bg-color: ${props => props.theme.notRequired.backgroundColor};
     --failed-color: ${props => props.theme.failed.textColor};
     --failed-bg-color: ${props => props.theme.failed.backgroundColor};
-    --warning-color: ${props => props.theme.warning.textColor};
-    --warning-bg-color: ${props => props.theme.warning.backgroundColor};
   }
 `

alm/src/themes/Light.ts

@@ -17,10 +17,6 @@ const theme = {
   failed: {
     textColor: '#de4437',
     backgroundColor: 'rgba(222,68,55,.1)'
-  },
-  warning: {
-    textColor: '#ffa758',
-    backgroundColor: 'rgba(222,68,55,.1)'
   }
 }
 export default theme

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

@@ -1,469 +0,0 @@
-import 'jest'
-import { getRequiredBlockConfirmations, getRequiredSignatures, getValidatorList } from '../contract'
-import { Contract } from 'web3-eth-contract'
-import { SnapshotProvider } from '../../services/SnapshotProvider'
-
-describe('getRequiredBlockConfirmations', () => {
-  const methodsBuilder = (value: string) => ({
-    requiredBlockConfirmations: () => {
-      return {
-        call: () => {
-          return value
-        }
-      }
-    }
-  })
-
-  test('Should call requiredBlockConfirmations method if no events present', async () => {
-    const contract = ({
-      getPastEvents: async () => {
-        return []
-      },
-      methods: methodsBuilder('1')
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      requiredBlockConfirmationEvents: () => {
-        return []
-      },
-      snapshotBlockNumber: () => {
-        return 10
-      }
-    } as unknown) as SnapshotProvider
-
-    const result = await getRequiredBlockConfirmations(contract, 10, snapshotProvider)
-
-    expect(result).toEqual(1)
-  })
-  test('Should not call to get events if block number was included in the snapshot', async () => {
-    const contract = ({
-      getPastEvents: jest.fn().mockImplementation(async () => []),
-      methods: methodsBuilder('3')
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      requiredBlockConfirmationEvents: () => {
-        return [
-          {
-            blockNumber: 8,
-            returnValues: {
-              requiredBlockConfirmations: '1'
-            }
-          }
-        ]
-      },
-      snapshotBlockNumber: () => {
-        return 15
-      }
-    } as unknown) as SnapshotProvider
-
-    const result = await getRequiredBlockConfirmations(contract, 10, snapshotProvider)
-
-    expect(result).toEqual(1)
-    expect(contract.getPastEvents).toBeCalledTimes(0)
-  })
-  test('Should call to get events if block number was not included in the snapshot', async () => {
-    const contract = ({
-      getPastEvents: jest.fn().mockImplementation(async () => [
-        {
-          blockNumber: 9,
-          returnValues: {
-            requiredBlockConfirmations: '2'
-          }
-        }
-      ]),
-      methods: methodsBuilder('3')
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      requiredBlockConfirmationEvents: () => {
-        return [
-          {
-            blockNumber: 8,
-            returnValues: {
-              requiredBlockConfirmations: '1'
-            }
-          }
-        ]
-      },
-      snapshotBlockNumber: () => {
-        return 8
-      }
-    } as unknown) as SnapshotProvider
-
-    const result = await getRequiredBlockConfirmations(contract, 10, snapshotProvider)
-
-    expect(result).toEqual(2)
-    expect(contract.getPastEvents).toBeCalledTimes(1)
-    expect(contract.getPastEvents).toHaveBeenCalledWith('RequiredBlockConfirmationChanged', {
-      fromBlock: 9,
-      toBlock: 10
-    })
-  })
-  test('Should use the most updated event', async () => {
-    const contract = ({
-      getPastEvents: jest.fn().mockImplementation(async () => [
-        {
-          blockNumber: 9,
-          returnValues: {
-            requiredBlockConfirmations: '2'
-          }
-        },
-        {
-          blockNumber: 11,
-          returnValues: {
-            requiredBlockConfirmations: '3'
-          }
-        }
-      ]),
-      methods: methodsBuilder('3')
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      requiredBlockConfirmationEvents: () => {
-        return []
-      },
-      snapshotBlockNumber: () => {
-        return 11
-      }
-    } as unknown) as SnapshotProvider
-
-    const result = await getRequiredBlockConfirmations(contract, 15, snapshotProvider)
-
-    expect(result).toEqual(3)
-    expect(contract.getPastEvents).toBeCalledTimes(1)
-    expect(contract.getPastEvents).toHaveBeenCalledWith('RequiredBlockConfirmationChanged', {
-      fromBlock: 12,
-      toBlock: 15
-    })
-  })
-})
-describe('getRequiredSignatures', () => {
-  test('Should not call to get events if block number was included in the snapshot', async () => {
-    const contract = ({
-      getPastEvents: jest.fn().mockImplementation(async () => [])
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      requiredSignaturesEvents: () => {
-        return [
-          {
-            blockNumber: 7,
-            returnValues: {
-              requiredSignatures: '1'
-            }
-          },
-          {
-            blockNumber: 8,
-            returnValues: {
-              requiredSignatures: '2'
-            }
-          }
-        ]
-      },
-      snapshotBlockNumber: () => {
-        return 10
-      }
-    } as unknown) as SnapshotProvider
-
-    const result = await getRequiredSignatures(contract, 10, snapshotProvider)
-
-    expect(result).toEqual(2)
-    expect(contract.getPastEvents).toBeCalledTimes(0)
-  })
-  test('Should call to get events if block number is higher than the snapshot block number', async () => {
-    const contract = ({
-      getPastEvents: jest.fn().mockImplementation(async () => [
-        {
-          blockNumber: 15,
-          returnValues: {
-            requiredSignatures: '3'
-          }
-        }
-      ])
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      requiredSignaturesEvents: () => {
-        return [
-          {
-            blockNumber: 7,
-            returnValues: {
-              requiredSignatures: '1'
-            }
-          },
-          {
-            blockNumber: 8,
-            returnValues: {
-              requiredSignatures: '2'
-            }
-          }
-        ]
-      },
-      snapshotBlockNumber: () => {
-        return 10
-      }
-    } as unknown) as SnapshotProvider
-
-    const result = await getRequiredSignatures(contract, 20, snapshotProvider)
-
-    expect(result).toEqual(3)
-    expect(contract.getPastEvents).toBeCalledTimes(1)
-    expect(contract.getPastEvents).toHaveBeenCalledWith('RequiredSignaturesChanged', {
-      fromBlock: 11,
-      toBlock: 20
-    })
-  })
-  test('Should use the most updated event before the block number', async () => {
-    const contract = ({
-      getPastEvents: jest.fn().mockImplementation(async () => [
-        {
-          blockNumber: 15,
-          returnValues: {
-            requiredSignatures: '4'
-          }
-        }
-      ])
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      requiredSignaturesEvents: () => {
-        return [
-          {
-            blockNumber: 5,
-            returnValues: {
-              requiredSignatures: '1'
-            }
-          },
-          {
-            blockNumber: 6,
-            returnValues: {
-              requiredSignatures: '2'
-            }
-          }
-        ]
-      },
-      snapshotBlockNumber: () => {
-        return 10
-      }
-    } as unknown) as SnapshotProvider
-
-    const result = await getRequiredSignatures(contract, 7, snapshotProvider)
-
-    expect(result).toEqual(2)
-    expect(contract.getPastEvents).toBeCalledTimes(0)
-  })
-})
-describe('getValidatorList', () => {
-  const validator1 = '0x45b96809336A8b714BFbdAB3E4B5e0fe5d839908'
-  const validator2 = '0xAe8bFfc8BBc6AAa9E21ED1E4e4957fe798BEA25f'
-  const validator3 = '0x285A6eB779be4db94dA65e2F3518B1c5F0f71244'
-  const methodsBuilder = (value: string[]) => ({
-    validatorList: () => {
-      return {
-        call: () => {
-          return value
-        }
-      }
-    }
-  })
-  test('Should return the current validator list if no events found', async () => {
-    const currentValidators = [validator1, validator2, validator3]
-    const contract = ({
-      getPastEvents: jest.fn().mockImplementation(async () => []),
-      methods: methodsBuilder(currentValidators)
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      validatorAddedEvents: () => {
-        return []
-      },
-      validatorRemovedEvents: () => {
-        return []
-      },
-      snapshotBlockNumber: () => {
-        return 10
-      }
-    } as unknown) as SnapshotProvider
-
-    const list = await getValidatorList(contract, 20, snapshotProvider)
-
-    expect(list.length).toEqual(3)
-    expect(list).toEqual(expect.arrayContaining(currentValidators))
-    expect(contract.getPastEvents).toBeCalledTimes(2)
-    expect(contract.getPastEvents).toHaveBeenCalledWith('ValidatorAdded', {
-      fromBlock: 20
-    })
-    expect(contract.getPastEvents).toHaveBeenCalledWith('ValidatorRemoved', {
-      fromBlock: 20
-    })
-  })
-  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(async () => []),
-      methods: methodsBuilder(currentValidators)
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      validatorAddedEvents: () => {
-        return [
-          {
-            blockNumber: 9,
-            returnValues: {
-              validator: validator3
-            },
-            event: 'ValidatorAdded'
-          }
-        ]
-      },
-      validatorRemovedEvents: () => {
-        return []
-      },
-      snapshotBlockNumber: () => {
-        return 10
-      }
-    } as unknown) as SnapshotProvider
-
-    const list = await getValidatorList(contract, 5, snapshotProvider)
-
-    expect(list.length).toEqual(2)
-    expect(list).toEqual(expect.arrayContaining([validator1, validator2]))
-    expect(contract.getPastEvents).toBeCalledTimes(2)
-    expect(contract.getPastEvents).toHaveBeenCalledWith('ValidatorAdded', {
-      fromBlock: 11
-    })
-    expect(contract.getPastEvents).toHaveBeenCalledWith('ValidatorRemoved', {
-      fromBlock: 11
-    })
-  })
-  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(async event => {
-        if (event === 'ValidatorAdded') {
-          return [
-            {
-              blockNumber: 9,
-              returnValues: {
-                validator: validator3
-              },
-              event: 'ValidatorAdded'
-            }
-          ]
-        } else {
-          return []
-        }
-      }),
-      methods: methodsBuilder(currentValidators)
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      validatorAddedEvents: () => {
-        return []
-      },
-      validatorRemovedEvents: () => {
-        return []
-      },
-      snapshotBlockNumber: () => {
-        return 10
-      }
-    } as unknown) as SnapshotProvider
-
-    const list = await getValidatorList(contract, 15, snapshotProvider)
-
-    expect(list.length).toEqual(2)
-    expect(list).toEqual(expect.arrayContaining([validator1, validator2]))
-    expect(contract.getPastEvents).toBeCalledTimes(2)
-    expect(contract.getPastEvents).toHaveBeenCalledWith('ValidatorAdded', {
-      fromBlock: 15
-    })
-    expect(contract.getPastEvents).toHaveBeenCalledWith('ValidatorRemoved', {
-      fromBlock: 15
-    })
-  })
-  test('If validator was removed later from snapshot it should include it', async () => {
-    const currentValidators = [validator1, validator2]
-    const contract = ({
-      getPastEvents: jest.fn().mockImplementation(async () => []),
-      methods: methodsBuilder(currentValidators)
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      validatorAddedEvents: () => {
-        return []
-      },
-      validatorRemovedEvents: () => {
-        return [
-          {
-            blockNumber: 9,
-            returnValues: {
-              validator: validator3
-            },
-            event: 'ValidatorRemoved'
-          }
-        ]
-      },
-      snapshotBlockNumber: () => {
-        return 10
-      }
-    } as unknown) as SnapshotProvider
-
-    const list = await getValidatorList(contract, 5, snapshotProvider)
-
-    expect(list.length).toEqual(3)
-    expect(list).toEqual(expect.arrayContaining([validator1, validator2, validator3]))
-    expect(contract.getPastEvents).toBeCalledTimes(2)
-    expect(contract.getPastEvents).toHaveBeenCalledWith('ValidatorAdded', {
-      fromBlock: 11
-    })
-    expect(contract.getPastEvents).toHaveBeenCalledWith('ValidatorRemoved', {
-      fromBlock: 11
-    })
-  })
-  test('If validator was removed later from chain it should include it', async () => {
-    const currentValidators = [validator1, validator2]
-    const contract = ({
-      getPastEvents: jest.fn().mockImplementation(async event => {
-        if (event === 'ValidatorRemoved') {
-          return [
-            {
-              blockNumber: 9,
-              returnValues: {
-                validator: validator3
-              },
-              event: 'ValidatorRemoved'
-            }
-          ]
-        } else {
-          return []
-        }
-      }),
-      methods: methodsBuilder(currentValidators)
-    } as unknown) as Contract
-
-    const snapshotProvider = ({
-      validatorAddedEvents: () => {
-        return []
-      },
-      validatorRemovedEvents: () => {
-        return []
-      },
-      snapshotBlockNumber: () => {
-        return 10
-      }
-    } as unknown) as SnapshotProvider
-
-    const list = await getValidatorList(contract, 15, snapshotProvider)
-
-    expect(list.length).toEqual(3)
-    expect(list).toEqual(expect.arrayContaining([validator1, validator2, validator3]))
-    expect(contract.getPastEvents).toBeCalledTimes(2)
-    expect(contract.getPastEvents).toHaveBeenCalledWith('ValidatorAdded', {
-      fromBlock: 15
-    })
-    expect(contract.getPastEvents).toHaveBeenCalledWith('ValidatorRemoved', {
-      fromBlock: 15
-    })
-  })
-})

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

@@ -1,172 +0,0 @@
-import 'jest'
-import {
-  getFailedTransactions,
-  getSuccessTransactions,
-  filterValidatorSignatureTransaction,
-  getExecutionFailedTransactionForMessage,
-  APITransaction,
-  getValidatorPendingTransactionsForMessage,
-  getExecutionPendingTransactionsForMessage
-} from '../explorer'
-import { EXECUTE_AFFIRMATION_HASH, EXECUTE_SIGNATURES_HASH, SUBMIT_SIGNATURE_HASH } from '../../config/constants'
-
-const messageData = '0x123456'
-const OTHER_HASH = 'aabbccdd'
-const bridgeAddress = '0xFe446bEF1DbF7AFE24E81e05BC8B271C1BA9a560'
-const otherAddress = '0xD4075FB57fCf038bFc702c915Ef9592534bED5c1'
-const validator1 = '0x45b96809336A8b714BFbdAB3E4B5e0fe5d839908'
-const validator2 = '0xAe8bFfc8BBc6AAa9E21ED1E4e4957fe798BEA25f'
-const validator3 = '0x285A6eB779be4db94dA65e2F3518B1c5F0f71244'
-
-describe('getFailedTransactions', () => {
-  test('should only return failed transactions', async () => {
-    const to = otherAddress
-    const transactions = [
-      { isError: '0', to, from: validator1 },
-      { isError: '1', to, from: validator1 },
-      { isError: '0', to, from: validator2 },
-      { isError: '1', to, from: validator2 },
-      { isError: '1', to, from: validator3 }
-    ]
-
-    const fetchAccountTransactions = jest.fn().mockImplementation(() => transactions)
-    const result = await getFailedTransactions(validator1, to, 0, 1, '', fetchAccountTransactions)
-    expect(result.length).toEqual(1)
-  })
-})
-describe('getSuccessTransactions', () => {
-  test('should only return success transactions', async () => {
-    const to = otherAddress
-    const transactions = [
-      { isError: '0', to, from: validator1 },
-      { isError: '1', to, from: validator1 },
-      { isError: '0', to, from: validator2 },
-      { isError: '1', to, from: validator2 },
-      { isError: '1', to, from: validator3 }
-    ]
-
-    const fetchAccountTransactions = jest.fn().mockImplementation(() => transactions)
-    const result = await getSuccessTransactions(validator1, to, 0, 1, '', fetchAccountTransactions)
-    expect(result.length).toEqual(1)
-  })
-})
-describe('filterValidatorSignatureTransaction', () => {
-  test('should return submit signatures related transaction', () => {
-    const transactions = [
-      { input: `0x${SUBMIT_SIGNATURE_HASH}112233` },
-      { input: `0x${SUBMIT_SIGNATURE_HASH}123456` },
-      { input: `0x${OTHER_HASH}123456` },
-      { input: `0x${OTHER_HASH}112233` }
-    ] as APITransaction[]
-
-    const result = filterValidatorSignatureTransaction(transactions, messageData)
-    expect(result.length).toEqual(1)
-    expect(result[0]).toEqual({ input: `0x${SUBMIT_SIGNATURE_HASH}123456` })
-  })
-  test('should return execute affirmation related transaction', () => {
-    const transactions = [
-      { input: `0x${EXECUTE_AFFIRMATION_HASH}112233` },
-      { input: `0x${EXECUTE_AFFIRMATION_HASH}123456` },
-      { input: `0x${OTHER_HASH}123456` },
-      { input: `0x${OTHER_HASH}112233` }
-    ] as APITransaction[]
-
-    const result = filterValidatorSignatureTransaction(transactions, messageData)
-    expect(result.length).toEqual(1)
-    expect(result[0]).toEqual({ input: `0x${EXECUTE_AFFIRMATION_HASH}123456` })
-  })
-})
-describe('getExecutionFailedTransactionForMessage', () => {
-  test('should return failed transaction related to signatures execution', async () => {
-    const transactions = [
-      { input: `0x${EXECUTE_SIGNATURES_HASH}112233` },
-      { input: `0x${EXECUTE_SIGNATURES_HASH}123456` },
-      { input: `0x${OTHER_HASH}123456` },
-      { input: `0x${OTHER_HASH}112233` }
-    ] as APITransaction[]
-    const fetchAccountTransactions = jest.fn().mockImplementation(() => transactions)
-
-    const result = await getExecutionFailedTransactionForMessage(
-      {
-        account: '',
-        to: '',
-        messageData,
-        startBlock: 0,
-        endBlock: 1
-      },
-      fetchAccountTransactions
-    )
-    expect(result.length).toEqual(1)
-    expect(result[0]).toEqual({ input: `0x${EXECUTE_SIGNATURES_HASH}123456` })
-  })
-})
-describe('getValidatorPendingTransactionsForMessage', () => {
-  test('should return pending transaction for submit signature transaction', async () => {
-    const transactions = [
-      { input: `0x${SUBMIT_SIGNATURE_HASH}112233`, to: bridgeAddress },
-      { input: `0x${SUBMIT_SIGNATURE_HASH}123456`, to: bridgeAddress },
-      { input: `0x${SUBMIT_SIGNATURE_HASH}123456`, to: otherAddress },
-      { input: `0x${OTHER_HASH}123456`, to: bridgeAddress },
-      { input: `0x${OTHER_HASH}112233`, to: bridgeAddress }
-    ] as APITransaction[]
-    const fetchAccountTransactions = jest.fn().mockImplementation(() => transactions)
-
-    const result = await getValidatorPendingTransactionsForMessage(
-      {
-        account: '',
-        to: bridgeAddress,
-        messageData
-      },
-      fetchAccountTransactions
-    )
-
-    expect(result.length).toEqual(1)
-    expect(result[0]).toEqual({ input: `0x${SUBMIT_SIGNATURE_HASH}123456`, to: bridgeAddress })
-  })
-  test('should return pending transaction for execute affirmation transaction', async () => {
-    const transactions = [
-      { input: `0x${EXECUTE_AFFIRMATION_HASH}112233`, to: bridgeAddress },
-      { input: `0x${EXECUTE_AFFIRMATION_HASH}123456`, to: bridgeAddress },
-      { input: `0x${EXECUTE_AFFIRMATION_HASH}123456`, to: otherAddress },
-      { input: `0x${OTHER_HASH}123456`, to: bridgeAddress },
-      { input: `0x${OTHER_HASH}112233`, to: bridgeAddress }
-    ] as APITransaction[]
-    const fetchAccountTransactions = jest.fn().mockImplementation(() => transactions)
-
-    const result = await getValidatorPendingTransactionsForMessage(
-      {
-        account: '',
-        to: bridgeAddress,
-        messageData
-      },
-      fetchAccountTransactions
-    )
-
-    expect(result.length).toEqual(1)
-    expect(result[0]).toEqual({ input: `0x${EXECUTE_AFFIRMATION_HASH}123456`, to: bridgeAddress })
-  })
-})
-describe('getExecutionPendingTransactionsForMessage', () => {
-  test('should return pending transaction for signatures execution transaction', async () => {
-    const transactions = [
-      { input: `0x${EXECUTE_SIGNATURES_HASH}112233`, to: bridgeAddress },
-      { input: `0x${EXECUTE_SIGNATURES_HASH}123456`, to: bridgeAddress },
-      { input: `0x${EXECUTE_SIGNATURES_HASH}123456`, to: otherAddress },
-      { input: `0x${OTHER_HASH}123456`, to: bridgeAddress },
-      { input: `0x${OTHER_HASH}112233`, to: bridgeAddress }
-    ] as APITransaction[]
-    const fetchAccountTransactions = jest.fn().mockImplementation(() => transactions)
-
-    const result = await getExecutionPendingTransactionsForMessage(
-      {
-        account: '',
-        to: bridgeAddress,
-        messageData
-      },
-      fetchAccountTransactions
-    )
-
-    expect(result.length).toEqual(1)
-    expect(result[0]).toEqual({ input: `0x${EXECUTE_SIGNATURES_HASH}123456`, to: bridgeAddress })
-  })
-})

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

@@ -1,830 +0,0 @@
-import 'jest'
-import { getConfirmationsForTx } from '../getConfirmationsForTx'
-import * as helpers from '../validatorConfirmationHelpers'
-import Web3 from 'web3'
-import { Contract } from 'web3-eth-contract'
-import { APIPendingTransaction, APITransaction } from '../explorer'
-import { VALIDATOR_CONFIRMATION_STATUS } from '../../config/constants'
-import { ConfirmationParam } from '../../hooks/useMessageConfirmations'
-
-jest.mock('../validatorConfirmationHelpers')
-
-const getSuccessExecutionTransaction = helpers.getSuccessExecutionTransaction as jest.Mock<any>
-const getValidatorConfirmation = helpers.getValidatorConfirmation as jest.Mock<any>
-const getValidatorFailedTransaction = helpers.getValidatorFailedTransaction as jest.Mock<any>
-const getValidatorPendingTransaction = helpers.getValidatorPendingTransaction as jest.Mock<any>
-
-const messageData = '0x111111111'
-const web3 = {
-  utils: {
-    soliditySha3Raw: (data: string) => `0xaaaa${data.replace('0x', '')}`
-  },
-  eth: {
-    accounts: new Web3().eth.accounts
-  }
-} as Web3
-const validator1 = '0x45b96809336A8b714BFbdAB3E4B5e0fe5d839908'
-const validator2 = '0xAe8bFfc8BBc6AAa9E21ED1E4e4957fe798BEA25f'
-const validator3 = '0x285A6eB779be4db94dA65e2F3518B1c5F0f71244'
-const validatorList = [validator1, validator2, validator3]
-const signature =
-  '0x6f5b74905669999f1abdb52e1e215506907e1849aac7b31854da458b33a5954e15b165007c3703cfd16e61ca46a96a56727ed11fa47be359d3834515accd016e1b'
-const bridgeContract = {
-  methods: {
-    signature: () => ({
-      call: () => signature
-    })
-  }
-} as Contract
-const requiredSignatures = 2
-const isCancelled = () => false
-let subscriptions: Array<number> = []
-const timestamp = 1594045859
-const getFailedTransactions = (): Promise<APITransaction[]> => Promise.resolve([])
-const getPendingTransactions = (): Promise<APIPendingTransaction[]> => Promise.resolve([])
-const getSuccessTransactions = (): Promise<APITransaction[]> => Promise.resolve([])
-
-const unsubscribe = () => {
-  subscriptions.forEach(s => {
-    clearTimeout(s)
-  })
-}
-
-beforeEach(() => {
-  // Clear all instances and calls to constructor and all methods:
-  getSuccessExecutionTransaction.mockClear()
-  getValidatorConfirmation.mockClear()
-  getValidatorFailedTransaction.mockClear()
-  getValidatorPendingTransaction.mockClear()
-  subscriptions = []
-})
-describe('getConfirmationsForTx', () => {
-  test('should set validator confirmations status when signatures collected even if validator transactions not found yet and set remaining validator as not required', async () => {
-    getValidatorConfirmation.mockImplementation(() => async (validator: string) => ({
-      validator,
-      status: validator !== validator3 ? VALIDATOR_CONFIRMATION_STATUS.SUCCESS : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
-    }))
-    getSuccessExecutionTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
-      txHash: '',
-      timestamp: 0
-    }))
-    getValidatorFailedTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: '',
-      timestamp: 0
-    }))
-    getValidatorPendingTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: '',
-      timestamp: 0
-    }))
-
-    const setResult = jest.fn()
-    const setSignatureCollected = jest.fn()
-    const setFailedConfirmations = jest.fn()
-    const setPendingConfirmations = jest.fn()
-
-    await getConfirmationsForTx(
-      messageData,
-      web3,
-      validatorList,
-      bridgeContract,
-      true,
-      setResult,
-      requiredSignatures,
-      setSignatureCollected,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      getFailedTransactions,
-      setFailedConfirmations,
-      getPendingTransactions,
-      setPendingConfirmations,
-      getSuccessTransactions
-    )
-
-    unsubscribe()
-
-    expect(subscriptions.length).toEqual(1)
-    expect(setResult).toBeCalledTimes(2)
-    expect(getValidatorConfirmation).toBeCalledTimes(1)
-    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
-    expect(setSignatureCollected).toBeCalledTimes(1)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual(true)
-
-    expect(getValidatorFailedTransaction).toBeCalledTimes(1)
-    expect(setFailedConfirmations).toBeCalledTimes(1)
-    expect(setFailedConfirmations.mock.calls[0][0]).toEqual(false)
-
-    expect(getValidatorPendingTransaction).toBeCalledTimes(0)
-    expect(setPendingConfirmations).toBeCalledTimes(1)
-    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(false)
-
-    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.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, txHash: '', timestamp: 0 }
-      ])
-    )
-  })
-  test('should set validator confirmations status when signatures not collected even if validator transactions not found yet', async () => {
-    getValidatorConfirmation.mockImplementation(() => async (validator: string) => ({
-      validator,
-      status: validator === validator3 ? VALIDATOR_CONFIRMATION_STATUS.SUCCESS : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
-    }))
-    getSuccessExecutionTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
-      txHash: '',
-      timestamp: 0
-    }))
-    getValidatorFailedTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: '',
-      timestamp: 0
-    }))
-    getValidatorPendingTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: '',
-      timestamp: 0
-    }))
-
-    const setResult = jest.fn()
-    const setSignatureCollected = jest.fn()
-    const setFailedConfirmations = jest.fn()
-    const setPendingConfirmations = jest.fn()
-
-    await getConfirmationsForTx(
-      messageData,
-      web3,
-      validatorList,
-      bridgeContract,
-      true,
-      setResult,
-      requiredSignatures,
-      setSignatureCollected,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      getFailedTransactions,
-      setFailedConfirmations,
-      getPendingTransactions,
-      setPendingConfirmations,
-      getSuccessTransactions
-    )
-
-    unsubscribe()
-
-    expect(setResult).toBeCalledTimes(1)
-    expect(getValidatorConfirmation).toBeCalledTimes(1)
-    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
-    expect(setSignatureCollected).toBeCalledTimes(1)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual(false)
-
-    expect(getValidatorFailedTransaction).toBeCalledTimes(1)
-    expect(setFailedConfirmations).toBeCalledTimes(1)
-    expect(setFailedConfirmations.mock.calls[0][0]).toEqual(false)
-
-    expect(getValidatorPendingTransaction).toBeCalledTimes(1)
-    expect(setPendingConfirmations).toBeCalledTimes(1)
-    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(false)
-  })
-  test('should set validator confirmations status, validator transactions and not retry', async () => {
-    getValidatorConfirmation.mockImplementation(() => async (validator: string) => ({
-      validator,
-      status: validator !== validator3 ? VALIDATOR_CONFIRMATION_STATUS.SUCCESS : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
-    }))
-    getSuccessExecutionTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
-      txHash: validatorData.validator !== validator3 ? '0x123' : '',
-      timestamp: validatorData.validator !== validator3 ? 123 : 0
-    }))
-    getValidatorFailedTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: '',
-      timestamp: 0
-    }))
-    getValidatorPendingTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: '',
-      timestamp: 0
-    }))
-
-    const setResult = jest.fn()
-    const setSignatureCollected = jest.fn()
-    const setFailedConfirmations = jest.fn()
-    const setPendingConfirmations = jest.fn()
-
-    await getConfirmationsForTx(
-      messageData,
-      web3,
-      validatorList,
-      bridgeContract,
-      true,
-      setResult,
-      requiredSignatures,
-      setSignatureCollected,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      getFailedTransactions,
-      setFailedConfirmations,
-      getPendingTransactions,
-      setPendingConfirmations,
-      getSuccessTransactions
-    )
-
-    unsubscribe()
-
-    expect(subscriptions.length).toEqual(0)
-    expect(setResult).toBeCalledTimes(3)
-    expect(getValidatorConfirmation).toBeCalledTimes(1)
-    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
-    expect(setSignatureCollected).toBeCalledTimes(1)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual(true)
-
-    expect(getValidatorFailedTransaction).toBeCalledTimes(1)
-    expect(setFailedConfirmations).toBeCalledTimes(1)
-    expect(setFailedConfirmations.mock.calls[0][0]).toEqual(false)
-
-    expect(getValidatorPendingTransaction).toBeCalledTimes(0)
-    expect(setPendingConfirmations).toBeCalledTimes(1)
-    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(false)
-
-    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, txHash: '0x123', timestamp: 123 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-    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 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.NOT_REQUIRED, txHash: '', timestamp: 0 }
-      ])
-    )
-  })
-  test('should set validator confirmations status, validator transactions, keep failed found transaction and not retry', async () => {
-    const validator4 = '0x9d2dC11C342F4eF3C5491A048D0f0eBCd2D8f7C3'
-    const validatorList = [validator1, validator2, validator3, validator4]
-    getValidatorConfirmation.mockImplementation(() => async (validator: string) => ({
-      validator,
-      status:
-        validator !== validator3 && validator !== validator4
-          ? VALIDATOR_CONFIRMATION_STATUS.SUCCESS
-          : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
-    }))
-    getSuccessExecutionTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
-      txHash: validatorData.validator !== validator3 && validatorData.validator !== validator4 ? '0x123' : '',
-      timestamp: validatorData.validator !== validator3 && validatorData.validator !== validator4 ? 123 : 0
-    }))
-    getValidatorFailedTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status:
-        validatorData.validator === validator3
-          ? VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID
-          : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: validatorData.validator === validator3 ? '0x123' : '',
-      timestamp: validatorData.validator === validator3 ? 123 : 0
-    }))
-    getValidatorPendingTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: '',
-      timestamp: 0
-    }))
-
-    const setResult = jest.fn()
-    const setSignatureCollected = jest.fn()
-    const setFailedConfirmations = jest.fn()
-    const setPendingConfirmations = jest.fn()
-
-    await getConfirmationsForTx(
-      messageData,
-      web3,
-      validatorList,
-      bridgeContract,
-      true,
-      setResult,
-      requiredSignatures,
-      setSignatureCollected,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      getFailedTransactions,
-      setFailedConfirmations,
-      getPendingTransactions,
-      setPendingConfirmations,
-      getSuccessTransactions
-    )
-
-    unsubscribe()
-
-    expect(subscriptions.length).toEqual(0)
-    expect(setResult).toBeCalledTimes(4)
-    expect(getValidatorConfirmation).toBeCalledTimes(1)
-    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
-    expect(setSignatureCollected).toBeCalledTimes(1)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual(true)
-
-    expect(getValidatorFailedTransaction).toBeCalledTimes(1)
-    expect(setFailedConfirmations).toBeCalledTimes(1)
-    expect(setFailedConfirmations.mock.calls[0][0]).toEqual(false)
-
-    expect(getValidatorPendingTransaction).toBeCalledTimes(0)
-    expect(setPendingConfirmations).toBeCalledTimes(1)
-    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(false)
-
-    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, txHash: '0x123', timestamp: 123 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
-        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-    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 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID, txHash: '0x123', timestamp: 123 },
-        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-    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 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID, txHash: '0x123', timestamp: 123 },
-        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.NOT_REQUIRED, txHash: '', timestamp: 0 }
-      ])
-    )
-  })
-  test('should look for failed and pending transactions for not confirmed validators', async () => {
-    // Validator1 success
-    // Validator2 failed
-    // Validator3 Pending
-
-    getValidatorConfirmation.mockImplementation(() => async (validator: string) => ({
-      validator,
-      status: validator === validator1 ? VALIDATOR_CONFIRMATION_STATUS.SUCCESS : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
-    }))
-    getSuccessExecutionTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
-      txHash: validatorData.validator === validator1 ? '0x123' : '',
-      timestamp: validatorData.validator === validator1 ? 123 : 0
-    }))
-    getValidatorFailedTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status:
-        validatorData.validator === validator2
-          ? VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID
-          : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: validatorData.validator === validator2 ? '0x123' : '',
-      timestamp: validatorData.validator === validator2 ? 123 : 0
-    }))
-    getValidatorPendingTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status:
-        validatorData.validator === validator3
-          ? VALIDATOR_CONFIRMATION_STATUS.PENDING
-          : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: validatorData.validator === validator3 ? '0x123' : '',
-      timestamp: validatorData.validator === validator3 ? 123 : 0
-    }))
-
-    const setResult = jest.fn()
-    const setSignatureCollected = jest.fn()
-    const setFailedConfirmations = jest.fn()
-    const setPendingConfirmations = jest.fn()
-
-    await getConfirmationsForTx(
-      messageData,
-      web3,
-      validatorList,
-      bridgeContract,
-      true,
-      setResult,
-      requiredSignatures,
-      setSignatureCollected,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      getFailedTransactions,
-      setFailedConfirmations,
-      getPendingTransactions,
-      setPendingConfirmations,
-      getSuccessTransactions
-    )
-
-    unsubscribe()
-
-    expect(setResult).toBeCalledTimes(4)
-    expect(getValidatorConfirmation).toBeCalledTimes(1)
-    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
-    expect(setSignatureCollected).toBeCalledTimes(1)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual(false)
-
-    expect(getValidatorFailedTransaction).toBeCalledTimes(1)
-    expect(setFailedConfirmations).toBeCalledTimes(1)
-    expect(setFailedConfirmations.mock.calls[0][0]).toEqual(false)
-
-    expect(getValidatorPendingTransaction).toBeCalledTimes(1)
-    expect(setPendingConfirmations).toBeCalledTimes(1)
-    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(true)
-
-    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, txHash: '0x123', timestamp: 123 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-    expect(res3).toEqual(
-      expect.arrayContaining([
-        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.PENDING, txHash: '0x123', timestamp: 123 }
-      ])
-    )
-    expect(res4).toEqual(
-      expect.arrayContaining([
-        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x123', timestamp: 123 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID, txHash: '0x123', timestamp: 123 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.PENDING, txHash: '0x123', timestamp: 123 }
-      ])
-    )
-  })
-  test('should set as failed if enough signatures failed', async () => {
-    // Validator1 success
-    // Validator2 failed
-    // Validator3 failed
-
-    getValidatorConfirmation.mockImplementation(() => async (validator: string) => ({
-      validator,
-      status: validator === validator1 ? VALIDATOR_CONFIRMATION_STATUS.SUCCESS : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
-    }))
-    getSuccessExecutionTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
-      txHash: validatorData.validator === validator1 ? '0x123' : '',
-      timestamp: validatorData.validator === validator1 ? 123 : 0
-    }))
-    getValidatorFailedTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status:
-        validatorData.validator !== validator1
-          ? VALIDATOR_CONFIRMATION_STATUS.FAILED
-          : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: validatorData.validator !== validator1 ? '0x123' : '',
-      timestamp: validatorData.validator !== validator1 ? 123 : 0
-    }))
-    getValidatorPendingTransaction.mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-      validator: validatorData.validator,
-      status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-      txHash: '',
-      timestamp: 0
-    }))
-
-    const setResult = jest.fn()
-    const setSignatureCollected = jest.fn()
-    const setFailedConfirmations = jest.fn()
-    const setPendingConfirmations = jest.fn()
-
-    await getConfirmationsForTx(
-      messageData,
-      web3,
-      validatorList,
-      bridgeContract,
-      true,
-      setResult,
-      requiredSignatures,
-      setSignatureCollected,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      getFailedTransactions,
-      setFailedConfirmations,
-      getPendingTransactions,
-      setPendingConfirmations,
-      getSuccessTransactions
-    )
-
-    unsubscribe()
-
-    expect(subscriptions.length).toEqual(0)
-    expect(setResult).toBeCalledTimes(3)
-    expect(getValidatorConfirmation).toBeCalledTimes(1)
-    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
-    expect(setSignatureCollected).toBeCalledTimes(1)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual(false)
-
-    expect(getValidatorFailedTransaction).toBeCalledTimes(1)
-    expect(setFailedConfirmations).toBeCalledTimes(1)
-    expect(setFailedConfirmations.mock.calls[0][0]).toEqual(true)
-
-    expect(getValidatorPendingTransaction).toBeCalledTimes(1)
-    expect(setPendingConfirmations).toBeCalledTimes(1)
-    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(false)
-
-    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, txHash: '0x123', timestamp: 123 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-    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 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x123', timestamp: 123 }
-      ])
-    )
-  })
-  test('should remove pending state after transaction mined', async () => {
-    const validator4 = '0x9d2dC11C342F4eF3C5491A048D0f0eBCd2D8f7C3'
-    const validatorList = [validator1, validator2, validator3, validator4]
-
-    // Validator1 success (ts=100)
-    // Validator2 failed (ts=200)
-    // Validator3 Pending (ts=300)
-    // Validator4 Excess confirmation (Failed) (ts=400)
-
-    getValidatorConfirmation
-      .mockImplementationOnce(() => async (validator: string) => ({
-        validator,
-        status:
-          validator === validator1 ? VALIDATOR_CONFIRMATION_STATUS.SUCCESS : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
-      }))
-      .mockImplementation(() => async (validator: string) => ({
-        validator,
-        status:
-          validator === validator1 || validator === validator3
-            ? VALIDATOR_CONFIRMATION_STATUS.SUCCESS
-            : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
-      }))
-    getSuccessExecutionTransaction
-      .mockImplementationOnce(() => async (validatorData: ConfirmationParam) => ({
-        validator: validatorData.validator,
-        status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
-        txHash: validatorData.validator === validator1 ? '0x100' : '',
-        timestamp: validatorData.validator === validator1 ? 100 : 0
-      }))
-      .mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-        validator: validatorData.validator,
-        status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
-        txHash:
-          validatorData.validator === validator1 ? '0x100' : validatorData.validator === validator3 ? '0x300' : '',
-        timestamp: validatorData.validator === validator1 ? 100 : validatorData.validator === validator3 ? 300 : ''
-      }))
-    getValidatorFailedTransaction
-      .mockImplementationOnce(() => async (validatorData: ConfirmationParam) => ({
-        validator: validatorData.validator,
-        status:
-          validatorData.validator === validator2
-            ? VALIDATOR_CONFIRMATION_STATUS.FAILED
-            : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-        txHash: validatorData.validator === validator2 ? '0x200' : '',
-        timestamp: validatorData.validator === validator2 ? 200 : 0
-      }))
-      .mockImplementation(() => async (validatorData: ConfirmationParam) => ({
-        validator: validatorData.validator,
-        status:
-          validatorData.validator === validator2 || validatorData.validator === validator4
-            ? validatorData.validator === validator2
-              ? VALIDATOR_CONFIRMATION_STATUS.FAILED
-              : VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID
-            : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-        txHash:
-          validatorData.validator === validator2 ? '0x200' : validatorData.validator === validator4 ? '0x400' : '',
-        timestamp: validatorData.validator === validator2 ? 200 : validatorData.validator === validator4 ? 400 : ''
-      }))
-    getValidatorPendingTransaction
-      .mockImplementationOnce(() => async (validatorData: ConfirmationParam) => ({
-        validator: validatorData.validator,
-        status:
-          validatorData.validator === validator3
-            ? VALIDATOR_CONFIRMATION_STATUS.PENDING
-            : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-        txHash: validatorData.validator === validator3 ? '0x300' : '',
-        timestamp: validatorData.validator === validator3 ? 300 : 0
-      }))
-      .mockImplementationOnce(() => async (validatorData: ConfirmationParam) => ({
-        validator: validatorData.validator,
-        status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-        txHash: '',
-        timestamp: 0
-      }))
-
-    const setResult = jest.fn()
-    const setSignatureCollected = jest.fn()
-    const setFailedConfirmations = jest.fn()
-    const setPendingConfirmations = jest.fn()
-
-    await getConfirmationsForTx(
-      messageData,
-      web3,
-      validatorList,
-      bridgeContract,
-      true,
-      setResult,
-      requiredSignatures,
-      setSignatureCollected,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      getFailedTransactions,
-      setFailedConfirmations,
-      getPendingTransactions,
-      setPendingConfirmations,
-      getSuccessTransactions
-    )
-
-    unsubscribe()
-
-    expect(setResult).toBeCalledTimes(4)
-    expect(getValidatorConfirmation).toBeCalledTimes(1)
-    expect(getSuccessExecutionTransaction).toBeCalledTimes(1)
-    expect(setSignatureCollected).toBeCalledTimes(1)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual(false)
-
-    expect(getValidatorFailedTransaction).toBeCalledTimes(1)
-    expect(setFailedConfirmations).toBeCalledTimes(1)
-    expect(setFailedConfirmations.mock.calls[0][0]).toEqual(true)
-
-    expect(getValidatorPendingTransaction).toBeCalledTimes(1)
-    expect(setPendingConfirmations).toBeCalledTimes(1)
-    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(true)
-
-    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 },
-        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-    expect(res2).toEqual(
-      expect.arrayContaining([
-        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x100', timestamp: 100 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
-        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-    expect(res3).toEqual(
-      expect.arrayContaining([
-        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x100', timestamp: 100 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.PENDING, txHash: '0x300', timestamp: 300 },
-        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-    expect(res4).toEqual(
-      expect.arrayContaining([
-        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x100', timestamp: 100 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x200', timestamp: 200 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.PENDING, txHash: '0x300', timestamp: 300 },
-        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-
-    await getConfirmationsForTx(
-      messageData,
-      web3,
-      validatorList,
-      bridgeContract,
-      true,
-      setResult,
-      requiredSignatures,
-      setSignatureCollected,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      getFailedTransactions,
-      setFailedConfirmations,
-      getPendingTransactions,
-      setPendingConfirmations,
-      getSuccessTransactions
-    )
-
-    unsubscribe()
-
-    expect(setResult).toBeCalledTimes(7)
-    expect(getValidatorConfirmation).toBeCalledTimes(2)
-    expect(getSuccessExecutionTransaction).toBeCalledTimes(2)
-    expect(setSignatureCollected).toBeCalledTimes(2)
-    expect(setSignatureCollected.mock.calls[0][0]).toEqual(false)
-    expect(setSignatureCollected.mock.calls[1][0]).toEqual(true)
-
-    expect(getValidatorFailedTransaction).toBeCalledTimes(2)
-    expect(setFailedConfirmations).toBeCalledTimes(2)
-    expect(setFailedConfirmations.mock.calls[0][0]).toEqual(true)
-    expect(setFailedConfirmations.mock.calls[1][0]).toEqual(false)
-
-    expect(getValidatorPendingTransaction).toBeCalledTimes(1)
-    expect(setPendingConfirmations).toBeCalledTimes(2)
-    expect(setPendingConfirmations.mock.calls[0][0]).toEqual(true)
-    expect(setPendingConfirmations.mock.calls[1][0]).toEqual(false)
-
-    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, txHash: '0x100', timestamp: 100 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x200', timestamp: 200 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x300', timestamp: 300 },
-        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-    expect(res6).toEqual(
-      expect.arrayContaining([
-        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x100', timestamp: 100 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x200', timestamp: 200 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x300', timestamp: 300 },
-        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED }
-      ])
-    )
-    expect(res7).toEqual(
-      expect.arrayContaining([
-        { validator: validator1, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x100', timestamp: 100 },
-        { validator: validator2, status: VALIDATOR_CONFIRMATION_STATUS.FAILED, txHash: '0x200', timestamp: 200 },
-        { validator: validator3, status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS, txHash: '0x300', timestamp: 300 },
-        { validator: validator4, status: VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID, txHash: '0x400', timestamp: 400 }
-      ])
-    )
-  })
-})

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

@@ -1,309 +0,0 @@
-import 'jest'
-import { Contract, EventData } from 'web3-eth-contract'
-import Web3 from 'web3'
-import { getFinalizationEvent } from '../getFinalizationEvent'
-import { VALIDATOR_CONFIRMATION_STATUS } from '../../config/constants'
-
-const timestamp = 1594045859
-const validator1 = '0x45b96809336A8b714BFbdAB3E4B5e0fe5d839908'
-const txHash = '0xdab36c9210e7e45fb82af10ffe4960461e41661dce0c9cd36b2843adaa1df156'
-
-const web3 = ({
-  eth: {
-    getTransactionReceipt: () => ({
-      from: validator1
-    }),
-    getBlock: () => ({ timestamp })
-  },
-  utils: {
-    toChecksumAddress: (a: string) => a
-  }
-} as unknown) as Web3
-const message = {
-  id: '0x123',
-  data: '0x123456789'
-}
-const isCancelled = () => false
-let subscriptions: Array<number> = []
-
-const event = {
-  transactionHash: txHash,
-  blockNumber: 5523145,
-  returnValues: {
-    status: true
-  }
-}
-
-const bridgeAddress = '0xFe446bEF1DbF7AFE24E81e05BC8B271C1BA9a560'
-
-const unsubscribe = () => {
-  subscriptions.forEach(s => {
-    clearTimeout(s)
-  })
-}
-
-beforeEach(() => {
-  subscriptions = []
-})
-describe('getFinalizationEvent', () => {
-  test('should get finalization event and not try to get failed or pending transactions', async () => {
-    const contract = ({
-      getPastEvents: async () => {
-        return [event]
-      }
-    } as unknown) as Contract
-
-    const collectedSignaturesEvent = null
-    const setResult = jest.fn()
-    const getFailedExecution = jest.fn()
-    const setFailedExecution = jest.fn()
-    const getPendingExecution = jest.fn()
-    const setPendingExecution = jest.fn()
-    const setExecutionEventsFetched = jest.fn()
-
-    await getFinalizationEvent(
-      true,
-      contract,
-      web3,
-      setResult,
-      message,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      collectedSignaturesEvent,
-      getFailedExecution,
-      setFailedExecution,
-      getPendingExecution,
-      setPendingExecution,
-      setExecutionEventsFetched
-    )
-
-    unsubscribe()
-
-    expect(subscriptions.length).toEqual(0)
-    expect(setResult).toBeCalledTimes(1)
-    expect(setResult.mock.calls[0][0]).toEqual({
-      validator: validator1,
-      status: VALIDATOR_CONFIRMATION_STATUS.EXECUTION_SUCCESS,
-      txHash,
-      timestamp,
-      executionResult: true,
-      blockNumber: 5523145
-    })
-
-    expect(getFailedExecution).toBeCalledTimes(0)
-    expect(setFailedExecution).toBeCalledTimes(0)
-
-    expect(getPendingExecution).toBeCalledTimes(0)
-    expect(setPendingExecution).toBeCalledTimes(0)
-  })
-  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: async () => {
-        return []
-      }
-    } as unknown) as Contract
-
-    const collectedSignaturesEvent = null
-    const setResult = jest.fn()
-    const getFailedExecution = jest.fn()
-    const setFailedExecution = jest.fn()
-    const getPendingExecution = jest.fn()
-    const setPendingExecution = jest.fn()
-    const setExecutionEventsFetched = jest.fn()
-
-    await getFinalizationEvent(
-      true,
-      contract,
-      web3,
-      setResult,
-      message,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      collectedSignaturesEvent,
-      getFailedExecution,
-      setFailedExecution,
-      getPendingExecution,
-      setPendingExecution,
-      setExecutionEventsFetched
-    )
-
-    unsubscribe()
-
-    expect(subscriptions.length).toEqual(1)
-    expect(setResult).toBeCalledTimes(0)
-
-    expect(getFailedExecution).toBeCalledTimes(0)
-    expect(setFailedExecution).toBeCalledTimes(0)
-
-    expect(getPendingExecution).toBeCalledTimes(0)
-    expect(setPendingExecution).toBeCalledTimes(0)
-  })
-  test('should retry to get finalization event and try to get failed and pending transactions if home to foreign transaction', async () => {
-    const contract = ({
-      getPastEvents: async () => {
-        return []
-      },
-      options: {
-        address: bridgeAddress
-      }
-    } as unknown) as Contract
-
-    const collectedSignaturesEvent = ({
-      returnValues: {
-        authorityResponsibleForRelay: validator1
-      }
-    } as unknown) as EventData
-    const setResult = jest.fn()
-    const getFailedExecution = jest.fn().mockResolvedValue([])
-    const setFailedExecution = jest.fn()
-    const getPendingExecution = jest.fn().mockResolvedValue([])
-    const setPendingExecution = jest.fn()
-    const setExecutionEventsFetched = jest.fn()
-
-    await getFinalizationEvent(
-      true,
-      contract,
-      web3,
-      setResult,
-      message,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      collectedSignaturesEvent,
-      getFailedExecution,
-      setFailedExecution,
-      getPendingExecution,
-      setPendingExecution,
-      setExecutionEventsFetched
-    )
-
-    unsubscribe()
-
-    expect(subscriptions.length).toEqual(1)
-    expect(setResult).toBeCalledTimes(0)
-
-    expect(getFailedExecution).toBeCalledTimes(1)
-    expect(setFailedExecution).toBeCalledTimes(0)
-
-    expect(getPendingExecution).toBeCalledTimes(1)
-    expect(setPendingExecution).toBeCalledTimes(0)
-  })
-  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: async () => {
-        return []
-      },
-      options: {
-        address: bridgeAddress
-      }
-    } as unknown) as Contract
-
-    const collectedSignaturesEvent = ({
-      returnValues: {
-        authorityResponsibleForRelay: validator1
-      }
-    } as unknown) as EventData
-    const setResult = jest.fn()
-    const getFailedExecution = jest.fn().mockResolvedValue([])
-    const setFailedExecution = jest.fn()
-    const getPendingExecution = jest.fn().mockResolvedValue([{ hash: txHash }])
-    const setPendingExecution = jest.fn()
-    const setExecutionEventsFetched = jest.fn()
-
-    await getFinalizationEvent(
-      true,
-      contract,
-      web3,
-      setResult,
-      message,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      collectedSignaturesEvent,
-      getFailedExecution,
-      setFailedExecution,
-      getPendingExecution,
-      setPendingExecution,
-      setExecutionEventsFetched
-    )
-
-    unsubscribe()
-
-    expect(subscriptions.length).toEqual(1)
-    expect(setResult).toBeCalledTimes(1)
-    expect(setResult.mock.calls[0][0]).toEqual({
-      validator: validator1,
-      status: VALIDATOR_CONFIRMATION_STATUS.PENDING,
-      txHash,
-      timestamp: expect.any(Number),
-      executionResult: false,
-      blockNumber: 0
-    })
-
-    expect(getFailedExecution).toBeCalledTimes(0)
-    expect(setFailedExecution).toBeCalledTimes(0)
-
-    expect(getPendingExecution).toBeCalledTimes(1)
-    expect(setPendingExecution).toBeCalledTimes(1)
-  })
-  test('should retry to get finalization event even if failed transaction found if home to foreign transaction', async () => {
-    const contract = ({
-      getPastEvents: async () => {
-        return []
-      },
-      options: {
-        address: bridgeAddress
-      }
-    } as unknown) as Contract
-
-    const collectedSignaturesEvent = ({
-      returnValues: {
-        authorityResponsibleForRelay: validator1
-      }
-    } as unknown) as EventData
-    const setResult = jest.fn()
-    const getFailedExecution = jest.fn().mockResolvedValue([{ timeStamp: timestamp, hash: txHash }])
-    const setFailedExecution = jest.fn()
-    const getPendingExecution = jest.fn().mockResolvedValue([])
-    const setPendingExecution = jest.fn()
-    const setExecutionEventsFetched = jest.fn()
-
-    await getFinalizationEvent(
-      true,
-      contract,
-      web3,
-      setResult,
-      message,
-      subscriptions.push.bind(subscriptions),
-      isCancelled,
-      timestamp,
-      collectedSignaturesEvent,
-      getFailedExecution,
-      setFailedExecution,
-      getPendingExecution,
-      setPendingExecution,
-      setExecutionEventsFetched
-    )
-
-    unsubscribe()
-
-    expect(subscriptions.length).toEqual(1)
-    expect(setResult).toBeCalledTimes(1)
-    expect(setResult.mock.calls[0][0]).toEqual({
-      validator: validator1,
-      status: VALIDATOR_CONFIRMATION_STATUS.FAILED,
-      txHash,
-      timestamp: expect.any(Number),
-      executionResult: false,
-      blockNumber: expect.any(Number)
-    })
-
-    expect(getFailedExecution).toBeCalledTimes(1)
-    expect(setFailedExecution).toBeCalledTimes(1)
-
-    expect(getPendingExecution).toBeCalledTimes(1)
-    expect(setPendingExecution).toBeCalledTimes(0)
-  })
-})

alm/src/utils/contract.ts

@@ -1,133 +1,51 @@
 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) => {
+  const events = await contract.getPastEvents('RequiredBlockConfirmationChanged', {
+    fromBlock: 0,
+    toBlock: blockNumber
+  })
 
-export const getRequiredBlockConfirmations = async (
-  contract: Contract,
-  blockNumber: number,
-  snapshotProvider: SnapshotProvider,
-  web3: Web3 | null = null,
-  api: string = ''
-) => {
   let blockConfirmations
-
-  try {
+  if (events.length > 0) {
+    // Use the value from last event before the transaction
+    const event = events[events.length - 1]
+    blockConfirmations = event.returnValues.requiredBlockConfirmations
+  } else {
+    // This is a special case where RequiredBlockConfirmationChanged was not emitted during initialization in early versions of AMB
+    // of Sokol - Kovan. In this case the current value is used.
     blockConfirmations = await contract.methods.requiredBlockConfirmations().call()
-  } catch {}
-
-  if (blockConfirmations) {
-    return parseInt(blockConfirmations)
   }
-
-  const eventsFromSnapshot = snapshotProvider.requiredBlockConfirmationEvents(blockNumber)
-  const snapshotBlockNumber = snapshotProvider.snapshotBlockNumber()
-
-  let contractEvents: EventData[] = []
-  if (blockNumber > snapshotBlockNumber) {
-    contractEvents = await getPastEventsWithFallback(api, web3, contract, 'RequiredBlockConfirmationChanged', {
-      fromBlock: snapshotBlockNumber + 1,
-      toBlock: blockNumber
-    })
-  }
-
-  const events = [...eventsFromSnapshot, ...contractEvents]
-
-  // Use the value from last event before the transaction
-  const event = events[events.length - 1]
-  blockConfirmations = event.returnValues.requiredBlockConfirmations
-
   return parseInt(blockConfirmations)
 }
 
 export const getValidatorAddress = (contract: Contract) => contract.methods.validatorContract().call()
 
-export const getRequiredSignatures = async (
-  contract: Contract,
-  blockNumber: number | 'latest',
-  snapshotProvider: SnapshotProvider,
-  web3: Web3 | null = null,
-  api: string = ''
-) => {
-  let requiredSignatures
-
-  try {
-    requiredSignatures = await contract.methods.requiredSignatures().call()
-  } catch {}
-
-  if (requiredSignatures) {
-    return parseInt(requiredSignatures)
-  }
-
-  if (blockNumber === 'latest') {
-    return contract.methods.requiredSignatures().call()
-  }
-
-  const eventsFromSnapshot = snapshotProvider.requiredSignaturesEvents(blockNumber)
-  const snapshotBlockNumber = snapshotProvider.snapshotBlockNumber()
-
-  let contractEvents: EventData[] = []
-  if (blockNumber > snapshotBlockNumber) {
-    contractEvents = await getPastEventsWithFallback(api, web3, contract, 'RequiredSignaturesChanged', {
-      fromBlock: snapshotBlockNumber + 1,
-      toBlock: blockNumber
-    })
-  }
-
-  const events = [...eventsFromSnapshot, ...contractEvents]
+export const getRequiredSignatures = async (contract: Contract, blockNumber: number) => {
+  const events = await contract.getPastEvents('RequiredSignaturesChanged', {
+    fromBlock: 0,
+    toBlock: blockNumber
+  })
 
   // Use the value form last event before the transaction
   const event = events[events.length - 1]
-  ;({ requiredSignatures } = event.returnValues)
+  const { requiredSignatures } = event.returnValues
   return parseInt(requiredSignatures)
 }
 
-export const getValidatorList = async (
-  contract: Contract,
-  blockNumber: number | 'latest',
-  snapshotProvider: SnapshotProvider,
-  web3: Web3 | null = null,
-  api: string = ''
-) => {
-  try {
-    const currentList = await contract.methods.validatorList().call()
-
-    if (currentList) {
-      return currentList
-    }
-  } catch {}
-
-  const addedEventsFromSnapshot = snapshotProvider.validatorAddedEvents(blockNumber)
-  const removedEventsFromSnapshot = snapshotProvider.validatorRemovedEvents(blockNumber)
-  const snapshotBlockNumber = snapshotProvider.snapshotBlockNumber()
-
-  const fromBlock = snapshotBlockNumber > blockNumber ? snapshotBlockNumber + 1 : blockNumber
-  const [currentList, added, removed] = await Promise.all([
-    contract.methods.validatorList().call(),
-    getPastEventsWithFallback(api, web3, contract, 'ValidatorAdded', {
-      fromBlock
+export const getValidatorList = async (contract: Contract, blockNumber: number) => {
+  let currentList: string[] = await contract.methods.validatorList().call()
+  const [added, removed] = await Promise.all([
+    contract.getPastEvents('ValidatorAdded', {
+      fromBlock: blockNumber
     }),
-    getPastEventsWithFallback(api, web3, contract, 'ValidatorRemoved', {
-      fromBlock
+    contract.getPastEvents('ValidatorRemoved', {
+      fromBlock: blockNumber
     })
   ])
 
   // Ordered desc
-  const orderedEvents = [...addedEventsFromSnapshot, ...added, ...removedEventsFromSnapshot, ...removed].sort(
-    ({ blockNumber: prev }, { blockNumber: next }) => next - prev
-  )
+  const orderedEvents = [...added, ...removed].sort(({ blockNumber: prev }, { blockNumber: next }) => next - prev)
 
   // Stored as a Set to avoid duplicates
   const validatorList = new Set(currentList)

alm/src/utils/executionWaitingForBlocks.ts

@@ -0,0 +1,58 @@
+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) {
+    setExecutionData({
+      status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
+      validator: collectedSignaturesEvent.returnValues.authorityResponsibleForRelay,
+      txHash: '',
+      timestamp: 0,
+      executionResult: false
+    })
+    setWaitingBlocksForExecution(false)
+    setWaitingBlocksForExecutionResolved(true)
+    blockProvider.stop()
+  } else {
+    let nextInterval = interval
+    if (!currentBlock) {
+      nextInterval = 500
+    } else {
+      setWaitingBlocksForExecution(true)
+      setExecutionData({
+        status: VALIDATOR_CONFIRMATION_STATUS.WAITING,
+        validator: collectedSignaturesEvent.returnValues.authorityResponsibleForRelay,
+        txHash: '',
+        timestamp: 0,
+        executionResult: false
+      })
+    }
+    const timeoutId = setTimeout(
+      () =>
+        checkWaitingBlocksForExecution(
+          blockProvider,
+          interval,
+          targetBlock,
+          collectedSignaturesEvent,
+          setWaitingBlocksForExecution,
+          setWaitingBlocksForExecutionResolved,
+          setExecutionData,
+          subscriptions
+        ),
+      nextInterval
+    )
+    subscriptions.push(timeoutId)
+  }
+}

alm/src/utils/explorer.ts

@@ -1,24 +1,17 @@
 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 {
-  from: string
   timeStamp: string
   isError: string
   input: string
   to: string
   hash: string
-  blockNumber: string
 }
 
 export interface APIPendingTransaction {
@@ -34,54 +27,110 @@ export interface PendingTransactionsParams {
 
 export interface AccountTransactionsParams {
   account: string
-  startBlock: number
-  endBlock: number
+  to: string
+  startTimestamp: number
+  endTimestamp: 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 interface GetTransactionParams extends GetPendingTransactionParams {
-  startBlock: number
-  endBlock: number
+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 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', 'to')
-  url.searchParams.append('startblock', startBlock.toString())
-  url.searchParams.append('endblock', endBlock.toString())
+export const getBlockByTimestampUrl = (api: string, timestamp: number) =>
+  `${api}&module=block&action=getblocknobytime&timestamp=${timestamp}&closest=before`
 
-  const result = await fetch(url.toString()).then(res => res.json())
+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())
+    ])
 
-  if (result.message === 'No transactions found') {
+    if (fromBlockResult.status !== '0') {
+      fromBlock = parseInt(fromBlockResult.result)
+    }
+
+    if (toBlockResult.status !== '0') {
+      toBlock = parseInt(toBlockResult.result)
+    }
+  } catch (e) {
+    console.log(e)
     return []
   }
 
-  return result.result || []
+  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
 }
 
 export const fetchPendingTransactions = async ({
   account,
   api
 }: PendingTransactionsParams): Promise<APIPendingTransaction[]> => {
-  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)
+  const url = `${api}?module=account&action=pendingtxlist&address=${account}`
 
   try {
-    const result = await fetch(url.toString()).then(res => res.json())
+    const result = await fetch(url).then(res => res.json())
     if (result.status === '0') {
       return []
     }
@@ -92,137 +141,30 @@ 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++) {
-        if (topics[j] !== null) {
-          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 filterSender = (from: string) => (tx: APITransaction) => tx.from.toLowerCase() === from.toLowerCase()
-
 export const getFailedTransactions = async (
   account: string,
   to: string,
-  startBlock: number,
-  endBlock: number,
+  startTimestamp: number,
+  endTimestamp: number,
   api: string,
-  getAccountTransactionsMethod = getAccountTransactions
+  fetchAccountTransactions: (args: AccountTransactionsParams) => Promise<APITransaction[]>
 ): Promise<APITransaction[]> => {
-  const transactions = await getAccountTransactionsMethod({ account: to, startBlock, endBlock, api })
+  const transactions = await fetchAccountTransactions({ account, to, startTimestamp, endTimestamp, api })
 
-  return transactions.filter(t => t.isError !== '0').filter(filterSender(account))
+  return transactions.filter(t => t.isError !== '0')
 }
 
 export const getSuccessTransactions = async (
   account: string,
   to: string,
-  startBlock: number,
-  endBlock: number,
+  startTimestamp: number,
+  endTimestamp: number,
   api: string,
-  getAccountTransactionsMethod = getAccountTransactions
+  fetchAccountTransactions: (args: AccountTransactionsParams) => Promise<APITransaction[]>
 ): Promise<APITransaction[]> => {
-  const transactions = await getAccountTransactionsMethod({ account: to, startBlock, endBlock, api })
+  const transactions = await fetchAccountTransactions({ account, to, startTimestamp, endTimestamp, api })
 
-  return transactions.filter(t => t.isError === '0').filter(filterSender(account))
+  return transactions.filter(t => t.isError === '0')
 }
 
 export const filterValidatorSignatureTransaction = (
@@ -241,10 +183,17 @@ export const getValidatorFailedTransactionsForMessage = async ({
   account,
   to,
   messageData,
-  startBlock,
-  endBlock
-}: GetTransactionParams): Promise<APITransaction[]> => {
-  const failedTransactions = await getFailedTransactions(account, to, startBlock, endBlock, HOME_EXPLORER_API)
+  startTimestamp,
+  endTimestamp
+}: GetFailedTransactionParams): Promise<APITransaction[]> => {
+  const failedTransactions = await getFailedTransactions(
+    account,
+    to,
+    startTimestamp,
+    endTimestamp,
+    HOME_EXPLORER_API,
+    fetchAccountTransactionsFromBlockscout
+  )
 
   return filterValidatorSignatureTransaction(failedTransactions, messageData)
 }
@@ -253,29 +202,47 @@ export const getValidatorSuccessTransactionsForMessage = async ({
   account,
   to,
   messageData,
-  startBlock,
-  endBlock
-}: GetTransactionParams): Promise<APITransaction[]> => {
-  const transactions = await getSuccessTransactions(account, to, startBlock, endBlock, HOME_EXPLORER_API)
+  startTimestamp,
+  endTimestamp
+}: GetFailedTransactionParams): Promise<APITransaction[]> => {
+  const transactions = await getSuccessTransactions(
+    account,
+    to,
+    startTimestamp,
+    endTimestamp,
+    HOME_EXPLORER_API,
+    fetchAccountTransactionsFromBlockscout
+  )
 
   return filterValidatorSignatureTransaction(transactions, messageData)
 }
 
-export const getExecutionFailedTransactionForMessage = async (
-  { account, to, messageData, startBlock, endBlock }: GetTransactionParams,
-  getFailedTransactionsMethod = getFailedTransactions
-): Promise<APITransaction[]> => {
-  const failedTransactions = await getFailedTransactionsMethod(account, to, startBlock, endBlock, FOREIGN_EXPLORER_API)
+export const getExecutionFailedTransactionForMessage = async ({
+  account,
+  to,
+  messageData,
+  startTimestamp,
+  endTimestamp
+}: GetFailedTransactionParams): Promise<APITransaction[]> => {
+  const failedTransactions = await getFailedTransactions(
+    account,
+    to,
+    startTimestamp,
+    endTimestamp,
+    FOREIGN_EXPLORER_API,
+    fetchAccountTransactions(FOREIGN_EXPLORER_API)
+  )
 
   const messageDataValue = messageData.replace('0x', '')
   return failedTransactions.filter(t => t.input.includes(EXECUTE_SIGNATURES_HASH) && t.input.includes(messageDataValue))
 }
 
-export const getValidatorPendingTransactionsForMessage = async (
-  { account, to, messageData }: GetPendingTransactionParams,
-  fetchPendingTransactionsMethod = fetchPendingTransactions
-): Promise<APIPendingTransaction[]> => {
-  const pendingTransactions = await fetchPendingTransactionsMethod({
+export const getValidatorPendingTransactionsForMessage = async ({
+  account,
+  to,
+  messageData
+}: GetPendingTransactionParams): Promise<APIPendingTransaction[]> => {
+  const pendingTransactions = await fetchPendingTransactions({
     account,
     api: HOME_EXPLORER_API
   })
@@ -291,11 +258,12 @@ export const getValidatorPendingTransactionsForMessage = async (
   )
 }
 
-export const getExecutionPendingTransactionsForMessage = async (
-  { account, to, messageData }: GetPendingTransactionParams,
-  fetchPendingTransactionsMethod = fetchPendingTransactions
-): Promise<APIPendingTransaction[]> => {
-  const pendingTransactions = await fetchPendingTransactionsMethod({
+export const getExecutionPendingTransactionsForMessage = async ({
+  account,
+  to,
+  messageData
+}: GetPendingTransactionParams): Promise<APIPendingTransaction[]> => {
+  const pendingTransactions = await fetchPendingTransactions({
     account,
     api: FOREIGN_EXPLORER_API
   })

alm/src/utils/getCollectedSignaturesEvent.ts

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

alm/src/utils/getConfirmationsForTx.ts

@@ -1,201 +1,317 @@
 import Web3 from 'web3'
 import { Contract } from 'web3-eth-contract'
-import { HOME_RPC_POLLING_INTERVAL, VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
-import { GetTransactionParams, APITransaction, APIPendingTransaction, GetPendingTransactionParams } from './explorer'
+import validatorsCache from '../services/ValidatorsCache'
 import {
-  getValidatorConfirmation,
-  getValidatorFailedTransaction,
-  getValidatorPendingTransaction,
-  getSuccessExecutionTransaction
-} from './validatorConfirmationHelpers'
-import { ConfirmationParam } from '../hooks/useMessageConfirmations'
-import { signatureToVRS } from './signatures'
+  CACHE_KEY_FAILED,
+  CACHE_KEY_SUCCESS,
+  HOME_RPC_POLLING_INTERVAL,
+  ONE_DAY_TIMESTAMP,
+  VALIDATOR_CONFIRMATION_STATUS
+} from '../config/constants'
+import {
+  GetFailedTransactionParams,
+  APITransaction,
+  APIPendingTransaction,
+  GetPendingTransactionParams
+} from './explorer'
+import { BasicConfirmationParam, ConfirmationParam } from '../hooks/useMessageConfirmations'
 
-const mergeConfirmations = (oldConfirmations: ConfirmationParam[], newConfirmations: ConfirmationParam[]) => {
-  const confirmations = [...oldConfirmations]
-  newConfirmations.forEach(validatorData => {
-    const index = confirmations.findIndex(e => e.validator === validatorData.validator)
-    if (index === -1) {
-      confirmations.push(validatorData)
-      return
-    }
-    const currentStatus = confirmations[index].status
-    const newStatus = validatorData.status
-    if (
-      validatorData.txHash ||
-      !!validatorData.signature ||
-      (newStatus !== currentStatus && newStatus !== VALIDATOR_CONFIRMATION_STATUS.UNDEFINED)
-    ) {
-      confirmations[index] = {
-        status: validatorData.status,
-        validator: validatorData.validator,
-        timestamp: confirmations[index].timestamp || validatorData.timestamp,
-        txHash: confirmations[index].txHash || validatorData.txHash,
-        signature: confirmations[index].signature || validatorData.signature
-      }
+export const getValidatorConfirmation = (
+  web3: Web3,
+  hashMsg: string,
+  bridgeContract: Contract,
+  confirmationContractMethod: Function
+) => async (validator: string): Promise<BasicConfirmationParam> => {
+  const hashSenderMsg = web3.utils.soliditySha3Raw(validator, hashMsg)
+
+  const signatureFromCache = validatorsCache.get(hashSenderMsg)
+  if (signatureFromCache) {
+    return {
+      validator,
+      status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS
     }
+  }
+
+  const confirmed = await confirmationContractMethod(bridgeContract, hashSenderMsg)
+  const status = confirmed ? VALIDATOR_CONFIRMATION_STATUS.SUCCESS : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
+
+  // If validator confirmed signature, we cache the result to avoid doing future requests for a result that won't change
+  if (confirmed) {
+    validatorsCache.set(hashSenderMsg, confirmed)
+  }
+
+  return {
+    validator,
+    status
+  }
+}
+
+export const getValidatorSuccessTransaction = (
+  bridgeContract: Contract,
+  messageData: string,
+  timestamp: number,
+  getSuccessTransactions: (args: GetFailedTransactionParams) => Promise<APITransaction[]>
+) => async (validatorData: BasicConfirmationParam): Promise<ConfirmationParam> => {
+  const { validator } = validatorData
+  const validatorCacheKey = `${CACHE_KEY_SUCCESS}${validatorData.validator}-${messageData}`
+  const fromCache = validatorsCache.getData(validatorCacheKey)
+
+  if (fromCache && fromCache.txHash) {
+    return fromCache
+  }
+
+  const transactions = await getSuccessTransactions({
+    account: validatorData.validator,
+    to: bridgeContract.options.address,
+    messageData,
+    startTimestamp: timestamp,
+    endTimestamp: timestamp + ONE_DAY_TIMESTAMP
   })
-  return confirmations
+
+  let txHashTimestamp = 0
+  let txHash = ''
+  const status = VALIDATOR_CONFIRMATION_STATUS.SUCCESS
+
+  if (transactions.length > 0) {
+    const tx = transactions[0]
+    txHashTimestamp = parseInt(tx.timeStamp)
+    txHash = tx.hash
+
+    // cache the result
+    validatorsCache.setData(validatorCacheKey, {
+      validator,
+      status,
+      txHash,
+      timestamp: txHashTimestamp
+    })
+  }
+
+  return {
+    validator,
+    status,
+    txHash,
+    timestamp: txHashTimestamp
+  }
+}
+
+export const getValidatorFailedTransaction = (
+  bridgeContract: Contract,
+  messageData: string,
+  timestamp: number,
+  getFailedTransactions: (args: GetFailedTransactionParams) => Promise<APITransaction[]>
+) => async (validatorData: BasicConfirmationParam): Promise<ConfirmationParam> => {
+  const validatorCacheKey = `${CACHE_KEY_FAILED}${validatorData.validator}-${messageData}`
+  const failedFromCache = validatorsCache.getData(validatorCacheKey)
+
+  if (failedFromCache && failedFromCache.txHash) {
+    return failedFromCache
+  }
+
+  const failedTransactions = await getFailedTransactions({
+    account: validatorData.validator,
+    to: bridgeContract.options.address,
+    messageData,
+    startTimestamp: timestamp,
+    endTimestamp: timestamp + ONE_DAY_TIMESTAMP
+  })
+  const newStatus =
+    failedTransactions.length > 0 ? VALIDATOR_CONFIRMATION_STATUS.FAILED : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
+
+  let txHashTimestamp = 0
+  let txHash = ''
+  // If validator signature failed, we cache the result to avoid doing future requests for a result that won't change
+  if (failedTransactions.length > 0) {
+    const failedTx = failedTransactions[0]
+    txHashTimestamp = parseInt(failedTx.timeStamp)
+    txHash = failedTx.hash
+
+    validatorsCache.setData(validatorCacheKey, {
+      validator: validatorData.validator,
+      status: newStatus,
+      txHash,
+      timestamp: txHashTimestamp
+    })
+  }
+
+  return {
+    validator: validatorData.validator,
+    status: newStatus,
+    txHash,
+    timestamp: txHashTimestamp
+  }
+}
+
+export const getValidatorPendingTransaction = (
+  bridgeContract: Contract,
+  messageData: string,
+  getPendingTransactions: (args: GetPendingTransactionParams) => Promise<APIPendingTransaction[]>
+) => async (validatorData: BasicConfirmationParam): Promise<ConfirmationParam> => {
+  const failedTransactions = await getPendingTransactions({
+    account: validatorData.validator,
+    to: bridgeContract.options.address,
+    messageData
+  })
+
+  const newStatus =
+    failedTransactions.length > 0 ? VALIDATOR_CONFIRMATION_STATUS.PENDING : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
+
+  let timestamp = 0
+  let txHash = ''
+
+  if (failedTransactions.length > 0) {
+    const failedTx = failedTransactions[0]
+    timestamp = Math.floor(new Date().getTime() / 1000.0)
+    txHash = failedTx.hash
+  }
+
+  return {
+    validator: validatorData.validator,
+    status: newStatus,
+    txHash,
+    timestamp
+  }
 }
 
 export const getConfirmationsForTx = async (
   messageData: string,
-  web3: Web3,
+  web3: Maybe<Web3>,
   validatorList: string[],
-  bridgeContract: Contract,
-  fromHome: boolean,
+  bridgeContract: Maybe<Contract>,
+  confirmationContractMethod: Function,
   setResult: Function,
   requiredSignatures: number,
   setSignatureCollected: Function,
-  setTimeoutId: (timeoutId: number) => void,
-  isCancelled: () => boolean,
-  startBlock: number,
-  getFailedTransactions: (args: GetTransactionParams) => Promise<APITransaction[]>,
+  waitingBlocksResolved: boolean,
+  subscriptions: number[],
+  timestamp: number,
+  getFailedTransactions: (args: GetFailedTransactionParams) => Promise<APITransaction[]>,
   setFailedConfirmations: Function,
   getPendingTransactions: (args: GetPendingTransactionParams) => Promise<APIPendingTransaction[]>,
   setPendingConfirmations: Function,
-  getSuccessTransactions: (args: GetTransactionParams) => Promise<APITransaction[]>
+  getSuccessTransactions: (args: GetFailedTransactionParams) => Promise<APITransaction[]>
 ) => {
+  if (!web3 || !validatorList || !validatorList.length || !bridgeContract || !waitingBlocksResolved) return
+
+  // 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, fromHome))
+    validatorList.map(getValidatorConfirmation(web3, hashMsg, bridgeContract, confirmationContractMethod))
   )
 
-  const updateConfirmations = (confirmations: ConfirmationParam[]) => {
-    if (confirmations.length === 0) {
-      return
-    }
-    validatorConfirmations = mergeConfirmations(validatorConfirmations, confirmations)
-    setResult((currentConfirmations: ConfirmationParam[]) => {
-      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 (hasEnoughSignatures) {
-    setPendingConfirmations(false)
-    if (fromHome) {
-      // fetch collected signatures for possible manual processing
-      const signatures = await Promise.all(
-        Array.from(Array(requiredSignatures).keys()).map(i => bridgeContract.methods.signature(hashMsg, i).call())
-      )
-      const confirmations = signatures.flatMap(sig => {
-        const { v, r, s } = signatureToVRS(sig)
-        const address = web3.eth.accounts.recover(messageData, `0x${v}`, `0x${r}`, `0x${s}`)
-        return successConfirmations.filter(c => c.validator === address).map(c => ({ ...c, signature: sig }))
-      })
-      updateConfirmations(confirmations)
-    }
-  }
-
-  // get transactions from success signatures
-  const successConfirmationWithData = await Promise.all(
-    successConfirmations.map(
-      getSuccessExecutionTransaction(web3, bridgeContract, fromHome, messageData, startBlock, getSuccessTransactions)
-    )
-  )
-
-  const successConfirmationWithTxFound = successConfirmationWithData.filter(v => v.txHash !== '')
-  updateConfirmations(successConfirmationWithTxFound)
-
-  // If signatures not collected, look for pending transactions
-  if (!hasEnoughSignatures) {
+  // If signatures not collected, it needs to retry in the next blocks
+  if (successConfirmations.length !== requiredSignatures) {
     // 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
     )
-    updateConfirmations(validatorPendingConfirmations)
-    setPendingConfirmations(validatorPendingConfirmations.length > 0)
-  }
 
-  const undefinedConfirmations = validatorConfirmations.filter(
-    c => c.status === VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
-  )
+    validatorPendingConfirmations.forEach(validatorData => {
+      const index = validatorConfirmations.findIndex(e => e.validator === validatorData.validator)
+      validatorConfirmations[index] = validatorData
+    })
 
-  // Check if confirmation failed
-  const validatorFailedConfirmationsChecks = await Promise.all(
-    undefinedConfirmations.map(
-      getValidatorFailedTransaction(web3, bridgeContract, messageData, startBlock, getFailedTransactions)
-    )
-  )
-  let validatorFailedConfirmations = validatorFailedConfirmationsChecks.filter(
-    c => c.status === VALIDATOR_CONFIRMATION_STATUS.FAILED || c.status === VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID
-  )
-  if (hasEnoughSignatures && !fromHome) {
-    const lastTS = Math.max(...successConfirmationWithTxFound.map(c => c.timestamp || 0))
-    validatorFailedConfirmations = validatorFailedConfirmations.map(
-      c =>
-        c.timestamp < lastTS
-          ? c
-          : {
-              ...c,
-              status: VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID
-            }
-    )
-  }
-  setFailedConfirmations(
-    !hasEnoughSignatures && validatorFailedConfirmations.some(c => c.status === VALIDATOR_CONFIRMATION_STATUS.FAILED)
-  )
-  updateConfirmations(validatorFailedConfirmations)
-
-  const missingConfirmations = validatorConfirmations.filter(
-    c => c.status === VALIDATOR_CONFIRMATION_STATUS.UNDEFINED || c.status === VALIDATOR_CONFIRMATION_STATUS.PENDING
-  )
-
-  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,
-      timestamp: 0,
-      txHash: ''
-    }))
-    updateConfirmations(notRequiredConfirmations)
-  }
-
-  // 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)
+    if (validatorPendingConfirmations.length > 0) {
+      setPendingConfirmations(true)
     }
+
+    const undefinedConfirmations = validatorConfirmations.filter(
+      c => c.status === VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
+    )
+    // Check if confirmation failed
+    const validatorFailedConfirmationsChecks = await Promise.all(
+      undefinedConfirmations.map(
+        getValidatorFailedTransaction(bridgeContract, messageData, timestamp, 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) {
+      setFailedConfirmations(true)
+    }
+
+    const missingConfirmations = validatorConfirmations.filter(
+      c => c.status === VALIDATOR_CONFIRMATION_STATUS.UNDEFINED || c.status === VALIDATOR_CONFIRMATION_STATUS.PENDING
+    )
+
+    if (missingConfirmations.length > 0) {
+      shouldRetry = true
+    }
+  } else {
+    // If signatures collected, it should set other signatures as not required
+    const notRequiredConfirmations = notSuccessConfirmations.map(c => ({
+      validator: c.validator,
+      status: VALIDATOR_CONFIRMATION_STATUS.NOT_REQUIRED
+    }))
+
+    validatorConfirmations = [...successConfirmations, ...notRequiredConfirmations]
+    setSignatureCollected(true)
+  }
+
+  // Set confirmations to update UI and continue requesting the transactions for the signatures
+  setResult(validatorConfirmations)
+
+  // get transactions from success signatures
+  const successConfirmationWithData = await Promise.all(
+    validatorConfirmations
+      .filter(c => c.status === VALIDATOR_CONFIRMATION_STATUS.SUCCESS)
+      .map(getValidatorSuccessTransaction(bridgeContract, messageData, timestamp, getSuccessTransactions))
+  )
+
+  const successConfirmationWithTxFound = successConfirmationWithData.filter(v => v.txHash !== '')
+
+  const updatedValidatorConfirmations = [...validatorConfirmations]
+
+  if (successConfirmationWithTxFound.length > 0) {
+    successConfirmationWithTxFound.forEach(validatorData => {
+      const index = updatedValidatorConfirmations.findIndex(e => e.validator === validatorData.validator)
+      updatedValidatorConfirmations[index] = validatorData
+    })
+  }
+
+  setResult(updatedValidatorConfirmations)
+
+  // 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,
+          confirmationContractMethod,
+          setResult,
+          requiredSignatures,
+          setSignatureCollected,
+          waitingBlocksResolved,
+          subscriptions,
+          timestamp,
+          getFailedTransactions,
+          setFailedConfirmations,
+          getPendingTransactions,
+          setPendingConfirmations,
+          getSuccessTransactions
+        ),
+      HOME_RPC_POLLING_INTERVAL
+    )
+    subscriptions.push(timeoutId)
   }
 }

alm/src/utils/getFinalizationEvent.ts

@@ -1,51 +1,40 @@
 import { Contract, EventData } from 'web3-eth-contract'
 import Web3 from 'web3'
-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 { CACHE_KEY_EXECUTION_FAILED, THREE_DAYS_TIMESTAMP, VALIDATOR_CONFIRMATION_STATUS } from '../config/constants'
 import { ExecutionData } from '../hooks/useMessageConfirmations'
 import {
   APIPendingTransaction,
   APITransaction,
-  GetTransactionParams,
-  GetPendingTransactionParams,
-  getLogs
+  GetFailedTransactionParams,
+  GetPendingTransactionParams
 } from './explorer'
 import { getBlock, MessageObject } from './web3'
 import validatorsCache from '../services/ValidatorsCache'
-import { foreignBlockNumberProvider, homeBlockNumberProvider } from '../services/BlockNumberProvider'
 
-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,
+export const getFinalizationEvent = async (
+  contract: Maybe<Contract>,
   eventName: string,
-  web3: Web3,
-  messageId: string,
-  api: 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
 ) => {
+  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 getPastEventsWithFallback(api, web3, contract, eventName, {
+  const events: EventData[] = await contract.getPastEvents(eventName, {
     fromBlock: 0,
     toBlock: 'latest',
     filter: {
-      messageId
+      messageId: message.id
     }
   })
   if (events.length > 0) {
@@ -58,43 +47,14 @@ export const getSuccessExecutionData = async (
     const blockTimestamp = typeof block.timestamp === 'string' ? parseInt(block.timestamp) : block.timestamp
     const validatorAddress = web3.utils.toChecksumAddress(txReceipt.from)
 
-    return {
-      status: VALIDATOR_CONFIRMATION_STATUS.EXECUTION_SUCCESS,
+    setResult({
+      status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
       validator: validatorAddress,
       txHash: event.transactionHash,
       timestamp: blockTimestamp,
-      executionResult: event.returnValues.status,
-      blockNumber: event.blockNumber
-    }
-  }
-  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)
+      executionResult: event.returnValues.status
+    })
   } else {
-    setExecutionEventsFetched(true)
     // If event is defined, it means it is a message from Home to Foreign
     if (collectedSignaturesEvent) {
       const validator = collectedSignaturesEvent.returnValues.authorityResponsibleForRelay
@@ -116,22 +76,20 @@ export const getFinalizationEvent = async (
           validator: validator,
           txHash: pendingTx.hash,
           timestamp: nowTimestamp,
-          executionResult: false,
-          blockNumber: 0
+          executionResult: false
         })
         setPendingExecution(true)
       } 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,
-            startBlock,
-            endBlock: blockProvider.get() || 0
+            startTimestamp: timestamp,
+            endTimestamp: timestamp + THREE_DAYS_TIMESTAMP
           })
 
           if (failedTransactions.length > 0) {
@@ -146,8 +104,7 @@ export const getFinalizationEvent = async (
               validator: validator,
               txHash: failedTx.hash,
               timestamp,
-              executionResult: false,
-              blockNumber: parseInt(failedTx.blockNumber)
+              executionResult: false
             })
             setFailedExecution(true)
           }
@@ -155,28 +112,26 @@ export const getFinalizationEvent = async (
       }
     }
 
-    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)
-    }
+    const timeoutId = setTimeout(
+      () =>
+        getFinalizationEvent(
+          contract,
+          eventName,
+          web3,
+          setResult,
+          waitingBlocksResolved,
+          message,
+          interval,
+          subscriptions,
+          timestamp,
+          collectedSignaturesEvent,
+          getFailedExecution,
+          setFailedExecution,
+          getPendingExecution,
+          setPendingExecution
+        ),
+      interval
+    )
+    subscriptions.push(timeoutId)
   }
 }

alm/src/utils/networks.ts

@@ -1,9 +1,5 @@
 import { formatDistance } from 'date-fns'
-import {
-  CONFIRMATIONS_STATUS_DESCRIPTION,
-  CONFIRMATIONS_STATUS_DESCRIPTION_HOME,
-  TRANSACTION_STATUS_DESCRIPTION
-} from '../config/descriptions'
+import { CONFIRMATIONS_STATUS_DESCRIPTION, TRANSACTION_STATUS_DESCRIPTION } from '../config/descriptions'
 import { FOREIGN_EXPLORER_TX_TEMPLATE, HOME_EXPLORER_TX_TEMPLATE } from '../config/constants'
 
 export const validTxHash = (txHash: string) => /^0x[a-fA-F0-9]{64}$/.test(txHash)
@@ -35,8 +31,11 @@ export const getTransactionStatusDescription = (status: string, timestamp: Maybe
   return description
 }
 
-export const getConfirmationsStatusDescription = (status: string, home: string, foreign: string, fromHome: boolean) => {
-  const statusDescription = fromHome ? CONFIRMATIONS_STATUS_DESCRIPTION_HOME : CONFIRMATIONS_STATUS_DESCRIPTION
+export const getConfirmationsStatusDescription = (status: string, home: string, foreign: string) => {
+  let description = CONFIRMATIONS_STATUS_DESCRIPTION[status]
 
-  return statusDescription[status]
+  description = description.replace('%homeChain', home)
+  description = description.replace('%foreignChain', foreign)
+
+  return description
 }

alm/src/utils/signatureWaitingForBlocks.ts

@@ -0,0 +1,50 @@
+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) {
+    setWaitingStatus(false)
+    setWaitingBlocksResolved(true)
+    blockProvider.stop()
+  } else {
+    let nextInterval = interval
+    if (!currentBlock) {
+      nextInterval = 500
+    } else {
+      const validatorsWaiting = validatorList.map(validator => {
+        return {
+          validator,
+          status: VALIDATOR_CONFIRMATION_STATUS.WAITING
+        }
+      })
+      setWaitingStatus(true)
+      setConfirmations(validatorsWaiting)
+    }
+    const timeoutId = setTimeout(
+      () =>
+        checkSignaturesWaitingForBLocks(
+          targetBlock,
+          setWaitingStatus,
+          setWaitingBlocksResolved,
+          validatorList,
+          setConfirmations,
+          blockProvider,
+          interval,
+          subscriptions
+        ),
+      nextInterval
+    )
+    subscriptions.push(timeoutId)
+  }
+}

alm/src/utils/signatures.ts

@@ -1,26 +0,0 @@
-import Web3 from 'web3'
-
-function strip0x(s: string) {
-  return Web3.utils.isHexStrict(s) ? s.substr(2) : s
-}
-
-export interface Signature {
-  v: string
-  r: string
-  s: string
-}
-
-export function signatureToVRS(rawSignature: string): Signature {
-  const signature = strip0x(rawSignature)
-  const v = signature.substr(64 * 2)
-  const r = signature.substr(0, 32 * 2)
-  const s = signature.substr(32 * 2, 32 * 2)
-  return { v, r, s }
-}
-
-export function packSignatures(array: Array<Signature>): string {
-  const length = strip0x(Web3.utils.toHex(array.length))
-  const msgLength = length.length === 1 ? `0${length}` : length
-  const [v, r, s] = array.reduce(([vs, rs, ss], { v, r, s }) => [vs + v, rs + r, ss + s], ['', '', ''])
-  return `0x${msgLength}${v}${r}${s}`
-}

alm/src/utils/validatorConfirmationHelpers.ts

@@ -1,176 +0,0 @@
-import Web3 from 'web3'
-import { Contract } from 'web3-eth-contract'
-import { ConfirmationParam } from '../hooks/useMessageConfirmations'
-import validatorsCache from '../services/ValidatorsCache'
-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'
-import { getAffirmationsSigned, getMessagesSigned } from './contract'
-
-export const getValidatorConfirmation = (
-  web3: Web3,
-  hashMsg: string,
-  bridgeContract: Contract,
-  fromHome: boolean
-) => async (validator: string): Promise<ConfirmationParam> => {
-  const hashSenderMsg = web3.utils.soliditySha3Raw(validator, hashMsg)
-
-  const fromCache = validatorsCache.getData(hashSenderMsg)
-  if (fromCache) {
-    return fromCache
-  }
-
-  const confirmationContractMethod = fromHome ? getMessagesSigned : getAffirmationsSigned
-  const confirmed = await confirmationContractMethod(bridgeContract, hashSenderMsg)
-
-  // If validator confirmed signature, we cache the result to avoid doing future requests for a result that won't change
-  if (confirmed) {
-    const confirmation: ConfirmationParam = {
-      status: VALIDATOR_CONFIRMATION_STATUS.SUCCESS,
-      validator,
-      timestamp: 0,
-      txHash: ''
-    }
-    validatorsCache.setData(hashSenderMsg, confirmation)
-    return confirmation
-  }
-
-  return {
-    status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-    validator,
-    timestamp: 0,
-    txHash: ''
-  }
-}
-
-export const getSuccessExecutionTransaction = (
-  web3: Web3,
-  bridgeContract: Contract,
-  fromHome: boolean,
-  messageData: string,
-  startBlock: number,
-  getSuccessTransactions: (args: GetTransactionParams) => Promise<APITransaction[]>
-) => async (validatorData: ConfirmationParam): Promise<ConfirmationParam> => {
-  const { validator } = validatorData
-  const validatorCacheKey = `${CACHE_KEY_SUCCESS}${validatorData.validator}-${messageData}`
-  const fromCache = validatorsCache.getData(validatorCacheKey)
-
-  if (fromCache && fromCache.txHash) {
-    return fromCache
-  }
-
-  const transactions = await getSuccessTransactions({
-    account: validatorData.validator,
-    to: bridgeContract.options.address,
-    messageData,
-    startBlock,
-    endBlock: homeBlockNumberProvider.get() || 0
-  })
-
-  let txHashTimestamp = 0
-  let txHash = ''
-  const status = VALIDATOR_CONFIRMATION_STATUS.SUCCESS
-
-  if (transactions.length > 0) {
-    const tx = transactions[0]
-    txHashTimestamp = parseInt(tx.timeStamp)
-    txHash = tx.hash
-
-    // cache the result
-    validatorsCache.setData(validatorCacheKey, {
-      validator,
-      status,
-      txHash,
-      timestamp: txHashTimestamp
-    })
-  }
-
-  return {
-    validator,
-    status,
-    txHash,
-    timestamp: txHashTimestamp
-  }
-}
-
-export const getValidatorFailedTransaction = (
-  web3: Web3,
-  bridgeContract: Contract,
-  messageData: string,
-  startBlock: number,
-  getFailedTransactions: (args: GetTransactionParams) => Promise<APITransaction[]>
-) => async (validatorData: ConfirmationParam): Promise<ConfirmationParam> => {
-  const validatorCacheKey = `${CACHE_KEY_FAILED}${validatorData.validator}-${messageData}`
-  const failedFromCache = validatorsCache.getData(validatorCacheKey)
-
-  if (failedFromCache && failedFromCache.txHash) {
-    return failedFromCache
-  }
-
-  const failedTransactions = await getFailedTransactions({
-    account: validatorData.validator,
-    to: bridgeContract.options.address,
-    messageData,
-    startBlock,
-    endBlock: homeBlockNumberProvider.get() || 0
-  })
-  // If validator signature failed, we cache the result to avoid doing future requests for a result that won't change
-  if (failedTransactions.length > 0) {
-    const failedTx = failedTransactions[0]
-    const confirmation: ConfirmationParam = {
-      status: VALIDATOR_CONFIRMATION_STATUS.FAILED,
-      validator: validatorData.validator,
-      txHash: failedTx.hash,
-      timestamp: parseInt(failedTx.timeStamp)
-    }
-
-    if (failedTx.input && failedTx.input.length > 10) {
-      try {
-        const res = web3.eth.abi.decodeParameters(['bytes', 'bytes'], `0x${failedTx.input.slice(10)}`)
-        confirmation.signature = res[0]
-        confirmation.status = VALIDATOR_CONFIRMATION_STATUS.FAILED_VALID
-        console.log(`Adding manual signature from failed message from ${validatorData.validator}`)
-      } catch {}
-    }
-    validatorsCache.setData(validatorCacheKey, confirmation)
-    return confirmation
-  }
-
-  return {
-    status: VALIDATOR_CONFIRMATION_STATUS.UNDEFINED,
-    validator: validatorData.validator,
-    txHash: '',
-    timestamp: 0
-  }
-}
-
-export const getValidatorPendingTransaction = (
-  bridgeContract: Contract,
-  messageData: string,
-  getPendingTransactions: (args: GetPendingTransactionParams) => Promise<APIPendingTransaction[]>
-) => async (validatorData: ConfirmationParam): Promise<ConfirmationParam> => {
-  const failedTransactions = await getPendingTransactions({
-    account: validatorData.validator,
-    to: bridgeContract.options.address,
-    messageData
-  })
-
-  const newStatus =
-    failedTransactions.length > 0 ? VALIDATOR_CONFIRMATION_STATUS.PENDING : VALIDATOR_CONFIRMATION_STATUS.UNDEFINED
-
-  let timestamp = 0
-  let txHash = ''
-
-  if (failedTransactions.length > 0) {
-    const failedTx = failedTransactions[0]
-    timestamp = Math.floor(new Date().getTime() / 1000.0)
-    txHash = failedTx.hash
-  }
-
-  return {
-    validator: validatorData.validator,
-    status: newStatus,
-    txHash,
-    timestamp
-  }
-}

alm/src/utils/web3.ts

@@ -5,42 +5,10 @@ import { AbiItem } from 'web3-utils'
 import memoize from 'fast-memoize'
 import promiseRetry from 'promise-retry'
 import { HOME_AMB_ABI, FOREIGN_AMB_ABI } from '../abis'
-import { SnapshotProvider } from '../services/SnapshotProvider'
 
 export interface MessageObject {
   id: string
   data: string
-  sender?: string
-  executor?: string
-  obToken?: string
-  obReceiver?: string
-}
-
-export interface WarnRule {
-  message: string
-  sender?: string
-  executor?: string
-  obToken?: string
-  obReceiver?: string
-}
-
-export const matchesRule = (rule: WarnRule, msg: MessageObject) => {
-  if (!msg.executor || !msg.sender) {
-    return false
-  }
-  if (!!rule.executor && rule.executor.toLowerCase() !== msg.executor.toLowerCase()) {
-    return false
-  }
-  if (!!rule.sender && rule.sender.toLowerCase() !== msg.sender.toLowerCase()) {
-    return false
-  }
-  if (!!rule.obToken && (!msg.obToken || rule.obToken.toLowerCase() !== msg.obToken.toLowerCase())) {
-    return false
-  }
-  if (!!rule.obReceiver && (!msg.obReceiver || rule.obReceiver.toLowerCase() !== msg.obReceiver.toLowerCase())) {
-    return false
-  }
-  return true
 }
 
 const rawGetWeb3 = (url: string) => new Web3(new Web3.providers.HttpProvider(url))
@@ -57,33 +25,15 @@ export const filterEventsByAbi = (
   const eventHash = web3.eth.abi.encodeEventSignature(eventAbi)
   const events = txReceipt.logs.filter(e => e.address === bridgeAddress && e.topics[0] === eventHash)
 
-  if (!eventAbi || !eventAbi.inputs || !eventAbi.inputs.length) {
-    return []
-  }
-  const inputs = eventAbi.inputs
   return events.map(e => {
-    const { messageId, encodedData } = web3.eth.abi.decodeLog(inputs, e.data, [e.topics[1]])
-    let sender, executor, obToken, obReceiver
-    if (encodedData.length >= 160) {
-      sender = `0x${encodedData.slice(66, 106)}`
-      executor = `0x${encodedData.slice(106, 146)}`
-      const dataOffset =
-        160 + (parseInt(encodedData.slice(154, 156), 16) + parseInt(encodedData.slice(156, 158), 16)) * 2 + 8
-      if (encodedData.length >= dataOffset + 64) {
-        obToken = `0x${encodedData.slice(dataOffset + 24, dataOffset + 64)}`
-      }
-      if (encodedData.length >= dataOffset + 128) {
-        obReceiver = `0x${encodedData.slice(dataOffset + 88, dataOffset + 128)}`
-      }
+    let decodedLogs: { [p: string]: string } = {
+      messageId: '',
+      encodedData: ''
     }
-    return {
-      id: messageId || '',
-      data: encodedData || '',
-      sender,
-      executor,
-      obToken,
-      obReceiver
+    if (eventAbi && eventAbi.inputs && eventAbi.inputs.length) {
+      decodedLogs = web3.eth.abi.decodeLog(eventAbi.inputs, e.data, [e.topics[1]])
     }
+    return { id: decodedLogs.messageId, data: decodedLogs.encodedData }
   })
 }
 
@@ -111,11 +61,3 @@ export const getBlock = async (web3: Web3, blockNumber: number): Promise<BlockTr
     }
     return result
   })
-
-export const getChainId = async (web3: Web3, snapshotProvider: SnapshotProvider) => {
-  let id = snapshotProvider.chainId()
-  if (id === 0) {
-    id = await web3.eth.getChainId()
-  }
-  return id
-}

burner-wallet-plugin/staging/src/index.tsx

@@ -2,37 +2,19 @@ import React from 'react'
 import ReactDOM from 'react-dom'
 import BurnerCore from '@burner-wallet/core'
 import { InjectedSigner, LocalSigner } from '@burner-wallet/core/signers'
-import { XDaiBridge } from '@burner-wallet/exchange'
-import { xdai } from '@burner-wallet/assets'
-import { InfuraGateway, InjectedGateway, XDaiGateway } from '@burner-wallet/core/gateways'
+import { InfuraGateway, InjectedGateway } from '@burner-wallet/core/gateways'
 import Exchange from '@burner-wallet/exchange'
 import ModernUI from '@burner-wallet/modern-ui'
-import {
-  Etc,
-  Wetc,
-  Dai,
-  qDai,
-  MOON,
-  xMOON,
-  TokenBridgeGateway,
-  WETCBridge,
-  QDAIBridge,
-  MOONBridge
-} from '@poanet/tokenbridge-bw-exchange'
+import { Etc, Wetc, TokenBridgeGateway, WETCBridge } from '@poanet/tokenbridge-bw-exchange'
 import MetamaskPlugin from '@burner-wallet/metamask-plugin'
 
 const core = new BurnerCore({
   signers: [new InjectedSigner(), new LocalSigner()],
-  gateways: [
-    new InjectedGateway(),
-    new XDaiGateway(),
-    new InfuraGateway(process.env.REACT_APP_INFURA_KEY),
-    new TokenBridgeGateway()
-  ],
-  assets: [xdai, Wetc, Etc, Dai, qDai, MOON, xMOON]
+  gateways: [new InjectedGateway(), new InfuraGateway(process.env.REACT_APP_INFURA_KEY), new TokenBridgeGateway()],
+  assets: [Wetc, Etc]
 })
 
-const exchange = new Exchange([new XDaiBridge(), new WETCBridge(), new QDAIBridge(), new MOONBridge()])
+const exchange = new Exchange([new WETCBridge()])
 
 const BurnerWallet = () => <ModernUI title="Staging Wallet" core={core} plugins={[exchange, new MetamaskPlugin()]} />
 

burner-wallet-plugin/testing/src/index.tsx

@@ -93,7 +93,8 @@ if (process.env.REACT_APP_MODE === 'AMB_NATIVE_TO_ERC677') {
     network: process.env.REACT_APP_FOREIGN_NETWORK,
     // @ts-ignore
     address: process.env.REACT_APP_FOREIGN_TOKEN_ADDRESS,
-    bridgeModes: ['erc-to-native-amb']
+    // @ts-ignore
+    bridgeAddress: process.env.REACT_APP_FOREIGN_MEDIATOR_ADDRESS
   })
 
   testBridge = new MediatorErcToNative({

burner-wallet-plugin/tokenbridge-bw-exchange/README.md

@@ -4,16 +4,12 @@ This plugin defines a Bridge trading pair to be used in the Exchange Plugin.
 
 Bridge trading pairs and assets supported:
 * ETC - WETC Bridge
-* MOON - xMOON Bridge
-* DAI - qDAI Bridge (For qDAI Bridge, it's necessary to use a custom DAI token from this repo instead of the DAI asset provided by burner-wallet)
 
 It also provides some generic resources that can be used and extended:
-* **ERC677Asset** - A representation of an Erc677 token.
-* **BridgeableERC20Asset** - A representation of Erc20 token with a possibility of bridging it via a call to `relayTokens`.
+* **ERC677Asset** - A representation of an Erc677 token
 * **NativeMediatorAsset** - Represents a native token that interacts with a Mediator extension.
 * **Mediator Pair** - Represents an Exchange Pair that interacts with mediators extensions.
-* **MediatorErcToNative Pair** - Represents a modified Mediator Pair that interacts with a tokenbridge erc-to-native mediators contracts.
-* **TokenBridgeGateway** - A gateway to operate with ETC, POA Sokol, POA Core and qDAI networks.
+* **TokenBridgeGateway** - A gateway to operate with ETC, POA Sokol and POA Core networks. 
 
 ### Install package
 ```
@@ -22,22 +18,13 @@ yarn add @poanet/tokenbridge-bw-exchange
  
 ### Usage
 
-#### WETCBridge example
-In this example, we use `TokenBridgeGateway` for connecting to the Ethereum Classic and `InfuraGateway` for connecting to the Ethereum Mainnet.
-
-`WETCBridge` operates with two assets: `WETC` (Ethereum Mainnet) and `ETC` (Ethereum Classic), they should be added in the assets list.
-
 ```javascript
-import BurnerCore from '@burner-wallet/core'
-import Exchange from '@burner-wallet/exchange'
-import { LocalSigner } from '@burner-wallet/core/signers'
-import { Etc, Wetc, TokenBridgeGateway, WETCBridge } from '@poanet/tokenbridge-bw-exchange'
-import { InfuraGateway } from '@burner-wallet/core/gateways'
+import { Etc, Wetc, EtcGateway, WETCBridge } from '@poanet/tokenbridge-bw-exchange'
 
 const core = new BurnerCore({
-  signers: [new LocalSigner()],
-  gateways: [new TokenBridgeGateway(), new InfuraGateway(process.env.REACT_APP_INFURA_KEY)],
-  assets: [Wetc, Etc]
+  ...
+  gateways: [new EtcGateway(), new InfuraGateway(process.env.REACT_APP_INFURA_KEY)],
+  assets: [Etc, Wetc]
 })
 
 const exchange = new Exchange({
@@ -45,33 +32,6 @@ const exchange = new Exchange({
 })
 ```
 
-### Using several exchanges simultaneously
-In this example, we use `TokenBridgeGateway` for connecting to the qDAI chain, `XDaiGatewai` for connecting to the xDAI chain and `InfuraGateway` for connecting to the Ethereum Mainnet and Rinkeby Network.
-
-`QDAIBridge` operates with two assets: `qDAI` (qDAI chain) and `DAI` (Ethereum Mainnet). Note that we use a custom DAI token from the `@poanet/tokenbridge-bw-exchange`, this is necessary for allowing bridge operations on this token.
-
-`MOONBridge` operates with two assets: `MOON` (Rinkeby network) and `xMOON` (xDAI chain).
-
-All four assets should be added to the assets list.
-
-```javascript
-import BurnerCore from '@burner-wallet/core'
-import Exchange from '@burner-wallet/exchange'
-import { LocalSigner } from '@burner-wallet/core/signers'
-import { InfuraGateway, XDaiGateway } from '@burner-wallet/core/gateways'
-import { Dai, qDai, MOON, xMOON, TokenBridgeGateway, QDAIBridge, MOONBridge } from '@poanet/tokenbridge-bw-exchange'
-
-const core = new BurnerCore({
-  signers: [new LocalSigner()],
-  gateways: [new TokenBridgeGateway(), new XDaiGateway(), new InfuraGateway(process.env.REACT_APP_INFURA_KEY)],
-  assets: [Dai, qDai, MOON, xMOON]
-})
-
-const exchange = new Exchange({
-  pairs: [new QDAIBridge(), new MOONBridge()]
-})
-```
-
 This is how the exchange plugin will look like:
 
 ![exchange-wetc](https://user-images.githubusercontent.com/4614574/80991095-e40d0900-8e0d-11ea-9915-1b4e4a052694.png) 

burner-wallet-plugin/tokenbridge-bw-exchange/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poanet/tokenbridge-bw-exchange",
-  "version": "1.1.0",
+  "version": "1.0.0",
   "license": "GPL-3.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

burner-wallet-plugin/tokenbridge-bw-exchange/src/bridges/MOONBridge.ts

@@ -1,12 +0,0 @@
-import { Mediator } from '../burner-wallet'
-
-export default class MOONBridge extends Mediator {
-  constructor() {
-    super({
-      assetA: 'xmoon',
-      assetABridge: '0x1E0507046130c31DEb20EC2f870ad070Ff266079',
-      assetB: 'moon',
-      assetBBridge: '0xFEaB457D95D9990b7eb6c943c839258245541754'
-    })
-  }
-}

burner-wallet-plugin/tokenbridge-bw-exchange/src/bridges/QDAIBridge.ts

@@ -1,12 +0,0 @@
-import { MediatorErcToNative } from '../burner-wallet'
-
-export default class QDAIBridge extends MediatorErcToNative {
-  constructor() {
-    super({
-      assetA: 'qdai',
-      assetABridge: '0xFEaB457D95D9990b7eb6c943c839258245541754',
-      assetB: 'dai',
-      assetBBridge: '0xf6edFA16926f30b0520099028A145F4E06FD54ed'
-    })
-  }
-}

burner-wallet-plugin/tokenbridge-bw-exchange/src/bridges/index.ts

@@ -1,3 +0,0 @@
-export { default as WETCBridge } from './WETCBridge'
-export { default as QDAIBridge } from './QDAIBridge'
-export { default as MOONBridge } from './MOONBridge'

burner-wallet-plugin/tokenbridge-bw-exchange/src/burner-wallet/assets/BridgeableERC20Asset.ts

@@ -1,55 +1,42 @@
 import { ERC20Asset } from '@burner-wallet/assets'
-import { AssetConstructor } from '@burner-wallet/assets/Asset'
-import { MEDIATOR_ABI, constants, isBridgeContract } from '../../utils'
-import { toBN, soliditySha3 } from 'web3-utils'
+import { MEDIATOR_ABI, constants } from '../../utils'
+import { toBN } from 'web3-utils'
 
-interface BridgeableERC20Constructor extends AssetConstructor {
+interface BridgeableERC20Constructor {
   abi?: object
   address: string
-  bridgeModes: string[]
+  id: string
+  name: string
+  network: string
+  bridgeAddress: string
 }
 
 export default class BridgeableERC20Asset extends ERC20Asset {
-  private _bridgeModes
-  private _bridges: { [addr: string]: object | false }
+  protected bridgeAddress: string
+  private _bridge
 
-  public set bridgeModes(bridgeModes: string[]) {
-    this._bridgeModes = bridgeModes.map(s => soliditySha3(s)!.slice(0, 10))
+  constructor({ bridgeAddress, ...params }: BridgeableERC20Constructor) {
+    super({ ...params })
+    this.bridgeAddress = bridgeAddress.toLowerCase()
   }
 
-  public get bridgeModes() {
-    return this._bridgeModes
-  }
-
-  constructor({
-    bridgeModes = ['erc-to-native-core', 'erc-to-native-amb', 'erc-to-erc-core', 'erc-to-erc-amb'],
-    ...params
-  }: BridgeableERC20Constructor) {
-    super(params)
-    this._bridges = {}
-    this.bridgeModes = bridgeModes
-  }
-
-  async getBridgeContract(addr: string) {
-    if (typeof this._bridges[addr] === 'undefined') {
+  getBridgeContract() {
+    if (!this._bridge) {
       const Contract = this.getWeb3().eth.Contract
-      const bridge = new Contract(MEDIATOR_ABI, addr)
-      if (await isBridgeContract(bridge, this.bridgeModes)) {
-        return (this._bridges[addr] = bridge)
-      }
-      return (this._bridges[addr] = false)
+      this._bridge = new Contract(MEDIATOR_ABI, this.bridgeAddress)
     }
-    return this._bridges[addr]
+    return this._bridge
   }
 
   async _send({ from, to, value }) {
-    const bridge = await this.getBridgeContract(to)
-    if (bridge) {
+    if (to.toLowerCase() === this.bridgeAddress) {
       const allowance = await this.allowance(from, to)
       if (toBN(allowance).lt(toBN(value))) {
         await this.approve(from, to, value)
       }
-      const receipt = await bridge.methods.relayTokens(from, value).send({ from })
+      const receipt = await this.getBridgeContract()
+        .methods.relayTokens(from, value)
+        .send({ from })
       const transferLog = Object.values(receipt.events as object).find(
         e => e.raw.topics[0] === constants.TRANSFER_TOPIC
       )

burner-wallet-plugin/tokenbridge-bw-exchange/src/burner-wallet/assets/Dai.ts

@@ -1,11 +0,0 @@
-import BridgeableERC20Asset from './BridgeableERC20Asset'
-
-export default new BridgeableERC20Asset({
-  id: 'dai',
-  name: 'Dai',
-  network: '1',
-  address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-  usdPrice: 1,
-  icon: 'https://static.burnerfactory.com/icons/mcd.svg',
-  bridgeModes: ['erc-to-native-amb']
-})

burner-wallet-plugin/tokenbridge-bw-exchange/src/burner-wallet/assets/ERC677Asset.ts

@@ -1,12 +1,14 @@
 import { ERC20Asset } from '@burner-wallet/assets'
-import { AssetConstructor } from '@burner-wallet/assets/Asset'
 import { ERC677_ABI, constants } from '../../utils'
 
 const BLOCK_LOOKBACK = 250
 
-interface ERC677Constructor extends AssetConstructor {
+interface ERC677Constructor {
   abi?: object
   address: string
+  id: string
+  name: string
+  network: string
 }
 
 export default class ERC677Asset extends ERC20Asset {

burner-wallet-plugin/tokenbridge-bw-exchange/src/burner-wallet/assets/Etc.ts

@@ -1,5 +1,5 @@
 import NativeMediatorAsset from './NativeMediatorAsset'
-import { isVanillaBridgeContract, HOME_NATIVE_TO_ERC_ABI } from '../../utils'
+import { isBridgeContract, HOME_NATIVE_TO_ERC_ABI } from '../../utils'
 
 class EtcNativeAsset extends NativeMediatorAsset {
   constructor(props) {
@@ -9,7 +9,7 @@ class EtcNativeAsset extends NativeMediatorAsset {
   async scanMediatorEvents(address, fromBlock, toBlock) {
     const web3 = this.getWeb3()
     const contract = new web3.eth.Contract(HOME_NATIVE_TO_ERC_ABI, this.mediatorAddress)
-    const listenToBridgeEvent = await isVanillaBridgeContract(contract)
+    const listenToBridgeEvent = await isBridgeContract(contract)
     if (listenToBridgeEvent && this.mediatorAddress != '') {
       const events = await contract.getPastEvents('AffirmationCompleted', {
         fromBlock,

burner-wallet-plugin/tokenbridge-bw-exchange/src/burner-wallet/assets/MOON.ts

@@ -1,10 +0,0 @@
-import BridgeableERC20Asset from './BridgeableERC20Asset'
-
-export default new BridgeableERC20Asset({
-  id: 'moon',
-  name: 'MOON',
-  network: '4',
-  address: '0xDF82c9014F127243CE1305DFE54151647d74B27A',
-  icon: 'https://blockscout.com/poa/xdai/images/icons/moon.png',
-  bridgeModes: ['erc-to-erc-amb']
-})

burner-wallet-plugin/tokenbridge-bw-exchange/src/burner-wallet/assets/NativeMediatorAsset.ts

@@ -1,10 +1,12 @@
 import { NativeAsset } from '@burner-wallet/assets'
 import { Contract, EventData } from 'web3-eth-contract'
 import { MEDIATOR_ABI } from '../../utils'
-import { AssetConstructor } from '@burner-wallet/assets/Asset'
 
-interface NativeMediatorConstructor extends AssetConstructor {
+interface NativeMediatorConstructor {
   mediatorAddress?: string
+  id: string
+  name: string
+  network: string
 }
 
 export default class NativeMediatorAsset extends NativeAsset {

burner-wallet-plugin/tokenbridge-bw-exchange/src/burner-wallet/assets/qDai.ts

@@ -1,9 +0,0 @@
-import NativeMediatorAsset from './NativeMediatorAsset'
-
-export default new NativeMediatorAsset({
-  id: 'qdai',
-  name: 'qDai',
-  network: '181',
-  usdPrice: 1,
-  mediatorAddress: '0xFEaB457D95D9990b7eb6c943c839258245541754'
-})

burner-wallet-plugin/tokenbridge-bw-exchange/src/burner-wallet/assets/xMOON.ts

@@ -1,9 +0,0 @@
-import { default as ERC677Asset } from './ERC677Asset'
-
-export default new ERC677Asset({
-  id: 'xmoon',
-  name: 'xMOON',
-  network: '100',
-  address: '0x1e16aa4Df73d29C029d94CeDa3e3114EC191E25A',
-  icon: 'https://blockscout.com/poa/xdai/images/icons/moon.png'
-})

burner-wallet-plugin/tokenbridge-bw-exchange/src/burner-wallet/gateways/TokenBridgeGateway.ts

@@ -9,8 +9,7 @@ export default class TokenBridgeGateway extends Gateway {
     this.providerStrings = {
       '61': `https://www.ethercluster.com/etc`,
       '77': 'https://sokol.poa.network',
-      '99': 'https://core.poa.network',
-      '181': 'https://quorum-rpc.tokenbridge.net'
+      '99': 'https://core.poa.network'
     }
     this.providers = {}
   }
@@ -20,7 +19,7 @@ export default class TokenBridgeGateway extends Gateway {
   }
 
   getNetworks() {
-    return ['61', '77', '99', '181']
+    return ['61', '77', '99']
   }
 
   _provider(network) {

burner-wallet-plugin/tokenbridge-bw-exchange/src/burner-wallet/index.ts

@@ -1,10 +1,6 @@
 export { default as sPOA } from './assets/sPOA'
 export { default as Etc } from './assets/Etc'
 export { default as Wetc } from './assets/Wetc'
-export { default as Dai } from './assets/Dai'
-export { default as qDai } from './assets/qDai'
-export { default as MOON } from './assets/MOON'
-export { default as xMOON } from './assets/xMOON'
 export { default as ERC677Asset } from './assets/ERC677Asset'
 export { default as BridgeableERC20Asset } from './assets/BridgeableERC20Asset'
 export { default as NativeMediatorAsset } from './assets/NativeMediatorAsset'

burner-wallet-plugin/tokenbridge-bw-exchange/src/index.ts

@@ -5,12 +5,8 @@ export {
   sPOA,
   Etc,
   Wetc,
-  qDai,
-  Dai,
-  MOON,
-  xMOON,
   TokenBridgeGateway,
   Mediator,
   MediatorErcToNative
 } from './burner-wallet'
-export { WETCBridge, QDAIBridge, MOONBridge } from './bridges'
+export { WETCBridge } from './wetc-bridge'

burner-wallet-plugin/tokenbridge-bw-exchange/src/utils/abis/Mediator.ts

@@ -52,19 +52,5 @@ export default [
     payable: false,
     stateMutability: 'nonpayable',
     type: 'function'
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: 'getBridgeMode',
-    outputs: [
-      {
-        name: '',
-        type: 'bytes4'
-      }
-    ],
-    payable: false,
-    stateMutability: 'pure',
-    type: 'function'
   }
 ]

burner-wallet-plugin/tokenbridge-bw-exchange/src/utils/index.ts

@@ -1,4 +1,4 @@
-export { constants, wait, waitForEvent, isVanillaBridgeContract, isBridgeContract } from './utils'
+export { constants, wait, waitForEvent, isBridgeContract } from './utils'
 export {
   ERC677_ABI,
   FOREIGN_NATIVE_TO_ERC_ABI,

burner-wallet-plugin/tokenbridge-bw-exchange/src/utils/utils.ts

@@ -34,7 +34,7 @@ export const waitForEvent = async (web3, contract: Contract, event: string, call
   }
 }
 
-export const isVanillaBridgeContract = async (contract: Contract): Promise<boolean> => {
+export const isBridgeContract = async (contract: Contract): Promise<boolean> => {
   try {
     await contract.methods.deployedAtBlock().call()
     return true
@@ -42,15 +42,3 @@ export const isVanillaBridgeContract = async (contract: Contract): Promise<boole
     return false
   }
 }
-
-export const isBridgeContract = async (contract: Contract, allowedModes?: string[]): Promise<boolean> => {
-  try {
-    const mode = await contract.methods.getBridgeMode().call()
-    if (typeof allowedModes === 'undefined') {
-      return true
-    }
-    return allowedModes.includes(mode)
-  } catch (e) {
-    return false
-  }
-}

burner-wallet-plugin/tokenbridge-bw-exchange/src/wetc-bridge/WETCBridge.ts

@@ -1,6 +1,6 @@
 import { Mediator } from '../burner-wallet'
 import { HOME_NATIVE_TO_ERC_ABI, FOREIGN_NATIVE_TO_ERC_ABI } from '../utils'
-import { waitForEvent, isVanillaBridgeContract, constants } from '../utils'
+import { waitForEvent, isBridgeContract, constants } from '../utils'
 import { ValueTypes } from '@burner-wallet/exchange'
 import { toBN, fromWei } from 'web3-utils'
 
@@ -19,7 +19,7 @@ export default class WETCBridge extends Mediator {
       .getAsset(this.assetA)
       .getWeb3()
     const contract = new web3.eth.Contract(HOME_NATIVE_TO_ERC_ABI, this.assetABridge)
-    const listenToBridgeEvent = await isVanillaBridgeContract(contract)
+    const listenToBridgeEvent = await isBridgeContract(contract)
     if (listenToBridgeEvent) {
       await waitForEvent(web3, contract, 'AffirmationCompleted', this.processBridgeEvents(sendResult.txHash))
     } else {
@@ -32,7 +32,7 @@ export default class WETCBridge extends Mediator {
       .getAsset(this.assetB)
       .getWeb3()
     const contract = new web3.eth.Contract(FOREIGN_NATIVE_TO_ERC_ABI, this.assetBBridge)
-    const listenToBridgeEvent = await isVanillaBridgeContract(contract)
+    const listenToBridgeEvent = await isBridgeContract(contract)
     if (listenToBridgeEvent) {
       await waitForEvent(web3, contract, 'RelayedMessage', this.processBridgeEvents(sendResult.txHash))
     } else {
@@ -53,7 +53,7 @@ export default class WETCBridge extends Mediator {
       .getWeb3()
     const contract = new web3.eth.Contract(FOREIGN_NATIVE_TO_ERC_ABI, this.assetBBridge)
 
-    const useBridgeContract = await isVanillaBridgeContract(contract)
+    const useBridgeContract = await isBridgeContract(contract)
 
     if (useBridgeContract) {
       const fee = toBN(await contract.methods.getHomeFee().call())
@@ -79,7 +79,7 @@ export default class WETCBridge extends Mediator {
       .getWeb3()
     const contract = new web3.eth.Contract(HOME_NATIVE_TO_ERC_ABI, this.assetABridge)
 
-    const useBridgeContract = await isVanillaBridgeContract(contract)
+    const useBridgeContract = await isBridgeContract(contract)
 
     if (useBridgeContract) {
       const fee = toBN(await contract.methods.getForeignFee().call())

burner-wallet-plugin/tokenbridge-bw-exchange/src/wetc-bridge/index.ts

@@ -0,0 +1 @@
+export { default as WETCBridge } from './WETCBridge'

burner-wallet-plugin/yarn.lock

@@ -2600,11 +2600,6 @@
   resolved "https://registry.yarnpkg.com/@types/minimatch/-/minimatch-3.0.3.tgz#3dca0e3f33b200fc7d1139c0cd96c1268cadfd9d"
   integrity sha512-tHq6qdbT9U1IRSGf14CL0pUlULksvY9OZ+5eEgl1N7t+OA3tGvNpxJCzuKQlsNgCVwbAs670L1vcVQi8j9HjnA==
 
-"@types/mocha@^7.0.2":
-  version "7.0.2"
-  resolved "https://registry.yarnpkg.com/@types/mocha/-/mocha-7.0.2.tgz#b17f16cf933597e10d6d78eae3251e692ce8b0ce"
-  integrity sha512-ZvO2tAcjmMi8V/5Z3JsyofMe3hasRcaw88cto5etSVMwVQfeivGAlEYmaQgceUSVYFofVjT+ioHsATjdWcFt1w==
-
 "@types/node@*", "@types/node@>= 8":
   version "13.11.0"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-13.11.0.tgz#390ea202539c61c8fa6ba4428b57e05bc36dc47b"
@@ -3220,11 +3215,6 @@ are-we-there-yet@~1.1.2:
     delegates "^1.0.0"
     readable-stream "^2.0.6"
 
-arg@^4.1.0:
-  version "4.1.3"
-  resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
-  integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
-
 argparse@^1.0.7:
   version "1.0.10"
   resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
@@ -3350,11 +3340,6 @@ assert@^1.1.1:
     object-assign "^4.1.1"
     util "0.10.3"
 
-assertion-error@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.1.0.tgz#e60b6b0e8f301bd97e5375215bda406c85118c0b"
-  integrity sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==
-
 assign-symbols@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
@@ -3450,13 +3435,6 @@ axios@^0.18.0:
     follow-redirects "1.5.10"
     is-buffer "^2.0.2"
 
-axios@^0.19.0:
-  version "0.19.2"
-  resolved "https://registry.yarnpkg.com/axios/-/axios-0.19.2.tgz#3ea36c5d8818d0d5f8a8a97a6d36b86cdc00cb27"
-  integrity sha512-fjgm5MvRHLhx+osE2xoekY70AhARk3a6hkN+3Io1jc00jtquGvxYlKlsFUhmUET0V5te6CcZI7lcv2Ym61mjHA==
-  dependencies:
-    follow-redirects "1.5.10"
-
 axobject-query@^2.0.2:
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/axobject-query/-/axobject-query-2.1.2.tgz#2bdffc0371e643e5f03ba99065d5179b9ca79799"
@@ -3821,11 +3799,6 @@ browser-resolve@^1.11.3:
   dependencies:
     resolve "1.1.7"
 
-browser-stdout@1.3.1:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60"
-  integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
-
 browserify-aes@^1.0.0, browserify-aes@^1.0.4, browserify-aes@^1.0.6:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/browserify-aes/-/browserify-aes-1.2.0.tgz#326734642f403dabc3003209853bb70ad428ef48"
@@ -4215,18 +4188,6 @@ caseless@~0.12.0:
   resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
   integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=
 
-chai@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/chai/-/chai-4.2.0.tgz#760aa72cf20e3795e84b12877ce0e83737aa29e5"
-  integrity sha512-XQU3bhBukrOsQCuwZndwGcCVQHyZi53fQ6Ys1Fym7E4olpIqqZZhhoFJoaKVvV17lWQoXYwgWN2nF5crA8J2jw==
-  dependencies:
-    assertion-error "^1.1.0"
-    check-error "^1.0.2"
-    deep-eql "^3.0.1"
-    get-func-name "^2.0.0"
-    pathval "^1.1.0"
-    type-detect "^4.0.5"
-
 chalk@2.4.2, chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.3.0, chalk@^2.3.1, chalk@^2.4.1, chalk@^2.4.2:
   version "2.4.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
@@ -4252,11 +4213,6 @@ chardet@^0.7.0:
   resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e"
   integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==
 
-check-error@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/check-error/-/check-error-1.0.2.tgz#574d312edd88bb5dd8912e9286dd6c0aed4aac82"
-  integrity sha1-V00xLt2Iu13YkS6Sht1sCu1KrII=
-
 check-types@^8.0.3:
   version "8.0.3"
   resolved "https://registry.yarnpkg.com/check-types/-/check-types-8.0.3.tgz#3356cca19c889544f2d7a95ed49ce508a0ecf552"
@@ -4490,11 +4446,6 @@ combined-stream@^1.0.6, combined-stream@~1.0.6:
   dependencies:
     delayed-stream "~1.0.0"
 
-commander@2.15.1:
-  version "2.15.1"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.15.1.tgz#df46e867d0fc2aec66a34662b406a9ccafff5b0f"
-  integrity sha512-VlfT9F3V0v+jr4yxPc5gg9s62/fIVWsd2Bk2iD435um1NlGMYdVCq+MjcXnhYq2icNOizHr1kK+5TI6H0Hy0ag==
-
 commander@2.17.x:
   version "2.17.1"
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.17.1.tgz#bd77ab7de6de94205ceacc72f1716d29f20a77bf"
@@ -5290,13 +5241,6 @@ dedent@^0.7.0:
   resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c"
   integrity sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=
 
-deep-eql@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/deep-eql/-/deep-eql-3.0.1.tgz#dfc9404400ad1c8fe023e7da1df1c147c4b444df"
-  integrity sha512-+QeIQyN5ZuO+3Uk5DYh6/1eKO0m0YmJFGNmFHGACpf1ClL1nmlV/p4gNgbl2pJGxgXb4faqo6UE+M5ACEMyVcw==
-  dependencies:
-    type-detect "^4.0.0"
-
 deep-equal@^1.0.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/deep-equal/-/deep-equal-1.1.1.tgz#b5c98c942ceffaf7cb051e24e1434a25a2e6076a"
@@ -5469,16 +5413,6 @@ diff-sequences@^24.9.0:
   resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-24.9.0.tgz#5715d6244e2aa65f48bba0bc972db0b0b11e95b5"
   integrity sha512-Dj6Wk3tWyTE+Fo1rW8v0Xhwk80um6yFYKbuAxc9c3EZxIHFDYwbi34Uk42u1CdnIiVorvt4RmlSDjIPyzGC2ew==
 
-diff@3.5.0:
-  version "3.5.0"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-3.5.0.tgz#800c0dd1e0a8bfbc95835c202ad220fe317e5a12"
-  integrity sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==
-
-diff@^4.0.1:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
-  integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
-
 diffie-hellman@^5.0.0:
   version "5.0.3"
   resolved "https://registry.yarnpkg.com/diffie-hellman/-/diffie-hellman-5.0.3.tgz#40e8ee98f55a2149607146921c63e1ae5f3d2875"
@@ -7159,11 +7093,6 @@ get-caller-file@^2.0.1:
   resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
   integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
 
-get-func-name@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/get-func-name/-/get-func-name-2.0.0.tgz#ead774abee72e20409433a066366023dd6887a41"
-  integrity sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=
-
 get-own-enumerable-property-symbols@^3.0.0:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz#b5fde77f22cbe35f390b4e089922c50bce6ef664"
@@ -7298,18 +7227,6 @@ glob-to-regexp@^0.3.0:
   resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.3.0.tgz#8c5a1494d2066c570cc3bfe4496175acc4d502ab"
   integrity sha1-jFoUlNIGbFcMw7/kSWF1rMTVAqs=
 
-glob@7.1.2:
-  version "7.1.2"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.2.tgz#c19c9df9a028702d678612384a6552404c636d15"
-  integrity sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.0.4"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
 glob@^7.0.3, glob@^7.1.1, glob@^7.1.2, glob@^7.1.3, glob@^7.1.4:
   version "7.1.6"
   resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6"
@@ -7443,11 +7360,6 @@ graceful-fs@^4.1.10, graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.
   resolved "https://registry.yarnpkg.com/graceful-readlink/-/graceful-readlink-1.0.1.tgz#4cafad76bc62f02fa039b2f94e9a3dd3a391a725"
   integrity sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=
 
-growl@1.10.5:
-  version "1.10.5"
-  resolved "https://registry.yarnpkg.com/growl/-/growl-1.10.5.tgz#f2735dc2283674fa67478b10181059355c369e5e"
-  integrity sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==
-
 growly@^1.3.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/growly/-/growly-1.3.0.tgz#f10748cbe76af964b7c96c93c6bcc28af120c081"
@@ -7606,11 +7518,6 @@ hdkey@^1.1.1:
     safe-buffer "^5.1.1"
     secp256k1 "^3.0.1"
 
-he@1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/he/-/he-1.1.1.tgz#93410fd21b009735151f8868c2f271f3427e23fd"
-  integrity sha1-k0EP0hsAlzUVH4howvJx80J+I/0=
-
 he@1.2.x:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f"
@@ -9685,11 +9592,6 @@ make-dir@^2.0.0, make-dir@^2.1.0:
     pify "^4.0.1"
     semver "^5.6.0"
 
-make-error@^1.1.1:
-  version "1.3.6"
-  resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
-  integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
-
 make-fetch-happen@^5.0.0:
   version "5.0.2"
   resolved "https://registry.yarnpkg.com/make-fetch-happen/-/make-fetch-happen-5.0.2.tgz#aa8387104f2687edca01c8687ee45013d02d19bd"
@@ -10041,11 +9943,6 @@ minimist-options@^3.0.1:
     arrify "^1.0.1"
     is-plain-obj "^1.1.0"
 
-minimist@0.0.8:
-  version "0.0.8"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d"
-  integrity sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=
-
 minimist@^1.1.1, minimist@^1.1.3, minimist@^1.2.0, minimist@^1.2.5:
   version "1.2.5"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
@@ -10110,13 +10007,6 @@ mkdirp@*:
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
   integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
 
-mkdirp@0.5.1:
-  version "0.5.1"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903"
-  integrity sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=
-  dependencies:
-    minimist "0.0.8"
-
 mkdirp@^0.5.0, mkdirp@^0.5.1:
   version "0.5.5"
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def"
@@ -10131,23 +10021,6 @@ mkdirp@~0.5.0, mkdirp@~0.5.1:
   dependencies:
     minimist "^1.2.5"
 
-mocha@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/mocha/-/mocha-5.2.0.tgz#6d8ae508f59167f940f2b5b3c4a612ae50c90ae6"
-  integrity sha512-2IUgKDhc3J7Uug+FxMXuqIyYzH7gJjXECKe/w43IGgQHTSj3InJi+yAA7T24L9bQMRKiUEHxEX37G5JpVUGLcQ==
-  dependencies:
-    browser-stdout "1.3.1"
-    commander "2.15.1"
-    debug "3.1.0"
-    diff "3.5.0"
-    escape-string-regexp "1.0.5"
-    glob "7.1.2"
-    growl "1.10.5"
-    he "1.1.1"
-    minimatch "3.0.4"
-    mkdirp "0.5.1"
-    supports-color "5.4.0"
-
 mock-fs@^4.1.0:
   version "4.11.0"
   resolved "https://registry.yarnpkg.com/mock-fs/-/mock-fs-4.11.0.tgz#0828107e4b843a6ba855ecebfe3c6e073b69db92"
@@ -11094,11 +10967,6 @@ path-type@^4.0.0:
   resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
   integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
 
-pathval@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/pathval/-/pathval-1.1.0.tgz#b942e6d4bde653005ef6b71361def8727d0645e0"
-  integrity sha1-uULm1L3mUwBe9rcTYd74cn0GReA=
-
 pbkdf2@^3.0.3:
   version "3.0.17"
   resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.0.17.tgz#976c206530617b14ebb32114239f7b09336e93a6"
@@ -13403,14 +13271,6 @@ source-map-support@0.5.6:
     buffer-from "^1.0.0"
     source-map "^0.6.0"
 
-source-map-support@^0.5.17:
-  version "0.5.19"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
-  integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
-  dependencies:
-    buffer-from "^1.0.0"
-    source-map "^0.6.0"
-
 source-map-support@^0.5.6, source-map-support@~0.5.10, source-map-support@~0.5.12:
   version "0.5.16"
   resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.16.tgz#0ae069e7fe3ba7538c64c98515e35339eac5a042"
@@ -13852,13 +13712,6 @@ stylis@^3.5.0:
   resolved "https://registry.yarnpkg.com/stylis/-/stylis-3.5.4.tgz#f665f25f5e299cf3d64654ab949a57c768b73fbe"
   integrity sha512-8/3pSmthWM7lsPBKv7NXkzn2Uc9W7NotcwGNpJaa3k7WMM1XDCA4MgT5k/8BIexd5ydZdboXtU90XH9Ec4Bv/Q==
 
-supports-color@5.4.0:
-  version "5.4.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.4.0.tgz#1c6b337402c2137605efe19f10fec390f6faab54"
-  integrity sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==
-  dependencies:
-    has-flag "^3.0.0"
-
 supports-color@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7"
@@ -14223,17 +14076,6 @@ tryer@^1.0.1:
   resolved "https://registry.yarnpkg.com/tryer/-/tryer-1.0.1.tgz#f2c85406800b9b0f74c9f7465b81eaad241252f8"
   integrity sha512-c3zayb8/kWWpycWYg87P71E1S1ZL6b6IJxfb5fvsUgsf0S2MVGaDhDXXjDMpdCpfWXqptc+4mXwmiy1ypXqRAA==
 
-ts-node@^8.8.2:
-  version "8.10.2"
-  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-8.10.2.tgz#eee03764633b1234ddd37f8db9ec10b75ec7fb8d"
-  integrity sha512-ISJJGgkIpDdBhWVu3jufsWpK3Rzo7bdiIXJjQc0ynKxVOVcg2oIrf2H2cejminGrptVc6q6/uynAHNCuWGbpVA==
-  dependencies:
-    arg "^4.1.0"
-    diff "^4.0.1"
-    make-error "^1.1.1"
-    source-map-support "^0.5.17"
-    yn "3.1.1"
-
 ts-pnp@1.1.2:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/ts-pnp/-/ts-pnp-1.1.2.tgz#be8e4bfce5d00f0f58e0666a82260c34a57af552"
@@ -14280,11 +14122,6 @@ type-check@~0.3.2:
   dependencies:
     prelude-ls "~1.1.2"
 
-type-detect@^4.0.0, type-detect@^4.0.5:
-  version "4.0.8"
-  resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c"
-  integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==
-
 type-fest@^0.3.0:
   version "0.3.1"
   resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.3.1.tgz#63d00d204e059474fe5e1b7c011112bbd1dc29e1"
@@ -14330,11 +14167,6 @@ typescript@3.5.3:
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.5.3.tgz#c830f657f93f1ea846819e929092f5fe5983e977"
   integrity sha512-ACzBtm/PhXBDId6a6sDJfroT2pOWt/oOnk4/dElG5G33ZL776N3Y6/6bKZJBFpd+b05F3Ct9qDjMeJmRWtE2/g==
 
-typescript@^3.5.2:
-  version "3.9.7"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.9.7.tgz#98d600a5ebdc38f40cb277522f12dc800e9e25fa"
-  integrity sha512-BLbiRkiBzAwsjut4x/dsibSTB6yWpwT5qWmC2OfuCg3GgVQCSgMs4vEctYPhsaGtd0AeuuHMkjZ2h2WG8MSzRw==
-
 uglify-js@3.4.x:
   version "3.4.10"
   resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.4.10.tgz#9ad9563d8eb3acdfb8d38597d2af1d815f6a755f"
@@ -15649,8 +15481,3 @@ yauzl@^2.4.2:
   dependencies:
     buffer-crc32 "~0.2.3"
     fd-slicer "~1.1.0"
-
-yn@3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
-  integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==

commons/.eslintrc

@@ -5,8 +5,7 @@
   ],
   "rules": {
     "no-unused-expressions": "off",
-    "import/no-extraneous-dependencies": "off",
-    "no-bitwise": "off"
+    "import/no-extraneous-dependencies": "off"
   },
   "env": {
     "mocha": true

commons/abis.js

@@ -1,17 +1,58 @@
+const HOME_NATIVE_TO_ERC_ABI = require('../contracts/build/contracts/HomeBridgeNativeToErc').abi
+const FOREIGN_NATIVE_TO_ERC_ABI = require('../contracts/build/contracts/ForeignBridgeNativeToErc').abi
+const HOME_ERC_TO_ERC_ABI = require('../contracts/build/contracts/HomeBridgeErcToErc').abi
+const FOREIGN_ERC_TO_ERC_ABI = require('../contracts/build/contracts/ForeignBridgeErc677ToErc677').abi
 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 ERC677_ABI = require('../contracts/build/contracts/ERC677').abi
+const ERC677_BRIDGE_TOKEN_ABI = require('../contracts/build/contracts/ERC677BridgeToken').abi
+const BLOCK_REWARD_ABI = require('../contracts/build/contracts/BlockReward').abi
 const BRIDGE_VALIDATORS_ABI = require('../contracts/build/contracts/BridgeValidators').abi
 const REWARDABLE_VALIDATORS_ABI = require('../contracts/build/contracts/RewardableValidators').abi
 const HOME_AMB_ABI = require('../contracts/build/contracts/HomeAMB').abi
 const FOREIGN_AMB_ABI = require('../contracts/build/contracts/ForeignAMB').abi
 const BOX_ABI = require('../contracts/build/contracts/Box').abi
+const SAI_TOP = require('../contracts/build/contracts/SaiTopMock').abi
 const HOME_AMB_ERC_TO_ERC_ABI = require('../contracts/build/contracts/HomeAMBErc677ToErc677').abi
 const FOREIGN_AMB_ERC_TO_ERC_ABI = require('../contracts/build/contracts/ForeignAMBErc677ToErc677').abi
+const HOME_STAKE_ERC_TO_ERC_ABI = require('../contracts/build/contracts/HomeStakeTokenMediator').abi
+const FOREIGN_STAKE_ERC_TO_ERC_ABI = require('../contracts/build/contracts/ForeignStakeTokenMediator').abi
 
+const { HOME_V1_ABI, FOREIGN_V1_ABI } = require('./v1Abis')
 const { BRIDGE_MODES } = require('./constants')
 
+const ERC20_BYTES32_ABI = [
+  {
+    constant: true,
+    inputs: [],
+    name: 'name',
+    outputs: [
+      {
+        name: '',
+        type: 'bytes32'
+      }
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function'
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'symbol',
+    outputs: [
+      {
+        name: '',
+        type: 'bytes32'
+      }
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function'
+  }
+]
+
 const OLD_AMB_USER_REQUEST_FOR_SIGNATURE_ABI = [
   {
     anonymous: false,
@@ -45,15 +86,27 @@ const OLD_AMB_USER_REQUEST_FOR_AFFIRMATION_ABI = [
 function getBridgeABIs(bridgeMode) {
   let HOME_ABI = null
   let FOREIGN_ABI = null
-  if (bridgeMode === BRIDGE_MODES.ERC_TO_NATIVE) {
+  if (bridgeMode === BRIDGE_MODES.NATIVE_TO_ERC) {
+    HOME_ABI = HOME_NATIVE_TO_ERC_ABI
+    FOREIGN_ABI = FOREIGN_NATIVE_TO_ERC_ABI
+  } else if (bridgeMode === BRIDGE_MODES.ERC_TO_ERC) {
+    HOME_ABI = HOME_ERC_TO_ERC_ABI
+    FOREIGN_ABI = FOREIGN_ERC_TO_ERC_ABI
+  } else if (bridgeMode === BRIDGE_MODES.ERC_TO_NATIVE) {
     HOME_ABI = HOME_ERC_TO_NATIVE_ABI
     FOREIGN_ABI = FOREIGN_ERC_TO_NATIVE_ABI
+  } else if (bridgeMode === BRIDGE_MODES.NATIVE_TO_ERC_V1) {
+    HOME_ABI = HOME_V1_ABI
+    FOREIGN_ABI = FOREIGN_V1_ABI
   } else if (bridgeMode === BRIDGE_MODES.ARBITRARY_MESSAGE) {
     HOME_ABI = HOME_AMB_ABI
     FOREIGN_ABI = FOREIGN_AMB_ABI
   } else if (bridgeMode === BRIDGE_MODES.AMB_ERC_TO_ERC) {
     HOME_ABI = HOME_AMB_ERC_TO_ERC_ABI
     FOREIGN_ABI = FOREIGN_AMB_ERC_TO_ERC_ABI
+  } else if (bridgeMode === BRIDGE_MODES.STAKE_AMB_ERC_TO_ERC) {
+    HOME_ABI = HOME_STAKE_ERC_TO_ERC_ABI
+    FOREIGN_ABI = FOREIGN_STAKE_ERC_TO_ERC_ABI
   } else {
     throw new Error(`Unrecognized bridge mode: ${bridgeMode}`)
   }
@@ -63,15 +116,27 @@ function getBridgeABIs(bridgeMode) {
 
 module.exports = {
   getBridgeABIs,
+  HOME_NATIVE_TO_ERC_ABI,
+  FOREIGN_NATIVE_TO_ERC_ABI,
+  HOME_ERC_TO_ERC_ABI,
+  FOREIGN_ERC_TO_ERC_ABI,
   HOME_ERC_TO_NATIVE_ABI,
   FOREIGN_ERC_TO_NATIVE_ABI,
   ERC20_ABI,
+  ERC677_ABI,
+  ERC677_BRIDGE_TOKEN_ABI,
   BLOCK_REWARD_ABI,
   BRIDGE_VALIDATORS_ABI,
   REWARDABLE_VALIDATORS_ABI,
+  HOME_V1_ABI,
+  FOREIGN_V1_ABI,
+  ERC20_BYTES32_ABI,
   HOME_AMB_ABI,
   FOREIGN_AMB_ABI,
   OLD_AMB_USER_REQUEST_FOR_AFFIRMATION_ABI,
   OLD_AMB_USER_REQUEST_FOR_SIGNATURE_ABI,
-  BOX_ABI
+  BOX_ABI,
+  SAI_TOP,
+  HOME_STAKE_ERC_TO_ERC_ABI,
+  FOREIGN_STAKE_ERC_TO_ERC_ABI
 }

commons/constants.js

@@ -1,12 +1,30 @@
 const BRIDGE_MODES = {
+  NATIVE_TO_ERC: 'NATIVE_TO_ERC',
+  ERC_TO_ERC: 'ERC_TO_ERC',
   ERC_TO_NATIVE: 'ERC_TO_NATIVE',
+  NATIVE_TO_ERC_V1: 'NATIVE_TO_ERC_V1',
   ARBITRARY_MESSAGE: 'ARBITRARY_MESSAGE',
-  AMB_ERC_TO_ERC: 'AMB_ERC_TO_ERC'
+  AMB_ERC_TO_ERC: 'AMB_ERC_TO_ERC',
+  STAKE_AMB_ERC_TO_ERC: 'STAKE_AMB_ERC_TO_ERC'
+}
+
+const ERC_TYPES = {
+  ERC20: 'ERC20',
+  ERC677: 'ERC677'
+}
+
+const FEE_MANAGER_MODE = {
+  ONE_DIRECTION: 'ONE_DIRECTION',
+  BOTH_DIRECTIONS: 'BOTH_DIRECTIONS',
+  ONE_DIRECTION_STAKE: 'ONE_DIRECTION_STAKE',
+  UNDEFINED: 'UNDEFINED'
 }
 
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
 
 module.exports = {
   BRIDGE_MODES,
+  ERC_TYPES,
+  FEE_MANAGER_MODE,
   ZERO_ADDRESS
 }

commons/message.js

@@ -1,18 +1,10 @@
-const { soliditySha3 } = require('web3-utils')
-
 function strip0x(input) {
   return input.replace(/^0x/, '')
 }
 
-/**
- * Decodes the datatype byte from the AMB message.
- * First (the most significant bit) denotes if the message should be forwarded to the manual lane.
- * @param dataType: number datatype of the received AMB message.
- * @return {{manualLane: boolean}}
- */
-const decodeAMBDataType = dataType => ({
-  manualLane: (dataType & 128) === 128
-})
+function addTxHashToData({ encodedData, transactionHash }) {
+  return encodedData.slice(0, 2) + strip0x(transactionHash) + encodedData.slice(2)
+}
 
 function parseAMBMessage(message) {
   message = strip0x(message)
@@ -20,56 +12,16 @@ function parseAMBMessage(message) {
   const messageId = `0x${message.slice(0, 64)}`
   const sender = `0x${message.slice(64, 104)}`
   const executor = `0x${message.slice(104, 144)}`
-  const dataType = parseInt(message.slice(156, 158), 16)
 
   return {
     sender,
     executor,
-    messageId,
-    dataType,
-    decodedDataType: decodeAMBDataType(dataType)
+    messageId
   }
 }
 
-const normalizeAMBMessageEvent = e => {
-  let msgData = e.returnValues.encodedData
-  if (!e.returnValues.messageId) {
-    // append tx hash to an old message, where message id was not used
-    // for old messages, e.messageId is a corresponding transactionHash
-    msgData = e.transactionHash + msgData.slice(2)
-  }
-  return parseAMBMessage(msgData)
-}
-
-const ambInformationSignatures = [
-  'eth_call(address,bytes)',
-  'eth_call(address,bytes,uint256)',
-  'eth_call(address,address,uint256,bytes)',
-  'eth_blockNumber()',
-  'eth_getBlockByNumber()',
-  'eth_getBlockByNumber(uint256)',
-  'eth_getBlockByHash(bytes32)',
-  'eth_getBalance(address)',
-  'eth_getBalance(address,uint256)',
-  'eth_getTransactionCount(address)',
-  'eth_getTransactionCount(address,uint256)',
-  'eth_getTransactionByHash(bytes32)',
-  'eth_getTransactionReceipt(bytes32)',
-  'eth_getStorageAt(address,bytes32)',
-  'eth_getStorageAt(address,bytes32,uint256)'
-]
-const ambInformationSelectors = Object.fromEntries(ambInformationSignatures.map(sig => [soliditySha3(sig), sig]))
-const normalizeAMBInfoRequest = e => ({
-  messageId: e.returnValues.messageId,
-  sender: e.returnValues.sender,
-  requestSelector: ambInformationSelectors[e.returnValues.requestSelector] || 'unknown',
-  data: e.returnValues.data
-})
-
 module.exports = {
-  strip0x,
+  addTxHashToData,
   parseAMBMessage,
-  normalizeAMBMessageEvent,
-  ambInformationSignatures,
-  normalizeAMBInfoRequest
+  strip0x
 }

commons/package.json

@@ -8,10 +8,7 @@
     "test": "NODE_ENV=test mocha"
   },
   "dependencies": {
-    "@mycrypto/gas-estimation": "^1.1.0",
-    "gas-price-oracle": "^0.1.5",
-    "web3-utils": "^1.3.0",
-    "node-fetch": "^2.1.2"
+    "web3-utils": "1.0.0-beta.34"
   },
   "devDependencies": {
     "bn-chai": "^1.0.1",

commons/test/constants.test.js

@@ -1,8 +1,12 @@
 const { expect } = require('chai')
-const { BRIDGE_MODES } = require('../constants')
+const { BRIDGE_MODES, ERC_TYPES } = require('../constants')
 
 describe('constants', () => {
   it('should contain correct number of bridge types', () => {
-    expect(Object.keys(BRIDGE_MODES).length).to.be.equal(3)
+    expect(Object.keys(BRIDGE_MODES).length).to.be.equal(7)
+  })
+
+  it('should contain correct number of erc types', () => {
+    expect(Object.keys(ERC_TYPES).length).to.be.equal(2)
   })
 })

commons/test/getTokenType.js

@@ -0,0 +1,159 @@
+const { expect } = require('chai')
+const { getTokenType, ERC_TYPES } = require('..')
+
+describe('getTokenType', () => {
+  it('should return ERC677 if bridgeContract is equal to bridgeAddress', async () => {
+    // Given
+    const bridgeAddress = '0xCecBE80Ed3548dE11D7d2D922a36576eA40C4c26'
+    const contract = {
+      methods: {
+        bridgeContract: () => {
+          return {
+            call: () => Promise.resolve(bridgeAddress)
+          }
+        }
+      }
+    }
+
+    // When
+    const type = await getTokenType(contract, bridgeAddress)
+
+    // Then
+    expect(type).to.equal(ERC_TYPES.ERC677)
+  })
+
+  it('should return ERC20 if bridgeContract is not equal to bridgeAddress', async () => {
+    // Given
+    const bridgeAddress = '0xCecBE80Ed3548dE11D7d2D922a36576eA40C4c26'
+    const contract = {
+      methods: {
+        bridgeContract: () => {
+          return {
+            call: () => Promise.resolve('0xBFCb120F7B1de491262CA4D9D8Eba70438b6896E')
+          }
+        }
+      }
+    }
+
+    // When
+    const type = await getTokenType(contract, bridgeAddress)
+
+    // Then
+    expect(type).to.equal(ERC_TYPES.ERC20)
+  })
+
+  it('should return ERC20 if bridgeContract is not present', async () => {
+    // Given
+    const bridgeAddress = '0xCecBE80Ed3548dE11D7d2D922a36576eA40C4c26'
+    const contract = {
+      methods: {
+        bridgeContract: () => {
+          return {
+            call: () => Promise.reject()
+          }
+        }
+      }
+    }
+
+    // When
+    const type = await getTokenType(contract, bridgeAddress)
+
+    // Then
+    expect(type).to.equal(ERC_TYPES.ERC20)
+  })
+
+  it('should return ERC20 if bridgeContract and isBridge are not present', async () => {
+    // Given
+    const bridgeAddress = '0xCecBE80Ed3548dE11D7d2D922a36576eA40C4c26'
+    const contract = {
+      methods: {
+        bridgeContract: () => {
+          return {
+            call: () => Promise.reject()
+          }
+        },
+        isBridge: () => {
+          return {
+            call: () => Promise.reject()
+          }
+        }
+      }
+    }
+
+    // When
+    const type = await getTokenType(contract, bridgeAddress)
+
+    // Then
+    expect(type).to.equal(ERC_TYPES.ERC20)
+  })
+
+  it('should return ERC677 if isBridge returns true', async () => {
+    // Given
+    const bridgeAddress = '0xCecBE80Ed3548dE11D7d2D922a36576eA40C4c26'
+    const contract = {
+      methods: {
+        bridgeContract: () => {
+          return {
+            call: () => Promise.reject()
+          }
+        },
+        isBridge: () => {
+          return {
+            call: () => Promise.resolve(true)
+          }
+        }
+      }
+    }
+
+    // When
+    const type = await getTokenType(contract, bridgeAddress)
+
+    // Then
+    expect(type).to.equal(ERC_TYPES.ERC677)
+  })
+
+  it('should return ERC677 if isBridge returns true and bridgeContract not present', async () => {
+    // Given
+    const bridgeAddress = '0xCecBE80Ed3548dE11D7d2D922a36576eA40C4c26'
+    const contract = {
+      methods: {
+        isBridge: () => {
+          return {
+            call: () => Promise.resolve(true)
+          }
+        }
+      }
+    }
+
+    // When
+    const type = await getTokenType(contract, bridgeAddress)
+
+    // Then
+    expect(type).to.equal(ERC_TYPES.ERC677)
+  })
+
+  it('should return ERC20 if isBridge returns false', async () => {
+    // Given
+    const bridgeAddress = '0xCecBE80Ed3548dE11D7d2D922a36576eA40C4c26'
+    const contract = {
+      methods: {
+        bridgeContract: () => {
+          return {
+            call: () => Promise.reject()
+          }
+        },
+        isBridge: () => {
+          return {
+            call: () => Promise.resolve(false)
+          }
+        }
+      }
+    }
+
+    // When
+    const type = await getTokenType(contract, bridgeAddress)
+
+    // Then
+    expect(type).to.equal(ERC_TYPES.ERC20)
+  })
+})