Merge the develop branch to the master branch, preparation to v2.0.0

.circleci/config.yml

@@ -11,7 +11,7 @@ orbs:
                 sudo apt-get clean
                 sudo apt-get update
                 sudo apt-get install dpkg
-          - run: 
+          - 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
@@ -89,29 +89,29 @@ jobs:
       - 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 
+          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" }}
+          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
+          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
+          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 }}
@@ -143,11 +143,11 @@ jobs:
   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
+      - 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:
@@ -161,9 +161,9 @@ jobs:
   monitor-e2e:
     executor: tokenbridge-orb/machine-with-docker-caching
     steps:
-        - checkout
-        - run: git submodule update --init
-        - run: ./monitor-e2e/run-tests.sh
+      - checkout
+      - run: git submodule update --init
+      - run: ./monitor-e2e/run-tests.sh
   cover:
     executor: tokenbridge-orb/docker-node
     steps:
@@ -194,7 +194,7 @@ jobs:
     steps:
       - checkout
       - run: git submodule update --init
-      - run: 
+      - run:
           name: Run the scenario
           command: deployment-e2e/molecule.sh monitor
           no_output_timeout: 40m
@@ -210,7 +210,15 @@ jobs:
           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:
@@ -222,6 +230,11 @@ jobs:
         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
@@ -232,16 +245,24 @@ jobs:
       - tokenbridge-orb/yarn-install-cached-on-machine
       - run:
           name: Prepare the infrastructure
-          command: e2e-commons/up.sh deploy << parameters.scenario-name >>
+          command: e2e-commons/up.sh deploy << parameters.scenario-name >> blocks
           no_output_timeout: 50m
       - tokenbridge-orb/wait-for-oracle:
           redis-key: << parameters.redis-key >>
-      - run:
-          name: Run the ui-e2e tests
-          command: |
-            nvm use default;
-            node ./e2e-commons/scripts/blocks.js &
-            cd ui-e2e; yarn mocha -g "<< parameters.ui-e2e-grep >>" -b ./test.js
+      - 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:
@@ -272,18 +293,24 @@ workflows:
       - deployment-ui
       - deployment-monitor
       - deployment-repo
+      - deployment-multiple
       - ultimate:
-          name: "ultimate: native to erc" 
+          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" 
+          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" 
+          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"

README.md

@@ -66,11 +66,13 @@ Clone the repository:
 git clone https://github.com/poanetwork/tokenbridge
 ```
 
-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
 ```
 
+Then refer to the corresponding README files to get information about particular TokenBridge component.
+
 ## Linting
 
 Running linter for all JS projects:

deployment-e2e/molecule/multiple/Dockerfile.j2

@@ -0,0 +1,14 @@
+# Molecule managed
+
+{% if item.registry is defined %}
+FROM {{ item.registry.url }}/{{ item.image }}
+{% else %}
+FROM {{ item.image }}
+{% endif %}
+
+RUN if [ $(command -v apt-get) ]; then apt-get update && apt-get install -y python sudo bash ca-certificates && apt-get clean; \
+    elif [ $(command -v dnf) ]; then dnf makecache && dnf --assumeyes install python sudo python-devel python*-dnf bash && dnf clean all; \
+    elif [ $(command -v yum) ]; then yum makecache fast && yum install -y python sudo yum-plugin-ovl bash && sed -i 's/plugins=0/plugins=1/g' /etc/yum.conf && yum clean all; \
+    elif [ $(command -v zypper) ]; then zypper refresh && zypper install -y python sudo bash python-xml && zypper clean -a; \
+    elif [ $(command -v apk) ]; then apk update && apk add --no-cache python sudo bash ca-certificates; \
+    elif [ $(command -v xbps-install) ]; then xbps-install -Syu && xbps-install -y python sudo bash ca-certificates && xbps-remove -O; fi

deployment-e2e/molecule/multiple/molecule.yml

@@ -0,0 +1,59 @@
+---
+dependency:
+  name: galaxy
+driver:
+  name: docker
+lint:
+  name: yamllint
+  enabled: True
+  options:
+    config-data:
+      ignore: ../../hosts.yml
+platforms:
+  - name: multiple-host
+    groups:
+      - example
+    children:
+      - oracle
+      - monitor
+      - ui
+    image: ubuntu:16.04
+    privileged: true
+    network_mode: host
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+provisioner:
+  name: ansible
+  lint:
+    name: ansible-lint
+    enabled: True
+    options:
+      r: ["bug"]
+  playbooks:
+    prepare: ../prepare.yml
+    converge: ../monitor/converge.yml
+  inventory:
+    host_vars:
+      multiple-host:
+        ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY: "8e829f695aed89a154550f30262f1529582cc49dc30eff74a6b491359e0230f9"
+        MONITOR_PORT: 3003
+        syslog_server_port: "udp://127.0.0.1:514"
+verifier:
+  name: testinfra
+  lint:
+    name: flake8
+  additional_files_or_dirs:
+    - ../../tests/*
+scenario:
+  name: multiple
+  test_sequence:
+    - lint
+    - cleanup
+    - destroy
+    - dependency
+    - syntax
+    - create
+    - prepare
+    - converge
+    - verify
+    - destroy

deployment-e2e/molecule/multiple/tests/test_multiple.py

@@ -0,0 +1,32 @@
+import os
+import pytest
+import testinfra.utils.ansible_runner
+
+testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
+    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')
+
+
+@pytest.mark.parametrize("service", [
+    ("poabridge"),
+    ("tokenbridge-ui"),
+    ("tokenbridge-monitor")
+])
+def test_services(host, service):
+    assert host.service(service).is_enabled
+    assert host.service(service).is_running
+
+
+@pytest.mark.parametrize("name", [
+    ("oracle_rabbit_1"),
+    ("oracle_redis_1"),
+    ("oracle_bridge_request_1"),
+    ("oracle_bridge_collected_1"),
+    ("oracle_bridge_affirmation_1"),
+    ("oracle_bridge_senderhome_1"),
+    ("oracle_bridge_senderforeign_1"),
+    ("ui_ui_1"),
+    ("monitor_monitor_1")
+])
+def test_docker_containers(host, name):
+    container = host.docker(name)
+    assert container.is_running

deployment-e2e/molecule/tests/test_all.py

@@ -9,7 +9,6 @@ testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
 def test_repo(host):
     assert host.file('/home/poadocker/bridge').exists
     assert host.file('/home/poadocker/bridge').is_directory
-    assert host.file('/home/poadocker/bridge/package.json').exists
 
 
 def test_docker_group(host):

deployment-e2e/molecule/ultimate-amb/Dockerfile.j2

@@ -0,0 +1,14 @@
+# Molecule managed
+
+{% if item.registry is defined %}
+FROM {{ item.registry.url }}/{{ item.image }}
+{% else %}
+FROM {{ item.image }}
+{% endif %}
+
+RUN if [ $(command -v apt-get) ]; then apt-get update && apt-get install -y python sudo bash ca-certificates && apt-get clean; \
+    elif [ $(command -v dnf) ]; then dnf makecache && dnf --assumeyes install python sudo python-devel python*-dnf bash && dnf clean all; \
+    elif [ $(command -v yum) ]; then yum makecache fast && yum install -y python sudo yum-plugin-ovl bash && sed -i 's/plugins=0/plugins=1/g' /etc/yum.conf && yum clean all; \
+    elif [ $(command -v zypper) ]; then zypper refresh && zypper install -y python sudo bash python-xml && zypper clean -a; \
+    elif [ $(command -v apk) ]; then apk update && apk add --no-cache python sudo bash ca-certificates; \
+    elif [ $(command -v xbps-install) ]; then xbps-install -Syu && xbps-install -y python sudo bash ca-certificates && xbps-remove -O; fi

deployment-e2e/molecule/ultimate-amb/molecule.yml

@@ -0,0 +1,40 @@
+---
+driver:
+  name: docker
+platforms:
+  - name: oracle-amb-host
+    groups:
+      - ultimate
+      - amb
+    children:
+      - oracle
+    image: ubuntu:16.04
+    privileged: true
+    network_mode: host
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+provisioner:
+  name: ansible
+  playbooks:
+    prepare: ../prepare.yml
+    converge: ../ultimate-commons/converge.yml
+  inventory:
+    host_vars:
+      oracle-amb-host:
+        COMMON_HOME_RPC_URL: "http://parity1:8545"
+        COMMON_FOREIGN_RPC_URL: "http://parity2:8545"
+        ORACLE_VALIDATOR_ADDRESS: "0xaaB52d66283F7A1D5978bcFcB55721ACB467384b"
+        ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY: "8e829f695aed89a154550f30262f1529582cc49dc30eff74a6b491359e0230f9"
+verifier:
+  name: testinfra
+  lint:
+    name: flake8
+scenario:
+  name: ultimate-amb
+  test_sequence:
+    - cleanup
+    - destroy
+    - syntax
+    - create
+    - prepare
+    - converge

deployment-e2e/molecule/ultimate-commons/oracle-add-docker-external-network.yml

@@ -1,7 +1,7 @@
 ---
 - name: Slurp docker compose file
   slurp:
-    src: "/home/poadocker/bridge/oracle/{{ item }}.yml"
+    src: "/home/poadocker/bridge/oracle/{{ file }}.yml"
   register: docker_compose_slurp
 - name: Parse docker compose file
   set_fact:
@@ -23,4 +23,4 @@
 - name: Write updated docker file
   copy:
     content: "{{ docker_compose_parsed | to_yaml }}"
-    dest: "/home/poadocker/bridge/oracle/{{ item }}.yml"
+    dest: "/home/poadocker/bridge/oracle/{{ file }}.yml"

deployment-e2e/molecule/ultimate-commons/oracle-docker-compose.yml

@@ -6,11 +6,30 @@
   - name: stop the service
     shell: service poabridge stop
 
-  - include_tasks: oracle-add-docker-external-network.yml
+  - name: Build current oracle image
+    shell: docker build -t oracle:ultimate-testing --file oracle/Dockerfile .
+    delegate_to: 127.0.0.1
+    become: false
+    args:
+      chdir: "{{ lookup('env', 'PWD') }}/.."
+
+  - name: Replace oracle image
+    replace:
+      path: "/home/poadocker/bridge/oracle/{{ item }}.yml"
+      regexp: 'poanetwork/tokenbridge-oracle:latest'
+      replace: "oracle:ultimate-testing"
     with_items:
       - docker-compose
       - docker-compose-transfer
       - docker-compose-erc-native
 
+  - include_tasks: oracle-add-docker-external-network.yml
+    with_items:
+      - docker-compose
+      - docker-compose-transfer
+      - docker-compose-erc-native
+    loop_control:
+      loop_var: file
+
   - name: start the service
     shell: service poabridge start

deployment/group_vars/amb.yml

@@ -0,0 +1,5 @@
+---
+ORACLE_BRIDGE_MODE: "ARBITRARY_MESSAGE"
+COMMON_HOME_BRIDGE_ADDRESS: "0x0AEe1FCD12dDFab6265F7f8956e6E012A9Fe4Aa0"
+COMMON_FOREIGN_BRIDGE_ADDRESS: "0x0AEe1FCD12dDFab6265F7f8956e6E012A9Fe4Aa0"
+MONITOR_PORT: 3013

deployment/roles/common/tasks/dependencies.yml

@@ -32,6 +32,9 @@
     group: "root"
     mode: "0755"
 
+- name: Upgrade pip version
+  shell: pip3 install --upgrade pip
+
 - name: Install python docker library
   shell: pip3 install docker docker-compose setuptools
 

deployment/roles/common/tasks/main.yml

@@ -1,6 +1,6 @@
 ---
 - name: Check if component is already deployed
-  shell: "test -f {{ bridge_path }}/{{ component }}/docker-compose.yml && echo 'true'"
+  shell: "test -f {{ bridge_path }}/{{ component }}/.env && echo 'true'"
   ignore_errors: True
   register: already_deployed
   when: check_deployed is defined
@@ -14,7 +14,7 @@
 
 - name: Include repo tasks
   include_tasks: repo.yml
-  when: skip_task != true
+  when: skip_task != true and skip_repo is undefined
 
 - name: Include logging tasks
   include_tasks: logging.yml

deployment/roles/monitor/meta/main.yml

@@ -1,3 +1,3 @@
 ---
 dependencies:
-  - { role: common, check_deployed: true, component: 'monitor' }
+  - { role: common, skip_repo: true, check_deployed: true, component: 'monitor' }

deployment/roles/monitor/tasks/jumpbox.yml

@@ -1,5 +1,5 @@
 ---
-- name: Build the containers
-  shell: docker-compose build
+- name: Pull the containers images
+  shell: docker-compose pull
   args:
     chdir: "{{ bridge_path }}/monitor"

deployment/roles/monitor/tasks/pre_config.yml

@@ -1,10 +1,46 @@
 ---
+- name: Create configs directory
+  file:
+    path: "{{ bridge_path }}/monitor/configs"
+    state: directory
+    mode: '0755'
+  when: skip_task != true
+
+- name: Create responses directory
+  file:
+    path: "{{ bridge_path }}/monitor/responses"
+    state: directory
+    mode: '0755'
+  when: skip_task != true
+
+- name: Create scripts directory
+  file:
+    path: "{{ bridge_path }}/monitor/scripts"
+    state: directory
+    mode: '0755'
+  when: skip_task != true
+
 - name: Install .env config
   template:
     src: .env.j2
     dest: "{{ bridge_path }}/monitor/.env"
   when: skip_task != true
 
+- name: Copy docker-compose file
+  copy:
+    src: ../../../../monitor/docker-compose.yml
+    dest: "{{ bridge_path }}/monitor/docker-compose.yml"
+    mode: '0755'
+  when: skip_task != true
+
+- name: Copy script file
+  copy:
+    src: ../../../../monitor/scripts/getBridgeStats.sh
+    dest: "{{ bridge_path }}/monitor/scripts/getBridgeStats.sh"
+    owner: "{{ compose_service_user }}"
+    mode: '0755'
+  when: skip_task != true
+
 - name: Install bridge config env
   template:
     src: config.env.j2

deployment/roles/monitor/tasks/servinstall.yml

@@ -1,6 +1,5 @@
 # This role creates a tokenbridge-monitor service which is designed to manage docker-compose monitor deployment.
 # /etc/init.d/tokenbridge-monitor start, status, stop, restart - does what the services usually do in such cases.
-# /etc/init.d/tokenbridge-monitor rebuild - builds a new monitor deployment from scratch.
 ---
 - name: "Set the service"
   template:

deployment/roles/monitor/templates/tokenbridge-monitor.j2

@@ -34,14 +34,6 @@ status(){
     sudo -u "{{ compose_service_user }}" /usr/local/bin/docker-compose  ps
 }
 
-rebuild(){
-    echo "Rebuild TokenBridge Monitor.."
-    cd $WORKDIR
-    sudo -u "{{ compose_service_user }}" /usr/local/bin/docker-compose  down -v
-    sudo -u "{{ compose_service_user }}" /usr/local/bin/docker-compose  rm -fv
-    sudo -u "{{ compose_service_user }}" /usr/local/bin/docker-compose  up  --detach --force-recreate --no-deps --build
-}
-
 
 case "$1" in
 
@@ -63,12 +55,8 @@ case "$1" in
     start
     ;;
 
-  rebuild)
-    rebuild
-    ;;
-
   *)
-    echo $"Usage: $0 {start|stop|restart|rebuild|status}"
+    echo $"Usage: $0 {start|stop|restart|status}"
     exit 1
     ;;
 

deployment/roles/oracle/meta/main.yml

@@ -1,3 +1,3 @@
 ---
 dependencies:
-  - role: common
+  - { role: common, skip_repo: true }

deployment/roles/oracle/tasks/jumpbox.yml

@@ -1,5 +1,5 @@
 ---
-- name: Build the containers
-  shell: docker-compose build
+- name: Pull the containers images
+  shell: docker-compose pull
   args:
     chdir: "{{ bridge_path }}/oracle"

deployment/roles/oracle/tasks/logging.yml

@@ -4,6 +4,8 @@
     - docker-compose
     - docker-compose-transfer
     - docker-compose-erc-native
+  loop_control:
+    loop_var: file
 
 - name: Set the local container logs configuration file
   template:

deployment/roles/oracle/tasks/logging_by_syslog.yml

@@ -1,7 +1,7 @@
 ---
 - name: Slurp docker compose file
   slurp:
-    src: "{{ bridge_path }}/oracle/{{ item }}.yml"
+    src: "{{ bridge_path }}/oracle/{{ file }}.yml"
   register: docker_compose_slurp
 
 - name: Parse docker compose file
@@ -16,4 +16,4 @@
 - name: Write updated docker file
   copy:
     content: "{{ docker_compose_parsed | to_yaml }}"
-    dest: "{{ bridge_path }}/oracle/{{ item }}.yml"
+    dest: "{{ bridge_path }}/oracle/{{ file }}.yml"

deployment/roles/oracle/tasks/post_config.yml

@@ -1,7 +1,7 @@
 ---
 - name: Get blocks
   become_user: "{{ compose_service_user }}"
-  shell: docker-compose run --entrypoint "node scripts/getValidatorStartBlocks.js" bridge_affirmation
+  shell: docker-compose run --rm --entrypoint "node scripts/getValidatorStartBlocks.js" bridge_affirmation
   args:
     chdir: "{{ bridge_path }}/oracle"
   register: BLOCKS
@@ -18,7 +18,7 @@
 
 - name: Get validator address
   become_user: "{{ compose_service_user }}"
-  shell: docker-compose run -e ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY="{{ ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY }}" --entrypoint "node scripts/privateKeyToAddress.js" bridge_affirmation
+  shell: docker-compose run --rm -e ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY="{{ ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY }}" --entrypoint "node scripts/privateKeyToAddress.js" bridge_affirmation
   args:
     chdir: "{{ bridge_path }}/oracle"
   register: VADDRESS
@@ -29,7 +29,7 @@
 
 - name: Get foreign erc type
   become_user: "{{ compose_service_user }}"
-  shell: docker-compose run --entrypoint "node scripts/initialChecks.js" bridge_affirmation
+  shell: docker-compose run --rm --entrypoint "node scripts/initialChecks.js" bridge_affirmation
   args:
     chdir: "{{ bridge_path }}/oracle"
   register: ERCTYPE

deployment/roles/oracle/tasks/pre_config.yml

@@ -1,5 +1,21 @@
 ---
+- name: Create oracle directory
+  file:
+    path: "{{ bridge_path }}/oracle"
+    state: directory
+    mode: '0755'
+
 - name: Install .env config
   template:
     src: .env.j2
     dest: "{{ bridge_path }}/oracle/.env"
+
+- name: Copy docker-compose files
+  copy:
+    src: ../../../../oracle/{{ item }}
+    dest: "{{ bridge_path }}/oracle/"
+    mode: '0755'
+  with_items:
+    - docker-compose.yml
+    - docker-compose-transfer.yml
+    - docker-compose-erc-native.yml

deployment/roles/oracle/tasks/servinstall.yml

@@ -1,6 +1,5 @@
 # This role creates a poabridge service which is designed to manage docker-compose bridge deployment.
 # /etc/init.d/poabridge start, status, stop, restart - does what the services usually do in such cases.
-# /etc/init.d/poabridge rebuild - builds a new bridge deployment from scratch.
 ---
 - name: "Set poabridge service"
   template:

deployment/roles/oracle/templates/poabridge.j2

@@ -52,14 +52,6 @@ status(){
     sudo -u "{{ compose_service_user }}" /usr/local/bin/docker-compose $composefileoverride  ps
 }
 
-rebuild(){
-    echo "Rebuild bridge.."
-    cd $WORKDIR
-    sudo -u "{{ compose_service_user }}" /usr/local/bin/docker-compose $composefileoverride down -v
-    sudo -u "{{ compose_service_user }}" /usr/local/bin/docker-compose $composefileoverride rm -fv
-    sudo -u "{{ compose_service_user }}" ORACLE_VALIDATOR_ADDRESS=$vaddr ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY=$vkey /usr/local/bin/docker-compose $composefileoverride up --detach --force-recreate --no-deps --build
-}
-
 
 case "$1" in
 
@@ -81,12 +73,8 @@ case "$1" in
     start
     ;;
 
-  rebuild)
-    rebuild
-    ;;
-
   *)
-    echo $"Usage: $0 {start|stop|restart|rebuild|status}"
+    echo $"Usage: $0 {start|stop|restart|status}"
     exit 1
     ;;
 

e2e-commons/constants.json

@@ -7,10 +7,26 @@
     "address": "0xcca2fb44C8C36E51f743269d6F484Fd027B9F9Aa",
     "privateKey": "0xcf954e07e6a439faf392eb474e95ddb444c2ca444847f2ad6ecc79e1a585e2b8"
   },
+  "thirdUser": {
+    "address": "0x441cc8537aB6cE63d060b63F3A44eE021d62e6cF",
+    "privateKey": "0xd3915199f27691d7784cb01ab0c7220308053b229f95d592e97493326314a8d0"
+  },
+  "fourthUser": {
+    "address": "0x3CC5baAB679eC0732C175760079Bf48F564ad26B",
+    "privateKey": "0xedb53ee050631b7914d5f1a66c2f0d2df3ec85a9ed2a9616b16a7b1b7a10b8d1"
+  },
   "validator": {
     "address": "0xaaB52d66283F7A1D5978bcFcB55721ACB467384b",
     "privateKey": "0x8e829f695aed89a154550f30262f1529582cc49dc30eff74a6b491359e0230f9"
   },
+  "secondValidator": {
+    "address": "0xdCC784657C78054aa61FbcFFd2605F32374816A4",
+    "privateKey": "0x5a5c3645d0f04e9eb4f27f94ed4c244a225587405b8838e7456f7781ce3a9513"
+  },
+  "thirdValidator": {
+    "address": "0xDcef88209a20D52165230104B245803C3269454d",
+    "privateKey": "0xf877f62a1c19f852cff1d29f0fb1ecac18821c0080d4cc0520c60c098293dca1"
+  },
   "blockGenerator": {
     "address": "0xB4579fd5AfEaB60B03Db3F408AAdD315035943f7",
     "privateKey": "0xd6143d390d8b28c33601bb0fe29392fb1c35c24ccfe8722c09c2bdd6ada2699f"
@@ -36,6 +52,7 @@
     "foreignToken": "0x7cc4b1851c35959d34e635a470f6b5c43ba3c9c9",
     "halfDuplexToken": "0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359",
     "saiTop": "0x9b0ccf7C8994E19F39b2B4CF708e0A7DF65fA8a3",
+    "chaiToken": "0x06af07097c9eeb7fd685c692751d5c66db49c215",
     "ui": "http://localhost:3002",
     "monitor": "http://monitor-erc20-native:3012/bridge"
   },

e2e-commons/contracts-envs/amb.env

@@ -22,4 +22,4 @@ FOREIGN_REQUIRED_BLOCK_CONFIRMATIONS=1
 FOREIGN_GAS_PRICE=10000000000
 
 REQUIRED_NUMBER_OF_VALIDATORS=1
-VALIDATORS=0xaaB52d66283F7A1D5978bcFcB55721ACB467384b
+VALIDATORS="0xaaB52d66283F7A1D5978bcFcB55721ACB467384b 0xdCC784657C78054aa61FbcFFd2605F32374816A4 0xDcef88209a20D52165230104B245803C3269454d"

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

@@ -34,8 +34,7 @@ FOREIGN_REWARDABLE=false
 ERC20_TOKEN_ADDRESS=0x3C665A31199694Bf723fD08844AD290207B5797f
 
 REQUIRED_NUMBER_OF_VALIDATORS=1
-VALIDATORS="0xaaB52d66283F7A1D5978bcFcB55721ACB467384b"
-VALIDATORS_REWARD_ACCOUNTS=0x0000000000000000000000000000000000000000
+VALIDATORS="0xaaB52d66283F7A1D5978bcFcB55721ACB467384b 0xdCC784657C78054aa61FbcFFd2605F32374816A4 0xDcef88209a20D52165230104B245803C3269454d"
 BLOCK_REWARD_ADDRESS=0x0000000000000000000000000000000000000000
 DPOS_STAKING_ADDRESS=0x0000000000000000000000000000000000000000
 ERC20_EXTENDED_BY_ERC677=false

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

@@ -35,5 +35,4 @@ BLOCK_REWARD_ADDRESS=0xF9698Eb93702dfdd0e2d802088d4c21822a8A977
 ERC20_TOKEN_ADDRESS=0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359
 
 REQUIRED_NUMBER_OF_VALIDATORS=1
-VALIDATORS="0xaaB52d66283F7A1D5978bcFcB55721ACB467384b"
-VALIDATORS_REWARD_ACCOUNTS=0x0000000000000000000000000000000000000000
+VALIDATORS="0xaaB52d66283F7A1D5978bcFcB55721ACB467384b 0xdCC784657C78054aa61FbcFFd2605F32374816A4 0xDcef88209a20D52165230104B245803C3269454d"

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

@@ -34,6 +34,5 @@ FOREIGN_GAS_PRICE=10000000000
 FOREIGN_REWARDABLE=false
 
 REQUIRED_NUMBER_OF_VALIDATORS=1
-VALIDATORS="0xaaB52d66283F7A1D5978bcFcB55721ACB467384b"
-VALIDATORS_REWARD_ACCOUNTS=0x0000000000000000000000000000000000000000
+VALIDATORS="0xaaB52d66283F7A1D5978bcFcB55721ACB467384b 0xdCC784657C78054aa61FbcFFd2605F32374816A4 0xDcef88209a20D52165230104B245803C3269454d"
 BLOCK_REWARD_ADDRESS=0x0000000000000000000000000000000000000000

e2e-commons/docker-compose.yml

@@ -24,16 +24,13 @@ services:
       - ultimate
   rabbit:
     image: "rabbitmq:3-management"
-    ports:
-    - "15672:15672"
     networks:
       - ultimate
   oracle:
     build:
       context: ..
       dockerfile: oracle/Dockerfile
-      args:
-        DOT_ENV_PATH: e2e-commons/components-envs/oracle.env
+    env_file: ../e2e-commons/components-envs/oracle.env
     environment:
     - NODE_ENV=production
     command: "true"
@@ -43,8 +40,7 @@ services:
     build:
       context: ..
       dockerfile: oracle/Dockerfile
-      args:
-        DOT_ENV_PATH: e2e-commons/components-envs/oracle-erc20.env
+    env_file: ../e2e-commons/components-envs/oracle-erc20.env
     environment:
     - NODE_ENV=production
     command: "true"
@@ -54,8 +50,7 @@ services:
     build:
       context: ..
       dockerfile: oracle/Dockerfile
-      args:
-        DOT_ENV_PATH: e2e-commons/components-envs/oracle-erc20-native.env
+    env_file: ../e2e-commons/components-envs/oracle-erc20-native.env
     environment:
     - NODE_ENV=production
     command: "true"
@@ -65,8 +60,7 @@ services:
     build:
       context: ..
       dockerfile: oracle/Dockerfile
-      args:
-        DOT_ENV_PATH: e2e-commons/components-envs/oracle-amb.env
+    env_file: ../e2e-commons/components-envs/oracle-amb.env
     environment:
     - NODE_ENV=production
     command: "true"
@@ -103,8 +97,7 @@ services:
     build:
       context: ..
       dockerfile: monitor/Dockerfile
-      args:
-        DOT_ENV_PATH: e2e-commons/components-envs/monitor.env
+    env_file: ../e2e-commons/components-envs/monitor.env
     entrypoint: yarn check-and-start
     ports:
       - "3010:3010"
@@ -114,8 +107,7 @@ services:
     build:
       context: ..
       dockerfile: monitor/Dockerfile
-      args:
-        DOT_ENV_PATH: e2e-commons/components-envs/monitor-erc20.env
+    env_file: ../e2e-commons/components-envs/monitor-erc20.env
     entrypoint: yarn check-and-start
     ports:
       - "3011:3011"
@@ -125,8 +117,7 @@ services:
     build:
       context: ..
       dockerfile: monitor/Dockerfile
-      args:
-        DOT_ENV_PATH: e2e-commons/components-envs/monitor-erc20-native.env
+    env_file: ../e2e-commons/components-envs/monitor-erc20-native.env
     entrypoint: yarn check-and-start
     ports:
       - "3012:3012"
@@ -136,8 +127,7 @@ services:
     build:
       context: ..
       dockerfile: monitor/Dockerfile
-      args:
-        DOT_ENV_PATH: e2e-commons/components-envs/monitor-amb.env
+    env_file: ../e2e-commons/components-envs/monitor-amb.env
     entrypoint: yarn check-and-start
     ports:
       - "3013:3013"
@@ -150,3 +140,10 @@ services:
     command: "true"
     networks:
       - ultimate
+  blocks:
+    build:
+      context: ..
+      dockerfile: Dockerfile.e2e
+    entrypoint: node e2e-commons/scripts/blocks.js
+    networks:
+      - ultimate

e2e-commons/down.sh

@@ -5,4 +5,6 @@ if [ $CI ]; then exit $rc; fi
 
 ps | grep node | grep -v grep | awk '{print "kill " $1}' | /bin/bash
 docker-compose down
+docker-compose -p validator2 down
+docker-compose -p validator3 down
 docker network rm ultimate || true

e2e-commons/scripts/blocks.js

@@ -1,8 +1,7 @@
 const Web3 = require('web3')
-const { generateNewBlock } = require('../utils')
 
-const homeWeb3 = new Web3(new Web3.providers.HttpProvider('http://localhost:8541'))
-const foreignWeb3 = new Web3(new Web3.providers.HttpProvider('http://localhost:8542'))
+const homeWeb3 = new Web3(new Web3.providers.HttpProvider('http://parity1:8545'))
+const foreignWeb3 = new Web3(new Web3.providers.HttpProvider('http://parity2:8545'))
 const {user, blockGenerator} = require('../constants.json');
 
 homeWeb3.eth.accounts.wallet.add(user.privateKey)
@@ -10,10 +9,24 @@ foreignWeb3.eth.accounts.wallet.add(user.privateKey)
 homeWeb3.eth.accounts.wallet.add(blockGenerator.privateKey)
 foreignWeb3.eth.accounts.wallet.add(blockGenerator.privateKey)
 
+function generateNewBlock(web3, address) {
+  return web3.eth.sendTransaction({
+    from: address,
+    to: '0x0000000000000000000000000000000000000000',
+    gasPrice: '1',
+    gas: '21000',
+    value: '1'
+  })
+}
+
 function main() {
   setTimeout(async () => {
-    generateNewBlock(homeWeb3, blockGenerator.address)
-    generateNewBlock(foreignWeb3, blockGenerator.address)
+    try {
+      generateNewBlock(homeWeb3, blockGenerator.address)
+    } catch {} // in case of Transaction with the same hash was already imported.
+    try {
+      generateNewBlock(foreignWeb3, blockGenerator.address)
+    } catch {} // in case of Transaction with the same hash was already imported.
     main()
   }, 1000)
 }

e2e-commons/scripts/deploy.sh

@@ -6,6 +6,9 @@ CONTRACTS_PATH="../../contracts"
 DEPLOY_PATH="$CONTRACTS_PATH/deploy"
 ENVS_PATH="../contracts-envs"
 
+# mock bridge validators contract with the one with deterministic isValidatorDuty
+mv "$CONTRACTS_PATH/build/contracts/BridgeValidatorsDeterministic.json" "$CONTRACTS_PATH/build/contracts/BridgeValidators.json"
+
 echo -e "\n\n############ Deploying native-to-erc ############\n"
 cp "$ENVS_PATH/native-to-erc.env" "$DEPLOY_PATH/.env"
 cd "$DEPLOY_PATH"

e2e-commons/up.sh

@@ -7,6 +7,30 @@ docker-compose build
 docker network create --driver bridge ultimate || true
 docker-compose up -d parity1 parity2 e2e
 
+startValidator () {
+    docker-compose $1 run -d --name $4 redis
+    docker-compose $1 run -d --name $5 rabbit
+    docker-compose $1 run $2 $3 -d oracle yarn watcher:signature-request
+    docker-compose $1 run $2 $3 -d oracle yarn watcher:collected-signatures
+    docker-compose $1 run $2 $3 -d oracle yarn watcher:affirmation-request
+    docker-compose $1 run $2 $3 -d oracle-erc20 yarn watcher:signature-request
+    docker-compose $1 run $2 $3 -d oracle-erc20 yarn watcher:collected-signatures
+    docker-compose $1 run $2 $3 -d oracle-erc20 yarn watcher:affirmation-request
+    docker-compose $1 run $2 $3 -d oracle-erc20 yarn watcher:transfer
+    docker-compose $1 run $2 $3 -d oracle-erc20-native yarn watcher:signature-request
+    docker-compose $1 run $2 $3 -d oracle-erc20-native yarn watcher:collected-signatures
+    docker-compose $1 run $2 $3 -d oracle-erc20-native yarn watcher:affirmation-request
+    docker-compose $1 run $2 $3 -d oracle-erc20-native yarn watcher:transfer
+    docker-compose $1 run $2 $3 -d oracle-erc20-native yarn watcher:half-duplex-transfer
+    docker-compose $1 run $2 $3 -d oracle-erc20-native yarn worker:swap-tokens
+    docker-compose $1 run $2 $3 -d oracle-erc20-native yarn worker:convert-to-chai
+    docker-compose $1 run $2 $3 -d oracle-amb yarn watcher:signature-request
+    docker-compose $1 run $2 $3 -d oracle-amb yarn watcher:collected-signatures
+    docker-compose $1 run $2 $3 -d oracle-amb yarn watcher:affirmation-request
+    docker-compose $1 run $2 $3 -d oracle-erc20-native yarn sender:home
+    docker-compose $1 run $2 $3 -d oracle-erc20-native yarn sender:foreign
+}
+
 while [ "$1" != "" ]; do
   if [ "$1" == "oracle" ]; then
     docker-compose up -d redis rabbit oracle oracle-erc20 oracle-erc20-native oracle-amb
@@ -24,6 +48,7 @@ while [ "$1" != "" ]; do
     docker-compose run -d oracle-erc20-native yarn watcher:transfer
     docker-compose run -d oracle-erc20-native yarn watcher:half-duplex-transfer
     docker-compose run -d oracle-erc20-native yarn worker:swap-tokens
+    docker-compose run -d oracle-erc20-native yarn worker:convert-to-chai
     docker-compose run -d oracle-amb yarn watcher:signature-request
     docker-compose run -d oracle-amb yarn watcher:collected-signatures
     docker-compose run -d oracle-amb yarn watcher:affirmation-request
@@ -31,6 +56,20 @@ while [ "$1" != "" ]; do
     docker-compose run -d oracle yarn sender:foreign
   fi
 
+  if [ "$1" == "oracle-validator-2" ]; then
+    oracle2name="-p validator2"
+    oracle2Values="-e ORACLE_VALIDATOR_ADDRESS=0xdCC784657C78054aa61FbcFFd2605F32374816A4 -e ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY=5a5c3645d0f04e9eb4f27f94ed4c244a225587405b8838e7456f7781ce3a9513"
+    oracle2comp="-e ORACLE_QUEUE_URL=amqp://rabbit2 -e ORACLE_REDIS_URL=redis://redis2"
+    startValidator "$oracle2name" "$oracle2Values" "$oracle2comp" "redis2" "rabbit2"
+  fi
+
+  if [ "$1" == "oracle-validator-3" ]; then
+    oracle3name="-p validator3"
+    oracle3Values="-e ORACLE_VALIDATOR_ADDRESS=0xDcef88209a20D52165230104B245803C3269454d -e ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY=f877f62a1c19f852cff1d29f0fb1ecac18821c0080d4cc0520c60c098293dca1"
+    oracle3comp="-e ORACLE_QUEUE_URL=amqp://rabbit3 -e ORACLE_REDIS_URL=redis://redis3"
+    startValidator "$oracle3name" "$oracle3Values" "$oracle3comp" "redis3" "rabbit3"
+  fi
+
   if [ "$1" == "ui" ]; then
     docker-compose up -d ui ui-erc20 ui-erc20-native
 
@@ -44,7 +83,7 @@ while [ "$1" != "" ]; do
   fi
 
   if [ "$1" == "blocks" ]; then
-    node ./scripts/blocks.js &
+    docker-compose up -d blocks
   fi
 
   if [ "$1" == "monitor" ]; then
@@ -63,5 +102,9 @@ while [ "$1" != "" ]; do
     ../deployment-e2e/molecule.sh ultimate-erc-to-erc
   fi
 
+  if [ "$1" == "amb" ]; then
+    ../deployment-e2e/molecule.sh ultimate-amb
+  fi
+
   shift # Shift all the parameters down by one
 done

e2e-commons/utils.js

@@ -1,13 +1,18 @@
-function generateNewBlock(web3, address) {
-  return web3.eth.sendTransaction({
-    from: address,
-    to: '0x0000000000000000000000000000000000000000',
-    gasPrice: '1',
-    gas: '21000',
-    value: '1'
+const promiseRetry = require('promise-retry')
+
+async function uniformRetry(f) {
+  return promiseRetry(f, {
+    forever: true,
+    factor: 1,
+    minTimeout: 500
   })
 }
 
-module.exports = {
-  generateNewBlock
+async function sleep(timeout) {
+  return new Promise(res => setTimeout(res, timeout))
+}
+
+module.exports = {
+  uniformRetry,
+  sleep
 }

monitor-e2e/run-tests.sh

@@ -1,6 +1,6 @@
 cd $(dirname $0)
 
-../e2e-commons/up.sh deploy monitor
+../e2e-commons/up.sh deploy blocks monitor
 
 ./wait-for-monitor.sh
 nohup ./periodically-check-all.sh < /dev/null > /dev/null 2>&1 &

monitor-e2e/test/ercToNative.js

@@ -1,7 +1,15 @@
 const assert = require('assert')
 const axios = require('axios')
 const { ercToNativeBridge, user, foreignRPC, validator } = require('../../e2e-commons/constants.json')
-const { waitUntil, sendTokens, addValidator } = require('../utils')
+const {
+  waitUntil,
+  sendTokens,
+  addValidator,
+  initializeChaiToken,
+  convertDaiToChai,
+  setMinDaiTokenBalance,
+  migrateToMCD
+} = require('../utils')
 
 const baseUrl = ercToNativeBridge.monitor
 
@@ -24,12 +32,45 @@ describe('ERC TO NATIVE with changing state of contracts', () => {
     assert((await axios.get(`${baseUrl}/validators`)).data.validatorsMatch === true)
   })
 
-  it('should change balanceDiff', async () => {
+  it('should change balanceDiff', async function() {
+    this.timeout(60000)
     await sendTokens(foreignRPC.URL, user, ercToNativeBridge.halfDuplexToken, ercToNativeBridge.foreign)
 
     await waitUntil(async () => {
       ;({ data } = await axios.get(`${baseUrl}`))
-      return data.balanceDiff !== 0
+      const { erc20Balance, halfDuplexErc20Balance, investedErc20Balance } = data.foreign
+      return (
+        data.balanceDiff === 0.01 &&
+        erc20Balance === '0.01' &&
+        halfDuplexErc20Balance === undefined &&
+        investedErc20Balance === undefined
+      )
+    })
+
+    await migrateToMCD(foreignRPC.URL, ercToNativeBridge.foreign)
+
+    await waitUntil(async () => {
+      ;({ data } = await axios.get(`${baseUrl}`))
+      const { erc20Balance, halfDuplexErc20Balance, investedErc20Balance } = data.foreign
+      return (
+        data.balanceDiff === 0.01 &&
+        erc20Balance === '0.01' &&
+        halfDuplexErc20Balance === '0' &&
+        investedErc20Balance === undefined
+      )
+    })
+
+    await sendTokens(foreignRPC.URL, user, ercToNativeBridge.halfDuplexToken, ercToNativeBridge.foreign)
+
+    await waitUntil(async () => {
+      ;({ data } = await axios.get(`${baseUrl}`))
+      const { erc20Balance, halfDuplexErc20Balance, investedErc20Balance } = data.foreign
+      return (
+        data.balanceDiff === 0.02 &&
+        erc20Balance === '0.01' &&
+        halfDuplexErc20Balance === '0.01' &&
+        investedErc20Balance === undefined
+      )
     })
   })
 
@@ -40,4 +81,52 @@ describe('ERC TO NATIVE with changing state of contracts', () => {
       return data.validatorsMatch === false
     })
   })
+
+  it('should consider chai token balance', async function() {
+    this.timeout(60000)
+    await initializeChaiToken(foreignRPC.URL, ercToNativeBridge.foreign)
+    await sendTokens(foreignRPC.URL, user, ercToNativeBridge.foreignToken, ercToNativeBridge.foreign)
+
+    await waitUntil(async () => {
+      ;({ data } = await axios.get(`${baseUrl}`))
+      const { erc20Balance, halfDuplexErc20Balance, investedErc20Balance, accumulatedInterest } = data.foreign
+      return (
+        data.balanceDiff === 0.03 &&
+        erc20Balance === '0.02' &&
+        halfDuplexErc20Balance === '0.01' &&
+        investedErc20Balance === '0' &&
+        accumulatedInterest === '0.001' // value of dsrBalance() is initially defined in genesis block as 0.001
+      )
+    })
+
+    await setMinDaiTokenBalance(foreignRPC.URL, ercToNativeBridge.foreign, '0.01')
+    await convertDaiToChai(foreignRPC.URL, ercToNativeBridge.foreign)
+
+    await waitUntil(async () => {
+      ;({ data } = await axios.get(`${baseUrl}`))
+      const { erc20Balance, halfDuplexErc20Balance, investedErc20Balance, accumulatedInterest } = data.foreign
+      return (
+        data.balanceDiff === 0.03 &&
+        erc20Balance === '0.01' &&
+        halfDuplexErc20Balance === '0.01' &&
+        investedErc20Balance === '0.01' &&
+        accumulatedInterest === '0.001'
+      )
+    })
+
+    await setMinDaiTokenBalance(foreignRPC.URL, ercToNativeBridge.foreign, '0.005')
+    await convertDaiToChai(foreignRPC.URL, ercToNativeBridge.foreign)
+
+    await waitUntil(async () => {
+      ;({ data } = await axios.get(`${baseUrl}`))
+      const { erc20Balance, halfDuplexErc20Balance, investedErc20Balance, accumulatedInterest } = data.foreign
+      return (
+        data.balanceDiff === 0.03 &&
+        erc20Balance === '0.005' &&
+        halfDuplexErc20Balance === '0.01' &&
+        investedErc20Balance === '0.015' &&
+        accumulatedInterest === '0.001'
+      )
+    })
+  })
 })

monitor-e2e/utils.js

@@ -1,5 +1,12 @@
 const Web3 = require('web3')
-const { ERC677_BRIDGE_TOKEN_ABI, BRIDGE_VALIDATORS_ABI, FOREIGN_NATIVE_TO_ERC_ABI, BOX_ABI } = require('../commons')
+const {
+  ERC677_BRIDGE_TOKEN_ABI,
+  BRIDGE_VALIDATORS_ABI,
+  FOREIGN_NATIVE_TO_ERC_ABI,
+  FOREIGN_ERC_TO_NATIVE_ABI,
+  BOX_ABI
+} = require('../commons')
+const { validator } = require('../e2e-commons/constants')
 
 const waitUntil = async (predicate, step = 100, timeout = 20000) => {
   const stopTime = Date.now() + timeout
@@ -60,10 +67,57 @@ const addValidator = async (rpcUrl, account, bridgeAddress) => {
   })
 }
 
+const migrateToMCD = async (rpcUrl, bridgeAddress) => {
+  const web3 = new Web3(new Web3.providers.HttpProvider(rpcUrl))
+  web3.eth.accounts.wallet.add(validator.privateKey)
+  const bridgeContract = new web3.eth.Contract(FOREIGN_ERC_TO_NATIVE_ABI, bridgeAddress)
+  await bridgeContract.methods.migrateToMCD().send({
+    from: validator.address,
+    gas: '4000000'
+  })
+}
+
+const initializeChaiToken = async (rpcUrl, bridgeAddress) => {
+  const web3 = new Web3(new Web3.providers.HttpProvider(rpcUrl))
+  web3.eth.accounts.wallet.add(validator.privateKey)
+  const bridgeContract = new web3.eth.Contract(FOREIGN_ERC_TO_NATIVE_ABI, bridgeAddress)
+
+  await bridgeContract.methods.initializeChaiToken().send({
+    from: validator.address,
+    gas: '1000000'
+  })
+}
+
+const setMinDaiTokenBalance = async (rpcUrl, bridgeAddress, limit) => {
+  const web3 = new Web3(new Web3.providers.HttpProvider(rpcUrl))
+  web3.eth.accounts.wallet.add(validator.privateKey)
+  const bridgeContract = new web3.eth.Contract(FOREIGN_ERC_TO_NATIVE_ABI, bridgeAddress)
+
+  await bridgeContract.methods.setMinDaiTokenBalance(web3.utils.toWei(limit)).send({
+    from: validator.address,
+    gas: '1000000'
+  })
+}
+
+const convertDaiToChai = async (rpcUrl, bridgeAddress) => {
+  const web3 = new Web3(new Web3.providers.HttpProvider(rpcUrl))
+  web3.eth.accounts.wallet.add(validator.privateKey)
+  const bridgeContract = new web3.eth.Contract(FOREIGN_ERC_TO_NATIVE_ABI, bridgeAddress)
+
+  await bridgeContract.methods.convertDaiToChai().send({
+    from: validator.address,
+    gas: '1000000'
+  })
+}
+
 module.exports = {
   waitUntil,
   sendEther,
   sendTokens,
   addValidator,
-  sendAMBMessage
+  sendAMBMessage,
+  migrateToMCD,
+  initializeChaiToken,
+  setMinDaiTokenBalance,
+  convertDaiToChai
 }

monitor/Dockerfile

@@ -15,9 +15,9 @@ RUN mv ./contracts/build ./ && rm -rf ./contracts/* ./contracts/.[!.]* && mv ./b
 COPY ./commons ./commons
 
 COPY ./monitor ./monitor
-ARG DOT_ENV_PATH=./monitor/.env
-COPY ${DOT_ENV_PATH} ./monitor/.env
 
 WORKDIR /mono/monitor
-CMD echo "To start the monitor run:" \
-  "yarn check-and-start"
+CMD echo "To start the monitor web service run:" \
+  "yarn start" \
+  "To run monitor scripts run:" \
+  "yarn check-all"

monitor/README.md

@@ -4,7 +4,12 @@ Tool for checking balances and unprocessed events in bridged networks.
 ## Overview
 Please refer to the [POA TokenBridge](../README.md) overview first of all.
 
-- Deployed version: https://bridge-monitoring.poa.net/
+- Deployed version serves several monitor configurations:
+  * https://bridge-monitoring.poa.net/poa
+  * https://bridge-monitoring.poa.net/xdai
+  * https://bridge-monitoring.poa.net/wetc
+  * https://bridge-monitoring.poa.net/amb-dai
+  * https://bridge-monitoring.poa.net/amb-poa
 
 This tool allows you to spin up a NODE.JS server to monitor for health of the TokenBridge contracts: check for the balance difference, discover inconsistency in the validators list, catch unhandled transactions.
 
@@ -122,14 +127,19 @@ yarn start
 You can run web interface via [pm2](https://www.npmjs.com/package/pm2) or similar supervisor program.
 
 Using Docker:
-```
-docker-compose up -d
-```
+  * to run it very first time (or after changes related to the monitor code):
+    ```
+    docker-compose -f docker-compose-build.yml -f docker-compose.yml up -d --build
+    ```
+  * next time (or in case of usage of an official docker image)
+    ```
+    docker-compose up -d
+    ```
 
 - The application will run on `http://localhost:MONITOR_PORT/MONITOR_BRIDGE_NAME`, where `MONITOR_PORT` and `MONITOR_BRIDGE_NAME` are specified in your `.env` file.
 - To enabled debug logging, set `DEBUG=1` variable in `.env`.
 
-## Check balances of contracts and validators, get unprocessed events
+## Preparing statistic about balances of bridge contracts and validators, get unprocessed events
 
 Using Yarn:
 ```
@@ -138,13 +148,32 @@ yarn check-all
 
 Using Docker:
 ```
-docker-compose exec monitor yarn check-all
+docker run --rm --env-file .env -v $(pwd)/responses:/mono/monitor/responses \
+  poanetwork/tokenbridge-monitor:latest /bin/bash -c 'yarn check-all'
 ```
 
+As soon as the process finishes, use the URL described above to get the statistic.
+
 ### Cron
 
 You can create cron job to run workers (see `crontab.example` for reference):
 
+## Ad-hoc monitoring
+
+There is a possibility to get bridge statistics without running the web interface use the commands provided above. In this case the results will be located in the `responses` directory.
+
+## Build the image without running the monitor
+
+To build the image change the directory:
+```
+cd monitor
+```
+
+And run the docker composer:
+```
+docker-compose -f docker-compose-build.yml build
+``` 
+
 ## Linting
 
 Running linter:

monitor/checkWorker3.js

@@ -1,19 +1,27 @@
+const Web3 = require('web3')
 const logger = require('./logger')('checkWorker3')
 const stuckTransfers = require('./stuckTransfers')
 const { writeFile, createDir } = require('./utils/file')
 
-const { MONITOR_BRIDGE_NAME } = process.env
+const { MONITOR_BRIDGE_NAME, COMMON_HOME_BRIDGE_ADDRESS, COMMON_HOME_RPC_URL } = process.env
+const { getBridgeMode, HOME_NATIVE_TO_ERC_ABI, BRIDGE_MODES } = require('../commons')
+
+const homeProvider = new Web3.providers.HttpProvider(COMMON_HOME_RPC_URL)
+const web3Home = new Web3(homeProvider)
 
 async function checkWorker3() {
   try {
-    createDir(`/responses/${MONITOR_BRIDGE_NAME}`)
-    logger.debug('calling stuckTransfers()')
-    const transfers = await stuckTransfers()
-    // console.log(transfers)
-    if (!transfers) throw new Error('transfers is empty: ' + JSON.stringify(transfers))
-    transfers.ok = transfers.total.length === 0
-    writeFile(`/responses/${MONITOR_BRIDGE_NAME}/stuckTransfers.json`, transfers)
-    logger.debug('Done')
+    const homeBridge = new web3Home.eth.Contract(HOME_NATIVE_TO_ERC_ABI, COMMON_HOME_BRIDGE_ADDRESS)
+    const bridgeMode = await getBridgeMode(homeBridge)
+    if (bridgeMode === BRIDGE_MODES.NATIVE_TO_ERC_V1) {
+      createDir(`/responses/${MONITOR_BRIDGE_NAME}`)
+      logger.debug('calling stuckTransfers()')
+      const transfers = await stuckTransfers()
+      if (!transfers) throw new Error('transfers is empty: ' + JSON.stringify(transfers))
+      transfers.ok = transfers.total.length === 0
+      writeFile(`/responses/${MONITOR_BRIDGE_NAME}/stuckTransfers.json`, transfers)
+      logger.debug('Done')
+    }
   } catch (e) {
     logger.error('checkWorker3.js', e)
   }

monitor/crontab.example

@@ -2,4 +2,4 @@
 */4 * * * * cd $HOME/tokenbridge/monitor; yarn check-all >>cronWorker.out 2>>cronWorker.err
 
 # Docker:
-*/4 * * * * cd $HOME/tokenbridge/monitor; docker-compose exec monitor yarn check-all >>cronWorker.out 2>>cronWorker.err
+*/4 * * * * cd $HOME/tokenbridge/monitor; docker run --rm --env-file .env -v $(pwd)/responses:/mono/monitor/responses poanetwork/tokenbridge-monitor:latest /bin/bash -c 'yarn check-all' >>cronWorker.out 2>>cronWorker.err

monitor/docker-compose-build.yml

@@ -0,0 +1,6 @@
+---
+version: '2.4'
+services:
+  monitor:
+    image: poanetwork/tokenbridge-monitor
+    build: .

monitor/docker-compose.yml

@@ -2,9 +2,7 @@
 version: '2.4'
 services:
   monitor:
-    build:
-      context: ..
-      dockerfile: monitor/Dockerfile
+    image: poanetwork/tokenbridge-monitor:latest
     ports:
     - "${MONITOR_PORT}:${MONITOR_PORT}"
     env_file: ./.env

monitor/getBalances.js

@@ -83,7 +83,10 @@ async function main(bridgeMode) {
     const foreignBridge = new web3Foreign.eth.Contract(FOREIGN_ERC_TO_NATIVE_ABI, COMMON_FOREIGN_BRIDGE_ADDRESS)
     const erc20Address = await foreignBridge.methods.erc20token().call()
     const erc20Contract = new web3Foreign.eth.Contract(ERC20_ABI, erc20Address)
+    let investedAmountInDai = 0
+    let bridgeDsrBalance = 0
     let foreignHalfDuplexErc20Balance = 0
+    let displayChaiToken = false
     let displayHalfDuplexToken = false
     let tokenSwapAllowed = false
     try {
@@ -103,6 +106,21 @@ async function main(bridgeMode) {
       logger.debug('Methods for half duplex token are not present')
     }
 
+    try {
+      logger.debug('calling foreignBridge.methods.isChaiTokenEnabled')
+      if (await foreignBridge.methods.isChaiTokenEnabled().call()) {
+        displayChaiToken = true
+        logger.debug('calling foreignBridge.methods.investedAmountInDai')
+        investedAmountInDai = await foreignBridge.methods.investedAmountInDai().call()
+        logger.debug('calling foreignBridge.methods.dsrBalance')
+        bridgeDsrBalance = await foreignBridge.methods.dsrBalance().call()
+      } else {
+        logger.debug('Chai token is currently disabled')
+      }
+    } catch (e) {
+      logger.debug('Methods for chai token are not present')
+    }
+
     logger.debug('calling erc20Contract.methods.balanceOf')
     const foreignErc20Balance = await erc20Contract.methods.balanceOf(COMMON_FOREIGN_BRIDGE_ADDRESS).call()
 
@@ -119,11 +137,14 @@ async function main(bridgeMode) {
     const burntCoinsBN = new BN(burntCoins)
     const totalSupplyBN = mintedCoinsBN.minus(burntCoinsBN)
     const foreignErc20BalanceBN = new BN(foreignErc20Balance)
+    const investedAmountInDaiBN = new BN(investedAmountInDai)
+    const bridgeDsrBalanceBN = new BN(bridgeDsrBalance)
     const halfDuplexErc20BalanceBN =
       displayHalfDuplexToken && tokenSwapAllowed ? new BN(foreignHalfDuplexErc20Balance) : new BN(0)
 
     const diff = foreignErc20BalanceBN
       .plus(halfDuplexErc20BalanceBN)
+      .plus(investedAmountInDaiBN)
       .minus(totalSupplyBN)
       .toFixed()
 
@@ -143,6 +164,11 @@ async function main(bridgeMode) {
       }
     }
 
+    if (displayChaiToken) {
+      foreign.investedErc20Balance = Web3Utils.fromWei(investedAmountInDai)
+      foreign.accumulatedInterest = Web3Utils.fromWei(bridgeDsrBalanceBN.minus(investedAmountInDaiBN).toString(10))
+    }
+
     logger.debug('Done')
     return {
       home: {

monitor/index.js

@@ -5,6 +5,7 @@ const { readFile } = require('./utils/file')
 const app = express()
 const bridgeRouter = express.Router({ mergeParams: true })
 
+app.get('/favicon.ico', (req, res) => res.sendStatus(204))
 app.use('/:bridgeName', bridgeRouter)
 
 bridgeRouter.get('/', async (req, res, next) => {

monitor/package.json

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

monitor/scripts/getBridgeStats.sh

@@ -4,7 +4,7 @@ cd $(dirname $0)/..
 if /usr/local/bin/docker-compose ps | grep -q -i 'monitor'; then
   for file in configs/*.env
   do
-    docker run --rm --env-file $file -v $(pwd)/responses:/mono/monitor/responses monitor_monitor /bin/bash -c 'yarn check-all'
+    docker run --rm --env-file $file -v $(pwd)/responses:/mono/monitor/responses poanetwork/tokenbridge-monitor:latest /bin/bash -c 'yarn check-all'
   done
 else
   echo "Monitor is not running, skipping checks."

monitor/utils/events.js

@@ -112,7 +112,26 @@ async function main(mode) {
       const bridgeTokensSwappedEvents = tokensSwappedEvents.filter(e => e.address === COMMON_FOREIGN_BRIDGE_ADDRESS)
 
       // Get transfer events for each previous erc20
-      const uniqueTokenAddresses = [...new Set(bridgeTokensSwappedEvents.map(e => e.returnValues.from))]
+      const uniqueTokenAddressesSet = new Set(bridgeTokensSwappedEvents.map(e => e.returnValues.from))
+
+      // Exclude chai token from previous erc20
+      try {
+        logger.debug('calling foreignBridge.chaiToken()')
+        const chaiToken = await foreignBridge.methods.chaiToken().call()
+        uniqueTokenAddressesSet.delete(chaiToken)
+      } catch (e) {
+        logger.debug('call to foreignBridge.chaiToken() failed')
+      }
+      // Exclude dai token from previous erc20
+      try {
+        logger.debug('calling foreignBridge.erc20token()')
+        const daiToken = await foreignBridge.methods.erc20token().call()
+        uniqueTokenAddressesSet.delete(daiToken)
+      } catch (e) {
+        logger.debug('call to foreignBridge.erc20token() failed')
+      }
+
+      const uniqueTokenAddresses = [...uniqueTokenAddressesSet]
       await Promise.all(
         uniqueTokenAddresses.map(async tokenAddress => {
           const halfDuplexTokenContract = new web3Foreign.eth.Contract(ERC20_ABI, tokenAddress)

oracle-e2e/package.json

@@ -6,7 +6,7 @@
   "scripts": {
     "start": "mocha",
     "lint": "eslint . --ignore-path ../.eslintignore",
-    "native-to-erc": "mocha test/nativeToErc.js"
+    "amb": "ULTIMATE=true mocha test/amb.js"
   },
   "author": "",
   "license": "ISC",

oracle-e2e/run-tests.sh

@@ -1,6 +1,6 @@
 cd $(dirname $0)
 
-../e2e-commons/up.sh deploy oracle
+../e2e-commons/up.sh deploy blocks oracle oracle-validator-2 oracle-validator-3
 
 docker-compose -f ../e2e-commons/docker-compose.yml run e2e yarn workspace oracle-e2e run start
 rc=$?

oracle-e2e/test/amb.js

@@ -1,22 +1,55 @@
 const Web3 = require('web3')
 const assert = require('assert')
-const promiseRetry = require('promise-retry')
-const { user, homeRPC, foreignRPC, amb } = require('../../e2e-commons/constants.json')
-const { generateNewBlock } = require('../../e2e-commons/utils')
-const { BOX_ABI } = require('../../commons')
+const { user, homeRPC, foreignRPC, amb, validator } = require('../../e2e-commons/constants.json')
+const { uniformRetry } = require('../../e2e-commons/utils')
+const { BOX_ABI, HOME_AMB_ABI, FOREIGN_AMB_ABI } = require('../../commons')
+const { setRequiredSignatures } = require('./utils')
 
 const { toBN } = Web3.utils
 
 const homeWeb3 = new Web3(new Web3.providers.HttpProvider(homeRPC.URL))
 const foreignWeb3 = new Web3(new Web3.providers.HttpProvider(foreignRPC.URL))
 
+const COMMON_HOME_BRIDGE_ADDRESS = amb.home
+const COMMON_FOREIGN_BRIDGE_ADDRESS = amb.foreign
+
 homeWeb3.eth.accounts.wallet.add(user.privateKey)
+homeWeb3.eth.accounts.wallet.add(validator.privateKey)
 foreignWeb3.eth.accounts.wallet.add(user.privateKey)
+foreignWeb3.eth.accounts.wallet.add(validator.privateKey)
 
 const homeBox = new homeWeb3.eth.Contract(BOX_ABI, amb.homeBox)
 const foreignBox = new foreignWeb3.eth.Contract(BOX_ABI, amb.foreignBox)
+const homeBridge = new homeWeb3.eth.Contract(HOME_AMB_ABI, COMMON_HOME_BRIDGE_ADDRESS)
+const foreignBridge = new foreignWeb3.eth.Contract(FOREIGN_AMB_ABI, COMMON_FOREIGN_BRIDGE_ADDRESS)
 
 describe('arbitrary message bridging', () => {
+  before(async () => {
+    // Only 1 validator is used in ultimate tests
+    if (process.env.ULTIMATE !== 'true') {
+      // Set 2 required signatures for home bridge
+      await setRequiredSignatures({
+        bridgeContract: homeBridge,
+        web3: homeWeb3,
+        requiredSignatures: 2,
+        options: {
+          from: validator.address,
+          gas: '4000000'
+        }
+      })
+
+      // Set 2 required signatures for foreign bridge
+      await setRequiredSignatures({
+        bridgeContract: foreignBridge,
+        web3: foreignWeb3,
+        requiredSignatures: 2,
+        options: {
+          from: validator.address,
+          gas: '4000000'
+        }
+      })
+    }
+  })
   describe('Home to Foreign', () => {
     describe('Subsidized Mode', () => {
       it('should bridge message', async () => {
@@ -25,7 +58,7 @@ describe('arbitrary message bridging', () => {
         const initialValue = await foreignBox.methods.value().call()
         assert(!toBN(initialValue).eq(toBN(newValue)), 'initial value should be different from new value')
 
-        const setValueTx = await homeBox.methods
+        await homeBox.methods
           .setValueOnOtherNetwork(newValue, amb.home, amb.foreignBox)
           .send({
             from: user.address,
@@ -35,30 +68,8 @@ describe('arbitrary message bridging', () => {
             console.error(e)
           })
 
-        // Send a trivial transaction to generate a new block since the watcher
-        // is configured to wait 1 confirmation block
-        await generateNewBlock(homeWeb3, user.address)
-
-        // The bridge should create a new transaction with a CollectedSignatures
-        // event so we generate another trivial transaction
-        await promiseRetry(
-          async retry => {
-            const lastBlockNumber = await homeWeb3.eth.getBlockNumber()
-            if (lastBlockNumber >= setValueTx.blockNumber + 2) {
-              await generateNewBlock(homeWeb3, user.address)
-            } else {
-              retry()
-            }
-          },
-          {
-            forever: true,
-            factor: 1,
-            minTimeout: 500
-          }
-        )
-
         // check that value changed and balance decreased
-        await promiseRetry(async retry => {
+        await uniformRetry(async retry => {
           const value = await foreignBox.methods.value().call()
           if (!toBN(value).eq(toBN(newValue))) {
             retry()
@@ -85,12 +96,8 @@ describe('arbitrary message bridging', () => {
             console.error(e)
           })
 
-        // Send a trivial transaction to generate a new block since the watcher
-        // is configured to wait 1 confirmation block
-        await generateNewBlock(foreignWeb3, user.address)
-
         // check that value changed and balance decreased
-        await promiseRetry(async retry => {
+        await uniformRetry(async retry => {
           const value = await homeBox.methods.value().call()
           if (!toBN(value).eq(toBN(newValue))) {
             retry()

oracle-e2e/test/ercToErc.js

@@ -1,9 +1,9 @@
 const Web3 = require('web3')
 const assert = require('assert')
-const promiseRetry = require('promise-retry')
-const { user, secondUser, ercToErcBridge, homeRPC, foreignRPC } = require('../../e2e-commons/constants.json')
-const { ERC677_BRIDGE_TOKEN_ABI, FOREIGN_ERC_TO_NATIVE_ABI } = require('../../commons')
-const { generateNewBlock } = require('../../e2e-commons/utils')
+const { user, secondUser, ercToErcBridge, homeRPC, foreignRPC, validator } = require('../../e2e-commons/constants.json')
+const { ERC677_BRIDGE_TOKEN_ABI, FOREIGN_ERC_TO_NATIVE_ABI, HOME_ERC_TO_ERC_ABI } = require('../../commons')
+const { uniformRetry } = require('../../e2e-commons/utils')
+const { setRequiredSignatures } = require('./utils')
 
 const homeWeb3 = new Web3(new Web3.providers.HttpProvider(homeRPC.URL))
 const foreignWeb3 = new Web3(new Web3.providers.HttpProvider(foreignRPC.URL))
@@ -14,13 +14,39 @@ const COMMON_FOREIGN_BRIDGE_ADDRESS = ercToErcBridge.foreign
 const { toBN } = foreignWeb3.utils
 
 homeWeb3.eth.accounts.wallet.add(user.privateKey)
+homeWeb3.eth.accounts.wallet.add(validator.privateKey)
 foreignWeb3.eth.accounts.wallet.add(user.privateKey)
+foreignWeb3.eth.accounts.wallet.add(validator.privateKey)
 
 const erc20Token = new foreignWeb3.eth.Contract(ERC677_BRIDGE_TOKEN_ABI, ercToErcBridge.foreignToken)
 const foreignBridge = new foreignWeb3.eth.Contract(FOREIGN_ERC_TO_NATIVE_ABI, COMMON_FOREIGN_BRIDGE_ADDRESS)
 const erc677Token = new homeWeb3.eth.Contract(ERC677_BRIDGE_TOKEN_ABI, ercToErcBridge.homeToken)
+const homeBridge = new homeWeb3.eth.Contract(HOME_ERC_TO_ERC_ABI, COMMON_HOME_BRIDGE_ADDRESS)
 
 describe('erc to erc', () => {
+  before(async () => {
+    // Set 2 required signatures for home bridge
+    await setRequiredSignatures({
+      bridgeContract: homeBridge,
+      web3: homeWeb3,
+      requiredSignatures: 2,
+      options: {
+        from: validator.address,
+        gas: '4000000'
+      }
+    })
+
+    // Set 2 required signatures for foreign bridge
+    await setRequiredSignatures({
+      bridgeContract: foreignBridge,
+      web3: foreignWeb3,
+      requiredSignatures: 2,
+      options: {
+        from: validator.address,
+        gas: '4000000'
+      }
+    })
+  })
   it('should convert tokens in foreign to tokens in home', async () => {
     const balance = await erc20Token.methods.balanceOf(user.address).call()
     assert(!toBN(balance).isZero(), 'Account should have tokens')
@@ -49,12 +75,8 @@ describe('erc to erc', () => {
         console.error(e)
       })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that balance increases
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = await erc677Token.methods.balanceOf(user.address).call()
       const recipientBalance = await erc677Token.methods.balanceOf(secondUser.address).call()
       assert(toBN(balance).isZero(), 'User balance should be the same')
@@ -76,12 +98,8 @@ describe('erc to erc', () => {
         console.error(e)
       })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that balance increases
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = await erc677Token.methods.balanceOf(user.address).call()
       if (toBN(balance).isZero()) {
         retry()
@@ -98,7 +116,7 @@ describe('erc to erc', () => {
     assert(!toBN(balance).isZero(), 'Account should have tokens')
 
     // send transaction to home bridge
-    const depositTx = await erc677Token.methods
+    await erc677Token.methods
       .transferAndCall(COMMON_HOME_BRIDGE_ADDRESS, homeWeb3.utils.toWei('0.01'), '0x')
       .send({
         from: user.address,
@@ -108,30 +126,8 @@ describe('erc to erc', () => {
         console.error(e)
       })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(homeWeb3, user.address)
-
-    // The bridge should create a new transaction with a CollectedSignatures
-    // event so we generate another trivial transaction
-    await promiseRetry(
-      async retry => {
-        const lastBlockNumber = await homeWeb3.eth.getBlockNumber()
-        if (lastBlockNumber >= depositTx.blockNumber + 2) {
-          await generateNewBlock(homeWeb3, user.address)
-        } else {
-          retry()
-        }
-      },
-      {
-        forever: true,
-        factor: 1,
-        minTimeout: 500
-      }
-    )
-
     // check that balance increases
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = await erc20Token.methods.balanceOf(user.address).call()
       if (toBN(balance).lte(toBN(originalBalance))) {
         retry()

oracle-e2e/test/ercToNative.js

@@ -9,8 +9,9 @@ const {
   homeRPC,
   foreignRPC
 } = require('../../e2e-commons/constants.json')
-const { ERC677_BRIDGE_TOKEN_ABI, FOREIGN_ERC_TO_NATIVE_ABI, SAI_TOP } = require('../../commons')
-const { generateNewBlock } = require('../../e2e-commons/utils')
+const { ERC677_BRIDGE_TOKEN_ABI, FOREIGN_ERC_TO_NATIVE_ABI, SAI_TOP, HOME_ERC_TO_NATIVE_ABI } = require('../../commons')
+const { uniformRetry, sleep } = require('../../e2e-commons/utils')
+const { setRequiredSignatures } = require('./utils')
 
 const homeWeb3 = new Web3(new Web3.providers.HttpProvider(homeRPC.URL))
 const foreignWeb3 = new Web3(new Web3.providers.HttpProvider(foreignRPC.URL))
@@ -21,11 +22,13 @@ const COMMON_FOREIGN_BRIDGE_ADDRESS = ercToNativeBridge.foreign
 const { toBN } = foreignWeb3.utils
 
 homeWeb3.eth.accounts.wallet.add(user.privateKey)
+homeWeb3.eth.accounts.wallet.add(validator.privateKey)
 foreignWeb3.eth.accounts.wallet.add(user.privateKey)
 foreignWeb3.eth.accounts.wallet.add(validator.privateKey)
 
 const erc20Token = new foreignWeb3.eth.Contract(ERC677_BRIDGE_TOKEN_ABI, ercToNativeBridge.foreignToken)
 const foreignBridge = new foreignWeb3.eth.Contract(FOREIGN_ERC_TO_NATIVE_ABI, COMMON_FOREIGN_BRIDGE_ADDRESS)
+const homeBridge = new homeWeb3.eth.Contract(HOME_ERC_TO_NATIVE_ABI, COMMON_HOME_BRIDGE_ADDRESS)
 
 describe('erc to native', () => {
   let halfDuplexTokenAddress
@@ -33,6 +36,28 @@ describe('erc to native', () => {
   before(async () => {
     halfDuplexTokenAddress = await foreignBridge.methods.halfDuplexErc20token().call()
     halfDuplexToken = new foreignWeb3.eth.Contract(ERC677_BRIDGE_TOKEN_ABI, halfDuplexTokenAddress)
+
+    // Set 2 required signatures for home bridge
+    await setRequiredSignatures({
+      bridgeContract: homeBridge,
+      web3: homeWeb3,
+      requiredSignatures: 2,
+      options: {
+        from: validator.address,
+        gas: '4000000'
+      }
+    })
+
+    // Set 2 required signatures for foreign bridge
+    await setRequiredSignatures({
+      bridgeContract: foreignBridge,
+      web3: foreignWeb3,
+      requiredSignatures: 2,
+      options: {
+        from: validator.address,
+        gas: '4000000'
+      }
+    })
   })
   it('should continue working after migration', async () => {
     const originalBalanceOnHome = await homeWeb3.eth.getBalance(user.address)
@@ -55,14 +80,9 @@ describe('erc to native', () => {
         console.error(e)
       })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that balance increases
     await promiseRetry(async (retry, number) => {
       const balance = await homeWeb3.eth.getBalance(user.address)
-      await generateNewBlock(foreignWeb3, user.address)
       // retry at least 4 times to check transfer is not double processed by the two watchers
       if (toBN(balance).lte(toBN(originalBalanceOnHome)) || number < 4) {
         retry()
@@ -81,7 +101,7 @@ describe('erc to native', () => {
     })
 
     // update min threshold for swap
-    await foreignBridge.methods.setMinHDTokenBalance(foreignWeb3.utils.toWei('1', 'ether')).send({
+    await foreignBridge.methods.setMinHDTokenBalance(foreignWeb3.utils.toWei('2', 'ether')).send({
       from: validator.address,
       gas: '1000000'
     })
@@ -99,14 +119,9 @@ describe('erc to native', () => {
         console.error(e)
       })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that balance increases
     await promiseRetry(async (retry, number) => {
       const balance = await homeWeb3.eth.getBalance(user.address)
-      await generateNewBlock(foreignWeb3, user.address)
       // retry at least 4 times to check transfer is not double processed by the two watchers
       if (toBN(balance).lte(toBN(AfterMigrateBalance)) || number < 4) {
         retry()
@@ -131,14 +146,9 @@ describe('erc to native', () => {
         console.error(e)
       })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that balance increases
     await promiseRetry(async (retry, number) => {
       const balance = await homeWeb3.eth.getBalance(user.address)
-      await generateNewBlock(foreignWeb3, user.address)
       // retry at least 4 times to check transfer is not double processed by the two watchers
       if (toBN(balance).lte(toBN(afterMigrateAndTransferBalance)) || number < 4) {
         retry()
@@ -178,12 +188,8 @@ describe('erc to native', () => {
         console.error(e)
       })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that balance increases
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = await homeWeb3.eth.getBalance(user.address)
       const secondUserbalance = await homeWeb3.eth.getBalance(secondUser.address)
       assert(toBN(balance).lte(toBN(originalBalanceOnHome)), 'User balance should be the same')
@@ -205,12 +211,8 @@ describe('erc to native', () => {
         console.error(e)
       })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that balance increases
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = await homeWeb3.eth.getBalance(user.address)
       if (toBN(balance).lte(toBN(originalBalanceOnHome))) {
         retry()
@@ -235,12 +237,8 @@ describe('erc to native', () => {
       gas: '1000000'
     })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that balance increases
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = await homeWeb3.eth.getBalance(user.address)
       if (toBN(balance).lte(toBN(originalBalanceOnHome))) {
         retry()
@@ -265,9 +263,9 @@ describe('erc to native', () => {
       gas: '1000000'
     })
 
-    await generateNewBlock(foreignWeb3, user.address)
+    await sleep(2000)
 
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const userBalance = await homeWeb3.eth.getBalance(user.address)
       const updatedBridgeErc20TokenBalance = await erc20Token.methods.balanceOf(COMMON_FOREIGN_BRIDGE_ADDRESS).call()
 
@@ -326,12 +324,8 @@ describe('erc to native', () => {
         console.error(e)
       })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that balance increases
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const secondUserbalance = await homeWeb3.eth.getBalance(secondUser.address)
       const updatedBridgeErc20TokenBalance = await erc20Token.methods.balanceOf(COMMON_FOREIGN_BRIDGE_ADDRESS).call()
       const userbalance = await homeWeb3.eth.getBalance(user.address)
@@ -376,7 +370,7 @@ describe('erc to native', () => {
 
     const valueToTransfer = foreignWeb3.utils.toWei('1', 'ether')
 
-    await generateNewBlock(foreignWeb3, user.address)
+    await sleep(2000)
 
     // this transfer won't trigger a call to swap tokens
     await halfDuplexToken.methods.transfer(COMMON_FOREIGN_BRIDGE_ADDRESS, valueToTransfer).send({
@@ -384,10 +378,6 @@ describe('erc to native', () => {
       gas: '1000000'
     })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that transfer and swap are not processed in the next blocks.
     await promiseRetry(async (retry, number) => {
       const balanceOnHome = await homeWeb3.eth.getBalance(user.address)
@@ -403,9 +393,6 @@ describe('erc to native', () => {
       )
       assert(toBN(currentBridgeErc20TokenBalance).eq(toBN(bridgeErc20TokenBalance)), 'erc20 balance should not change')
 
-      // generate new blocks
-      await generateNewBlock(foreignWeb3, user.address)
-
       // after several retries, the state is corrects
       if (number < 4) {
         retry()
@@ -425,9 +412,9 @@ describe('erc to native', () => {
       gas: '1000000'
     })
 
-    await generateNewBlock(foreignWeb3, user.address)
+    await sleep(2000)
 
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const userBalance = await homeWeb3.eth.getBalance(user.address)
       const updatedBridgeErc20TokenBalance = await erc20Token.methods.balanceOf(COMMON_FOREIGN_BRIDGE_ADDRESS).call()
 
@@ -462,7 +449,7 @@ describe('erc to native', () => {
     assert(!toBN(balance).isZero(), 'Account should have tokens')
 
     // send transaction to home bridge
-    const depositTx = await homeWeb3.eth.sendTransaction({
+    await homeWeb3.eth.sendTransaction({
       from: user.address,
       to: COMMON_HOME_BRIDGE_ADDRESS,
       gasPrice: '1',
@@ -470,34 +457,217 @@ describe('erc to native', () => {
       value: homeWeb3.utils.toWei('0.01')
     })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(homeWeb3, user.address)
-
-    // The bridge should create a new transaction with a CollectedSignatures
-    // event so we generate another trivial transaction
-    await promiseRetry(
-      async retry => {
-        const lastBlockNumber = await homeWeb3.eth.getBlockNumber()
-        if (lastBlockNumber >= depositTx.blockNumber + 2) {
-          await generateNewBlock(homeWeb3, user.address)
-        } else {
-          retry()
-        }
-      },
-      {
-        forever: true,
-        factor: 1,
-        minTimeout: 500
-      }
-    )
-
     // check that balance increases
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = await erc20Token.methods.balanceOf(user.address).call()
       if (toBN(balance).lte(toBN(originalBalance))) {
         retry()
       }
     })
   })
+  it('should not invest dai when chai token is disabled', async () => {
+    const bridgeDaiTokenBalance = await erc20Token.methods.balanceOf(COMMON_FOREIGN_BRIDGE_ADDRESS).call()
+
+    await foreignBridge.methods.setMinDaiTokenBalance(foreignWeb3.utils.toWei('2', 'ether')).send({
+      from: validator.address,
+      gas: '1000000'
+    }) // set min limit for automatic investment to 2*2 dai
+
+    const valueToTransfer = foreignWeb3.utils.toWei('5', 'ether')
+
+    // this transfer won't trigger a call to convert to chai
+    await erc20Token.methods.transfer(COMMON_FOREIGN_BRIDGE_ADDRESS, valueToTransfer).send({
+      from: user.address,
+      gas: '1000000'
+    })
+
+    await promiseRetry(async (retry, number) => {
+      if (number < 4) {
+        retry()
+      } else {
+        const updatedBridgeDaiTokenBalance = await erc20Token.methods.balanceOf(COMMON_FOREIGN_BRIDGE_ADDRESS).call()
+        assert(
+          toBN(bridgeDaiTokenBalance)
+            .add(toBN(valueToTransfer))
+            .eq(toBN(updatedBridgeDaiTokenBalance)),
+          'Dai tokens should not be when chai is disabled'
+        )
+      }
+    })
+  })
+  it('should invest dai after enough tokens are collected on bridge account', async () => {
+    await foreignBridge.methods.initializeChaiToken().send({
+      from: validator.address,
+      gas: '1000000'
+    }) // initialize chai token
+    await foreignBridge.methods.setMinDaiTokenBalance('0').send({
+      from: validator.address,
+      gas: '1000000'
+    }) // set investing limit to 0
+    await foreignBridge.methods.convertDaiToChai().send({
+      from: validator.address,
+      gas: '1000000'
+    }) // convert all existing dai tokens on bridge account to chai, in order to start from zero balance
+    await foreignBridge.methods.setMinDaiTokenBalance(foreignWeb3.utils.toWei('2', 'ether')).send({
+      from: validator.address,
+      gas: '1000000'
+    }) // set investing limit to 2 dai, automatically invest should happen after 4 dai
+
+    const valueToTransfer = foreignWeb3.utils.toWei('3', 'ether')
+
+    // this transfer won't trigger a call to convert to chai
+    await erc20Token.methods.transfer(COMMON_FOREIGN_BRIDGE_ADDRESS, valueToTransfer).send({
+      from: user.address,
+      gas: '1000000'
+    })
+
+    await promiseRetry(async (retry, number) => {
+      if (number < 4) {
+        retry()
+      } else {
+        const bridgeDaiTokenBalance = await erc20Token.methods.balanceOf(COMMON_FOREIGN_BRIDGE_ADDRESS).call()
+        assert(
+          valueToTransfer === bridgeDaiTokenBalance,
+          'Dai tokens should not be invested automatically before twice limit is reached'
+        )
+      }
+    })
+
+    // this transfer will trigger call to convert to chai
+    await erc20Token.methods.transfer(COMMON_FOREIGN_BRIDGE_ADDRESS, valueToTransfer).send({
+      from: user.address,
+      gas: '1000000'
+    })
+
+    await promiseRetry(async retry => {
+      const updatedBalance = await erc20Token.methods.balanceOf(COMMON_FOREIGN_BRIDGE_ADDRESS).call()
+      if (toBN(updatedBalance).gte(toBN(valueToTransfer).add(toBN(valueToTransfer)))) {
+        retry()
+      } else {
+        const updatedBalance = await erc20Token.methods.balanceOf(COMMON_FOREIGN_BRIDGE_ADDRESS).call()
+        assert(
+          toBN(updatedBalance).eq(toBN(foreignWeb3.utils.toWei('2', 'ether'))),
+          'Dai bridge balance should be equal to limit'
+        )
+      }
+    })
+  })
+
+  describe('handling of chai swaps', async () => {
+    before(async () => {
+      // Next tests check validator nonces, this will force every validator to submit signature/affirmation
+      // Set 3 required signatures for home bridge
+      await setRequiredSignatures({
+        bridgeContract: homeBridge,
+        web3: homeWeb3,
+        requiredSignatures: 3,
+        options: {
+          from: validator.address,
+          gas: '4000000'
+        }
+      })
+
+      // Set 3 required signatures for foreign bridge
+      await setRequiredSignatures({
+        bridgeContract: foreignBridge,
+        web3: foreignWeb3,
+        requiredSignatures: 3,
+        options: {
+          from: validator.address,
+          gas: '4000000'
+        }
+      })
+    })
+
+    it('should not handle transfer event in paying interest', async () => {
+      await foreignBridge.methods.setInterestReceiver(user.address).send({
+        from: validator.address,
+        gas: '1000000'
+      })
+      const initialNonce = await homeWeb3.eth.getTransactionCount(validator.address)
+      await foreignBridge.methods.payInterest().send({
+        from: user.address,
+        gas: '1000000'
+      })
+
+      await promiseRetry(async (retry, number) => {
+        if (number < 6) {
+          retry()
+        } else {
+          const nonce = await homeWeb3.eth.getTransactionCount(validator.address)
+          assert(
+            nonce === initialNonce,
+            'Validator should not process transfer event originated during converting Chai => Dai'
+          )
+        }
+      })
+    })
+
+    it('should not handle chai withdrawal transfer event in executeSignatures as a regular transfer', async () => {
+      await foreignBridge.methods.setMinDaiTokenBalance('0').send({
+        from: validator.address,
+        gas: '1000000'
+      }) // set investing limit to 0
+      await foreignBridge.methods.convertDaiToChai().send({
+        from: validator.address,
+        gas: '1000000'
+      }) // convert all existing dai tokens on bridge account to chai, in order to start from zero balance
+
+      const initialNonce = await homeWeb3.eth.getTransactionCount(validator.address)
+
+      const originalBalance = await erc20Token.methods.balanceOf(user.address).call()
+      // send transaction to home bridge
+      await homeWeb3.eth.sendTransaction({
+        from: user.address,
+        to: COMMON_HOME_BRIDGE_ADDRESS,
+        gasPrice: '1',
+        gas: '1000000',
+        value: homeWeb3.utils.toWei('0.01')
+      })
+
+      // check that balance increases
+      await uniformRetry(async retry => {
+        const balance = await erc20Token.methods.balanceOf(user.address).call()
+        if (toBN(balance).lte(toBN(originalBalance))) {
+          retry()
+        }
+      })
+
+      await promiseRetry(async (retry, number) => {
+        if (number < 6) {
+          retry()
+        } else {
+          const nonce = await homeWeb3.eth.getTransactionCount(validator.address)
+          assert(
+            nonce === initialNonce + 1,
+            'Validator should not process transfer event originated during converting Chai => Dai'
+          )
+        }
+      })
+    })
+
+    after(async () => {
+      // Set 2 required signatures for home bridge
+      await setRequiredSignatures({
+        bridgeContract: homeBridge,
+        web3: homeWeb3,
+        requiredSignatures: 2,
+        options: {
+          from: validator.address,
+          gas: '4000000'
+        }
+      })
+
+      // Set 2 required signatures for foreign bridge
+      await setRequiredSignatures({
+        bridgeContract: foreignBridge,
+        web3: foreignWeb3,
+        requiredSignatures: 2,
+        options: {
+          from: validator.address,
+          gas: '4000000'
+        }
+      })
+    })
+  })
 })

oracle-e2e/test/mocha.opts

@@ -1 +1 @@
---timeout 30000
+--timeout 120000

oracle-e2e/test/nativeToErc.js

@@ -1,16 +1,20 @@
 const Web3 = require('web3')
 const assert = require('assert')
-const promiseRetry = require('promise-retry')
 const {
   user,
   validator,
+  secondValidator,
+  thirdValidator,
   nativeToErcBridge,
   secondUser,
+  thirdUser,
+  fourthUser,
   homeRPC,
   foreignRPC
 } = require('../../e2e-commons/constants.json')
-const { ERC677_BRIDGE_TOKEN_ABI } = require('../../commons')
-const { generateNewBlock } = require('../../e2e-commons/utils')
+const { ERC677_BRIDGE_TOKEN_ABI, HOME_NATIVE_TO_ERC_ABI, FOREIGN_NATIVE_TO_ERC_ABI } = require('../../commons')
+const { uniformRetry, sleep } = require('../../e2e-commons/utils')
+const { setRequiredSignatures } = require('./utils')
 
 const homeWeb3 = new Web3(new Web3.providers.HttpProvider(homeRPC.URL))
 const foreignWeb3 = new Web3(new Web3.providers.HttpProvider(foreignRPC.URL))
@@ -19,25 +23,58 @@ const { toBN } = foreignWeb3.utils
 const COMMON_HOME_BRIDGE_ADDRESS = nativeToErcBridge.home
 const COMMON_FOREIGN_BRIDGE_ADDRESS = nativeToErcBridge.foreign
 
+const validatorAddresses = [validator.address, secondValidator.address, thirdValidator.address]
+
 homeWeb3.eth.accounts.wallet.add(user.privateKey)
 homeWeb3.eth.accounts.wallet.add(validator.privateKey)
 homeWeb3.eth.accounts.wallet.add(secondUser.privateKey)
+homeWeb3.eth.accounts.wallet.add(secondValidator.privateKey)
+homeWeb3.eth.accounts.wallet.add(thirdValidator.privateKey)
+homeWeb3.eth.accounts.wallet.add(thirdUser.privateKey)
+homeWeb3.eth.accounts.wallet.add(fourthUser.privateKey)
 foreignWeb3.eth.accounts.wallet.add(user.privateKey)
 foreignWeb3.eth.accounts.wallet.add(validator.privateKey)
 foreignWeb3.eth.accounts.wallet.add(secondUser.privateKey)
+foreignWeb3.eth.accounts.wallet.add(secondValidator.privateKey)
+foreignWeb3.eth.accounts.wallet.add(thirdValidator.privateKey)
+foreignWeb3.eth.accounts.wallet.add(thirdUser.privateKey)
+foreignWeb3.eth.accounts.wallet.add(fourthUser.privateKey)
 
 const token = new foreignWeb3.eth.Contract(ERC677_BRIDGE_TOKEN_ABI, nativeToErcBridge.foreignToken)
-
-const sleep = timeout => new Promise(res => setTimeout(res, timeout))
+const homeBridge = new homeWeb3.eth.Contract(HOME_NATIVE_TO_ERC_ABI, COMMON_HOME_BRIDGE_ADDRESS)
+const foreignBridge = new foreignWeb3.eth.Contract(FOREIGN_NATIVE_TO_ERC_ABI, COMMON_FOREIGN_BRIDGE_ADDRESS)
 
 describe('native to erc', () => {
+  before(async () => {
+    // Set 2 required signatures for home bridge
+    await setRequiredSignatures({
+      bridgeContract: homeBridge,
+      web3: homeWeb3,
+      requiredSignatures: 2,
+      options: {
+        from: validator.address,
+        gas: '4000000'
+      }
+    })
+
+    // Set 2 required signatures for foreign bridge
+    await setRequiredSignatures({
+      bridgeContract: foreignBridge,
+      web3: foreignWeb3,
+      requiredSignatures: 2,
+      options: {
+        from: validator.address,
+        gas: '4000000'
+      }
+    })
+  })
   it('should convert eth in home to tokens in foreign', async () => {
     // check that account has zero tokens in the foreign chain
     const balance = await token.methods.balanceOf(user.address).call()
     assert(toBN(balance).isZero(), 'Account should not have tokens yet')
 
     // send transaction to home chain
-    const depositTx = await homeWeb3.eth.sendTransaction({
+    await homeWeb3.eth.sendTransaction({
       from: user.address,
       to: COMMON_HOME_BRIDGE_ADDRESS,
       gasPrice: '1',
@@ -45,30 +82,8 @@ describe('native to erc', () => {
       value: '1000000000000000000'
     })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(homeWeb3, user.address)
-
-    // The bridge should create a new transaction with a CollectedSignatures
-    // event so we generate another trivial transaction
-    await promiseRetry(
-      async retry => {
-        const lastBlockNumber = await homeWeb3.eth.getBlockNumber()
-        if (lastBlockNumber >= depositTx.blockNumber + 2) {
-          await generateNewBlock(homeWeb3, user.address)
-        } else {
-          retry()
-        }
-      },
-      {
-        forever: true,
-        factor: 1,
-        minTimeout: 500
-      }
-    )
-
     // check that account has tokens in the foreign chain
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = await token.methods.balanceOf(user.address).call()
       if (toBN(balance).isZero()) {
         retry()
@@ -90,12 +105,8 @@ describe('native to erc', () => {
         console.error(e)
       })
 
-    // Send a trivial transaction to generate a new block since the watcher
-    // is configured to wait 1 confirmation block
-    await generateNewBlock(foreignWeb3, user.address)
-
     // check that balance increases
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = await homeWeb3.eth.getBalance(user.address)
       if (toBN(balance).lte(toBN(originalBalance))) {
         retry()
@@ -109,9 +120,12 @@ describe('native to erc', () => {
 
     // empty validator funds
     await sendAllBalance(homeWeb3, validator.address, secondUser.address)
+    await sendAllBalance(homeWeb3, secondValidator.address, thirdUser.address)
+    await sendAllBalance(homeWeb3, thirdValidator.address, fourthUser.address)
 
+    const nonces = await Promise.all(validatorAddresses.map(homeWeb3.eth.getTransactionCount))
     // send transaction to home chain
-    const depositTx = await homeWeb3.eth.sendTransaction({
+    await homeWeb3.eth.sendTransaction({
       from: user.address,
       to: COMMON_HOME_BRIDGE_ADDRESS,
       gasPrice: '1',
@@ -119,39 +133,20 @@ describe('native to erc', () => {
       value: '1000000000000000000'
     })
 
-    // Send a Tx to generate a new block
-    await generateNewBlock(homeWeb3, user.address)
-
     // wait two seconds, no new blocks should have been generated
     await sleep(2000)
-    const lastBlockNumber = await homeWeb3.eth.getBlockNumber()
+    const newNonces = await Promise.all(validatorAddresses.map(homeWeb3.eth.getTransactionCount))
     const balance = toBN(await token.methods.balanceOf(user.address).call())
-    assert(lastBlockNumber === depositTx.blockNumber + 1, "Shouldn't have emitted a new block")
+    assert.deepStrictEqual(nonces, newNonces, "Shouldn't sent new tx")
     assert(originalBalance.eq(balance), "Token balance shouldn't have changed")
 
     // send funds back to validator
-    const sendBalanceBackTx = await sendAllBalance(homeWeb3, secondUser.address, validator.address)
-
-    // expect Deposit event to be processed
-    await promiseRetry(
-      async retry => {
-        const lastBlockNumber = await homeWeb3.eth.getBlockNumber()
-        // check that a new block was created since the last transaction
-        if (lastBlockNumber === sendBalanceBackTx.blockNumber + 1) {
-          await generateNewBlock(homeWeb3, user.address)
-        } else {
-          retry()
-        }
-      },
-      {
-        forever: true,
-        factor: 1,
-        minTimeout: 500
-      }
-    )
+    await sendAllBalance(homeWeb3, secondUser.address, validator.address)
+    await sendAllBalance(homeWeb3, thirdUser.address, secondValidator.address)
+    await sendAllBalance(homeWeb3, fourthUser.address, thirdValidator.address)
 
     // check that token balance was incremented in foreign chain
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = toBN(await token.methods.balanceOf(user.address).call())
       if (!balance.gt(originalBalance)) {
         retry()
@@ -165,7 +160,9 @@ describe('native to erc', () => {
 
     // empty foreign validator funds
     await sendAllBalance(foreignWeb3, validator.address, secondUser.address)
-    const foreignBlockNumber = await foreignWeb3.eth.getBlockNumber()
+    await sendAllBalance(foreignWeb3, secondValidator.address, thirdUser.address)
+    await sendAllBalance(foreignWeb3, thirdValidator.address, fourthUser.address)
+    const nonces = await Promise.all(validatorAddresses.map(foreignWeb3.eth.getTransactionCount))
 
     // send transaction to home chain
     await homeWeb3.eth.sendTransaction({
@@ -176,36 +173,18 @@ describe('native to erc', () => {
       value: '1000000000000000000'
     })
 
-    // Send a Tx to generate a new block
-    const lastHomeTx = await generateNewBlock(homeWeb3, user.address)
-
-    // wait for the deposit to be processed
-    await promiseRetry(
-      async retry => {
-        const lastBlockNumber = await homeWeb3.eth.getBlockNumber()
-        if (lastBlockNumber === lastHomeTx.blockNumber + 1) {
-          await generateNewBlock(homeWeb3, user.address)
-        } else {
-          retry()
-        }
-      },
-      {
-        forever: true,
-        factor: 1,
-        minTimeout: 500
-      }
-    )
-
     // tokens shouldn't be generated in the foreign chain because the validator doesn't have funds
     await sleep(2000)
-    const lastForeignBlockNumber = await foreignWeb3.eth.getBlockNumber()
-    assert(lastForeignBlockNumber === foreignBlockNumber, "Shouldn't have emitted a new block")
+    const newNonces = await Promise.all(validatorAddresses.map(foreignWeb3.eth.getTransactionCount))
+    assert.deepStrictEqual(nonces, newNonces, "Shouldn't sent new tx")
 
     // send funds back to validator
     await sendAllBalance(foreignWeb3, secondUser.address, validator.address)
+    await sendAllBalance(foreignWeb3, thirdUser.address, secondValidator.address)
+    await sendAllBalance(foreignWeb3, fourthUser.address, thirdValidator.address)
 
     // check that account has tokens in the foreign chain
-    await promiseRetry(async retry => {
+    await uniformRetry(async retry => {
       const balance = toBN(await token.methods.balanceOf(user.address).call())
       if (balance.eq(originalBalance)) {
         retry()

oracle-e2e/test/utils.js

@@ -0,0 +1,12 @@
+const { BRIDGE_VALIDATORS_ABI } = require('../../commons')
+
+const setRequiredSignatures = async ({ bridgeContract, web3, requiredSignatures, options }) => {
+  const validatorAddress = await bridgeContract.methods.validatorContract().call()
+  const validatorContract = new web3.eth.Contract(BRIDGE_VALIDATORS_ABI, validatorAddress)
+
+  return validatorContract.methods.setRequiredSignatures(requiredSignatures).send(options)
+}
+
+module.exports = {
+  setRequiredSignatures
+}

oracle/Dockerfile

@@ -22,8 +22,6 @@ RUN mv ./contracts/build ./ && rm -rf ./contracts/* ./contracts/.[!.]* && mv ./b
 COPY ./commons ./commons
 
 COPY ./oracle ./oracle
-ARG DOT_ENV_PATH=./oracle/.env
-COPY ${DOT_ENV_PATH} ./oracle/.env
 
 WORKDIR /mono/oracle
 CMD echo "To start a bridge process run:" \

oracle/README.md

@@ -117,8 +117,18 @@ There are two options to run the TokenBridge processes:
 
 ### Docker 
 
-  - While running the bridge containers for the first time use `ORACLE_VALIDATOR_ADDRESS=<validator address> ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY=<validator address private key> docker-compose up -d --build` 
-  - For further launches use `ORACLE_VALIDATOR_ADDRESS=<validator address>  ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY=<validator address private key> docker-compose  up  --detach`
+  - While running the bridge containers for the first time use
+    ```
+    env ORACLE_VALIDATOR_ADDRESS=<validator address> \
+      env ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY=<validator address private key> \
+      docker-compose -f docker-compose-build.yml -f docker-compose.yml up -d --build
+    ``` 
+  - For further launches (or in case of usage an official docker image) use
+    ```
+    env ORACLE_VALIDATOR_ADDRESS=<validator address> \
+      env ORACLE_VALIDATOR_ADDRESS_PRIVATE_KEY=<validator address private key> \
+      docker-compose up --d
+    ```
 
 All [watcher](#watcher) & [sender](#sender) services launch when `docker-compose` is called. 
 
@@ -144,6 +154,18 @@ In case you need to reset your bridge or setup a new one (with different configu
 
 See the [UI instructions](../ui/README.md) to configure and use the optional Bridge UI.
 
+### Build the image without running the oracle
+
+To build the image change the directory:
+```
+cd oracle
+```
+
+And run the docker composer:
+```
+docker-compose -f docker-compose-build.yml build
+``` 
+
 ## Rollback the Last Processed Block in Redis
 
 If the bridge does not handle an event properly (i.e. a transaction stalls due to a low gas price), the Redis DB can be rolled back. You must identify which watcher needs to re-run. For example, if the validator signatures were collected but the transaction with signatures was not sent to the Foreign network, the `collected-signatures` watcher must look at the block where the corresponding `CollectedSignatures` event was raised.

oracle/config/convert-to-chai-worker.config.js

@@ -0,0 +1,20 @@
+const baseConfig = require('./base.config')
+const { EXIT_CODES } = require('../src/utils/constants')
+
+const id = `${baseConfig.id}-convert-to-chai`
+
+const workerRequired = baseConfig.id === 'erc-native'
+
+if (!workerRequired) {
+  console.error(`Convert to chai tokens worker not required for bridge mode ${process.env.ORACLE_BRIDGE_MODE}`)
+  process.exit(EXIT_CODES.WATCHER_NOT_REQUIRED)
+}
+
+module.exports = {
+  ...baseConfig.bridgeConfig,
+  ...baseConfig.foreignConfig,
+  workerQueue: 'convert-to-chai',
+  senderQueue: 'foreign',
+  name: `worker-${id}`,
+  id
+}

oracle/config/transfer-watcher.config.js

@@ -29,6 +29,11 @@ if (!transferWatcherRequired) {
   process.exit(EXIT_CODES.WATCHER_NOT_REQUIRED)
 }
 
+const workerQueueConfig = {}
+if (baseConfig.id === 'erc-native') {
+  workerQueueConfig.workerQueue = 'convert-to-chai'
+}
+
 module.exports = {
   ...baseConfig.bridgeConfig,
   ...baseConfig.foreignConfig,
@@ -37,6 +42,7 @@ module.exports = {
   eventAbi: ERC20_ABI,
   eventFilter: { to: process.env.COMMON_FOREIGN_BRIDGE_ADDRESS },
   queue: 'home',
+  ...workerQueueConfig,
   name: `watcher-${id}`,
   id
 }

oracle/docker-compose-build.yml

@@ -0,0 +1,6 @@
+---
+version: '2.4'
+services:
+  oracle:
+    image: poanetwork/tokenbridge-oracle
+    build: .

oracle/docker-compose-erc-native.yml

@@ -9,6 +9,7 @@ services:
       - net_rabbit_bridge_transfer
       - net_rabbit_bridge_half_duplex_transfer
       - net_rabbit_bridge_swap_tokens_worker
+      - net_rabbit_bridge_convert_to_chai_worker
   redis:
     extends:
       file: docker-compose.yml
@@ -40,9 +41,7 @@ services:
   bridge_transfer:
     cpus: 0.1
     mem_limit: 500m
-    build:
-      context: ..
-      dockerfile: oracle/Dockerfile
+    image: poanetwork/tokenbridge-oracle:latest
     env_file: ./.env
     environment:
       - NODE_ENV=production
@@ -55,9 +54,7 @@ services:
   bridge_half_duplex_transfer:
     cpus: 0.1
     mem_limit: 500m
-    build:
-      context: ..
-      dockerfile: oracle/Dockerfile
+    image: poanetwork/tokenbridge-oracle:latest
     env_file: ./.env
     environment:
       - NODE_ENV=production
@@ -70,9 +67,7 @@ services:
   bridge_swap_tokens_worker:
     cpus: 0.1
     mem_limit: 500m
-    build:
-      context: ..
-      dockerfile: oracle/Dockerfile
+    image: poanetwork/tokenbridge-oracle:latest
     env_file: ./.env
     environment:
       - NODE_ENV=production
@@ -81,6 +76,18 @@ services:
     entrypoint: yarn worker:swap-tokens
     networks:
       - net_rabbit_bridge_swap_tokens_worker
+  bridge_convert_to_chai_worker:
+    cpus: 0.1
+    mem_limit: 500m
+    image: poanetwork/tokenbridge-oracle:latest
+    env_file: ./.env
+    environment:
+      - NODE_ENV=production
+      - ORACLE_VALIDATOR_ADDRESS=${ORACLE_VALIDATOR_ADDRESS}
+    restart: unless-stopped
+    entrypoint: yarn worker:convert-to-chai
+    networks:
+      - net_rabbit_bridge_convert_to_chai_worker
   bridge_senderhome:
     extends:
       file: docker-compose.yml
@@ -127,3 +134,5 @@ networks:
     driver: bridge
   net_rabbit_bridge_senderforeign:
     driver: bridge
+  net_rabbit_bridge_convert_to_chai_worker:
+    driver: bridge

oracle/docker-compose-transfer.yml

@@ -37,9 +37,7 @@ services:
   bridge_transfer:
     cpus: 0.1
     mem_limit: 500m
-    build:
-      context: ..
-      dockerfile: oracle/Dockerfile
+    image: poanetwork/tokenbridge-oracle:latest
     env_file: ./.env
     environment:
       - NODE_ENV=production

oracle/docker-compose.yml

@@ -32,9 +32,7 @@ services:
   bridge_request:
     cpus: 0.1
     mem_limit: 500m
-    build:
-      context: ..
-      dockerfile: oracle/Dockerfile
+    image: poanetwork/tokenbridge-oracle:latest
     env_file: ./.env
     environment: 
       - NODE_ENV=production 
@@ -47,9 +45,7 @@ services:
   bridge_collected:
     cpus: 0.1
     mem_limit: 500m
-    build:
-      context: ..
-      dockerfile: oracle/Dockerfile
+    image: poanetwork/tokenbridge-oracle:latest
     env_file: ./.env
     environment: 
       - NODE_ENV=production 
@@ -62,9 +58,7 @@ services:
   bridge_affirmation:
     cpus: 0.1
     mem_limit: 500m
-    build:
-      context: ..
-      dockerfile: oracle/Dockerfile
+    image: poanetwork/tokenbridge-oracle:latest
     env_file: ./.env
     environment: 
       - NODE_ENV=production 
@@ -77,9 +71,7 @@ services:
   bridge_senderhome:
     cpus: 0.1
     mem_limit: 500m
-    build:
-      context: ..
-      dockerfile: oracle/Dockerfile
+    image: poanetwork/tokenbridge-oracle:latest
     env_file: ./.env
     environment: 
       - NODE_ENV=production 
@@ -92,9 +84,7 @@ services:
   bridge_senderforeign:
     cpus: 0.1
     mem_limit: 500m
-    build:
-      context: ..
-      dockerfile: oracle/Dockerfile
+    image: poanetwork/tokenbridge-oracle:latest
     env_file: ./.env
     environment: 
       - NODE_ENV=production 

oracle/package.json

@@ -11,6 +11,7 @@
     "watcher:transfer": "./scripts/start-worker.sh watcher transfer-watcher",
     "watcher:half-duplex-transfer": "./scripts/start-worker.sh watcher half-duplex-transfer-watcher",
     "worker:swap-tokens": "./scripts/start-worker.sh worker swap-tokens-worker",
+    "worker:convert-to-chai": "./scripts/start-worker.sh worker convert-to-chai-worker",
     "sender:home": "./scripts/start-worker.sh sender home-sender",
     "sender:foreign": "./scripts/start-worker.sh sender foreign-sender",
     "dev": "concurrently -n 'watcher:signature-request,watcher:collected-signatures,watcher:affirmation-request,watcher:transfer,watcher:half-duplex-transfer, worker:swap-tokens, sender:home,sender:foreign' -c 'red,green,yellow,blue,white,gray,magenta,cyan' 'yarn watcher:signature-request' 'yarn watcher:collected-signatures' 'yarn watcher:affirmation-request' 'yarn watcher:transfer' 'yarn watcher:half-duplex-transfer' 'yarn worker:swap-tokens' 'yarn sender:home' 'yarn sender:foreign'",

oracle/src/events/processAMBCollectedSignatures/estimateGas.js

@@ -46,7 +46,7 @@ async function estimateGas({
 
     // check if all the signatures were made by validators
     for (let i = 0; i < v.length; i++) {
-      const address = web3.eth.accounts.recover(message, web3.utils.toHex(v[i]), r[i], s[i])
+      const address = web3.eth.accounts.recover(message, `0x${v[i]}`, `0x${r[i]}`, `0x${s[i]}`)
       logger.debug({ address }, 'Check that signature is from a validator')
       const isValidator = await validatorContract.methods.isValidator(address).call()
 

oracle/src/events/processAMBCollectedSignatures/index.js

@@ -4,7 +4,7 @@ const { HttpListProviderError } = require('http-list-provider')
 const bridgeValidatorsABI = require('../../../../contracts/build/contracts/BridgeValidators').abi
 const rootLogger = require('../../services/logger')
 const { web3Home, web3Foreign } = require('../../services/web3')
-const { signatureToVRS, signatureToVRSAMB, packSignatures } = require('../../utils/message')
+const { signatureToVRS, packSignatures } = require('../../utils/message')
 const { parseAMBMessage } = require('../../../../commons')
 const estimateGas = require('./estimateGas')
 const { AlreadyProcessedError, IncompatibleContractError, InvalidValidatorError } = require('../../utils/errors')
@@ -63,8 +63,7 @@ function processCollectedSignaturesBuilder(config) {
           v.push(vrs.v)
           r.push(vrs.r)
           s.push(vrs.s)
-          const recover = signatureToVRSAMB(signature)
-          signaturesArray.push(recover)
+          signaturesArray.push(vrs)
         })
 
         await Promise.all(signaturePromises)

oracle/src/events/processCollectedSignatures/estimateGas.js

@@ -9,9 +9,18 @@ const logger = require('../../services/logger').child({
 const web3 = new Web3()
 const { toBN } = Web3.utils
 
-async function estimateGas({ foreignBridge, validatorContract, message, numberOfCollectedSignatures, v, r, s }) {
+async function estimateGas({
+  foreignBridge,
+  validatorContract,
+  message,
+  numberOfCollectedSignatures,
+  v,
+  r,
+  s,
+  signatures
+}) {
   try {
-    const gasEstimate = await foreignBridge.methods.executeSignatures(v, r, s, message).estimateGas()
+    const gasEstimate = await foreignBridge.methods.executeSignatures(message, signatures).estimateGas()
     return gasEstimate
   } catch (e) {
     if (e instanceof HttpListProviderError) {
@@ -35,7 +44,7 @@ async function estimateGas({ foreignBridge, validatorContract, message, numberOf
 
     // check if all the signatures were made by validators
     for (let i = 0; i < v.length; i++) {
-      const address = web3.eth.accounts.recover(message, web3.utils.toHex(v[i]), r[i], s[i])
+      const address = web3.eth.accounts.recover(message, `0x${v[i]}`, `0x${r[i]}`, `0x${s[i]}`)
       logger.debug({ address }, 'Check that signature is from a validator')
       const isValidator = await validatorContract.methods.isValidator(address).call()
 

oracle/src/events/processCollectedSignatures/index.js

@@ -4,7 +4,7 @@ const { HttpListProviderError } = require('http-list-provider')
 const { BRIDGE_VALIDATORS_ABI } = require('../../../../commons')
 const rootLogger = require('../../services/logger')
 const { web3Home, web3Foreign } = require('../../services/web3')
-const { signatureToVRS } = require('../../utils/message')
+const { signatureToVRS, packSignatures } = require('../../utils/message')
 const estimateGas = require('./estimateGas')
 const { AlreadyProcessedError, IncompatibleContractError, InvalidValidatorError } = require('../../utils/errors')
 const { MAX_CONCURRENT_EVENTS } = require('../../utils/constants')
@@ -52,18 +52,21 @@ function processCollectedSignaturesBuilder(config) {
         requiredSignatures.length = NumberOfCollectedSignatures
         requiredSignatures.fill(0)
 
+        const signaturesArray = []
         const [v, r, s] = [[], [], []]
         logger.debug('Getting message signatures')
         const signaturePromises = requiredSignatures.map(async (el, index) => {
           logger.debug({ index }, 'Getting message signature')
           const signature = await homeBridge.methods.signature(messageHash, index).call()
-          const recover = signatureToVRS(signature)
-          v.push(recover.v)
-          r.push(recover.r)
-          s.push(recover.s)
+          const vrs = signatureToVRS(signature)
+          v.push(vrs.v)
+          r.push(vrs.r)
+          s.push(vrs.s)
+          signaturesArray.push(vrs)
         })
 
         await Promise.all(signaturePromises)
+        const signatures = packSignatures(signaturesArray)
 
         let gasEstimate
         try {
@@ -74,6 +77,7 @@ function processCollectedSignaturesBuilder(config) {
             v,
             r,
             s,
+            signatures,
             message,
             numberOfCollectedSignatures: NumberOfCollectedSignatures
           })
@@ -92,7 +96,7 @@ function processCollectedSignaturesBuilder(config) {
             throw e
           }
         }
-        const data = await foreignBridge.methods.executeSignatures(v, r, s, message).encodeABI()
+        const data = await foreignBridge.methods.executeSignatures(message, signatures).encodeABI()
         txToSend.push({
           data,
           gasEstimate,

oracle/src/utils/chaiUtils.js

@@ -0,0 +1,13 @@
+async function isChaiTokenEnabled(bridgeContract, logger) {
+  logger.debug('Checking Chai availability')
+  try {
+    return await bridgeContract.methods.isChaiTokenEnabled().call()
+  } catch (e) {
+    logger.debug('Method isChaiTokenEnabled is not supported')
+    return false
+  }
+}
+
+module.exports = {
+  isChaiTokenEnabled
+}

oracle/src/utils/message.js

@@ -50,17 +50,9 @@ function parseMessage(message) {
   }
 }
 
-function signatureToVRS(signature) {
-  assert.strictEqual(signature.length, 2 + 32 * 2 + 32 * 2 + 2)
-  signature = strip0x(signature)
-  const v = parseInt(signature.substr(64 * 2), 16)
-  const r = `0x${signature.substr(0, 32 * 2)}`
-  const s = `0x${signature.substr(32 * 2, 32 * 2)}`
-  return { v, r, s }
-}
-
-function signatureToVRSAMB(rawSignature) {
+function signatureToVRS(rawSignature) {
   const signature = strip0x(rawSignature)
+  assert.strictEqual(signature.length, 2 + 32 * 2 + 32 * 2)
   const v = signature.substr(64 * 2)
   const r = signature.substr(0, 32 * 2)
   const s = signature.substr(32 * 2, 32 * 2)
@@ -85,6 +77,5 @@ module.exports = {
   createMessage,
   parseMessage,
   signatureToVRS,
-  signatureToVRSAMB,
   packSignatures
 }

oracle/src/watcher.js

@@ -9,6 +9,7 @@ const rpcUrlsManager = require('./services/getRpcUrlsManager')
 const { getRequiredBlockConfirmations, getEvents } = require('./tx/web3')
 const { checkHTTPS, watchdog } = require('./utils/utils')
 const { EXIT_CODES } = require('./utils/constants')
+const { isChaiTokenEnabled } = require('./utils/chaiUtils')
 
 if (process.argv.length < 3) {
   logger.error('Please check the number of arguments, config file was not provided')
@@ -157,6 +158,15 @@ async function getLastBlockToProcess() {
   return lastBlockNumber.sub(requiredBlockConfirmations)
 }
 
+async function isWorkerNeeded() {
+  switch (config.id) {
+    case 'erc-native-transfer':
+      return isChaiTokenEnabled(bridgeContract, logger)
+    default:
+      return true
+  }
+}
+
 async function main({ sendToQueue, sendToWorker }) {
   try {
     await checkConditions()
@@ -186,7 +196,7 @@ async function main({ sendToQueue, sendToWorker }) {
     logger.info(`Found ${events.length} ${config.event} events`)
 
     if (events.length) {
-      if (sendToWorker) {
+      if (sendToWorker && (await isWorkerNeeded())) {
         await sendToWorker({ blockNumber: toBlock.toString() })
       }
 

oracle/src/worker.js

@@ -8,6 +8,7 @@ const { connectWorkerToQueue } = require('./services/amqpClient')
 const config = require(path.join('../config/', process.argv[2]))
 
 const swapTokens = require('./workers/swapTokens')(config)
+const convertToChai = require('./workers/convertToChai')(config)
 
 async function initialize() {
   try {
@@ -39,6 +40,8 @@ async function initialize() {
 async function run(blockNumber) {
   if (config.id === 'erc-native-swap-tokens') {
     return swapTokens(blockNumber)
+  } else if (config.id === 'erc-native-convert-to-chai') {
+    return convertToChai(blockNumber)
   } else {
     return []
   }

oracle/src/workers/convertToChai.js

@@ -0,0 +1,80 @@
+require('../../env')
+const { HttpListProviderError } = require('http-list-provider')
+const rootLogger = require('../services/logger')
+const { web3Foreign } = require('../services/web3')
+
+const { BRIDGE_VALIDATORS_ABI } = require('../../../commons')
+
+let validatorContract = null
+
+function convertToChaiBuilder(config) {
+  const foreignBridge = new web3Foreign.eth.Contract(config.foreignBridgeAbi, config.foreignBridgeAddress)
+  return async function convertToChai(blockNumber) {
+    const txToSend = []
+
+    const logger = rootLogger.child({
+      blockNumber: blockNumber.toString()
+    })
+
+    logger.debug(`Starting convert to chai operation`)
+
+    if (validatorContract === null) {
+      logger.debug('Getting validator contract address')
+      const validatorContractAddress = await foreignBridge.methods.validatorContract().call()
+      logger.debug({ validatorContractAddress }, 'Validator contract address obtained')
+
+      validatorContract = new web3Foreign.eth.Contract(BRIDGE_VALIDATORS_ABI, validatorContractAddress)
+    }
+
+    logger.debug(`Checking if is validator duty`)
+    const validatorDuty = await validatorContract.methods.isValidatorDuty(config.validatorAddress).call()
+
+    if (!validatorDuty) {
+      logger.info(`Convert to chai discarded because is not validator duty`)
+      return txToSend
+    }
+
+    logger.debug(`Checking if dai token balance is above the threshold`)
+    const daiNeedsToBeInvested = await foreignBridge.methods.isDaiNeedsToBeInvested().call()
+
+    if (!daiNeedsToBeInvested) {
+      logger.info(`Convert to chai discarded because dai balance is below the threshold or chai token is not set`)
+      return txToSend
+    }
+
+    let gasEstimate
+
+    try {
+      logger.debug(`Estimate gas`)
+      gasEstimate = await foreignBridge.methods.convertDaiToChai().estimateGas({
+        from: config.validatorAddress
+      })
+
+      logger.debug({ gasEstimate }, 'Gas estimated')
+    } catch (e) {
+      if (e instanceof HttpListProviderError) {
+        const errorMsg = 'RPC Connection Error: convertToChai Gas Estimate cannot be obtained.'
+        logger.error(e, errorMsg)
+        throw new Error(errorMsg)
+      } else {
+        logger.error(e, 'Unknown error while processing transaction')
+        throw e
+      }
+    }
+
+    // generate data
+    const data = await foreignBridge.methods.convertDaiToChai().encodeABI()
+
+    // push to job
+    txToSend.push({
+      data,
+      gasEstimate,
+      transactionReference: `convert to chai operation for block number ${blockNumber.toString()}`,
+      to: config.foreignBridgeAddress
+    })
+
+    return txToSend
+  }
+}
+
+module.exports = convertToChaiBuilder

oracle/test/message.test.js

@@ -259,9 +259,9 @@ describe('message utils', () => {
       const { v, r, s } = signatureToVRS(signature)
 
       // then
-      expect(v).to.equal(27)
-      expect(r).to.equal('0xed157c39b80281741e7d4075655f25b11a9182f12d90878a1ba9bfed111c8996')
-      expect(s).to.equal('0x20b74dc25ba2f581be753e11673413eb90f1f08285c2100d8e16c6799818c77d')
+      expect(v).to.equal('1b')
+      expect(r).to.equal('ed157c39b80281741e7d4075655f25b11a9182f12d90878a1ba9bfed111c8996')
+      expect(s).to.equal('20b74dc25ba2f581be753e11673413eb90f1f08285c2100d8e16c6799818c77d')
     })
 
     it('should fail if signature is too short', () => {

oracle/test/processCollectedSignatures.test.js

@@ -2,7 +2,7 @@ const { expect } = require('chai').use(require('chai-as-promised'))
 const sinon = require('sinon')
 const Web3 = require('web3')
 const { HttpListProviderError } = require('http-list-provider')
-const { createMessage } = require('../src/utils/message')
+const { createMessage, signatureToVRS } = require('../src/utils/message')
 const estimateGas = require('../src/events/processCollectedSignatures/estimateGas')
 const errors = require('../src/utils/errors')
 
@@ -116,10 +116,11 @@ describe('processCollectedSignatures', () => {
       }
 
       const message = randomMessage()
-      const { v, r, s } = web3.eth.accounts.sign(
+      const { signature } = web3.eth.accounts.sign(
         message,
         '0xf41510ea3e58c22cbabe881c9c87e60078dac25b23f93319e355c9ae0562987a'
       )
+      const { v, r, s } = signatureToVRS(signature)
 
       // when
       const result = estimateGas({
@@ -155,10 +156,11 @@ describe('processCollectedSignatures', () => {
       }
 
       const message = randomMessage()
-      const { v, r, s } = web3.eth.accounts.sign(
+      const { signature } = web3.eth.accounts.sign(
         message,
         '0xf41510ea3e58c22cbabe881c9c87e60078dac25b23f93319e355c9ae0562987a'
       )
+      const { v, r, s } = signatureToVRS(signature)
 
       // when
       const result = estimateGas({

ui-e2e/MetaMask.js

@@ -3,7 +3,7 @@ const { By } = require('selenium-webdriver/lib/by')
 const { Page } = require('./Page.js')
 const { homeRPC, foreignRPC } = require('../e2e-commons/constants.json')
 
-const IDMetaMask = 'nkbihfbeogaeaoehlefnkodbefgpgknn'
+const IDMetaMask = 'dapggmdndodedfoaljbglbkaicfpmkkm'
 const URL = 'chrome-extension://' + IDMetaMask + '//popup.html'
 const buttonSubmit = By.className('confirm btn-green')
 const buttonAccept = By.xpath('//*[@id="app-content"]/div/div[4]/div/button')