Merge branch 'hotfix/bookie2024' into 'master'

Bookie 2024

See merge request PBSA/peerplays!259

.gitlab-ci.yml

@@ -9,6 +9,8 @@ stages:
   - build
   - test
   - dockerize
+  - python-test
+  - deploy
 
 build-mainnet:
   stage: build
@@ -48,6 +50,7 @@ dockerize-mainnet:
     IMAGE: $CI_REGISTRY_IMAGE/mainnet/$CI_COMMIT_REF_SLUG:$CI_COMMIT_SHA
   before_script:
     - docker info
+    - docker builder prune -a -f
     - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
   script:
     - docker build --no-cache -t $IMAGE .
@@ -56,8 +59,6 @@ dockerize-mainnet:
     - docker rmi $IMAGE
   tags:
     - builder
-  when:
-    manual
   timeout:
     3h
 
@@ -78,12 +79,27 @@ build-testnet:
       - build/libraries/
       - build/programs/
       - build/tests/
+  when: manual
   tags:
     - builder
-  when:
-    manual
-  timeout:
-    3h
+
+deploy-testnet:
+  stage: deploy
+  dependencies:
+    - build-testnet
+  script:
+    - sudo systemctl stop witness
+    - rm $WORK_DIR/peerplays/witness_node || true
+    - cp build/programs/witness_node/witness_node $WORK_DIR/peerplays/
+    - sudo systemctl restart witness
+  rules:
+    - if: $CI_COMMIT_BRANCH == "master"
+      when: always
+  environment:
+    name: devnet
+    url: $DEVNET_URL
+  tags: 
+    - devnet
 
 test-testnet:
   stage: test
@@ -119,3 +135,37 @@ dockerize-testnet:
     manual
   timeout:
     3h
+
+test-e2e:
+  stage: python-test
+  variables:
+    IMAGE: $CI_REGISTRY_IMAGE/mainnet/$CI_COMMIT_REF_SLUG:$CI_COMMIT_SHA
+  before_script:
+    - docker info
+    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
+  script:
+    - git clone https://gitlab.com/PBSA/tools-libs/peerplays-utils.git
+    - cd peerplays-utils/peerplays-qa-environment
+    - git checkout origin/feature/python-e2e-tests-for-CI
+    - cd e2e-tests/
+    - python3 -m venv venv
+    - source venv/bin/activate
+    - pip3 install -r requirements.txt
+    - docker-compose down --remove-orphans
+    - docker ps -a
+    - docker pull $IMAGE
+    - docker tag $IMAGE peerplays-base:latest
+    - docker image ls -a
+    - docker-compose build
+    - python3 main.py --start all
+    - docker ps -a
+    - python3 -m pytest test_btc_init_state.py test_hive_inital_state.py test_pp_inital_state.py
+    - python3 main.py --stop
+    - deactivate
+    - docker ps -a
+  after_script:
+    - docker rmi $(docker images -a | grep -v 'hive-for-peerplays\|ethereum-for-peerplays\|bitcoin-for-peerplays\|ubuntu-for-peerplays' | awk '{print $3}')
+  tags:
+    - python-tests
+  when:
+    manual

Dockerfile

@@ -1,5 +1,4 @@
 FROM ubuntu:20.04
-MAINTAINER Peerplays Blockchain Standards Association
 
 #===============================================================================
 # Ubuntu setup
@@ -11,15 +10,14 @@ RUN \
       apt-utils \
       autoconf \
       bash \
+      bison \
       build-essential \
       ca-certificates \
-      cmake \
       dnsutils \
-      doxygen \
       expect \
+      flex \
       git \
       graphviz \
-      libboost-all-dev \
       libbz2-dev \
       libcurl4-openssl-dev \
       libncurses-dev \
@@ -35,7 +33,6 @@ RUN \
       ntp \
       openssh-server \
       pkg-config \
-      perl \
       python3 \
       python3-jinja2 \
       sudo \
@@ -53,16 +50,105 @@ RUN echo 'peerplays:peerplays' | chpasswd
 # SSH
 EXPOSE 22
 
+WORKDIR /home/peerplays/src
+
+#===============================================================================
+# Boost setup
+#===============================================================================
+
+RUN \
+    wget https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.gz && \
+    tar -xzf boost_1_72_0.tar.gz && \
+    cd boost_1_72_0 && \
+    ./bootstrap.sh && \
+    ./b2 install && \
+    ldconfig && \
+    rm -rf /home/peerplays/src/*
+
+#===============================================================================
+# cmake setup
+#===============================================================================
+
+RUN \
+    wget https://github.com/Kitware/CMake/releases/download/v3.24.2/cmake-3.24.2-linux-x86_64.sh && \
+    chmod 755 ./cmake-3.24.2-linux-x86_64.sh && \
+    ./cmake-3.24.2-linux-x86_64.sh --prefix=/usr --skip-license && \
+    cmake --version && \
+    rm -rf /home/peerplays/src/*
+
 #===============================================================================
 # libzmq setup
 #===============================================================================
 
-WORKDIR /home/peerplays/
+RUN \
+    wget https://github.com/zeromq/libzmq/archive/refs/tags/v4.3.4.tar.gz && \
+    tar -xzvf v4.3.4.tar.gz && \
+    cd libzmq-4.3.4 && \
+    mkdir build && \
+    cd build && \
+    cmake .. && \
+    make -j$(nproc) && \
+    make install && \
+    ldconfig && \
+    rm -rf /home/peerplays/src/*
+
+#===============================================================================
+# cppzmq setup
+#===============================================================================
 
 RUN \
-    wget https://github.com/zeromq/libzmq/archive/refs/tags/v4.3.4.zip && \
-    unzip v4.3.4.zip && \
-    cd libzmq-4.3.4 && \
+    wget https://github.com/zeromq/cppzmq/archive/refs/tags/v4.9.0.tar.gz && \
+    tar -xzvf v4.9.0.tar.gz && \
+    cd cppzmq-4.9.0 && \
+    mkdir build && \
+    cd build && \
+    cmake .. && \
+    make -j$(nproc) && \
+    make install && \
+    ldconfig && \
+    rm -rf /home/peerplays/src/*
+
+#===============================================================================
+# gsl setup
+#===============================================================================
+
+RUN \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y \
+      libpcre3-dev
+
+RUN \
+    wget https://github.com/imatix/gsl/archive/refs/tags/v4.1.4.tar.gz && \
+    tar -xzvf v4.1.4.tar.gz && \
+    cd gsl-4.1.4 && \
+    make -j$(nproc) && \
+    make install && \
+    rm -rf /home/peerplays/src/*
+
+#===============================================================================
+# libbitcoin-build setup
+# libbitcoin-explorer setup
+#===============================================================================
+
+RUN \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y \
+      libsodium-dev
+
+RUN \
+    git clone --branch version3.8.0 --depth 1 https://gitlab.com/PBSA/peerplays-1.0/libbitcoin-explorer.git && \
+    cd libbitcoin-explorer && \
+    ./install.sh && \
+    ldconfig && \
+    rm -rf /home/peerplays/src/*
+
+#===============================================================================
+# Doxygen setup
+#===============================================================================
+
+RUN \
+    sudo apt install -y bison flex && \
+    wget https://github.com/doxygen/doxygen/archive/refs/tags/Release_1_8_17.tar.gz && \
+    tar -xvf Release_1_8_17.tar.gz && \
+    cd doxygen-Release_1_8_17 && \
     mkdir build && \
     cd build && \
     cmake .. && \
@@ -70,18 +156,14 @@ RUN \
     ldconfig
 
 #===============================================================================
-# cppzmq setup
+# Perl setup
 #===============================================================================
 
-WORKDIR /home/peerplays/
-
 RUN \
-    wget https://github.com/zeromq/cppzmq/archive/refs/tags/v4.8.1.zip && \
-    unzip v4.8.1.zip && \
-    cd cppzmq-4.8.1 && \
-    mkdir build && \
-    cd build && \
-    cmake .. && \
+    wget https://github.com/Perl/perl5/archive/refs/tags/v5.30.0.tar.gz && \
+    tar -xvf v5.30.0.tar.gz && \
+    cd perl5-5.30.0 && \
+    ./Configure -des && \
     make -j$(nproc) install && \
     ldconfig
 
@@ -89,8 +171,6 @@ RUN \
 # Peerplays setup
 #===============================================================================
 
-WORKDIR /home/peerplays/
-
 ## Clone Peerplays
 #RUN \
 #    git clone https://gitlab.com/PBSA/peerplays.git && \
@@ -106,6 +186,8 @@ ADD . peerplays
 # Configure Peerplays
 RUN \
     cd peerplays && \
+    git submodule update --init --recursive && \
+    git log --oneline -n 5 && \
     mkdir build && \
     cd build && \
     cmake -DCMAKE_BUILD_TYPE=Release ..
@@ -119,8 +201,8 @@ WORKDIR /home/peerplays/peerplays-network
 
 # Setup Peerplays runimage
 RUN \
-    ln -s /home/peerplays/peerplays/build/programs/cli_wallet/cli_wallet ./ && \
-    ln -s /home/peerplays/peerplays/build/programs/witness_node/witness_node ./
+    ln -s /home/peerplays/src/peerplays/build/programs/cli_wallet/cli_wallet ./ && \
+    ln -s /home/peerplays/src/peerplays/build/programs/witness_node/witness_node ./
 
 RUN ./witness_node --create-genesis-json genesis.json && \
     rm genesis.json

Dockerfile.18.04

@@ -1,5 +1,4 @@
 FROM ubuntu:18.04
-MAINTAINER Peerplays Blockchain Standards Association
 
 #===============================================================================
 # Ubuntu setup
@@ -11,11 +10,12 @@ RUN \
       apt-utils \
       autoconf \
       bash \
+      bison \
       build-essential \
       ca-certificates \
       dnsutils \
-      doxygen \
       expect \
+      flex \
       git \
       graphviz \
       libbz2-dev \
@@ -33,7 +33,6 @@ RUN \
       ntp \
       openssh-server \
       pkg-config \
-      perl \
       python3 \
       python3-jinja2 \
       sudo \
@@ -51,41 +50,105 @@ RUN echo 'peerplays:peerplays' | chpasswd
 # SSH
 EXPOSE 22
 
+WORKDIR /home/peerplays/src
+
 #===============================================================================
 # Boost setup
 #===============================================================================
 
-WORKDIR /home/peerplays/
-
 RUN \
-    wget -c 'https://boostorg.jfrog.io/artifactory/main/release/1.71.0/source/boost_1_71_0.tar.bz2' -O boost_1_71_0.tar.bz2 && \
-    tar xjf boost_1_71_0.tar.bz2 && \
-    cd boost_1_71_0/ && \
+    wget https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.gz && \
+    tar -xzf boost_1_72_0.tar.gz && \
+    cd boost_1_72_0 && \
     ./bootstrap.sh && \
-    ./b2 install
+    ./b2 install && \
+    ldconfig && \
+    rm -rf /home/peerplays/src/*
 
 #===============================================================================
 # cmake setup
 #===============================================================================
 
-WORKDIR /home/peerplays/
-
 RUN \
-    wget -c 'https://cmake.org/files/v3.23/cmake-3.23.1-linux-x86_64.sh' -O cmake-3.23.1-linux-x86_64.sh && \
-    chmod 755 ./cmake-3.23.1-linux-x86_64.sh && \
-    ./cmake-3.23.1-linux-x86_64.sh --prefix=/usr/ --skip-license && \
-    cmake --version
+    wget https://github.com/Kitware/CMake/releases/download/v3.24.2/cmake-3.24.2-linux-x86_64.sh && \
+    chmod 755 ./cmake-3.24.2-linux-x86_64.sh && \
+    ./cmake-3.24.2-linux-x86_64.sh --prefix=/usr --skip-license && \
+    cmake --version && \
+    rm -rf /home/peerplays/src/*
 
 #===============================================================================
 # libzmq setup
 #===============================================================================
 
-WORKDIR /home/peerplays/
+RUN \
+    wget https://github.com/zeromq/libzmq/archive/refs/tags/v4.3.4.tar.gz && \
+    tar -xzvf v4.3.4.tar.gz && \
+    cd libzmq-4.3.4 && \
+    mkdir build && \
+    cd build && \
+    cmake .. && \
+    make -j$(nproc) && \
+    make install && \
+    ldconfig && \
+    rm -rf /home/peerplays/src/*
+
+#===============================================================================
+# cppzmq setup
+#===============================================================================
 
 RUN \
-    wget https://github.com/zeromq/libzmq/archive/refs/tags/v4.3.4.zip && \
-    unzip v4.3.4.zip && \
-    cd libzmq-4.3.4 && \
+    wget https://github.com/zeromq/cppzmq/archive/refs/tags/v4.9.0.tar.gz && \
+    tar -xzvf v4.9.0.tar.gz && \
+    cd cppzmq-4.9.0 && \
+    mkdir build && \
+    cd build && \
+    cmake .. && \
+    make -j$(nproc) && \
+    make install && \
+    ldconfig && \
+    rm -rf /home/peerplays/src/*
+
+#===============================================================================
+# gsl setup
+#===============================================================================
+
+RUN \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y \
+      libpcre3-dev
+
+RUN \
+    wget https://github.com/imatix/gsl/archive/refs/tags/v4.1.4.tar.gz && \
+    tar -xzvf v4.1.4.tar.gz && \
+    cd gsl-4.1.4 && \
+    make -j$(nproc) && \
+    make install && \
+    rm -rf /home/peerplays/src/*
+
+#===============================================================================
+# libbitcoin-build setup
+# libbitcoin-explorer setup
+#===============================================================================
+
+RUN \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y \
+      libsodium-dev
+
+RUN \
+    git clone --branch version3.8.0 --depth 1 https://gitlab.com/PBSA/peerplays-1.0/libbitcoin-explorer.git && \
+    cd libbitcoin-explorer && \
+    ./install.sh && \
+    ldconfig && \
+    rm -rf /home/peerplays/src/*
+
+#===============================================================================
+# Doxygen setup
+#===============================================================================
+
+RUN \
+    sudo apt install -y bison flex && \
+    wget https://github.com/doxygen/doxygen/archive/refs/tags/Release_1_8_17.tar.gz && \
+    tar -xvf Release_1_8_17.tar.gz && \
+    cd doxygen-Release_1_8_17 && \
     mkdir build && \
     cd build && \
     cmake .. && \
@@ -93,18 +156,14 @@ RUN \
     ldconfig
 
 #===============================================================================
-# cppzmq setup
+# Perl setup
 #===============================================================================
 
-WORKDIR /home/peerplays/
-
 RUN \
-    wget https://github.com/zeromq/cppzmq/archive/refs/tags/v4.8.1.zip && \
-    unzip v4.8.1.zip && \
-    cd cppzmq-4.8.1 && \
-    mkdir build && \
-    cd build && \
-    cmake .. && \
+    wget https://github.com/Perl/perl5/archive/refs/tags/v5.30.0.tar.gz && \
+    tar -xvf v5.30.0.tar.gz && \
+    cd perl5-5.30.0 && \
+    ./Configure -des && \
     make -j$(nproc) install && \
     ldconfig
 
@@ -112,8 +171,6 @@ RUN \
 # Peerplays setup
 #===============================================================================
 
-WORKDIR /home/peerplays/
-
 ## Clone Peerplays
 #RUN \
 #    git clone https://gitlab.com/PBSA/peerplays.git && \
@@ -129,6 +186,9 @@ ADD . peerplays
 # Configure Peerplays
 RUN \
     cd peerplays && \
+    git submodule update --init --recursive && \
+    git symbolic-ref --short HEAD && \
+    git log --oneline -n 5 && \
     mkdir build && \
     cd build && \
     cmake -DCMAKE_BUILD_TYPE=Release ..
@@ -142,8 +202,8 @@ WORKDIR /home/peerplays/peerplays-network
 
 # Setup Peerplays runimage
 RUN \
-    ln -s /home/peerplays/peerplays/build/programs/cli_wallet/cli_wallet ./ && \
-    ln -s /home/peerplays/peerplays/build/programs/witness_node/witness_node ./
+    ln -s /home/peerplays/src/peerplays/build/programs/cli_wallet/cli_wallet ./ && \
+    ln -s /home/peerplays/src/peerplays/build/programs/witness_node/witness_node ./
 
 RUN ./witness_node --create-genesis-json genesis.json && \
     rm genesis.json

README.md

@@ -8,100 +8,41 @@ This is a quick introduction to get new developers and witnesses up to speed on
 
 Officially supported OS are Ubuntu 20.04 and Ubuntu 18.04.
 
-## Ubuntu 20.04
+## Ubuntu 20.04 and 18.04
 
-Following dependencies are needed for a clean install of Ubuntu 20.04:
+Following dependencies are needed for a clean install of Ubuntu 20.04 and Ubuntu 18.04:
 ```
 sudo apt-get install \
-    apt-utils autoconf bash build-essential ca-certificates clang-format cmake \
-    dnsutils doxygen expect git graphviz libboost-all-dev libbz2-dev \
-    libcurl4-openssl-dev libncurses-dev libsnappy-dev \
-    libssl-dev libtool libzip-dev locales lsb-release mc nano net-tools ntp \
-    openssh-server pkg-config perl python3 python3-jinja2 sudo \
+    autoconf bash bison build-essential ca-certificates dnsutils expect flex git \
+    graphviz libbz2-dev libcurl4-openssl-dev libncurses-dev libpcre3-dev \
+    libsnappy-dev libsodium-dev libssl-dev libtool libzip-dev locales lsb-release \
+    mc nano net-tools ntp openssh-server pkg-config python3 python3-jinja2 sudo \
     systemd-coredump wget
 ```
 
-Install libzmq from source:
+Boost libraries setup:
 ```
-wget https://github.com/zeromq/libzmq/archive/refs/tags/v4.3.4.zip
-unzip v4.3.4.zip
-cd libzmq-4.3.4
-mkdir build
-cd build
-cmake ..
-make -j$(nproc)
-sudo make install
-sudo ldconfig
-```
-
-Install cppzmq from source:
-```
-wget https://github.com/zeromq/cppzmq/archive/refs/tags/v4.8.1.zip
-unzip v4.8.1.zip
-cd cppzmq-4.8.1
-mkdir build
-cd build
-cmake ..
-make -j$(nproc)
-sudo make install
-sudo ldconfig
-```
-
-Building Peerplays
-```
-git clone https://gitlab.com/PBSA/peerplays.git
-cd peerplays
-git submodule update --init --recursive
-
-# If you want to build Mainnet node
-cmake -DCMAKE_BUILD_TYPE=Release
-
-# If you want to build Testnet node
-cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_PEERPLAYS_TESTNET=1
-
-# Update -j flag depending on your current system specs;
-# Recommended 4GB of RAM per 1 CPU core
-# make -j2 for 8GB RAM
-# make -j4 for 16GB RAM
-# make -j8 for 32GB RAM
-make -j$(nproc)
-
-sudo make install # this can install the executable files under /usr/local
-```
-
-## Ubuntu 18.04
-
-Following dependencies are needed for a clean install of Ubuntu 18.04:
-```
-sudo apt-get install \
-    apt-utils autoconf bash build-essential ca-certificates clang-format \
-    dnsutils doxygen expect git graphviz libbz2-dev \
-    libcurl4-openssl-dev libncurses-dev libsnappy-dev \
-    libssl-dev libtool libzip-dev locales lsb-release mc nano net-tools ntp \
-    openssh-server pkg-config perl python3 python3-jinja2 sudo \
-    systemd-coredump wget
-```
-
-Install Boost libraries from source
-```
-wget -c 'https://boostorg.jfrog.io/artifactory/main/release/1.71.0/source/boost_1_71_0.tar.bz2' -O boost_1_71_0.tar.bz2
-tar xjf boost_1_71_0.tar.bz2
-cd boost_1_71_0/
+wget https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.gz
+tar -xzf boost_1_72_0.tar.gz boost_1_72_0
+cd boost_1_72_0
 ./bootstrap.sh
+./b2
 sudo ./b2 install
+sudo ldconfig
 ```
 
-Install cmake
+cmake setup:
 ```
-wget -c 'https://cmake.org/files/v3.23/cmake-3.23.1-linux-x86_64.sh' -O cmake-3.23.1-linux-x86_64.sh
-chmod 755 ./cmake-3.23.1-linux-x86_64.sh
-sudo ./cmake-3.23.1-linux-x86_64.sh --prefix=/usr/ --skip-license
+wget https://github.com/Kitware/CMake/releases/download/v3.24.2/cmake-3.24.2-linux-x86_64.sh
+chmod 755 ./cmake-3.24.2-linux-x86_64.sh
+sudo ./cmake-3.24.2-linux-x86_64.sh --prefix=/usr --skip-license
+cmake --version
 ```
 
-Install libzmq from source:
+libzmq setup:
 ```
-wget https://github.com/zeromq/libzmq/archive/refs/tags/v4.3.4.zip
-unzip v4.3.4.zip
+wget https://github.com/zeromq/libzmq/archive/refs/tags/v4.3.4.tar.gz
+tar -xzvf v4.3.4.tar.gz
 cd libzmq-4.3.4
 mkdir build
 cd build
@@ -111,11 +52,11 @@ sudo make install
 sudo ldconfig
 ```
 
-Install cppzmq from source:
+cppzmq setup:
 ```
-wget https://github.com/zeromq/cppzmq/archive/refs/tags/v4.8.1.zip
-unzip v4.8.1.zip
-cd cppzmq-4.8.1
+wget https://github.com/zeromq/cppzmq/archive/refs/tags/v4.9.0.tar.gz
+tar -xzvf v4.9.0.tar.gz
+cd cppzmq-4.9.0
 mkdir build
 cd build
 cmake ..
@@ -124,6 +65,48 @@ sudo make install
 sudo ldconfig
 ```
 
+gsl setup:
+```
+wget https://github.com/imatix/gsl/archive/refs/tags/v4.1.4.tar.gz
+tar -xzvf v4.1.4.tar.gz
+cd gsl-4.1.4
+make -j$(nproc)
+sudo make install
+sudo ldconfig
+```
+
+libbitcoin-explorer setup:
+```
+git clone --branch version3.8.0 --depth 1 https://gitlab.com/PBSA/peerplays-1.0/libbitcoin-explorer.git
+cd libbitcoin-explorer
+sudo ./install.sh
+sudo ldconfig
+```
+
+Doxygen setup:
+```
+wget https://github.com/doxygen/doxygen/archive/refs/tags/Release_1_8_17.tar.gz
+tar -xvf Release_1_8_17.tar.gz
+cd doxygen-Release_1_8_17
+mkdir build
+cd build
+cmake ..
+make -j$(nproc)
+sudo make install
+sudo ldconfig
+```
+
+Perl setup:
+```
+wget https://github.com/Perl/perl5/archive/refs/tags/v5.30.0.tar.gz
+tar -xvf v5.30.0.tar.gz
+cd perl5-5.30.0
+./Configure -des
+make -j$(nproc)
+sudo make install
+sudo ldconfig
+```
+
 Building Peerplays
 ```
 git clone https://gitlab.com/PBSA/peerplays.git
@@ -146,7 +129,6 @@ make -j$(nproc)
 sudo make install # this can install the executable files under /usr/local
 ```
 
-
 ## Docker images
 
 Install docker, and add current user to docker group.

libraries/app/api.cpp

@@ -210,8 +210,8 @@ network_node_api::network_node_api(application &a) :
       }
 
       /*
-             * Remove expired transactions from pending_transactions
-             */
+       * Remove expired transactions from pending_transactions
+       */
       for (const auto &transaction : _pending_transactions) {
          if (transaction.second.expiration < block.timestamp) {
             auto transaction_it = _pending_transactions.find(transaction.second.id());

libraries/app/application.cpp

@@ -391,8 +391,8 @@ public:
    }
 
    /**
-       * If delegate has the item, the network has no need to fetch it.
-       */
+    * If delegate has the item, the network has no need to fetch it.
+    */
    virtual bool has_item(const net::item_id &id) override {
       try {
          if (id.item_type == graphene::net::block_message_type)
@@ -404,13 +404,13 @@ public:
    }
 
    /**
-       * @brief allows the application to validate an item prior to broadcasting to peers.
-       *
-       * @param sync_mode true if the message was fetched through the sync process, false during normal operation
-       * @returns true if this message caused the blockchain to switch forks, false if it did not
-       *
-       * @throws exception if error validating the item, otherwise the item is safe to broadcast on.
-       */
+    * @brief allows the application to validate an item prior to broadcasting to peers.
+    *
+    * @param sync_mode true if the message was fetched through the sync process, false during normal operation
+    * @returns true if this message caused the blockchain to switch forks, false if it did not
+    *
+    * @throws exception if error validating the item, otherwise the item is safe to broadcast on.
+    */
    virtual bool handle_block(const graphene::net::block_message &blk_msg, bool sync_mode,
                              std::vector<fc::uint160_t> &contained_transaction_message_ids) override {
 
@@ -498,14 +498,14 @@ public:
    }
 
    /**
-       * Assuming all data elements are ordered in some way, this method should
-       * return up to limit ids that occur *after* the last ID in synopsis that
-       * we recognize.
-       *
-       * On return, remaining_item_count will be set to the number of items
-       * in our blockchain after the last item returned in the result,
-       * or 0 if the result contains the last item in the blockchain
-       */
+    * Assuming all data elements are ordered in some way, this method should
+    * return up to limit ids that occur *after* the last ID in synopsis that
+    * we recognize.
+    *
+    * On return, remaining_item_count will be set to the number of items
+    * in our blockchain after the last item returned in the result,
+    * or 0 if the result contains the last item in the blockchain
+    */
    virtual std::vector<item_hash_t> get_block_ids(const std::vector<item_hash_t> &blockchain_synopsis,
                                                   uint32_t &remaining_item_count,
                                                   uint32_t limit) override {
@@ -552,8 +552,8 @@ public:
    }
 
    /**
-       * Given the hash of the requested data, fetch the body.
-       */
+    * Given the hash of the requested data, fetch the body.
+    */
    virtual message get_item(const item_id &id) override {
       try {
          // ilog("Request for item ${id}", ("id", id));
@@ -576,63 +576,63 @@ public:
    }
 
    /**
-       * Returns a synopsis of the blockchain used for syncing.  This consists of a list of
-       * block hashes at intervals exponentially increasing towards the genesis block.
-       * When syncing to a peer, the peer uses this data to determine if we're on the same
-       * fork as they are, and if not, what blocks they need to send us to get us on their
-       * fork.
-       *
-       * In the over-simplified case, this is a straighforward synopsis of our current
-       * preferred blockchain; when we first connect up to a peer, this is what we will be sending.
-       * It looks like this:
-       *   If the blockchain is empty, it will return the empty list.
-       *   If the blockchain has one block, it will return a list containing just that block.
-       *   If it contains more than one block:
-       *     the first element in the list will be the hash of the highest numbered block that
-       *         we cannot undo
-       *     the second element will be the hash of an item at the half way point in the undoable
-       *         segment of the blockchain
-       *     the third will be ~3/4 of the way through the undoable segment of the block chain
-       *     the fourth will be at ~7/8...
-       *       &c.
-       *     the last item in the list will be the hash of the most recent block on our preferred chain
-       * so if the blockchain had 26 blocks labeled a - z, the synopsis would be:
-       *    a n u x z
-       * the idea being that by sending a small (<30) number of block ids, we can summarize a huge
-       * blockchain.  The block ids are more dense near the end of the chain where because we are
-       * more likely to be almost in sync when we first connect, and forks are likely to be short.
-       * If the peer we're syncing with in our example is on a fork that started at block 'v',
-       * then they will reply to our synopsis with a list of all blocks starting from block 'u',
-       * the last block they know that we had in common.
-       *
-       * In the real code, there are several complications.
-       *
-       * First, as an optimization, we don't usually send a synopsis of the entire blockchain, we
-       * send a synopsis of only the segment of the blockchain that we have undo data for.  If their
-       * fork doesn't build off of something in our undo history, we would be unable to switch, so there's
-       * no reason to fetch the blocks.
-       *
-       * Second, when a peer replies to our initial synopsis and gives us a list of the blocks they think
-       * we are missing, they only send a chunk of a few thousand blocks at once.  After we get those
-       * block ids, we need to request more blocks by sending another synopsis (we can't just say "send me
-       * the next 2000 ids" because they may have switched forks themselves and they don't track what
-       * they've sent us).  For faster performance, we want to get a fairly long list of block ids first,
-       * then start downloading the blocks.
-       * The peer doesn't handle these follow-up block id requests any different from the initial request;
-       * it treats the synopsis we send as our blockchain and bases its response entirely off that.  So to
-       * get the response we want (the next chunk of block ids following the last one they sent us, or,
-       * failing that, the shortest fork off of the last list of block ids they sent), we need to construct
-       * a synopsis as if our blockchain was made up of:
-       *    1. the blocks in our block chain up to the fork point (if there is a fork) or the head block (if no fork)
-       *    2. the blocks we've already pushed from their fork (if there's a fork)
-       *    3. the block ids they've previously sent us
-       * Segment 3 is handled in the p2p code, it just tells us the number of blocks it has (in
-       * number_of_blocks_after_reference_point) so we can leave space in the synopsis for them.
-       * We're responsible for constructing the synopsis of Segments 1 and 2 from our active blockchain and
-       * fork database.  The reference_point parameter is the last block from that peer that has been
-       * successfully pushed to the blockchain, so that tells us whether the peer is on a fork or on
-       * the main chain.
-       */
+    * Returns a synopsis of the blockchain used for syncing.  This consists of a list of
+    * block hashes at intervals exponentially increasing towards the genesis block.
+    * When syncing to a peer, the peer uses this data to determine if we're on the same
+    * fork as they are, and if not, what blocks they need to send us to get us on their
+    * fork.
+    *
+    * In the over-simplified case, this is a straighforward synopsis of our current
+    * preferred blockchain; when we first connect up to a peer, this is what we will be sending.
+    * It looks like this:
+    *   If the blockchain is empty, it will return the empty list.
+    *   If the blockchain has one block, it will return a list containing just that block.
+    *   If it contains more than one block:
+    *     the first element in the list will be the hash of the highest numbered block that
+    *         we cannot undo
+    *     the second element will be the hash of an item at the half way point in the undoable
+    *         segment of the blockchain
+    *     the third will be ~3/4 of the way through the undoable segment of the block chain
+    *     the fourth will be at ~7/8...
+    *       &c.
+    *     the last item in the list will be the hash of the most recent block on our preferred chain
+    * so if the blockchain had 26 blocks labeled a - z, the synopsis would be:
+    *    a n u x z
+    * the idea being that by sending a small (<30) number of block ids, we can summarize a huge
+    * blockchain.  The block ids are more dense near the end of the chain where because we are
+    * more likely to be almost in sync when we first connect, and forks are likely to be short.
+    * If the peer we're syncing with in our example is on a fork that started at block 'v',
+    * then they will reply to our synopsis with a list of all blocks starting from block 'u',
+    * the last block they know that we had in common.
+    *
+    * In the real code, there are several complications.
+    *
+    * First, as an optimization, we don't usually send a synopsis of the entire blockchain, we
+    * send a synopsis of only the segment of the blockchain that we have undo data for.  If their
+    * fork doesn't build off of something in our undo history, we would be unable to switch, so there's
+    * no reason to fetch the blocks.
+    *
+    * Second, when a peer replies to our initial synopsis and gives us a list of the blocks they think
+    * we are missing, they only send a chunk of a few thousand blocks at once.  After we get those
+    * block ids, we need to request more blocks by sending another synopsis (we can't just say "send me
+    * the next 2000 ids" because they may have switched forks themselves and they don't track what
+    * they've sent us).  For faster performance, we want to get a fairly long list of block ids first,
+    * then start downloading the blocks.
+    * The peer doesn't handle these follow-up block id requests any different from the initial request;
+    * it treats the synopsis we send as our blockchain and bases its response entirely off that.  So to
+    * get the response we want (the next chunk of block ids following the last one they sent us, or,
+    * failing that, the shortest fork off of the last list of block ids they sent), we need to construct
+    * a synopsis as if our blockchain was made up of:
+    *    1. the blocks in our block chain up to the fork point (if there is a fork) or the head block (if no fork)
+    *    2. the blocks we've already pushed from their fork (if there's a fork)
+    *    3. the block ids they've previously sent us
+    * Segment 3 is handled in the p2p code, it just tells us the number of blocks it has (in
+    * number_of_blocks_after_reference_point) so we can leave space in the synopsis for them.
+    * We're responsible for constructing the synopsis of Segments 1 and 2 from our active blockchain and
+    * fork database.  The reference_point parameter is the last block from that peer that has been
+    * successfully pushed to the blockchain, so that tells us whether the peer is on a fork or on
+    * the main chain.
+    */
    virtual std::vector<item_hash_t> get_blockchain_synopsis(const item_hash_t &reference_point,
                                                             uint32_t number_of_blocks_after_reference_point) override {
       try {
@@ -733,26 +733,26 @@ public:
             low_block_num += (true_high_block_num - low_block_num + 2) / 2;
          } while (low_block_num <= high_block_num);
 
-         //idump((synopsis));
+         // idump((synopsis));
          return synopsis;
       }
       FC_CAPTURE_AND_RETHROW()
    }
 
    /**
-       * Call this after the call to handle_message succeeds.
-       *
-       * @param item_type the type of the item we're synchronizing, will be the same as item passed to the sync_from() call
-       * @param item_count the number of items known to the node that haven't been sent to handle_item() yet.
-       *                   After `item_count` more calls to handle_item(), the node will be in sync
-       */
+    * Call this after the call to handle_message succeeds.
+    *
+    * @param item_type the type of the item we're synchronizing, will be the same as item passed to the sync_from() call
+    * @param item_count the number of items known to the node that haven't been sent to handle_item() yet.
+    *                   After `item_count` more calls to handle_item(), the node will be in sync
+    */
    virtual void sync_status(uint32_t item_type, uint32_t item_count) override {
       // any status reports to GUI go here
    }
 
    /**
-       * Call any time the number of connected peers changes.
-       */
+    * Call any time the number of connected peers changes.
+    */
    virtual void connection_count_changed(uint32_t c) override {
       // any status reports to GUI go here
    }
@@ -769,9 +769,9 @@ public:
    }
 
    /**
-       * Returns the time a block was produced (if block_id = 0, returns genesis time).
-       * If we don't know about the block, returns time_point_sec::min()
-       */
+    * Returns the time a block was produced (if block_id = 0, returns genesis time).
+    * If we don't know about the block, returns time_point_sec::min()
+    */
    virtual fc::time_point_sec get_block_time(const item_hash_t &block_id) override {
       try {
          auto opt_block = _chain_db->fetch_block_by_id(block_id);
@@ -917,7 +917,7 @@ void application::initialize(const fc::path &data_dir, const boost::program_opti
       wanted.insert("accounts_list");
       wanted.insert("affiliate_stats");
    }
-   if (!wanted.count("delayed_node") && !wanted.count("witness")) // explicitly requested delayed_node functionality suppresses witness functions
+   if (!wanted.count("delayed_node") && !wanted.count("debug_witness") && !wanted.count("witness")) // explicitly requested delayed_node or debug_witness functionality suppresses witness functions
       wanted.insert("witness");
    wanted.insert("bookie");
 

libraries/app/database_api.cpp

@@ -71,6 +71,17 @@ std::string object_id_to_string(object_id_type id) {
    return object_id;
 }
 
+signed_block_with_info::signed_block_with_info(){};
+
+signed_block_with_info::signed_block_with_info(const signed_block &block) :
+      signed_block(block) {
+   block_id = id();
+   signing_key = signee();
+   transaction_ids.reserve(transactions.size());
+   for (const processed_transaction &tx : transactions)
+      transaction_ids.push_back(tx.id());
+}
+
 class database_api_impl : public std::enable_shared_from_this<database_api_impl> {
 public:
    database_api_impl(graphene::chain::database &db);
@@ -89,6 +100,7 @@ public:
    optional<block_header> get_block_header(uint32_t block_num) const;
    map<uint32_t, optional<block_header>> get_block_header_batch(const vector<uint32_t> block_nums) const;
    optional<signed_block> get_block(uint32_t block_num) const;
+   optional<signed_block_with_info> get_block2(uint32_t block_num) const;
    vector<optional<signed_block>> get_blocks(uint32_t block_num_from, uint32_t block_num_to) const;
    processed_transaction get_transaction(uint32_t block_num, uint32_t trx_in_block) const;
 
@@ -184,6 +196,10 @@ public:
    fc::optional<son_object> get_son_by_account(const std::string account_id_or_name) const;
    map<string, son_id_type> lookup_son_accounts(const string &lower_bound_name, uint32_t limit) const;
    uint64_t get_son_count() const;
+   flat_map<sidechain_type, vector<son_sidechain_info>> get_active_sons();
+   vector<son_sidechain_info> get_active_sons_by_sidechain(sidechain_type sidechain);
+   map<sidechain_type, map<son_id_type, string>> get_son_network_status();
+   map<son_id_type, string> get_son_network_status_by_sidechain(sidechain_type sidechain);
 
    // SON wallets
    optional<son_wallet_object> get_active_son_wallet();
@@ -265,8 +281,9 @@ public:
    uint64_t nft_get_total_supply(const nft_metadata_id_type nft_metadata_id) const;
    nft_object nft_token_by_index(const nft_metadata_id_type nft_metadata_id, const uint64_t token_idx) const;
    nft_object nft_token_of_owner_by_index(const nft_metadata_id_type nft_metadata_id, const account_id_type owner, const uint64_t token_idx) const;
-   vector<nft_object> nft_get_all_tokens() const;
-   vector<nft_object> nft_get_tokens_by_owner(const account_id_type owner) const;
+   vector<nft_object> nft_get_all_tokens(const nft_id_type lower_id, uint32_t limit) const;
+   vector<nft_object> nft_get_tokens_by_owner(const account_id_type owner, const nft_id_type lower_id, uint32_t limit) const;
+   vector<nft_metadata_object> nft_get_metadata_by_owner(const account_id_type owner, const nft_metadata_id_type lower_id, uint32_t limit) const;
 
    // Marketplace
    vector<offer_object> list_offers(const offer_id_type lower_id, uint32_t limit) const;
@@ -287,6 +304,7 @@ public:
    uint32_t api_limit_get_limit_orders_by_account = 101;
    uint32_t api_limit_get_order_book = 50;
    uint32_t api_limit_all_offers_count = 100;
+   uint32_t api_limit_nft_tokens = 100;
    uint32_t api_limit_lookup_accounts = 1000;
    uint32_t api_limit_lookup_witness_accounts = 1000;
    uint32_t api_limit_lookup_committee_member_accounts = 1000;
@@ -295,7 +313,7 @@ public:
    uint32_t api_limit_get_trade_history = 100;
    uint32_t api_limit_get_trade_history_by_sequence = 100;
 
-   //private:
+   // private:
    const account_object *get_account_from_string(const std::string &name_or_id,
                                                  bool throw_if_not_found = true) const;
    const asset_object *get_asset_from_string(const std::string &symbol_or_id,
@@ -452,7 +470,7 @@ void database_api::set_subscribe_callback(std::function<void(const variant &)> c
 }
 
 void database_api_impl::set_subscribe_callback(std::function<void(const variant &)> cb, bool notify_remove_create) {
-   //edump((clear_filter));
+   // edump((clear_filter));
    _subscribe_callback = cb;
    _notify_remove_create = notify_remove_create;
    _subscribed_accounts.clear();
@@ -526,6 +544,17 @@ optional<signed_block> database_api_impl::get_block(uint32_t block_num) const {
    return _db.fetch_block_by_number(block_num);
 }
 
+optional<signed_block_with_info> database_api::get_block2(uint32_t block_num) const {
+   return my->get_block2(block_num);
+}
+
+optional<signed_block_with_info> database_api_impl::get_block2(uint32_t block_num) const {
+   auto result = _db.fetch_block_by_number(block_num);
+   if (result)
+      return signed_block_with_info(*result);
+   return {};
+}
+
 vector<optional<signed_block>> database_api::get_blocks(uint32_t block_num_from, uint32_t block_num_to) const {
    return my->get_blocks(block_num_from, block_num_to);
 }
@@ -1848,6 +1877,80 @@ uint64_t database_api_impl::get_son_count() const {
    return _db.get_index_type<son_index>().indices().size();
 }
 
+flat_map<sidechain_type, vector<son_sidechain_info>> database_api::get_active_sons() {
+   return my->get_active_sons();
+}
+
+flat_map<sidechain_type, vector<son_sidechain_info>> database_api_impl::get_active_sons() {
+   return get_global_properties().active_sons;
+}
+
+vector<son_sidechain_info> database_api::get_active_sons_by_sidechain(sidechain_type sidechain) {
+   return my->get_active_sons_by_sidechain(sidechain);
+}
+
+vector<son_sidechain_info> database_api_impl::get_active_sons_by_sidechain(sidechain_type sidechain) {
+   const global_property_object &gpo = get_global_properties();
+
+   vector<son_sidechain_info> result;
+
+   if (gpo.active_sons.find(sidechain) != gpo.active_sons.end()) {
+      result = gpo.active_sons.at(sidechain);
+   }
+
+   return result;
+}
+
+map<sidechain_type, map<son_id_type, string>> database_api::get_son_network_status() {
+   return my->get_son_network_status();
+}
+
+map<sidechain_type, map<son_id_type, string>> database_api_impl::get_son_network_status() {
+   map<sidechain_type, map<son_id_type, string>> result;
+
+   for (auto active_sidechain_type : active_sidechain_types(_db.head_block_time())) {
+      result[active_sidechain_type] = get_son_network_status_by_sidechain(active_sidechain_type);
+   }
+
+   return result;
+}
+
+map<son_id_type, string> database_api::get_son_network_status_by_sidechain(sidechain_type sidechain) {
+   return my->get_son_network_status_by_sidechain(sidechain);
+}
+
+map<son_id_type, string> database_api_impl::get_son_network_status_by_sidechain(sidechain_type sidechain) {
+   const global_property_object &gpo = get_global_properties();
+
+   map<son_id_type, string> result;
+
+   if (gpo.active_sons.find(sidechain) != gpo.active_sons.end()) {
+      for (const auto si : gpo.active_sons.at(sidechain)) {
+         const auto son_obj = si.son_id(_db);
+         const auto sso = son_obj.statistics(_db);
+         string status;
+
+         if (sso.last_active_timestamp.find(sidechain) != sso.last_active_timestamp.end()) {
+            if (time_point_sec(sso.last_active_timestamp.at(sidechain) + fc::seconds(gpo.parameters.son_heartbeat_frequency())) > _db.head_block_time()) {
+               status = "OK, regular SON heartbeat";
+            } else {
+               if (time_point_sec(sso.last_active_timestamp.at(sidechain) + fc::seconds(gpo.parameters.son_down_time())) > _db.head_block_time()) {
+                  status = "OK, irregular SON heartbeat, but not triggering SON down proposal";
+               } else {
+                  status = "NOT OK, irregular SON heartbeat, triggering SON down proposal";
+               }
+            }
+         } else {
+            status = "No heartbeats sent";
+         }
+
+         result[si.son_id] = status;
+      }
+   }
+
+   return result;
+}
+
 //////////////////////////////////////////////////////////////////////
 //                                                                  //
 // SON Wallets                                                      //
@@ -2094,7 +2197,7 @@ vector<variant> database_api_impl::lookup_vote_ids(const vector<vote_id_type> &v
       case vote_id_type::committee: {
          auto itr = committee_idx.find(id);
          if (itr != committee_idx.end())
-            result.emplace_back(variant(*itr, 1));
+            result.emplace_back(variant(*itr, 2)); // Depth of committee_member_object is 1, add 1 to be safe
          else
             result.emplace_back(variant());
          break;
@@ -2102,7 +2205,7 @@ vector<variant> database_api_impl::lookup_vote_ids(const vector<vote_id_type> &v
       case vote_id_type::witness: {
          auto itr = witness_idx.find(id);
          if (itr != witness_idx.end())
-            result.emplace_back(variant(*itr, 1));
+            result.emplace_back(variant(*itr, 2)); // Depth of witness_object is 1, add 1 here to be safe
          else
             result.emplace_back(variant());
          break;
@@ -2110,11 +2213,15 @@ vector<variant> database_api_impl::lookup_vote_ids(const vector<vote_id_type> &v
       case vote_id_type::worker: {
          auto itr = for_worker_idx.find(id);
          if (itr != for_worker_idx.end()) {
-            result.emplace_back(variant(*itr, 1));
+            result.emplace_back(variant(*itr, 4)); // Depth of worker_object is 3, add 1 here to be safe.
+                                                   // If we want to extract the balance object inside,
+                                                   //   need to increase this value
          } else {
             auto itr = against_worker_idx.find(id);
             if (itr != against_worker_idx.end()) {
-               result.emplace_back(variant(*itr, 1));
+               result.emplace_back(variant(*itr, 4)); // Depth of worker_object is 3, add 1 here to be safe.
+                                                      // If we want to extract the balance object inside,
+                                                      //   need to increase this value
             } else {
                result.emplace_back(variant());
             }
@@ -2237,7 +2344,9 @@ votes_info database_api_impl::get_votes(const string &account_name_or_id) const
          votes_for_sons[sidechain].reserve(sidechain_ids.size());
          for (const auto &son : sidechain_ids) {
             const auto &son_obj = son.as<son_object>(6);
-            votes_for_sons[sidechain].emplace_back(votes_info_object{son_obj.get_sidechain_vote_id(sidechain), son_obj.id});
+            if (son_obj.get_sidechain_vote_id(sidechain).valid()) {
+               votes_for_sons[sidechain].emplace_back(votes_info_object{*son_obj.get_sidechain_vote_id(sidechain), son_obj.id});
+            }
          }
       }
       result.votes_for_sons = std::move(votes_for_sons);
@@ -2798,7 +2907,7 @@ graphene::app::gpos_info database_api::get_gpos_info(const account_id_type accou
 }
 
 graphene::app::gpos_info database_api_impl::get_gpos_info(const account_id_type account) const {
-   FC_ASSERT(_db.head_block_time() > HARDFORK_GPOS_TIME); //Can be deleted after GPOS hardfork time
+   FC_ASSERT(_db.head_block_time() > HARDFORK_GPOS_TIME); // Can be deleted after GPOS hardfork time
    gpos_info result;
 
    result.vesting_factor = _db.calculate_vesting_factor(account(_db));
@@ -3024,30 +3133,61 @@ nft_object database_api_impl::nft_token_of_owner_by_index(const nft_metadata_id_
    return {};
 }
 
-vector<nft_object> database_api::nft_get_all_tokens() const {
-   return my->nft_get_all_tokens();
+vector<nft_object> database_api::nft_get_all_tokens(const nft_id_type lower_id, uint32_t limit) const {
+   return my->nft_get_all_tokens(lower_id, limit);
 }
 
-vector<nft_object> database_api_impl::nft_get_all_tokens() const {
+vector<nft_object> database_api_impl::nft_get_all_tokens(const nft_id_type lower_id, uint32_t limit) const {
+   FC_ASSERT(limit <= api_limit_nft_tokens,
+             "Number of queried nft tokens can not be greater than ${configured_limit}",
+             ("configured_limit", api_limit_nft_tokens));
+
    const auto &idx_nft = _db.get_index_type<nft_index>().indices().get<by_id>();
    vector<nft_object> result;
-   for (auto itr = idx_nft.begin(); itr != idx_nft.end(); ++itr) {
-      result.push_back(*itr);
-   }
+   result.reserve(limit);
+   auto itr = idx_nft.lower_bound(lower_id);
+   while (limit-- && itr != idx_nft.end())
+      result.emplace_back(*itr++);
    return result;
 }
 
-vector<nft_object> database_api::nft_get_tokens_by_owner(const account_id_type owner) const {
-   return my->nft_get_tokens_by_owner(owner);
+vector<nft_object> database_api::nft_get_tokens_by_owner(const account_id_type owner, const nft_id_type lower_id, uint32_t limit) const {
+   return my->nft_get_tokens_by_owner(owner, lower_id, limit);
 }
 
-vector<nft_object> database_api_impl::nft_get_tokens_by_owner(const account_id_type owner) const {
+vector<nft_object> database_api_impl::nft_get_tokens_by_owner(const account_id_type owner, const nft_id_type lower_id, uint32_t limit) const {
+   FC_ASSERT(limit <= api_limit_nft_tokens,
+             "Number of queried nft tokens can not be greater than ${configured_limit}",
+             ("configured_limit", api_limit_nft_tokens));
    const auto &idx_nft = _db.get_index_type<nft_index>().indices().get<by_owner>();
    auto idx_nft_range = idx_nft.equal_range(owner);
    vector<nft_object> result;
-   for (auto itr = idx_nft_range.first; itr != idx_nft_range.second; ++itr) {
-      result.push_back(*itr);
-   }
+   result.reserve(limit);
+   auto itr = std::find_if(idx_nft_range.first, idx_nft_range.second, [&lower_id](const nft_object &obj) {
+      return !(obj.id.instance() < lower_id.instance);
+   });
+   while (limit-- && itr != idx_nft_range.second)
+      result.emplace_back(*itr++);
+   return result;
+}
+
+vector<nft_metadata_object> database_api::nft_get_metadata_by_owner(const account_id_type owner, const nft_metadata_id_type lower_id, uint32_t limit) const {
+   return my->nft_get_metadata_by_owner(owner, lower_id, limit);
+}
+
+vector<nft_metadata_object> database_api_impl::nft_get_metadata_by_owner(const account_id_type owner, const nft_metadata_id_type lower_id, uint32_t limit) const {
+   FC_ASSERT(limit <= api_limit_nft_tokens,
+             "Number of queried nft metadata objects can not be greater than ${configured_limit}",
+             ("configured_limit", api_limit_nft_tokens));
+   const auto &idx_nft = _db.get_index_type<nft_metadata_index>().indices().get<by_owner>();
+   auto idx_nft_range = idx_nft.equal_range(owner);
+   vector<nft_metadata_object> result;
+   result.reserve(limit);
+   auto itr = std::find_if(idx_nft_range.first, idx_nft_range.second, [&lower_id](const nft_metadata_object &obj) {
+      return !(obj.id.instance() < lower_id.instance);
+   });
+   while (limit-- && itr != idx_nft_range.second)
+      result.emplace_back(*itr++);
    return result;
 }
 
@@ -3414,9 +3554,9 @@ void database_api_impl::handle_object_changed(bool force_notify, bool full_objec
       /// pushing the future back / popping the prior future if it is complete.
       /// if a connection hangs then this could get backed up and result in
       /// a failure to exit cleanly.
-      //fc::async([capture_this,this,updates,market_broadcast_queue](){
-      //if( _subscribe_callback )
-      //         _subscribe_callback( updates );
+      // fc::async([capture_this,this,updates,market_broadcast_queue](){
+      // if( _subscribe_callback )
+      //          _subscribe_callback( updates );
 
       for (auto id : ids) {
          if (id.is<call_order_object>()) {

libraries/app/include/graphene/app/api.hpp

@@ -85,10 +85,10 @@ struct asset_holders {
 };
 
 /**
-    * @brief The history_api class implements the RPC API for account history
-    *
-    * This API contains methods to access account histories
-    */
+ * @brief The history_api class implements the RPC API for account history
+ *
+ * This API contains methods to access account histories
+ */
 class history_api {
 public:
    history_api(application &app) :
@@ -97,27 +97,27 @@ public:
    }
 
    /**
-          * @brief Get operations relevant to the specificed account
-          * @param account_id_or_name The account ID or name whose history should be queried
-          * @param stop ID of the earliest operation to retrieve
-          * @param limit Maximum number of operations to retrieve (must not exceed 100)
-          * @param start ID of the most recent operation to retrieve
-          * @return A list of operations performed by account, ordered from most recent to oldest.
-          */
+    * @brief Get operations relevant to the specificed account
+    * @param account_id_or_name The account ID or name whose history should be queried
+    * @param stop ID of the earliest operation to retrieve
+    * @param limit Maximum number of operations to retrieve (must not exceed 100)
+    * @param start ID of the most recent operation to retrieve
+    * @return A list of operations performed by account, ordered from most recent to oldest.
+    */
    vector<operation_history_object> get_account_history(const std::string account_id_or_name,
                                                         operation_history_id_type stop = operation_history_id_type(),
                                                         unsigned limit = 100,
                                                         operation_history_id_type start = operation_history_id_type()) const;
 
    /**
-          * @brief Get only asked operations relevant to the specified account
-          * @param account_id_or_name The account ID or name whose history should be queried
-          * @param operation_id The ID of the operation we want to get operations in the account( 0 = transfer , 1 = limit order create, ...)
-          * @param stop ID of the earliest operation to retrieve
-          * @param limit Maximum number of operations to retrieve (must not exceed 100)
-          * @param start ID of the most recent operation to retrieve
-          * @return A list of operations performed by account, ordered from most recent to oldest.
-          */
+    * @brief Get only asked operations relevant to the specified account
+    * @param account_id_or_name The account ID or name whose history should be queried
+    * @param operation_id The ID of the operation we want to get operations in the account( 0 = transfer , 1 = limit order create, ...)
+    * @param stop ID of the earliest operation to retrieve
+    * @param limit Maximum number of operations to retrieve (must not exceed 100)
+    * @param start ID of the most recent operation to retrieve
+    * @return A list of operations performed by account, ordered from most recent to oldest.
+    */
    vector<operation_history_object> get_account_history_operations(const std::string account_id_or_name,
                                                                    int operation_id,
                                                                    operation_history_id_type start = operation_history_id_type(),
@@ -125,17 +125,17 @@ public:
                                                                    unsigned limit = 100) const;
 
    /**
-          * @breif Get operations relevant to the specified account referenced
-          * by an event numbering specific to the account. The current number of operations
-          * for the account can be found in the account statistics (or use 0 for start).
-          * @param account_id_or_name The account ID or name whose history should be queried
-          * @param stop Sequence number of earliest operation. 0 is default and will
-          * query 'limit' number of operations.
-          * @param limit Maximum number of operations to retrieve (must not exceed 100)
-          * @param start Sequence number of the most recent operation to retrieve.
-          * 0 is default, which will start querying from the most recent operation.
-          * @return A list of operations performed by account, ordered from most recent to oldest.
-          */
+    * @breif Get operations relevant to the specified account referenced
+    * by an event numbering specific to the account. The current number of operations
+    * for the account can be found in the account statistics (or use 0 for start).
+    * @param account_id_or_name The account ID or name whose history should be queried
+    * @param stop Sequence number of earliest operation. 0 is default and will
+    * query 'limit' number of operations.
+    * @param limit Maximum number of operations to retrieve (must not exceed 100)
+    * @param start Sequence number of the most recent operation to retrieve.
+    * 0 is default, which will start querying from the most recent operation.
+    * @return A list of operations performed by account, ordered from most recent to oldest.
+    */
    vector<operation_history_object> get_relative_account_history(const std::string account_id_or_name,
                                                                  uint32_t stop = 0,
                                                                  unsigned limit = 100,
@@ -156,8 +156,8 @@ private:
 };
 
 /**
-    * @brief Block api
-    */
+ * @brief Block api
+ */
 class block_api {
 public:
    block_api(graphene::chain::database &db);
@@ -170,8 +170,8 @@ private:
 };
 
 /**
-    * @brief The network_broadcast_api class allows broadcasting of transactions.
-    */
+ * @brief The network_broadcast_api class allows broadcasting of transactions.
+ */
 class network_broadcast_api : public std::enable_shared_from_this<network_broadcast_api> {
 public:
    network_broadcast_api(application &a);
@@ -186,36 +186,36 @@ public:
    typedef std::function<void(variant /*transaction_confirmation*/)> confirmation_callback;
 
    /**
-          * @brief Broadcast a transaction to the network
-          * @param trx The transaction to broadcast
-          *
-          * The transaction will be checked for validity in the local database prior to broadcasting. If it fails to
-          * apply locally, an error will be thrown and the transaction will not be broadcast.
-          */
+    * @brief Broadcast a transaction to the network
+    * @param trx The transaction to broadcast
+    *
+    * The transaction will be checked for validity in the local database prior to broadcasting. If it fails to
+    * apply locally, an error will be thrown and the transaction will not be broadcast.
+    */
    void broadcast_transaction(const signed_transaction &trx);
 
    /** this version of broadcast transaction registers a callback method that will be called when the transaction is
-          * included into a block.  The callback method includes the transaction id, block number, and transaction number in the
-          * block.
-          */
+    * included into a block.  The callback method includes the transaction id, block number, and transaction number in the
+    * block.
+    */
    void broadcast_transaction_with_callback(confirmation_callback cb, const signed_transaction &trx);
 
    /** this version of broadcast transaction registers a callback method that will be called when the transaction is
-          * included into a block.  The callback method includes the transaction id, block number, and transaction number in the
-          * block.
-          */
+    * included into a block.  The callback method includes the transaction id, block number, and transaction number in the
+    * block.
+    */
    fc::variant broadcast_transaction_synchronous(const signed_transaction &trx);
 
    void broadcast_block(const signed_block &block);
 
    /**
-          * @brief Not reflected, thus not accessible to API clients.
-          *
-          * This function is registered to receive the applied_block
-          * signal from the chain database when a block is received.
-          * It then dispatches callbacks to clients who have requested
-          * to be notified when a particular txid is included in a block.
-          */
+    * @brief Not reflected, thus not accessible to API clients.
+    *
+    * This function is registered to receive the applied_block
+    * signal from the chain database when a block is received.
+    * It then dispatches callbacks to clients who have requested
+    * to be notified when a particular txid is included in a block.
+    */
    void on_applied_block(const signed_block &b);
 
 private:
@@ -225,60 +225,60 @@ private:
 };
 
 /**
-    * @brief The network_node_api class allows maintenance of p2p connections.
-    */
+ * @brief The network_node_api class allows maintenance of p2p connections.
+ */
 class network_node_api {
 public:
    network_node_api(application &a);
 
    /**
-          * @brief Return general network information, such as p2p port
-          */
+    * @brief Return general network information, such as p2p port
+    */
    fc::variant_object get_info() const;
 
    /**
-          * @brief add_node Connect to a new peer
-          * @param ep The IP/Port of the peer to connect to
-          */
+    * @brief add_node Connect to a new peer
+    * @param ep The IP/Port of the peer to connect to
+    */
    void add_node(const fc::ip::endpoint &ep);
 
    /**
-          * @brief Get status of all current connections to peers
-          */
+    * @brief Get status of all current connections to peers
+    */
    std::vector<net::peer_status> get_connected_peers() const;
 
    /**
-          * @brief Get advanced node parameters, such as desired and max
-          *        number of connections
-          */
+    * @brief Get advanced node parameters, such as desired and max
+    *        number of connections
+    */
    fc::variant_object get_advanced_node_parameters() const;
 
    /**
-          * @brief Set advanced node parameters, such as desired and max
-          *        number of connections
-          * @param params a JSON object containing the name/value pairs for the parameters to set
-          */
+    * @brief Set advanced node parameters, such as desired and max
+    *        number of connections
+    * @param params a JSON object containing the name/value pairs for the parameters to set
+    */
    void set_advanced_node_parameters(const fc::variant_object &params);
 
    /**
-          * @brief Return list of potential peers
-          */
+    * @brief Return list of potential peers
+    */
    std::vector<net::potential_peer_record> get_potential_peers() const;
 
    /**
-          * @brief Return list of pending transactions.
-          */
+    * @brief Return list of pending transactions.
+    */
    map<transaction_id_type, signed_transaction> list_pending_transactions() const;
 
    /**
-          * @brief Subscribes caller for notifications about pending transactions.
-          * @param callback a functional object which will be called when new transaction is created.
-          */
+    * @brief Subscribes caller for notifications about pending transactions.
+    * @param callback a functional object which will be called when new transaction is created.
+    */
    void subscribe_to_pending_transactions(std::function<void(const variant &)> callback);
 
    /**
-          * @brief Unsubscribes caller from notifications about pending transactions.
-          */
+    * @brief Unsubscribes caller from notifications about pending transactions.
+    */
    void unsubscribe_from_pending_transactions();
 
 private:
@@ -290,33 +290,33 @@ private:
 };
 
 /**
-    * @brief
-    */
+ * @brief
+ */
 class asset_api {
 public:
    asset_api(graphene::app::application &app);
    ~asset_api();
 
    /**
-          * @brief Get asset holders for a specific asset
-          * @param asset The specific asset id or symbol
-          * @param start The start index
-          * @param limit Maximum limit must not exceed 100
-          * @return A list of asset holders for the specified asset
-          */
+    * @brief Get asset holders for a specific asset
+    * @param asset The specific asset id or symbol
+    * @param start The start index
+    * @param limit Maximum limit must not exceed 100
+    * @return A list of asset holders for the specified asset
+    */
    vector<account_asset_balance> get_asset_holders(std::string asset, uint32_t start, uint32_t limit) const;
 
    /**
-          * @brief Get asset holders count for a specific asset
-          * @param asset The specific asset id or symbol
-          * @return Holders count for the specified asset
-          */
+    * @brief Get asset holders count for a specific asset
+    * @param asset The specific asset id or symbol
+    * @return Holders count for the specified asset
+    */
    int get_asset_holders_count(std::string asset) const;
 
    /**
-          * @brief Get all asset holders
-          * @return A list of all asset holders
-          */
+    * @brief Get all asset holders
+    * @return A list of all asset holders
+    */
    vector<asset_holders> get_all_asset_holders() const;
 
    uint32_t api_limit_get_asset_holders = 100;
@@ -337,24 +337,24 @@ extern template class fc::api<graphene::debug_witness::debug_api>;
 
 namespace graphene { namespace app {
 /**
-    * @brief The login_api class implements the bottom layer of the RPC API
-    *
-    * All other APIs must be requested from this API.
-    */
+ * @brief The login_api class implements the bottom layer of the RPC API
+ *
+ * All other APIs must be requested from this API.
+ */
 class login_api {
 public:
    login_api(application &a);
    ~login_api();
 
    /**
-          * @brief Authenticate to the RPC server
-          * @param user Username to login with
-          * @param password Password to login with
-          * @return True if logged in successfully; false otherwise
-          *
-          * @note This must be called prior to requesting other APIs. Other APIs may not be accessible until the client
-          * has sucessfully authenticated.
-          */
+    * @brief Authenticate to the RPC server
+    * @param user Username to login with
+    * @param password Password to login with
+    * @return True if logged in successfully; false otherwise
+    *
+    * @note This must be called prior to requesting other APIs. Other APIs may not be accessible until the client
+    * has sucessfully authenticated.
+    */
    bool login(const string &user, const string &password);
    /// @brief Retrieve the network block API
    fc::api<block_api> block() const;

libraries/app/include/graphene/app/database_api.hpp

@@ -82,6 +82,15 @@ using namespace std;
 
 class database_api_impl;
 
+struct signed_block_with_info : public signed_block {
+   signed_block_with_info();
+   signed_block_with_info(const signed_block &block);
+   signed_block_with_info(const signed_block_with_info &block) = default;
+   block_id_type block_id;
+   public_key_type signing_key;
+   vector<transaction_id_type> transaction_ids;
+};
+
 struct order {
    double price;
    double quote;
@@ -189,10 +198,10 @@ public:
    optional<block_header> get_block_header(uint32_t block_num) const;
 
    /**
-      * @brief Retrieve multiple block header by block numbers
-      * @param block_num vector containing heights of the block whose header should be returned
-      * @return array of headers of the referenced blocks, or null if no matching block was found
-      */
+    * @brief Retrieve multiple block header by block numbers
+    * @param block_num vector containing heights of the block whose header should be returned
+    * @return array of headers of the referenced blocks, or null if no matching block was found
+    */
    map<uint32_t, optional<block_header>> get_block_header_batch(const vector<uint32_t> block_nums) const;
 
    /**
@@ -202,6 +211,13 @@ public:
     */
    optional<signed_block> get_block(uint32_t block_num) const;
 
+   /**
+    * @brief Retrieve a full, signed block, with some extra info
+    * @param block_num Height of the block to be returned
+    * @return the referenced block, or null if no matching block was found
+    */
+   optional<signed_block_with_info> get_block2(uint32_t block_num) const;
+
    /**
     * @brief Retrieve a list of signed blocks
     * @param block_num_from start
@@ -263,12 +279,12 @@ public:
    vector<vector<account_id_type>> get_key_references(vector<public_key_type> key) const;
 
    /**
-      * Determine whether a textual representation of a public key
-      * (in Base-58 format) is *currently* linked
-      * to any *registered* (i.e. non-stealth) account on the blockchain
-      * @param public_key Public key
-      * @return Whether a public key is known
-      */
+    * Determine whether a textual representation of a public key
+    * (in Base-58 format) is *currently* linked
+    * to any *registered* (i.e. non-stealth) account on the blockchain
+    * @param public_key Public key
+    * @return Whether a public key is known
+    */
    bool is_public_key_registered(string public_key) const;
 
    //////////////
@@ -675,6 +691,32 @@ public:
     */
    uint64_t get_son_count() const;
 
+   /**
+    * @brief Get list of active sons
+    * @return List of active SONs
+    */
+   flat_map<sidechain_type, vector<son_sidechain_info>> get_active_sons();
+
+   /**
+    * @brief Get list of active sons
+    * @param sidechain Sidechain type [bitcoin|ethereum|hive]
+    * @return List of active SONs
+    */
+   vector<son_sidechain_info> get_active_sons_by_sidechain(sidechain_type sidechain);
+
+   /**
+    * @brief Get SON network status
+    * @return SON network status description for a given sidechain type
+    */
+   map<sidechain_type, map<son_id_type, string>> get_son_network_status();
+
+   /**
+    * @brief Get SON network status
+    * @param sidechain Sidechain type [bitcoin|ethereum|hive]
+    * @return SON network status description for a given sidechain type
+    */
+   map<son_id_type, string> get_son_network_status_by_sidechain(sidechain_type sidechain);
+
    /////////////////////////
    // SON Wallets      //
    /////////////////////////
@@ -1001,14 +1043,25 @@ public:
     * @brief Returns list of all available NTF's
     * @return List of all available NFT's
     */
-   vector<nft_object> nft_get_all_tokens() const;
+   vector<nft_object> nft_get_all_tokens(const nft_id_type lower_id, uint32_t limit) const;
 
    /**
     * @brief Returns NFT's owned by owner
     * @param owner NFT owner
+    * @param lower_id ID of the first NFT to return
+    * @param limit Maximum number of results to return
     * @return List of NFT owned by owner
     */
-   vector<nft_object> nft_get_tokens_by_owner(const account_id_type owner) const;
+   vector<nft_object> nft_get_tokens_by_owner(const account_id_type owner, const nft_id_type lower_id, uint32_t limit) const;
+
+   /**
+    * @brief Returns NFT metadata owned by owner
+    * @param owner NFT owner
+    * @param lower_id ID of the first NFT metadata to return
+    * @param limit Maximum number of results to return
+    * @return List of NFT owned by owner
+    */
+   vector<nft_metadata_object> nft_get_metadata_by_owner(const account_id_type owner, const nft_metadata_id_type lower_id, uint32_t limit) const;
 
    //////////////////
    // MARKET PLACE //
@@ -1038,6 +1091,8 @@ extern template class fc::api<graphene::app::database_api>;
 
 // clang-format off
 
+FC_REFLECT_DERIVED(graphene::app::signed_block_with_info, (graphene::chain::signed_block), (block_id)(signing_key)(transaction_ids));
+
 FC_REFLECT(graphene::app::order, (price)(quote)(base));
 FC_REFLECT(graphene::app::order_book, (base)(quote)(bids)(asks));
 FC_REFLECT(graphene::app::market_ticker, (base)(quote)(latest)(lowest_ask)(highest_bid)(percent_change)(base_volume)(quote_volume));
@@ -1060,6 +1115,7 @@ FC_API(graphene::app::database_api,
    (get_block_header)
    (get_block_header_batch)
    (get_block)
+   (get_block2)
    (get_blocks)
    (get_transaction)
    (get_recent_transaction_by_id)
@@ -1149,6 +1205,10 @@ FC_API(graphene::app::database_api,
    (get_son_by_account)
    (lookup_son_accounts)
    (get_son_count)
+   (get_active_sons)
+   (get_active_sons_by_sidechain)
+   (get_son_network_status)
+   (get_son_network_status_by_sidechain)
 
    // SON wallets
    (get_active_son_wallet)
@@ -1219,6 +1279,7 @@ FC_API(graphene::app::database_api,
    (nft_token_of_owner_by_index)
    (nft_get_all_tokens)
    (nft_get_tokens_by_owner)
+   (nft_get_metadata_by_owner)
 
    // Marketplace
    (list_offers)

libraries/chain/account_evaluator.cpp

@@ -53,7 +53,54 @@ void verify_authority_accounts( const database& db, const authority& a )
    }
 }
 
-void verify_account_votes( const database& db, const account_options& options )
+// Overwrites the num_son values from the origin to the destination for those sidechains which are found in the origin.
+// Keeps the values of num_son for the sidechains which are found in the destination, but not in the origin.
+// Returns false if an error is detected.
+bool merge_num_sons( flat_map<sidechain_type, uint16_t>& destination,
+                     const flat_map<sidechain_type, uint16_t>& origin,
+                     fc::optional<time_point_sec> head_block_time = {})
+{
+   const auto active_sidechains = head_block_time.valid() ? active_sidechain_types(*head_block_time) : all_sidechain_types;
+   bool success = true;
+
+   for (const auto &ns : origin)
+   {
+      destination[ns.first] = ns.second;
+      if (active_sidechains.find(ns.first) == active_sidechains.end())
+      {
+         success = false;
+      }
+   }
+
+   return success;
+}
+
+flat_map<sidechain_type, uint16_t> count_SON_votes_per_sidechain( const flat_set<vote_id_type>& votes )
+{
+   flat_map<sidechain_type, uint16_t> SON_votes_per_sidechain = account_options::ext::empty_num_son();
+
+   for (const auto &vote : votes)
+   {
+      switch (vote.type())
+     {
+      case vote_id_type::son_bitcoin:
+         SON_votes_per_sidechain[sidechain_type::bitcoin]++;
+         break;
+      case vote_id_type::son_hive:
+         SON_votes_per_sidechain[sidechain_type::hive]++;
+         break;
+      case vote_id_type::son_ethereum:
+         SON_votes_per_sidechain[sidechain_type::ethereum]++;
+         break;
+      default:
+         break;
+      }
+   }
+
+   return SON_votes_per_sidechain;
+}
+
+void verify_account_votes( const database& db, const account_options& options, fc::optional<account_object> account = {} )
 {
    // ensure account's votes satisfy requirements
    // NB only the part of vote checking that requires chain state is here,
@@ -69,12 +116,40 @@ void verify_account_votes( const database& db, const account_options& options )
    FC_ASSERT( options.num_committee <= chain_params.maximum_committee_count,
               "Voted for more committee members than currently allowed (${c})", ("c", chain_params.maximum_committee_count) );
    FC_ASSERT( chain_params.extensions.value.maximum_son_count.valid() , "Invalid maximum son count" );
-   FC_ASSERT( options.extensions.value.num_son.valid() , "Invalid son number" );
-   for(const auto& num_sons : *options.extensions.value.num_son)
+
+   flat_map<sidechain_type, uint16_t> merged_num_sons = account_options::ext::empty_num_son();
+
+   // Merge with existing account if exists
+   if ( account.valid() && account->options.extensions.value.num_son.valid())
+   {
+      merge_num_sons( merged_num_sons, *account->options.extensions.value.num_son, db.head_block_time() );
+   }
+
+   // Apply update operation on top
+   if ( options.extensions.value.num_son.valid() )
+   {
+      merge_num_sons( merged_num_sons, *options.extensions.value.num_son, db.head_block_time() );
+   }
+
+   for(const auto& num_sons : merged_num_sons)
    {
       FC_ASSERT( num_sons.second <= *chain_params.extensions.value.maximum_son_count,
                 "Voted for more sons than currently allowed (${c})", ("c", *chain_params.extensions.value.maximum_son_count) );
    }
+
+   // Count the votes for SONs and confirm that the account did not vote for less SONs than num_son
+   flat_map<sidechain_type, uint16_t> SON_votes_per_sidechain = count_SON_votes_per_sidechain(options.votes);
+
+   for (const auto& number_of_votes : SON_votes_per_sidechain)
+   {
+      // Number of votes of account_options are also checked in account_options::do_evaluate,
+      // but there we are checking the value before merging num_sons, so the values should be checked again
+      const auto sidechain = number_of_votes.first;
+      FC_ASSERT( number_of_votes.second >= merged_num_sons[sidechain],
+                "Voted for less sons than specified in num_son (votes ${v} < num_son ${ns}) for sidechain ${s}",
+                ("v", number_of_votes.second) ("ns", merged_num_sons[sidechain]) ("s", sidechain) );
+   }
+
    FC_ASSERT( db.find_object(options.voting_account), "Invalid proxy account specified." );
 
    uint32_t max_vote_id = gpo.next_available_vote_id;
@@ -188,6 +263,13 @@ object_id_type account_create_evaluator::do_apply( const account_create_operatio
       obj.owner            = o.owner;
       obj.active           = o.active;
       obj.options          = o.options;
+
+      obj.options.extensions.value.num_son = account_options::ext::empty_num_son();
+      if ( o.options.extensions.value.num_son.valid() )
+      {
+         merge_num_sons( *obj.options.extensions.value.num_son, *o.options.extensions.value.num_son );
+      }
+
       obj.statistics = d.create<account_statistics_object>([&obj](account_statistics_object& s){
                            s.owner = obj.id;
                            s.name = obj.name;
@@ -287,7 +369,7 @@ void_result account_update_evaluator::do_evaluate( const account_update_operatio
    acnt = &o.account(d);
 
    if( o.new_options.valid() )
-      verify_account_votes( d, *o.new_options );
+      verify_account_votes( d, *o.new_options, *acnt );
 
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (o) ) }
@@ -326,7 +408,31 @@ void_result account_update_evaluator::do_apply( const account_update_operation&
          a.active = *o.active;
          a.top_n_control_flags = 0;
       }
-      if( o.new_options ) a.options = *o.new_options;
+
+      // New num_son structure initialized to 0
+      flat_map<sidechain_type, uint16_t> new_num_son = account_options::ext::empty_num_son();
+
+      // If num_son of existing object is valid, we should merge the existing data
+      if ( a.options.extensions.value.num_son.valid() )
+      {
+         merge_num_sons( new_num_son, *a.options.extensions.value.num_son );
+      }
+
+      // If num_son of the operation are valid, they should merge the existing data
+      if ( o.new_options )
+      {
+         const auto new_options = *o.new_options;
+
+         if ( new_options.extensions.value.num_son.valid() )
+         {
+            merge_num_sons( new_num_son, *new_options.extensions.value.num_son );
+         }
+
+         a.options = *o.new_options;
+      }
+
+      a.options.extensions.value.num_son = new_num_son;
+
       if( o.extensions.value.owner_special_authority.valid() )
       {
          a.owner_special_authority = *(o.extensions.value.owner_special_authority);

libraries/chain/confidential_evaluator.cpp

@@ -33,45 +33,163 @@ namespace graphene { namespace chain {
 
 void_result transfer_to_blind_evaluator::do_evaluate( const transfer_to_blind_operation& o )
 { try {
-   return void_result();
+  const auto& d = db();
+  if( d.head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME )
+  {
+     const auto& atype = o.amount.asset_id(d);
+     FC_ASSERT( atype.allow_confidential() );
+     FC_ASSERT( !atype.is_transfer_restricted() );
+     FC_ASSERT( !(atype.options.flags & white_list) );
+
+     for( const auto& out : o.outputs )
+     {
+        for( const auto& a : out.owner.account_auths )
+           a.first(d); // verify all accounts exist and are valid
+     }
+  }
+
+  return void_result();
 } FC_CAPTURE_AND_RETHROW( (o) ) }
 
 
-void_result transfer_to_blind_evaluator::do_apply( const transfer_to_blind_operation& o ) 
+void_result transfer_to_blind_evaluator::do_apply( const transfer_to_blind_operation& o )
 { try {
-   return void_result();
+  if( db().head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+     db().adjust_balance(o.from, -o.amount);
+
+     const auto &add = o.amount.asset_id(db()).dynamic_asset_data_id(db()); // verify fee is a legit asset
+     db().modify(add, [&](asset_dynamic_data_object &obj) {
+        obj.confidential_supply += o.amount.amount;
+        FC_ASSERT(obj.confidential_supply >= 0);
+     });
+     for (const auto &out : o.outputs) {
+        db().create<blinded_balance_object>([&](blinded_balance_object &obj) {
+           obj.asset_id = o.amount.asset_id;
+           obj.owner = out.owner;
+           obj.commitment = out.commitment;
+        });
+     }
+  }
+  return void_result();
 } FC_CAPTURE_AND_RETHROW( (o) ) }
 
 void transfer_to_blind_evaluator::pay_fee()
 {
+  const auto& d = db();
+  if( d.head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+     if (d.head_block_time() >= HARDFORK_563_TIME)
+        pay_fba_fee(fba_accumulator_id_transfer_to_blind);
+     else
+        generic_evaluator::pay_fee();
+  }
 }
 
 void_result transfer_from_blind_evaluator::do_evaluate( const transfer_from_blind_operation& o )
 { try {
-   return void_result();
+  const auto& d = db();
+  if( d.head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+     o.fee.asset_id(d); // verify fee is a legit asset
+     const auto &bbi = d.get_index_type<blinded_balance_index>();
+     const auto &cidx = bbi.indices().get<by_commitment>();
+     for (const auto &in : o.inputs) {
+        auto itr = cidx.find(in.commitment);
+        FC_ASSERT(itr != cidx.end());
+        FC_ASSERT(itr->asset_id == o.fee.asset_id);
+        FC_ASSERT(itr->owner == in.owner);
+     }
+  }
+  return void_result();
 } FC_CAPTURE_AND_RETHROW( (o) ) }
 
-void_result transfer_from_blind_evaluator::do_apply( const transfer_from_blind_operation& o ) 
+void_result transfer_from_blind_evaluator::do_apply( const transfer_from_blind_operation& o )
 { try {
-   return void_result();
+  if( db().head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+     db().adjust_balance(o.fee_payer(), o.fee);
+     db().adjust_balance(o.to, o.amount);
+     const auto &bbi = db().get_index_type<blinded_balance_index>();
+     const auto &cidx = bbi.indices().get<by_commitment>();
+     for (const auto &in : o.inputs) {
+        auto itr = cidx.find(in.commitment);
+        FC_ASSERT(itr != cidx.end());
+        db().remove(*itr);
+     }
+     const auto &add = o.amount.asset_id(db()).dynamic_asset_data_id(db()); // verify fee is a legit asset
+     db().modify(add, [&](asset_dynamic_data_object &obj) {
+        obj.confidential_supply -= o.amount.amount + o.fee.amount;
+        FC_ASSERT(obj.confidential_supply >= 0);
+     });
+  }
+  return void_result();
 } FC_CAPTURE_AND_RETHROW( (o) ) }
 
 void transfer_from_blind_evaluator::pay_fee()
 {
+  const auto& d = db();
+  if( d.head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+     if (d.head_block_time() >= HARDFORK_563_TIME)
+        pay_fba_fee(fba_accumulator_id_transfer_from_blind);
+     else
+        generic_evaluator::pay_fee();
+  }
 }
 
 void_result blind_transfer_evaluator::do_evaluate( const blind_transfer_operation& o )
 { try {
-   return void_result();
+  const auto& d = db();
+  if( d.head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+     o.fee.asset_id(d); // verify fee is a legit asset
+     const auto &bbi = d.get_index_type<blinded_balance_index>();
+     const auto &cidx = bbi.indices().get<by_commitment>();
+     for (const auto &out : o.outputs) {
+        for (const auto &a : out.owner.account_auths)
+           a.first(d); // verify all accounts exist and are valid
+     }
+     for (const auto &in : o.inputs) {
+        auto itr = cidx.find(in.commitment);
+        GRAPHENE_ASSERT(itr != cidx.end(), blind_transfer_unknown_commitment, "", ("commitment", in.commitment));
+        FC_ASSERT(itr->asset_id == o.fee.asset_id);
+        FC_ASSERT(itr->owner == in.owner);
+     }
+  }
+  return void_result();
 } FC_CAPTURE_AND_RETHROW( (o) ) }
 
-void_result blind_transfer_evaluator::do_apply( const blind_transfer_operation& o ) 
+void_result blind_transfer_evaluator::do_apply( const blind_transfer_operation& o )
 { try {
-   return void_result();
+  if( db().head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+     db().adjust_balance(o.fee_payer(), o.fee); // deposit the fee to the temp account
+     const auto &bbi = db().get_index_type<blinded_balance_index>();
+     const auto &cidx = bbi.indices().get<by_commitment>();
+     for (const auto &in : o.inputs) {
+        auto itr = cidx.find(in.commitment);
+        GRAPHENE_ASSERT(itr != cidx.end(), blind_transfer_unknown_commitment, "", ("commitment", in.commitment));
+        db().remove(*itr);
+     }
+     for (const auto &out : o.outputs) {
+        db().create<blinded_balance_object>([&](blinded_balance_object &obj) {
+           obj.asset_id = o.fee.asset_id;
+           obj.owner = out.owner;
+           obj.commitment = out.commitment;
+        });
+     }
+     const auto &add = o.fee.asset_id(db()).dynamic_asset_data_id(db());
+     db().modify(add, [&](asset_dynamic_data_object &obj) {
+        obj.confidential_supply -= o.fee.amount;
+        FC_ASSERT(obj.confidential_supply >= 0);
+     });
+  }
+  return void_result();
 } FC_CAPTURE_AND_RETHROW( (o) ) }
 
 void blind_transfer_evaluator::pay_fee()
 {
+  const auto& d = db();
+  if( d.head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+     if (d.head_block_time() >= HARDFORK_563_TIME)
+        pay_fba_fee(fba_accumulator_id_blind_transfer);
+     else
+        generic_evaluator::pay_fee();
+  }
 }
 
 } } // graphene::chain

libraries/chain/db_block.cpp

@@ -40,8 +40,10 @@
 #include <graphene/chain/exceptions.hpp>
 #include <graphene/chain/evaluator.hpp>
 #include <graphene/chain/witness_schedule_object.hpp>
+#include <graphene/db/object_database.hpp>
 #include <fc/crypto/digest.hpp>
 
+#include <boost/filesystem.hpp>
 
 namespace {
 
@@ -160,10 +162,13 @@ void database::check_transaction_for_duplicated_operations(const signed_transact
       existed_operations_digests.insert( proposed_operations_digests.begin(), proposed_operations_digests.end() );
    });
 
-   for (auto& pending_transaction: _pending_tx)
    {
-      auto proposed_operations_digests = gather_proposed_operations_digests(pending_transaction);
-      existed_operations_digests.insert(proposed_operations_digests.begin(), proposed_operations_digests.end());
+      const std::lock_guard<std::mutex> pending_tx_lock{_pending_tx_mutex};
+      for (auto &pending_transaction : _pending_tx)
+      {
+         auto proposed_operations_digests = gather_proposed_operations_digests(pending_transaction);
+         existed_operations_digests.insert(proposed_operations_digests.begin(), proposed_operations_digests.end());
+      }
    }
 
    auto proposed_operations_digests = gather_proposed_operations_digests(trx);
@@ -185,7 +190,12 @@ bool database::push_block(const signed_block& new_block, uint32_t skip)
    bool result;
    detail::with_skip_flags( *this, skip, [&]()
    {
-      detail::without_pending_transactions( *this, std::move(_pending_tx),
+      std::vector<processed_transaction> pending_tx = [this] {
+         const std::lock_guard<std::mutex> pending_tx_lock{_pending_tx_mutex};
+         return std::move(_pending_tx);
+      }();
+
+      detail::without_pending_transactions( *this, std::move(pending_tx),
       [&]()
       {
          result = _push_block(new_block);
@@ -196,6 +206,9 @@ bool database::push_block(const signed_block& new_block, uint32_t skip)
 
 bool database::_push_block(const signed_block& new_block)
 { try {
+   boost::filesystem::space_info si = boost::filesystem::space(get_data_dir());
+   FC_ASSERT((si.available) > 104857600, "Rejecting block due to low disk space"); // 104857600 bytes = 100 MB
+
    uint32_t skip = get_node_properties().skip_flags;
    const auto now = fc::time_point::now().sec_since_epoch();
 
@@ -382,17 +395,26 @@ processed_transaction database::_push_transaction( const signed_transaction& trx
 {
    // If this is the first transaction pushed after applying a block, start a new undo session.
    // This allows us to quickly rewind to the clean state of the head block, in case a new block arrives.
-   if( !_pending_tx_session.valid() )
-      _pending_tx_session = _undo_db.start_undo_session();
+   {
+      const std::lock_guard<std::mutex> pending_tx_session_lock{_pending_tx_session_mutex};
+      if (!_pending_tx_session.valid()) {
+         const std::lock_guard<std::mutex> undo_db_lock{_undo_db_mutex};
+         _pending_tx_session = _undo_db.start_undo_session();
+      }
+   }
 
    // Create a temporary undo session as a child of _pending_tx_session.
    // The temporary session will be discarded by the destructor if
    // _apply_transaction fails.  If we make it to merge(), we
    // apply the changes.
 
+   const std::lock_guard<std::mutex> undo_db_lock{_undo_db_mutex};
    auto temp_session = _undo_db.start_undo_session();
-   auto processed_trx = _apply_transaction( trx );
-   _pending_tx.push_back(processed_trx);
+   auto processed_trx = _apply_transaction(trx);
+   {
+      const std::lock_guard<std::mutex> pending_tx_lock{_pending_tx_mutex};
+      _pending_tx.push_back(processed_trx);
+   }
 
    // notify_changed_objects();
    // The transaction applied successfully. Merge its changes into the pending block session.
@@ -405,6 +427,7 @@ processed_transaction database::_push_transaction( const signed_transaction& trx
 
 processed_transaction database::validate_transaction( const signed_transaction& trx )
 {
+   const std::lock_guard<std::mutex> undo_db_lock{_undo_db_mutex};
    auto session = _undo_db.start_undo_session();
    return _apply_transaction( trx );
 }
@@ -504,47 +527,52 @@ signed_block database::_generate_block(
    // the value of the "when" variable is known, which means we need to
    // re-apply pending transactions in this method.
    //
-   _pending_tx_session.reset();
-   _pending_tx_session = _undo_db.start_undo_session();
+   {
+      const std::lock_guard<std::mutex> pending_tx_session_lock{_pending_tx_session_mutex};
+      _pending_tx_session.reset();
+      _pending_tx_session = _undo_db.start_undo_session();
+   }
 
    uint64_t postponed_tx_count = 0;
    // pop pending state (reset to head block state)
-   for( const processed_transaction& tx : _pending_tx )
    {
-      size_t new_total_size = total_block_size + fc::raw::pack_size( tx );
+      const std::lock_guard<std::mutex> pending_tx_lock{_pending_tx_mutex};
+      for (const processed_transaction &tx : _pending_tx) {
+         size_t new_total_size = total_block_size + fc::raw::pack_size(tx);
 
-      // postpone transaction if it would make block too big
-      if( new_total_size >= maximum_block_size )
-      {
-         postponed_tx_count++;
-         continue;
-      }
+         // postpone transaction if it would make block too big
+         if (new_total_size >= maximum_block_size) {
+            postponed_tx_count++;
+            continue;
+         }
 
-      try
-      {
-         auto temp_session = _undo_db.start_undo_session();
-         processed_transaction ptx = _apply_transaction( tx );
-         temp_session.merge();
+         try {
+            auto temp_session = _undo_db.start_undo_session();
+            processed_transaction ptx = _apply_transaction(tx);
+            temp_session.merge();
 
-         // We have to recompute pack_size(ptx) because it may be different
-         // than pack_size(tx) (i.e. if one or more results increased
-         // their size)
-         total_block_size += fc::raw::pack_size( ptx );
-         pending_block.transactions.push_back( ptx );
-      }
-      catch ( const fc::exception& e )
-      {
-         // Do nothing, transaction will not be re-applied
-         wlog( "Transaction was not processed while generating block due to ${e}", ("e", e) );
-         wlog( "The transaction was ${t}", ("t", tx) );
+            // We have to recompute pack_size(ptx) because it may be different
+            // than pack_size(tx) (i.e. if one or more results increased
+            // their size)
+            total_block_size += fc::raw::pack_size(ptx);
+            pending_block.transactions.push_back(ptx);
+         } catch (const fc::exception &e) {
+            // Do nothing, transaction will not be re-applied
+            wlog("Transaction was not processed while generating block due to ${e}", ("e", e));
+            wlog("The transaction was ${t}", ("t", tx));
+         }
       }
    }
+
    if( postponed_tx_count > 0 )
    {
       wlog( "Postponed ${n} transactions due to block size limit", ("n", postponed_tx_count) );
    }
 
-   _pending_tx_session.reset();
+   {
+      const std::lock_guard<std::mutex> pending_tx_session_lock{_pending_tx_session_mutex};
+      _pending_tx_session.reset();
+   }
 
    // We have temporarily broken the invariant that
    // _pending_tx_session is the result of applying _pending_tx, as
@@ -592,7 +620,11 @@ signed_block database::_generate_block(
  */
 void database::pop_block()
 { try {
-   _pending_tx_session.reset();
+   {
+      const std::lock_guard<std::mutex> pending_tx_session_lock{_pending_tx_session_mutex};
+      _pending_tx_session.reset();
+   }
+
    auto head_id = head_block_id();
    optional<signed_block> head_block = fetch_block_by_id( head_id );
    GRAPHENE_ASSERT( head_block.valid(), pop_empty_chain, "there are no blocks to pop" );
@@ -606,6 +638,8 @@ void database::pop_block()
 
 void database::clear_pending()
 { try {
+   const std::lock_guard<std::mutex> pending_tx_lock{_pending_tx_mutex};
+   const std::lock_guard<std::mutex> pending_tx_session_lock{_pending_tx_session_mutex};
    assert( (_pending_tx.size() == 0) || _pending_tx_session.valid() );
    _pending_tx.clear();
    _pending_tx_session.reset();
@@ -705,13 +739,11 @@ void database::_apply_block( const signed_block& next_block )
 
    if (global_props.parameters.witness_schedule_algorithm == GRAPHENE_WITNESS_SCHEDULED_ALGORITHM) {
       update_witness_schedule(next_block);
-      bool need_to_update_son_schedule = false;
-      for(const auto& active_sons : global_props.active_sons){
-         if(!active_sons.second.empty())
-            need_to_update_son_schedule = true;
-      }
-      if(need_to_update_son_schedule) {
-         update_son_schedule(next_block);
+
+      for(const auto& active_sons : global_props.active_sons) {
+         if(!active_sons.second.empty()) {
+            update_son_schedule(active_sons.first, next_block);
+         }
       }
    }
 
@@ -726,7 +758,7 @@ void database::_apply_block( const signed_block& next_block )
 
    check_ending_lotteries();
    check_ending_nft_lotteries();
-   
+
    create_block_summary(next_block);
    place_delayed_bets(); // must happen after update_global_dynamic_data() updates the time
    clear_expired_transactions();
@@ -749,15 +781,11 @@ void database::_apply_block( const signed_block& next_block )
    if (global_props.parameters.witness_schedule_algorithm == GRAPHENE_WITNESS_SHUFFLED_ALGORITHM) {
       update_witness_schedule();
 
-      bool need_update_son_schedule = false;
-      for(const auto& active_sidechain_type : active_sidechain_types) {
+      for(const auto& active_sidechain_type : active_sidechain_types(dynamic_global_props.time)) {
          if(global_props.active_sons.at(active_sidechain_type).size() > 0) {
-            need_update_son_schedule = true;
+            update_son_schedule(active_sidechain_type);
          }
       }
-      if(need_update_son_schedule) {
-         update_son_schedule();
-      }
    }
 
    if( !_node_property_object.debug_updates.empty() )

libraries/chain/db_getter.cpp

@@ -236,8 +236,10 @@ std::set<son_id_type> database::get_sons_to_be_deregistered()
             // TODO : We need to add a function that returns if we can deregister SON
             // i.e. with introduction of PW code, we have to make a decision if the SON
             // is needed for release of funds from the PW
-            if (head_block_time() - stats.last_down_timestamp.at(sidechain) < fc::seconds(get_global_properties().parameters.son_deregister_time())) {
-               need_to_be_deregistered = false;
+            if(stats.last_active_timestamp.contains(sidechain)) {
+               if (head_block_time() - stats.last_active_timestamp.at(sidechain) < fc::seconds(get_global_properties().parameters.son_deregister_time())) {
+                  need_to_be_deregistered = false;
+               }
             }
          }
       }
@@ -303,17 +305,16 @@ bool database::is_son_dereg_valid( son_id_type son_id )
    }
 
    bool status_son_dereg_valid = true;
-   for(const auto& status : son->statuses)
-   {
-      const auto& sidechain = status.first;
-      if(status.second != son_status::in_maintenance)
+   for (const auto &active_sidechain_type : active_sidechain_types(head_block_time())) {
+      if(son->statuses.at(active_sidechain_type) != son_status::in_maintenance)
          status_son_dereg_valid = false;
 
       if(status_son_dereg_valid)
       {
-         if(head_block_time() - son->statistics(*this).last_down_timestamp.at(sidechain) < fc::seconds(get_global_properties().parameters.son_deregister_time()))
-         {
-            status_son_dereg_valid = false;
+         if(son->statistics(*this).last_active_timestamp.contains(active_sidechain_type)) {
+            if (head_block_time() - son->statistics(*this).last_active_timestamp.at(active_sidechain_type) < fc::seconds(get_global_properties().parameters.son_deregister_time())) {
+               status_son_dereg_valid = false;
+            }
          }
       }
    }
@@ -339,7 +340,7 @@ bool database::is_son_active( sidechain_type type, son_id_type son_id )
    active_son_ids.reserve(gpo_as.size());
    std::transform(gpo_as.cbegin(), gpo_as.cend(),
                   std::inserter(active_son_ids, active_son_ids.end()),
-                  [](const son_info& swi) {
+                  [](const son_sidechain_info& swi) {
       return swi.son_id;
    });
 
@@ -385,23 +386,14 @@ vector<uint64_t> database::get_random_numbers(uint64_t minimum, uint64_t maximum
 
 bool database::is_asset_creation_allowed(const string &symbol)
 {
-   time_point_sec now = head_block_time();
-   std::unordered_set<std::string> post_son_hf_symbols = {"ETH", "USDT", "BNB", "ADA", "DOGE", "XRP", "USDC", "DOT", "UNI", "BUSD", "BCH", "LTC", "SOL", "LINK", "MATIC", "THETA",
-                                                          "WBTC", "XLM", "ICP", "DAI", "VET", "ETC", "TRX", "FIL", "XMR", "EGR", "EOS", "SHIB", "AAVE", "CRO", "ALGO", "AMP", "BTCB",
-                                                          "BSV", "KLAY", "CAKE", "FTT", "LEO", "XTZ", "TFUEL", "MIOTA", "LUNA", "NEO", "ATOM", "MKR", "FEI", "WBNB", "UST", "AVAX",
-                                                          "STEEM", "HIVE", "HBD", "SBD", "BTS"};
    if (symbol == "BTC")
    {
-      if (now < HARDFORK_SON_TIME)
-         return false;
-   }
-
-   if (post_son_hf_symbols.find(symbol) != post_son_hf_symbols.end())
-   {
-      if (now >= HARDFORK_SON_TIME)
+      if (head_block_time() < HARDFORK_SON_TIME)
          return false;
    }
    return true;
 }
 
-} }
+}
+
+}

libraries/chain/db_init.cpp

@@ -365,7 +365,7 @@ void database::initialize_hardforks()
   _hardfork_times.emplace_back(HARDFORK_SON_FOR_HIVE_TIME);
   _hardfork_times.emplace_back(HARDFORK_SON_TIME);
   _hardfork_times.emplace_back(HARDFORK_SON2_TIME);
-  _hardfork_times.emplace_back(HARDFORK_SON3_TIME);
+  _hardfork_times.emplace_back(HARDFORK_SON_FOR_ETHEREUM_TIME);
   _hardfork_times.emplace_back(HARDFORK_SWEEPS_TIME);
 
   std::sort(_hardfork_times.begin(), _hardfork_times.end());
@@ -374,7 +374,9 @@ void database::initialize_hardforks()
 void database::initialize_indexes()
 {
    reset_indexes();
-   _undo_db.set_max_size( GRAPHENE_MIN_UNDO_HISTORY );
+
+   const std::lock_guard<std::mutex> undo_db_lock{_undo_db_mutex};
+   _undo_db.set_max_size(GRAPHENE_MIN_UNDO_HISTORY);
 
    //Protocol object indexes
    add_index< primary_index<asset_index, 13> >(); // 8192 assets per chunk
@@ -474,7 +476,9 @@ void database::init_genesis(const genesis_state_type& genesis_state)
    FC_ASSERT(genesis_state.initial_active_witnesses <= genesis_state.initial_witness_candidates.size(),
              "initial_active_witnesses is larger than the number of candidate witnesses.");
 
+   const std::lock_guard<std::mutex> undo_db_lock{_undo_db_mutex};
    _undo_db.disable();
+
    struct auth_inhibitor {
       auth_inhibitor(database& db) : db(db), old_flags(db.node_properties().skip_flags)
       { db.node_properties().skip_flags |= skip_authority_check; }
@@ -1164,6 +1168,11 @@ void database::init_genesis(const genesis_state_type& genesis_state)
    });
    assert( ssohive.id == son_schedule_id_type(get_son_schedule_id(sidechain_type::hive)) );
 
+   // Enable fees
+   modify(get_global_properties(), [&genesis_state](global_property_object& p) {
+      p.parameters.current_fees = genesis_state.initial_parameters.current_fees;
+   });
+
    // Create FBA counters
    create<fba_accumulator_object>([&]( fba_accumulator_object& acc )
    {

libraries/chain/db_maint.cpp

@@ -84,27 +84,29 @@ vector<std::reference_wrapper<const son_object>> database::sort_votable_objects<
    std::vector<std::reference_wrapper<const son_object>> refs;
    for( auto& son : all_sons )
    {
-      if(son.has_valid_config(head_block_time()) && son.statuses.at(sidechain) != son_status::deregistered)
+      if(son.has_valid_config(head_block_time(), sidechain) && son.statuses.at(sidechain) != son_status::deregistered)
       {
          refs.push_back(std::cref(son));
       }
    }
    count = std::min(count, refs.size());
    std::partial_sort(refs.begin(), refs.begin() + count, refs.end(),
-                   [this, sidechain](const son_object& a, const son_object& b)->bool {
-      FC_ASSERT(sidechain == sidechain_type::bitcoin ||
-                sidechain == sidechain_type::ethereum ||
-                sidechain == sidechain_type::hive,
-                "Unexpected sidechain type");
+      [this, sidechain](const son_object& a, const son_object& b)->bool {
+         FC_ASSERT(sidechain == sidechain_type::bitcoin ||
+                   sidechain == sidechain_type::ethereum ||
+                   sidechain == sidechain_type::hive,
+                   "Unexpected sidechain type");
 
-      const share_type oa_vote = _vote_tally_buffer[a.get_sidechain_vote_id(sidechain)];
-      const share_type ob_vote = _vote_tally_buffer[b.get_sidechain_vote_id(sidechain)];
+         FC_ASSERT(a.get_sidechain_vote_id(sidechain).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", sidechain)("son", a));
+         FC_ASSERT(b.get_sidechain_vote_id(sidechain).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", sidechain)("son", b));
+         const share_type oa_vote = _vote_tally_buffer.size() > *a.get_sidechain_vote_id(sidechain) ? _vote_tally_buffer[*a.get_sidechain_vote_id(sidechain)] : 0;
+         const share_type ob_vote = _vote_tally_buffer.size() > *b.get_sidechain_vote_id(sidechain) ? _vote_tally_buffer[*b.get_sidechain_vote_id(sidechain)] : 0;
 
-      if( oa_vote != ob_vote )
-         return oa_vote > ob_vote;
+         if( oa_vote != ob_vote )
+            return oa_vote > ob_vote;
 
-      return a.get_sidechain_vote_id(sidechain) < b.get_sidechain_vote_id(sidechain);
-});
+         return a.get_sidechain_vote_id(sidechain) < b.get_sidechain_vote_id(sidechain);
+   });
 
    refs.resize(count, refs.front());
    return refs;
@@ -168,6 +170,7 @@ struct worker_pay_visitor
          worker.pay_worker(pay, db);
       }
 };
+
 void database::update_worker_votes()
 {
    auto& idx = get_index_type<worker_index>();
@@ -183,14 +186,132 @@ void database::update_worker_votes()
    }
 }
 
-void database::pay_sons()
+void database::hotfix_2024()
+{
+   if (head_block_time() >= HARDFORK_HOTFIX_2024_TIME)
+   {
+      if (get_chain_id().str() == "6b6b5f0ce7a36d323768e534f3edb41c6d6332a541a95725b98e28d140850134")
+      {
+         const auto& vb_idx = get_index_type<vesting_balance_index>().indices().get<by_id>();
+         auto vbo = vb_idx.find(vesting_balance_id_type(388));
+         if (vbo != vb_idx.end())
+         {
+            if (vbo->owner == account_id_type(14786))
+            {
+               modify(*vbo, [&]( vesting_balance_object& _vbo)
+               {
+                  _vbo.owner = account_id_type(0);
+               });
+            }
+         }
+      }
+   }
+}
+
+void database::pay_sons_before_hf_ethereum()
+{
+   const auto now = head_block_time();
+   const dynamic_global_property_object& dpo = get_dynamic_global_properties();
+   // Current requirement is that we have to pay every 24 hours, so the following check
+   if( dpo.son_budget.value > 0 && ((now - dpo.last_son_payout_time) >= fc::seconds(get_global_properties().parameters.son_pay_time())))
+   {
+      const sidechain_type st = sidechain_type::bitcoin;
+      const auto sons = sort_votable_objects<son_index>(st, get_global_properties().parameters.maximum_son_count());
+
+      // After SON2 HF
+      uint64_t total_votes = 0;
+      for( const son_object& son : sons )
+      {
+         FC_ASSERT(son.get_sidechain_vote_id(st).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", st)("son", son));
+         total_votes += _vote_tally_buffer[*son.get_sidechain_vote_id(st)];
+      }
+      const int8_t bits_to_drop = std::max(int(boost::multiprecision::detail::find_msb(total_votes)) - 15, 0);
+      auto get_weight = [&bits_to_drop]( uint64_t son_votes ) {
+         const uint16_t weight = std::max((son_votes >> bits_to_drop), uint64_t(1) );
+         return weight;
+      };
+
+      // Before SON2 HF
+      auto get_weight_before_son2_hf = []( uint64_t son_votes ) {
+         const int8_t bits_to_drop = std::max(int(boost::multiprecision::detail::find_msb(son_votes)) - 15, 0);
+         const uint16_t weight = std::max((son_votes >> bits_to_drop), uint64_t(1) );
+         return weight;
+      };
+
+      uint64_t weighted_total_txs_signed = 0;
+      const share_type son_budget = dpo.son_budget;
+      get_index_type<son_stats_index>().inspect_all_objects([this, &weighted_total_txs_signed, &get_weight, &now, &get_weight_before_son2_hf, &st](const object& o) {
+         const son_statistics_object& s = static_cast<const son_statistics_object&>(o);
+         const auto& idx = get_index_type<son_index>().indices().get<by_id>();
+         const auto son_obj = idx.find( s.owner );
+         uint16_t son_weight = 0;
+         FC_ASSERT(son_obj->get_sidechain_vote_id(st).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", st)("son", *son_obj));
+         if( now >= HARDFORK_SON2_TIME ) {
+            son_weight += get_weight(_vote_tally_buffer[*son_obj->get_sidechain_vote_id(st)]);
+         }
+         else {
+            son_weight += get_weight_before_son2_hf(_vote_tally_buffer[*son_obj->get_sidechain_vote_id(st)]);
+         }
+         const uint64_t txs_signed_bitcoin = s.txs_signed.contains(sidechain_type::bitcoin) ? s.txs_signed.at(sidechain_type::bitcoin) : 0;
+         const uint64_t txs_signed_hive = s.txs_signed.contains(sidechain_type::hive) ? s.txs_signed.at(sidechain_type::hive) : 0;
+         weighted_total_txs_signed += ((txs_signed_bitcoin + txs_signed_hive) * son_weight);
+      });
+
+      // Now pay off each SON proportional to the number of transactions signed.
+      get_index_type<son_stats_index>().inspect_all_objects([this, &weighted_total_txs_signed, &dpo, &son_budget, &get_weight, &get_weight_before_son2_hf, &now, &st](const object& o) {
+         const son_statistics_object& s = static_cast<const son_statistics_object&>(o);
+         const uint64_t txs_signed_bitcoin = s.txs_signed.contains(sidechain_type::bitcoin) ? s.txs_signed.at(sidechain_type::bitcoin) : 0;
+         const uint64_t txs_signed_hive = s.txs_signed.contains(sidechain_type::hive) ? s.txs_signed.at(sidechain_type::hive) : 0;
+
+         if(txs_signed_bitcoin > 0 || txs_signed_hive > 0) {
+            const auto& idx = get_index_type<son_index>().indices().get<by_id>();
+            auto son_obj = idx.find( s.owner );
+            uint16_t son_weight = 0;
+            FC_ASSERT(son_obj->get_sidechain_vote_id(st).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", st)("son", *son_obj));
+            if( now >= HARDFORK_SON2_TIME ) {
+               son_weight += get_weight(_vote_tally_buffer[*son_obj->get_sidechain_vote_id(st)]);
+            }
+            else {
+               son_weight += get_weight_before_son2_hf(_vote_tally_buffer[*son_obj->get_sidechain_vote_id(st)]);
+            }
+            const share_type pay = ((txs_signed_bitcoin + txs_signed_hive) * son_weight * son_budget.value)/weighted_total_txs_signed;
+            modify( *son_obj, [&]( son_object& _son_obj)
+            {
+               _son_obj.pay_son_fee(pay, *this);
+            });
+            //Remove the amount paid out to SON from global SON Budget
+            modify( dpo, [&]( dynamic_global_property_object& _dpo )
+            {
+               _dpo.son_budget -= pay;
+            } );
+            //Reset the tx counter in each son statistics object
+            modify( s, [&]( son_statistics_object& _s)
+            {
+               if(_s.txs_signed.contains(sidechain_type::bitcoin))
+                  _s.txs_signed.at(sidechain_type::bitcoin) = 0;
+               if(_s.txs_signed.contains(sidechain_type::hive))
+                  _s.txs_signed.at(sidechain_type::hive) = 0;
+            });
+         }
+      });
+
+      //Note the last son pay out time
+      modify( dpo, [&]( dynamic_global_property_object& _dpo )
+      {
+         _dpo.last_son_payout_time = now;
+      });
+   }
+}
+
+void database::pay_sons_after_hf_ethereum()
 {
    const time_point_sec now = head_block_time();
    const dynamic_global_property_object& dpo = get_dynamic_global_properties();
    // Current requirement is that we have to pay every 24 hours, so the following check
    if( dpo.son_budget.value > 0 && ((now - dpo.last_son_payout_time) >= fc::seconds(get_global_properties().parameters.son_pay_time())))
    {
-      for(const auto& active_sidechain_type : active_sidechain_types)
+      flat_map<sidechain_type, int8_t> bits_to_drop;
+      for(const auto& active_sidechain_type : active_sidechain_types(now))
       {
          assert( _son_count_histogram_buffer.at(active_sidechain_type).size() > 0 );
          const share_type  stake_target = (_total_voting_stake-_son_count_histogram_buffer.at(active_sidechain_type)[0]) / 2;
@@ -207,87 +328,76 @@ void database::pay_sons()
             }
          }
 
-         const auto sons = sort_votable_objects<son_index>(active_sidechain_type,
-            (std::max(son_count*2+1, (size_t)get_chain_properties().immutable_parameters.min_son_count))
-         );
+         const auto sons = sort_votable_objects<son_index>(active_sidechain_type, (std::max(son_count*2+1, (size_t)get_chain_properties().immutable_parameters.min_son_count)));
 
          // After SON2 HF
          uint64_t total_votes = 0;
          for( const son_object& son : sons )
          {
-            total_votes += _vote_tally_buffer[son.sidechain_vote_ids.at(active_sidechain_type)];
+            FC_ASSERT(son.get_sidechain_vote_id(active_sidechain_type).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", active_sidechain_type)("son", son));
+            total_votes += _vote_tally_buffer[*son.get_sidechain_vote_id(active_sidechain_type)];
          }
-         const int8_t bits_to_drop = std::max(int(boost::multiprecision::detail::find_msb(total_votes)) - 15, 0);
-         auto get_weight = [&bits_to_drop]( uint64_t son_votes ) {
-            const uint16_t weight = std::max((son_votes >> bits_to_drop), uint64_t(1) );
-            return weight;
-         };
-         // Before SON2 HF
-         auto get_weight_before_son2_hf = []( uint64_t son_votes ) {
-            const int8_t bits_to_drop = std::max(int(boost::multiprecision::detail::find_msb(son_votes)) - 15, 0);
-            const uint16_t weight = std::max((son_votes >> bits_to_drop), uint64_t(1) );
-            return weight;
-         };
-         uint64_t weighted_total_txs_signed = 0;
-         const share_type son_budget = dpo.son_budget;
-         get_index_type<son_stats_index>().inspect_all_objects([this, &weighted_total_txs_signed, &get_weight, &now, &get_weight_before_son2_hf, &active_sidechain_type](const object& o) {
-            const son_statistics_object& s = static_cast<const son_statistics_object&>(o);
-            const auto& idx = get_index_type<son_index>().indices().get<by_id>();
-            const auto son_obj = idx.find( s.owner );
-            uint16_t son_weight = 0;
-            if( now >= HARDFORK_SON2_TIME ) {
-               son_weight += get_weight(_vote_tally_buffer[son_obj->sidechain_vote_ids.at(active_sidechain_type)]);
-            }
-            else {
-               son_weight += get_weight_before_son2_hf(_vote_tally_buffer[son_obj->sidechain_vote_ids.at(active_sidechain_type)]);
-            }
+         bits_to_drop[active_sidechain_type] = std::max(int(boost::multiprecision::detail::find_msb(total_votes)) - 15, 0);
+      }
+
+      auto get_weight = [&bits_to_drop]( sidechain_type sidechain, uint64_t son_votes ) {
+         const uint16_t weight = std::max((son_votes >> bits_to_drop.at(sidechain)), uint64_t(1) );
+         return weight;
+      };
+
+      // Calculate weighted_total_txs_signed
+      uint64_t weighted_total_txs_signed = 0;
+      get_index_type<son_stats_index>().inspect_all_objects([this, &weighted_total_txs_signed, &get_weight, &now](const object& o) {
+         for(const auto& active_sidechain_type : active_sidechain_types(now)) {
+            const son_statistics_object &s = static_cast<const son_statistics_object &>(o);
+            const auto &idx = get_index_type<son_index>().indices().get<by_id>();
+            const auto son_obj = idx.find(s.owner);
+            FC_ASSERT(son_obj->get_sidechain_vote_id(active_sidechain_type).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", active_sidechain_type)("son", *son_obj));
+            const uint16_t son_weight = get_weight(active_sidechain_type, _vote_tally_buffer[*son_obj->get_sidechain_vote_id(active_sidechain_type)]);
             const uint64_t txs_signed = s.txs_signed.contains(active_sidechain_type) ? s.txs_signed.at(active_sidechain_type) : 0;
             weighted_total_txs_signed += (txs_signed * son_weight);
-         });
+         }
+      });
+
+      // Now pay off each SON proportional to the number of transactions signed
+      const share_type son_budget = dpo.son_budget;
+      get_index_type<son_stats_index>().inspect_all_objects([this, &now, &get_weight, &weighted_total_txs_signed, &dpo, &son_budget](const object& o) {
+         for(const auto& active_sidechain_type : active_sidechain_types(now)) {
+            const son_statistics_object &s = static_cast<const son_statistics_object &>(o);
 
-         // Now pay off each SON proportional to the number of transactions signed.
-         get_index_type<son_stats_index>().inspect_all_objects([this, &weighted_total_txs_signed, &dpo, &son_budget, &get_weight, &get_weight_before_son2_hf, &now, &active_sidechain_type](const object& o) {
-            const son_statistics_object& s = static_cast<const son_statistics_object&>(o);
             const uint64_t txs_signed = s.txs_signed.contains(active_sidechain_type) ? s.txs_signed.at(active_sidechain_type) : 0;
-
-            if(txs_signed > 0){
-               const auto& idx = get_index_type<son_index>().indices().get<by_id>();
-               auto son_obj = idx.find( s.owner );
+            if (txs_signed > 0) {
+               const auto &idx = get_index_type<son_index>().indices().get<by_id>();
+               auto son_obj = idx.find(s.owner);
                uint16_t son_weight = 0;
-               if( now >= HARDFORK_SON2_TIME ) {
-                  son_weight += get_weight(_vote_tally_buffer[son_obj->sidechain_vote_ids.at(active_sidechain_type)]);
-               }
-               else {
-                  son_weight += get_weight_before_son2_hf(_vote_tally_buffer[son_obj->sidechain_vote_ids.at(active_sidechain_type)]);
-               }
-               const share_type pay = (txs_signed * son_weight * son_budget.value)/weighted_total_txs_signed;
-               modify( *son_obj, [&]( son_object& _son_obj)
-               {
-                _son_obj.pay_son_fee(pay, *this);
+               FC_ASSERT(son_obj->get_sidechain_vote_id(active_sidechain_type).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", active_sidechain_type)("son", *son_obj));
+               son_weight += get_weight(active_sidechain_type, _vote_tally_buffer[*son_obj->get_sidechain_vote_id(active_sidechain_type)]);
+               const share_type pay = (txs_signed * son_weight * son_budget.value) / weighted_total_txs_signed;
+               modify(*son_obj, [&](son_object &_son_obj) {
+                  _son_obj.pay_son_fee(pay, *this);
                });
-               //Remove the amount paid out to SON from global SON Budget
-               modify( dpo, [&]( dynamic_global_property_object& _dpo )
-               {
-                _dpo.son_budget -= pay;
-               } );
-               //Reset the tx counter in each son statistics object
-               modify( s, [&]( son_statistics_object& _s)
-               {
-                  if(_s.txs_signed.contains(active_sidechain_type))
+               // Remove the amount paid out to SON from global SON Budget
+               modify(dpo, [&](dynamic_global_property_object &_dpo) {
+                  _dpo.son_budget -= pay;
+               });
+               // Reset the tx counter in each son statistics object
+               modify(s, [&](son_statistics_object &_s) {
+                  if (_s.txs_signed.contains(active_sidechain_type))
                      _s.txs_signed.at(active_sidechain_type) = 0;
                });
             }
-         });
-         //Note the last son pay out time
-         modify( dpo, [&]( dynamic_global_property_object& _dpo )
-         {
-          _dpo.last_son_payout_time = now;
-         });
-      }
+         }
+      });
+
+      //Note the last son pay out time
+      modify( dpo, [&]( dynamic_global_property_object& _dpo )
+      {
+         _dpo.last_son_payout_time = now;
+      });
    }
 }
 
-void database::update_son_metrics(const flat_map<sidechain_type, vector<son_info> >& curr_active_sons)
+void database::update_son_metrics(const flat_map<sidechain_type, vector<son_sidechain_info> >& curr_active_sons)
 {
    for(const auto& curr_active_sidechain_sons : curr_active_sons) {
       const auto& sidechain = curr_active_sidechain_sons.first;
@@ -298,7 +408,7 @@ void database::update_son_metrics(const flat_map<sidechain_type, vector<son_info
       current_sons.reserve(_curr_active_sidechain_sons.size());
       std::transform(_curr_active_sidechain_sons.cbegin(), _curr_active_sidechain_sons.cend(),
                      std::inserter(current_sons, current_sons.end()),
-                     [](const son_info &swi) {
+                     [](const son_sidechain_info &swi) {
                         return swi.son_id;
                      });
 
@@ -310,7 +420,10 @@ void database::update_son_metrics(const flat_map<sidechain_type, vector<son_info
             if (is_active_son) {
                _stats.total_voted_time[sidechain] = _stats.total_voted_time[sidechain] + get_global_properties().parameters.maintenance_interval;
             }
-            _stats.total_downtime[sidechain] += _stats.current_interval_downtime[sidechain];
+            if(!_stats.current_interval_downtime.contains(sidechain))
+               _stats.current_interval_downtime[sidechain] = 0;
+
+            _stats.total_downtime[sidechain] += _stats.current_interval_downtime.at(sidechain);
             _stats.current_interval_downtime[sidechain] = 0;
             _stats.sidechain_txs_reported[sidechain] = 0;
          });
@@ -318,8 +431,8 @@ void database::update_son_metrics(const flat_map<sidechain_type, vector<son_info
    }
 }
 
-void database::update_son_statuses( const flat_map<sidechain_type, vector<son_info> >& curr_active_sons,
-                                    const flat_map<sidechain_type, vector<son_info> >& new_active_sons )
+void database::update_son_statuses( const flat_map<sidechain_type, vector<son_sidechain_info> >& curr_active_sons,
+                                    const flat_map<sidechain_type, vector<son_sidechain_info> >& new_active_sons )
 {
    for(const auto& new_active_sidechain_sons : new_active_sons) {
       const auto& sidechain = new_active_sidechain_sons.first;
@@ -332,7 +445,7 @@ void database::update_son_statuses( const flat_map<sidechain_type, vector<son_in
          current_sons.reserve(curr_active_sons.at(sidechain).size());
          std::transform(curr_active_sons.at(sidechain).cbegin(), curr_active_sons.at(sidechain).cend(),
                         std::inserter(current_sons, current_sons.end()),
-                        [](const son_info &swi) {
+                        [](const son_sidechain_info &swi) {
                            return swi.son_id;
                         });
       }
@@ -340,7 +453,7 @@ void database::update_son_statuses( const flat_map<sidechain_type, vector<son_in
       new_sons.reserve(new_active_sons.at(sidechain).size());
       std::transform(new_active_sons.at(sidechain).cbegin(), new_active_sons.at(sidechain).cend(),
                      std::inserter(new_sons, new_sons.end()),
-                     [](const son_info &swi) {
+                     [](const son_sidechain_info &swi) {
                         return swi.son_id;
                      });
 
@@ -376,7 +489,7 @@ void database::update_son_statuses( const flat_map<sidechain_type, vector<son_in
 
       for (const auto &sid : sons_to_add) {
          auto son = idx.find(sid);
-         FC_ASSERT(son != idx.end(), "Invalid SON in active list, id={sonid}.", ("sonid", sid));
+         FC_ASSERT(son != idx.end(), "Invalid SON in active list, id = ${sonid}.", ("sonid", sid));
          // keep maintenance status for new nodes
          if (son->statuses.at(sidechain) == son_status::inactive) {
             modify(*son, [&](son_object &obj) {
@@ -411,7 +524,7 @@ void database::update_son_statuses( const flat_map<sidechain_type, vector<son_in
    }
 }
 
-void database::update_son_wallet(const flat_map<sidechain_type, vector<son_info> >& new_active_sons)
+void database::update_son_wallet(const flat_map<sidechain_type, vector<son_sidechain_info> >& new_active_sons)
 {
    bool should_recreate_pw = true;
 
@@ -720,45 +833,28 @@ void database::update_active_sons()
    }
 
    assert( _son_count_histogram_buffer.size() > 0 );
-   for( const auto& son_count_histogram_buffer : _son_count_histogram_buffer ){
 #ifndef NDEBUG
+   for( const auto& son_count_histogram_buffer : _son_count_histogram_buffer ){
       assert( son_count_histogram_buffer.second.size() > 0 );
-#endif
    }
+#endif
 
-   const flat_map<sidechain_type, share_type> stake_target = [this]{
-      flat_map<sidechain_type, share_type> stake_target;
-      for( const auto& son_count_histogram_buffer : _son_count_histogram_buffer ){
-         const auto sidechain = son_count_histogram_buffer.first;
-         stake_target[sidechain] = (_total_voting_stake-son_count_histogram_buffer.second[0]) / 2;
-      }
-      return stake_target;
-   }();
+   const auto supported_active_sidechain_types = active_sidechain_types(head_block_time());
+   flat_map<sidechain_type, size_t> son_count;
+   for(const auto& active_sidechain_type : supported_active_sidechain_types)
+   {
+      const share_type  stake_target = (_total_voting_stake-_son_count_histogram_buffer.at(active_sidechain_type)[0]) / 2;
 
-   /// accounts that vote for 0 or 1 son do not get to express an opinion on
-   /// the number of sons to have (they abstain and are non-voting accounts)
-   flat_map<sidechain_type, share_type> stake_tally = []{
-      flat_map<sidechain_type, share_type> stake_tally;
-      for(const auto& active_sidechain_type : active_sidechain_types){
-         stake_tally[active_sidechain_type] = 0;
-      }
-      return stake_tally;
-   }();
-   flat_map<sidechain_type, size_t> son_count = []{
-      flat_map<sidechain_type, size_t> son_count;
-      for(const auto& active_sidechain_type : active_sidechain_types){
-         son_count[active_sidechain_type] = 0;
-      }
-      return son_count;
-   }();
-   for( const auto& stake_target_sidechain : stake_target ){
-      const auto sidechain = stake_target_sidechain.first;
-      if( stake_target_sidechain.second > 0 )
+      /// accounts that vote for 0 or 1 son do not get to express an opinion on
+      /// the number of sons to have (they abstain and are non-voting accounts)
+      share_type stake_tally = 0;
+      son_count[active_sidechain_type] = 0;
+      if( stake_target > 0 )
       {
-         while( (son_count[sidechain] < _son_count_histogram_buffer.at(sidechain).size() - 1)
-                && (stake_tally[sidechain] <= stake_target_sidechain.second) )
+         while( (son_count.at(active_sidechain_type) < _son_count_histogram_buffer.at(active_sidechain_type).size() - 1)
+                && (stake_tally <= stake_target) )
          {
-            stake_tally[sidechain] += _son_count_histogram_buffer.at(sidechain)[ ++son_count[sidechain] ];
+               stake_tally += _son_count_histogram_buffer.at(active_sidechain_type)[ ++son_count[active_sidechain_type] ];
          }
       }
    }
@@ -767,18 +863,17 @@ void database::update_active_sons()
    const chain_property_object& cpo = get_chain_properties();
    const auto& all_sons = get_index_type<son_index>().indices();
    flat_map<sidechain_type, vector<std::reference_wrapper<const son_object> > > sons;
-   for(const auto& active_sidechain_type : active_sidechain_types)
+   for(const auto& active_sidechain_type : supported_active_sidechain_types)
    {
-      if(head_block_time() >= HARDFORK_SON3_TIME) {
+      if(head_block_time() >= HARDFORK_SON_FOR_ETHEREUM_TIME) {
          sons[active_sidechain_type] = sort_votable_objects<son_index>(active_sidechain_type,
                                                                        (std::max(son_count.at(active_sidechain_type) * 2 + 1, (size_t)cpo.immutable_parameters.min_son_count)));
       }
       else {
-         sons[active_sidechain_type] = sort_votable_objects<son_index>(active_sidechain_type, get_global_properties().parameters.maximum_son_count());
+         sons[active_sidechain_type] = sort_votable_objects<son_index>(sidechain_type::bitcoin, get_global_properties().parameters.maximum_son_count());
       }
    }
 
-   auto& local_vote_buffer_ref = _vote_tally_buffer;
    for( const son_object& son : all_sons )
    {
       for(const auto& status: son.statuses)
@@ -793,9 +888,9 @@ void database::update_active_sons()
          }
       }
 
-      modify( son, [local_vote_buffer_ref]( son_object& obj ){
+      modify( son, [this]( son_object& obj ){
          for(const auto& sidechain_vote_id : obj.sidechain_vote_ids ){
-            obj.total_votes[sidechain_vote_id.first] = local_vote_buffer_ref[sidechain_vote_id.second];
+            obj.total_votes[sidechain_vote_id.first] = _vote_tally_buffer.size() > sidechain_vote_id.second ? _vote_tally_buffer[sidechain_vote_id.second] : 0;
          }
          for(auto& status: obj.statuses)
          {
@@ -850,7 +945,7 @@ void database::update_active_sons()
 
    // Compare current and to-be lists of active sons
    const auto cur_active_sons = gpo.active_sons;
-   flat_map<sidechain_type, vector<son_info> > new_active_sons;
+   flat_map<sidechain_type, vector<son_sidechain_info> > new_active_sons;
    const auto &acc = get(gpo.parameters.son_account());
    for( const auto& sidechain_sons : sons ){
       const auto& sidechain = sidechain_sons.first;
@@ -858,11 +953,12 @@ void database::update_active_sons()
 
       new_active_sons[sidechain].reserve(sons_array.size());
       for( const son_object& son : sons_array ) {
-         son_info swi;
+         son_sidechain_info swi;
          swi.son_id = son.id;
          swi.weight = acc.active.account_auths.at(son.son_account);
          swi.signing_key = son.signing_key;
-         swi.public_key = son.sidechain_public_keys.at(sidechain);
+         if (son.sidechain_public_keys.find(sidechain) != son.sidechain_public_keys.end())
+            swi.public_key = son.sidechain_public_keys.at(sidechain);
          new_active_sons[sidechain].push_back(swi);
       }
    }
@@ -902,7 +998,7 @@ void database::update_active_sons()
       }
    });
 
-   for(const auto& active_sidechain_type : active_sidechain_types)
+   for(const auto& active_sidechain_type : supported_active_sidechain_types)
    {
       const son_schedule_object& sidechain_sso = son_schedule_id_type(get_son_schedule_id(active_sidechain_type))(*this);
       modify(sidechain_sso, [&](son_schedule_object& _sso)
@@ -911,12 +1007,13 @@ void database::update_active_sons()
          active_sons.reserve(gpo.active_sons.at(active_sidechain_type).size());
          std::transform(gpo.active_sons.at(active_sidechain_type).cbegin(), gpo.active_sons.at(active_sidechain_type).cend(),
                         std::inserter(active_sons, active_sons.end()),
-                        [](const son_info& swi) {
+                        [](const son_sidechain_info& swi) {
                            return swi.son_id;
                         });
          _sso.scheduler.update(active_sons);
          // similar to witness, produce schedule for sons
-         if(cur_active_sons.at(active_sidechain_type).size() == 0 && new_active_sons.at(active_sidechain_type).size() > 0)
+         if( ((cur_active_sons.contains(active_sidechain_type) && cur_active_sons.at(active_sidechain_type).size() == 0) ||
+               !cur_active_sons.contains(active_sidechain_type)) && new_active_sons.at(active_sidechain_type).size() > 0 )
          {
             witness_scheduler_rng rng(_sso.rng_seed.begin(), GRAPHENE_NEAR_SCHEDULE_CTR_IV);
             for( size_t i=0; i<new_active_sons.at(active_sidechain_type).size(); ++i )
@@ -1463,17 +1560,19 @@ void rolling_period_start(database& db)
 {
    if(db.head_block_time() >= HARDFORK_GPOS_TIME)
    {
-      auto gpo = db.get_global_properties();
+      const auto gpo = db.get_global_properties();
       auto period_start = db.get_global_properties().parameters.gpos_period_start();
-      auto vesting_period = db.get_global_properties().parameters.gpos_period();
+      const auto vesting_period = db.get_global_properties().parameters.gpos_period();
 
-      auto now = db.head_block_time();
-      if(now.sec_since_epoch() >= (period_start + vesting_period))
+      const auto now = db.head_block_time();
+      while(now.sec_since_epoch() >= (period_start + vesting_period))
       {
          // roll
          db.modify(db.get_global_properties(), [period_start, vesting_period](global_property_object& p) {
             p.parameters.extensions.value.gpos_period_start =  period_start + vesting_period;
          });
+
+         period_start = db.get_global_properties().parameters.gpos_period_start();
       }
    }
 }
@@ -2151,7 +2250,7 @@ void database::perform_son_tasks()
       });
    }
    // create HIVE asset here because son_account is the issuer of the HIVE
-   if (gpo.parameters.hive_asset() == asset_id_type()  && head_block_time() >= HARDFORK_SON_FOR_HIVE_TIME)
+   if (gpo.parameters.hive_asset() == asset_id_type() && head_block_time() >= HARDFORK_SON_FOR_HIVE_TIME)
    {
       const asset_dynamic_data_object& dyn_asset =
          create<asset_dynamic_data_object>([](asset_dynamic_data_object& a) {
@@ -2184,26 +2283,69 @@ void database::perform_son_tasks()
                gpo.pending_parameters->extensions.value.hive_asset = hive_asset.get_id();
       });
    }
+
    // Pay the SONs
    if (head_block_time() >= HARDFORK_SON_TIME)
    {
       // Before making a budget we should pay out SONs
       // This function should check if its time to pay sons
       // and modify the global son funds accordingly, whatever is left is passed on to next budget
-      pay_sons();
+      if(head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME)
+         pay_sons_before_hf_ethereum();
+      else
+         pay_sons_after_hf_ethereum();
+   }
+
+   // Split vote_ids
+   if (head_block_time() >= HARDFORK_SON_FOR_ETHEREUM_TIME) {
+      // Get SON 1.33.0 and check if it has HIVE vote_id
+      const son_id_type sid = son_id_type(0);
+      const auto p_son = find(sid);
+      if(p_son != nullptr) {
+         if (p_son->sidechain_vote_ids.find(sidechain_type::hive) == p_son->sidechain_vote_ids.end()) {
+            // Add vote_ids for HIVE and ETHEREUM to all existing SONs
+            const auto &all_sons = get_index_type<son_index>().indices().get<by_id>();
+            for (const son_object &son : all_sons) {
+               const auto existing_vote_id_bitcoin = son.get_bitcoin_vote_id();
+               vote_id_type new_vote_id_hive;
+               vote_id_type new_vote_id_eth;
+
+               modify(gpo, [&new_vote_id_hive, &new_vote_id_eth](global_property_object &p) {
+                  new_vote_id_hive = get_next_vote_id(p, vote_id_type::son_hive);
+                  new_vote_id_eth = get_next_vote_id(p, vote_id_type::son_ethereum);
+               });
+
+               modify(son, [new_vote_id_hive, new_vote_id_eth](son_object &obj) {
+                  obj.sidechain_vote_ids[sidechain_type::hive] = new_vote_id_hive;
+                  obj.sidechain_vote_ids[sidechain_type::ethereum] = new_vote_id_eth;
+               });
+
+               // Duplicate all votes from bitcoin to hive
+               const auto &all_accounts = get_index_type<account_index>().indices().get<by_id>();
+               for (const auto &account : all_accounts) {
+                  if (existing_vote_id_bitcoin.valid() && account.options.votes.count(*existing_vote_id_bitcoin) != 0) {
+                     modify(account, [new_vote_id_hive](account_object &a) {
+                        a.options.votes.insert(new_vote_id_hive);
+                     });
+                  }
+               }
+            }
+         }
+      }
    }
 }
 
 void update_son_params(database& db)
 {
-   if( (db.head_block_time() >= HARDFORK_SON2_TIME) && (db.head_block_time() < HARDFORK_SON3_TIME) )
+   if( (db.head_block_time() >= HARDFORK_SON2_TIME) && (db.head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME) )
    {
       const auto& gpo = db.get_global_properties();
       db.modify( gpo, []( global_property_object& gpo ) {
          gpo.parameters.extensions.value.maximum_son_count = 7;
       });
    }
-   else
+
+   if( (db.head_block_time() >= HARDFORK_SON_FOR_ETHEREUM_TIME) )
    {
       const auto& gpo = db.get_global_properties();
       db.modify( gpo, []( global_property_object& gpo ) {
@@ -2338,20 +2480,23 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g
                // same rationale as for witnesses
                d._committee_count_histogram_buffer[offset] += voting_stake;
             }
-            FC_ASSERT( opinion_account.options.extensions.value.num_son.valid() , "Invalid son number" );
-            for(const auto& num_sidechain_son : *opinion_account.options.extensions.value.num_son) {
-               const auto sidechain = num_sidechain_son.first;
-               const auto& num_son = num_sidechain_son.second;
-               if (num_son <= props.parameters.maximum_son_count()) {
-                  uint16_t offset = std::min(size_t(num_son / 2),
-                                             d._son_count_histogram_buffer.at(sidechain).size() - 1);
-                  // votes for a number greater than maximum_son_count
-                  // are turned into votes for maximum_son_count.
-                  //
-                  // in particular, this takes care of the case where a
-                  // member was voting for a high number, then the
-                  // parameter was lowered.
-                  d._son_count_histogram_buffer.at(sidechain)[offset] += voting_stake;
+
+            if ( opinion_account.options.extensions.value.num_son.valid() )
+            {
+               for(const auto& num_sidechain_son : *opinion_account.options.extensions.value.num_son) {
+                  const auto sidechain = num_sidechain_son.first;
+                  const auto& num_son = num_sidechain_son.second;
+                  if (num_son <= props.parameters.maximum_son_count()) {
+                     uint16_t offset = std::min(size_t(num_son / 2),
+                                                d._son_count_histogram_buffer.at(sidechain).size() - 1);
+                     // votes for a number greater than maximum_son_count
+                     // are turned into votes for maximum_son_count.
+                     //
+                     // in particular, this takes care of the case where a
+                     // member was voting for a high number, then the
+                     // parameter was lowered.
+                     d._son_count_histogram_buffer.at(sidechain)[offset] += voting_stake;
+                  }
                }
             }
 
@@ -2388,6 +2533,7 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g
    update_active_committee_members();
    update_active_sons();
    update_worker_votes();
+   hotfix_2024();
 
    const dynamic_global_property_object& dgpo = get_dynamic_global_properties();
 

libraries/chain/db_witness_schedule.cpp

@@ -200,43 +200,41 @@ void database::update_witness_schedule()
    }
 }
 
-void database::update_son_schedule()
+void database::update_son_schedule(sidechain_type type)
 {
    const global_property_object& gpo = get_global_properties();
 
-   for(const auto& active_sidechain_type : active_sidechain_types)
+   const son_schedule_object& sidechain_sso = get(son_schedule_id_type(get_son_schedule_id(type)));
+   if( gpo.active_sons.at(type).size() != 0 &&
+         head_block_num() % gpo.active_sons.at(type).size() == 0)
    {
-      const son_schedule_object& sidechain_sso = get(son_schedule_id_type(get_son_schedule_id(active_sidechain_type)));
-      if( head_block_num() % gpo.active_sons.at(active_sidechain_type).size() == 0)
+      modify( sidechain_sso, [&]( son_schedule_object& _sso )
       {
-         modify( sidechain_sso, [&]( son_schedule_object& _sso )
+         _sso.current_shuffled_sons.clear();
+         _sso.current_shuffled_sons.reserve( gpo.active_sons.at(type).size() );
+
+         for ( const auto &w : gpo.active_sons.at(type) ) {
+               _sso.current_shuffled_sons.push_back(w.son_id);
+         }
+
+         auto now_hi = uint64_t(head_block_time().sec_since_epoch()) << 32;
+
+         for (uint32_t i = 0; i < _sso.current_shuffled_sons.size(); ++i)
          {
-            _sso.current_shuffled_sons.clear();
-            _sso.current_shuffled_sons.reserve( gpo.active_sons.at(active_sidechain_type).size() );
+            /// High performance random generator
+            /// http://xorshift.di.unimi.it/
+            uint64_t k = now_hi + uint64_t(i) * 2685821657736338717ULL;
+            k ^= (k >> 12);
+            k ^= (k << 25);
+            k ^= (k >> 27);
+            k *= 2685821657736338717ULL;
 
-            for ( const son_info &w : gpo.active_sons.at(active_sidechain_type) ) {
-                  _sso.current_shuffled_sons.push_back(w.son_id);
-            }
-
-            auto now_hi = uint64_t(head_block_time().sec_since_epoch()) << 32;
-
-            for (uint32_t i = 0; i < _sso.current_shuffled_sons.size(); ++i)
-            {
-               /// High performance random generator
-               /// http://xorshift.di.unimi.it/
-               uint64_t k = now_hi + uint64_t(i) * 2685821657736338717ULL;
-               k ^= (k >> 12);
-               k ^= (k << 25);
-               k ^= (k >> 27);
-               k *= 2685821657736338717ULL;
-
-               uint32_t jmax = _sso.current_shuffled_sons.size() - i;
-               uint32_t j = i + k % jmax;
-               std::swap(_sso.current_shuffled_sons[i],
-                         _sso.current_shuffled_sons[j]);
-            }
-         });
-      }
+            uint32_t jmax = _sso.current_shuffled_sons.size() - i;
+            uint32_t j = i + k % jmax;
+            std::swap(_sso.current_shuffled_sons[i],
+                      _sso.current_shuffled_sons[j]);
+         }
+      });
    }
 }
 
@@ -320,23 +318,15 @@ void database::update_witness_schedule(const signed_block& next_block)
       idump( ( double(total_time/1000000.0)/calls) );
 }
 
-void database::update_son_schedule(const signed_block& next_block)
+void database::update_son_schedule(sidechain_type type, const signed_block& next_block)
 {
    auto start = fc::time_point::now();
 #ifndef NDEBUG
    const son_schedule_object& sso = get(son_schedule_id_type());
 #endif
    const global_property_object& gpo = get_global_properties();
-   const flat_map<sidechain_type, uint32_t> schedule_needs_filled = [&gpo]()
-   {
-      flat_map<sidechain_type, uint32_t> schedule_needs_filled;
-      for(const auto& sidechain_active_sons : gpo.active_sons)
-      {
-         schedule_needs_filled[sidechain_active_sons.first] = sidechain_active_sons.second.size();
-      }
-      return schedule_needs_filled;
-   }();
-   uint32_t schedule_slot = get_slot_at_time(next_block.timestamp);
+   const uint32_t schedule_needs_filled = gpo.active_sons.at(type).size();
+   const uint32_t schedule_slot = get_slot_at_time(next_block.timestamp);
 
    // We shouldn't be able to generate _pending_block with timestamp
    // in the past, and incoming blocks from the network with timestamp
@@ -350,46 +340,43 @@ void database::update_son_schedule(const signed_block& next_block)
    assert( dpo.random.data_size() == witness_scheduler_rng::seed_length );
    assert( witness_scheduler_rng::seed_length == sso.rng_seed.size() );
 
-   for(const auto& active_sidechain_type : active_sidechain_types)
+   const son_schedule_object& sidechain_sso = get(son_schedule_id_type(get_son_schedule_id(type)));
+   son_id_type first_son;
+   bool slot_is_near = sidechain_sso.scheduler.get_slot( schedule_slot-1, first_son );
+   son_id_type son_id;
+
+   modify(sidechain_sso, [&](son_schedule_object& _sso)
    {
-      const son_schedule_object& sidechain_sso = get(son_schedule_id_type(get_son_schedule_id(active_sidechain_type)));
-      son_id_type first_son;
-      bool slot_is_near = sidechain_sso.scheduler.get_slot( schedule_slot-1, first_son );
-      son_id_type son_id;
+    _sso.slots_since_genesis += schedule_slot;
+    witness_scheduler_rng rng(_sso.rng_seed.data, _sso.slots_since_genesis);
 
-      modify(sidechain_sso, [&](son_schedule_object& _sso)
-      {
-       _sso.slots_since_genesis += schedule_slot;
-       witness_scheduler_rng rng(_sso.rng_seed.data, _sso.slots_since_genesis);
+    _sso.scheduler._min_token_count = std::max(int(gpo.active_sons.at(type).size()) / 2, 1);
 
-       _sso.scheduler._min_token_count = std::max(int(gpo.active_sons.at(active_sidechain_type).size()) / 2, 1);
-
-       if( slot_is_near )
+    if( slot_is_near )
+    {
+       uint32_t drain = schedule_slot;
+       while( drain > 0 )
        {
-          uint32_t drain = schedule_slot;
-          while( drain > 0 )
-          {
-             if( _sso.scheduler.size() == 0 )
-                break;
-             _sso.scheduler.consume_schedule();
-             --drain;
-          }
+          if( _sso.scheduler.size() == 0 )
+             break;
+          _sso.scheduler.consume_schedule();
+          --drain;
        }
-       else
-       {
-          _sso.scheduler.reset_schedule( first_son );
-       }
-       while( !_sso.scheduler.get_slot(schedule_needs_filled.at(active_sidechain_type), son_id) )
-       {
-          if( _sso.scheduler.produce_schedule(rng) & emit_turn )
-             memcpy(_sso.rng_seed.begin(), dpo.random.data(), dpo.random.data_size());
-       }
-       _sso.last_scheduling_block = next_block.block_num();
-       _sso.recent_slots_filled = (
-                                        (_sso.recent_slots_filled << 1)
-                                        + 1) << (schedule_slot - 1);
-      });
-   }
+    }
+    else
+    {
+       _sso.scheduler.reset_schedule( first_son );
+    }
+    while( !_sso.scheduler.get_slot(schedule_needs_filled, son_id) )
+    {
+       if( _sso.scheduler.produce_schedule(rng) & emit_turn )
+          memcpy(_sso.rng_seed.begin(), dpo.random.data(), dpo.random.data_size());
+    }
+    _sso.last_scheduling_block = next_block.block_num();
+    _sso.recent_slots_filled = (
+                                     (_sso.recent_slots_filled << 1)
+                                     + 1) << (schedule_slot - 1);
+   });
 
    auto end = fc::time_point::now();
    static uint64_t total_time = 0;

libraries/chain/hardfork.d/HOTFIX_2024.hf

@@ -0,0 +1,7 @@
+#ifndef HARDFORK_HOTFIX_2024_TIME
+#ifdef BUILD_PEERPLAYS_TESTNET
+#define HARDFORK_HOTFIX_2024_TIME (fc::time_point_sec::from_iso_string("2023-12-20T00:00:00"))
+#else
+#define HARDFORK_HOTFIX_2024_TIME (fc::time_point_sec::from_iso_string("2023-12-20T00:00:00"))
+#endif
+#endif

libraries/chain/hardfork.d/SIDECHAIN.hf

@@ -0,0 +1,7 @@
+#ifndef HARDFORK_SIDECHAIN_DELETE_TIME
+#ifdef BUILD_PEERPLAYS_TESTNET
+#define HARDFORK_SIDECHAIN_DELETE_TIME (fc::time_point_sec::from_iso_string("2022-11-16T02:00:00"))
+#else
+#define HARDFORK_SIDECHAIN_DELETE_TIME (fc::time_point_sec::from_iso_string("2022-11-16T02:00:00"))
+#endif
+#endif

libraries/chain/hardfork.d/SON3.hf

@@ -1,7 +0,0 @@
-#ifndef HARDFORK_SON3_TIME
-#ifdef BUILD_PEERPLAYS_TESTNET
-#define HARDFORK_SON3_TIME (fc::time_point_sec::from_iso_string("2022-07-16T00:00:00"))
-#else
-#define HARDFORK_SON3_TIME (fc::time_point_sec::from_iso_string("2022-07-16T00:00:00"))
-#endif
-#endif

libraries/chain/hardfork.d/SON_FOR_ETHEREUM.hf

@@ -1,7 +1,7 @@
 #ifndef HARDFORK_SON_FOR_ETHEREUM_TIME
 #ifdef BUILD_PEERPLAYS_TESTNET
-#define HARDFORK_SON_FOR_ETHEREUM_TIME (fc::time_point_sec::from_iso_string("2022-07-01T00:00:00"))
+#define HARDFORK_SON_FOR_ETHEREUM_TIME (fc::time_point_sec::from_iso_string("2023-07-17T12:00:00"))
 #else
-#define HARDFORK_SON_FOR_ETHEREUM_TIME (fc::time_point_sec::from_iso_string("2022-07-01T00:00:00"))
+#define HARDFORK_SON_FOR_ETHEREUM_TIME (fc::time_point_sec::from_iso_string("2023-10-24T12:00:00"))
 #endif
 #endif

libraries/chain/include/graphene/chain/config.hpp

@@ -158,7 +158,7 @@
 #define GRAPHENE_RECENTLY_MISSED_COUNT_INCREMENT             4
 #define GRAPHENE_RECENTLY_MISSED_COUNT_DECREMENT             3
 
-#define GRAPHENE_CURRENT_DB_VERSION                          "PPY2.4"
+#define GRAPHENE_CURRENT_DB_VERSION                          "PPY2.5"
 
 #define GRAPHENE_IRREVERSIBLE_THRESHOLD                      (70 * GRAPHENE_1_PERCENT)
 

libraries/chain/include/graphene/chain/database.hpp

@@ -292,8 +292,8 @@ namespace graphene { namespace chain {
          vector<witness_id_type> get_near_witness_schedule()const;
          void update_witness_schedule();
          void update_witness_schedule(const signed_block& next_block);
-         void update_son_schedule();
-         void update_son_schedule(const signed_block& next_block);
+         void update_son_schedule(sidechain_type type);
+         void update_son_schedule(sidechain_type type, const signed_block& next_block);
       
          void check_lottery_end_by_participants( asset_id_type asset_id );
          void check_ending_lotteries();
@@ -520,6 +520,7 @@ namespace graphene { namespace chain {
          void notify_changed_objects();
 
       private:
+         std::mutex                             _pending_tx_session_mutex;
          optional<undo_database::session>       _pending_tx_session;
          vector< unique_ptr<op_evaluator> >     _operation_evaluators;
 
@@ -578,20 +579,22 @@ namespace graphene { namespace chain {
          void initialize_budget_record( fc::time_point_sec now, budget_record& rec )const;
          void process_budget();
          void pay_workers( share_type& budget );
-         void pay_sons();
+         void pay_sons_before_hf_ethereum();
+         void pay_sons_after_hf_ethereum();
          void perform_son_tasks();
          void perform_chain_maintenance(const signed_block& next_block, const global_property_object& global_props);
          void update_active_witnesses();
          void update_active_committee_members();
-         void update_son_metrics( const flat_map<sidechain_type, vector<son_info> >& curr_active_sons );
+         void update_son_metrics( const flat_map<sidechain_type, vector<son_sidechain_info> >& curr_active_sons );
          void update_active_sons();
          void remove_son_proposal( const proposal_object& proposal );
          void remove_inactive_son_down_proposals( const vector<son_id_type>& son_ids_to_remove );
          void remove_inactive_son_proposals( const vector<son_id_type>& son_ids_to_remove );
-         void update_son_statuses( const flat_map<sidechain_type, vector<son_info> >& curr_active_sons,
-                                   const flat_map<sidechain_type, vector<son_info> >& new_active_sons );
-         void update_son_wallet( const flat_map<sidechain_type, vector<son_info> >& new_active_sons );
+         void update_son_statuses( const flat_map<sidechain_type, vector<son_sidechain_info> >& curr_active_sons,
+                                   const flat_map<sidechain_type, vector<son_sidechain_info> >& new_active_sons );
+         void update_son_wallet( const flat_map<sidechain_type, vector<son_sidechain_info> >& new_active_sons );
          void update_worker_votes();
+         void hotfix_2024();
 
          public:
             double calculate_vesting_factor(const account_object& stake_account);
@@ -602,6 +605,7 @@ namespace graphene { namespace chain {
          ///@}
          ///@}
 
+         std::mutex                             _pending_tx_mutex;
          vector< processed_transaction >        _pending_tx;
          fork_database                          _fork_db;
 
@@ -634,7 +638,7 @@ namespace graphene { namespace chain {
          vector<uint64_t>                             _committee_count_histogram_buffer;
          flat_map<sidechain_type, vector<uint64_t> >  _son_count_histogram_buffer = []{
             flat_map<sidechain_type, vector<uint64_t> >  son_count_histogram_buffer;
-            for(const auto& active_sidechain_type : active_sidechain_types){
+            for(const auto& active_sidechain_type : all_sidechain_types){
                son_count_histogram_buffer[active_sidechain_type] = vector<uint64_t>{};
             }
             return son_count_histogram_buffer;

libraries/chain/include/graphene/chain/exceptions.hpp

@@ -182,6 +182,9 @@ namespace graphene { namespace chain {
    GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( override_transfer );
    GRAPHENE_DECLARE_OP_EVALUATE_EXCEPTION( not_permitted, override_transfer, 1, "not permitted" )
 
+   GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( blind_transfer );
+   GRAPHENE_DECLARE_OP_EVALUATE_EXCEPTION( unknown_commitment, blind_transfer, 1, "Attempting to claim an unknown prior commitment" );
+
    /*
    FC_DECLARE_DERIVED_EXCEPTION( addition_overflow,                 graphene::chain::chain_exception, 30002, "addition overflow" )
    FC_DECLARE_DERIVED_EXCEPTION( subtraction_overflow,              graphene::chain::chain_exception, 30003, "subtraction overflow" )

libraries/chain/include/graphene/chain/global_property_object.hpp

@@ -27,7 +27,7 @@
 #include <graphene/chain/protocol/chain_parameters.hpp>
 #include <graphene/chain/protocol/types.hpp>
 #include <graphene/chain/database.hpp>
-#include <graphene/chain/son_info.hpp>
+#include <graphene/chain/son_sidechain_info.hpp>
 #include <graphene/db/object.hpp>
 
 namespace graphene { namespace chain {
@@ -49,15 +49,15 @@ namespace graphene { namespace chain {
          chain_parameters           parameters;
          optional<chain_parameters> pending_parameters;
 
-         uint32_t                                     next_available_vote_id = 0;
-         vector<committee_member_id_type>             active_committee_members;  // updated once per maintenance interval
-         flat_set<witness_id_type>                    active_witnesses;          // updated once per maintenance interval
-         flat_map<sidechain_type, vector<son_info> >  active_sons = []()         // updated once per maintenance interval
+         uint32_t                                                 next_available_vote_id = 0;
+         vector<committee_member_id_type>                         active_committee_members;  // updated once per maintenance interval
+         flat_set<witness_id_type>                                active_witnesses;          // updated once per maintenance interval
+         flat_map<sidechain_type, vector<son_sidechain_info> >    active_sons = []()         // updated once per maintenance interval
          {
-            flat_map<sidechain_type, vector<son_info> > active_sons;
-            for(const auto& active_sidechain_type : active_sidechain_types)
+            flat_map<sidechain_type, vector<son_sidechain_info> > active_sons;
+            for(const auto& active_sidechain_type : all_sidechain_types)
             {
-               active_sons[active_sidechain_type] = vector<son_info>();
+               active_sons[active_sidechain_type] = vector<son_sidechain_info>();
             }
             return active_sons;
          }();

libraries/chain/include/graphene/chain/nft_object.hpp

@@ -130,6 +130,9 @@ namespace graphene { namespace chain {
                std::greater< uint32_t >,
                std::greater< object_id_type >
             >
+         >,
+         ordered_non_unique< tag<by_owner>,
+            member<nft_metadata_object, account_id_type, &nft_metadata_object::owner>
          >
       >
    >;

libraries/chain/include/graphene/chain/protocol/account.hpp

@@ -36,21 +36,28 @@ namespace graphene { namespace chain {
    bool is_cheap_name( const string& n );
 
    /// These are the fields which can be updated by the active authority.
-   struct account_options
+   struct   account_options
    {
       struct ext
       {
          /// The number of active son members this account votes the blockchain should appoint
          /// Must not exceed the actual number of son members voted for in @ref votes
-         optional< flat_map<sidechain_type, uint16_t> > num_son = []{
+         optional< flat_map<sidechain_type, uint16_t> > num_son;
+
+         /// Returns and empty num_son map with all sidechains
+         static flat_map<sidechain_type, uint16_t> empty_num_son()
+         {
             flat_map<sidechain_type, uint16_t> num_son;
-            for(const auto& active_sidechain_type : active_sidechain_types){
+            for(const auto& active_sidechain_type : all_sidechain_types)
+            {
                num_son[active_sidechain_type] = 0;
             }
+
             return num_son;
-         }();
+         }
       };
 
+
       /// The memo key is the key this account will typically use to encrypt/sign transaction memos and other non-
       /// validated account activities. This field is here to prevent confusion if the active authority has zero or
       /// multiple keys in it.

libraries/chain/include/graphene/chain/protocol/confidential.hpp

@@ -158,9 +158,7 @@ struct transfer_to_blind_operation : public base_operation
    blind_factor_type     blinding_factor;
    vector<blind_output>  outputs;
 
-   account_id_type fee_payer()const { return account_id_type{}; }
-
-   //account_id_type fee_payer()const { return from; }
+   account_id_type fee_payer()const { return from; }
    //void            validate()const;
    //share_type      calculate_fee(const fee_parameters_type& )const;
 };
@@ -181,9 +179,7 @@ struct transfer_from_blind_operation : public base_operation
    blind_factor_type     blinding_factor;
    vector<blind_input>   inputs;
 
-   account_id_type fee_payer()const { return account_id_type{}; }
-
-   //account_id_type fee_payer()const { return GRAPHENE_TEMP_ACCOUNT; }
+   account_id_type fee_payer()const { return GRAPHENE_TEMP_ACCOUNT; }
    //void            validate()const;
    //void            get_required_authorities( vector<authority>& a )const
    //{
@@ -246,10 +242,8 @@ struct blind_transfer_operation : public base_operation
    vector<blind_input>   inputs;
    vector<blind_output>  outputs;
 
-   account_id_type fee_payer()const { return account_id_type{}; }
-
    /** graphene TEMP account */
-   //account_id_type fee_payer()const;
+   account_id_type fee_payer()const { return GRAPHENE_TEMP_ACCOUNT; }
    //void            validate()const;
    //share_type      calculate_fee( const fee_parameters_type& k )const;
    //void            get_required_authorities( vector<authority>& a )const

libraries/chain/include/graphene/chain/protocol/nft_lottery.hpp

@@ -18,7 +18,7 @@ namespace graphene
             // Buyer purchasing lottery tickets
             account_id_type buyer;
             // count of tickets to buy
-            uint64_t tickets_to_buy;
+            share_type tickets_to_buy;
             // amount that can spent
             asset amount;
 
@@ -83,4 +83,4 @@ FC_REFLECT(graphene::chain::nft_lottery_reward_operation::fee_parameters_type, (
 FC_REFLECT(graphene::chain::nft_lottery_end_operation::fee_parameters_type, (fee))
 FC_REFLECT(graphene::chain::nft_lottery_token_purchase_operation, (fee)(lottery_id)(buyer)(tickets_to_buy)(amount)(extensions))
 FC_REFLECT(graphene::chain::nft_lottery_reward_operation, (fee)(lottery_id)(winner)(amount)(win_percentage)(is_benefactor_reward)(winner_ticket_id)(extensions))
-FC_REFLECT(graphene::chain::nft_lottery_end_operation, (fee)(lottery_id)(extensions))
+FC_REFLECT(graphene::chain::nft_lottery_end_operation, (fee)(lottery_id)(extensions))

libraries/chain/include/graphene/chain/protocol/sidechain_transaction.hpp

@@ -71,7 +71,7 @@ FC_REFLECT( graphene::chain::sidechain_transaction_create_operation, (fee)(payer
         (sidechain)
         (object_id)
         (transaction)
-        (signers) )
+        (signers))
 
 FC_REFLECT( graphene::chain::sidechain_transaction_sign_operation::fee_parameters_type, (fee) )
 FC_REFLECT( graphene::chain::sidechain_transaction_sign_operation, (fee)(signer)(payer)

libraries/chain/include/graphene/chain/protocol/son_wallet.hpp

@@ -1,40 +1,47 @@
 #pragma once
 #include <graphene/chain/protocol/base.hpp>
 #include <graphene/chain/son_info.hpp>
+#include <graphene/chain/son_sidechain_info.hpp>
 
 namespace graphene { namespace chain {
 
-    struct son_wallet_recreate_operation : public base_operation
-    {
-        struct fee_parameters_type { uint64_t fee = 0; };
+   struct son_wallet_recreate_operation : public base_operation
+   {
+     struct fee_parameters_type { uint64_t fee = 0; };
+     struct ext
+     {
+        optional<flat_map<sidechain_type, vector<son_sidechain_info> > > sidechain_sons;
+     };
 
-        asset fee;
-        account_id_type payer;
+     asset fee;
+     account_id_type payer;
 
-        flat_map<sidechain_type, vector<son_info> > sons;
+     vector<son_info> sons;
+     extension< ext > extensions;
 
-        account_id_type fee_payer()const { return payer; }
-        share_type      calculate_fee(const fee_parameters_type& k)const { return 0; }
-    };
+     account_id_type fee_payer()const { return payer; }
+     share_type      calculate_fee(const fee_parameters_type& k)const { return 0; }
+   };
 
-    struct son_wallet_update_operation : public base_operation
-    {
-        struct fee_parameters_type { uint64_t fee = 0; };
+   struct son_wallet_update_operation : public base_operation
+   {
+     struct fee_parameters_type { uint64_t fee = 0; };
 
-        asset fee;
-        account_id_type payer;
+     asset fee;
+     account_id_type payer;
 
-        son_wallet_id_type son_wallet_id;
-        sidechain_type sidechain;
-        string address;
+     son_wallet_id_type son_wallet_id;
+     sidechain_type sidechain;
+     string address;
 
-        account_id_type fee_payer()const { return payer; }
-        share_type      calculate_fee(const fee_parameters_type& k)const { return 0; }
-    };
+     account_id_type fee_payer()const { return payer; }
+     share_type      calculate_fee(const fee_parameters_type& k)const { return 0; }
+   };
 
 } } // namespace graphene::chain
 
 FC_REFLECT(graphene::chain::son_wallet_recreate_operation::fee_parameters_type, (fee) )
-FC_REFLECT(graphene::chain::son_wallet_recreate_operation, (fee)(payer)(sons) )
+FC_REFLECT(graphene::chain::son_wallet_recreate_operation::ext, (sidechain_sons))
+FC_REFLECT(graphene::chain::son_wallet_recreate_operation, (fee)(payer)(sons)(extensions) )
 FC_REFLECT(graphene::chain::son_wallet_update_operation::fee_parameters_type, (fee) )
 FC_REFLECT(graphene::chain::son_wallet_update_operation, (fee)(payer)(son_wallet_id)(sidechain)(address) )

libraries/chain/include/graphene/chain/protocol/types.hpp

@@ -395,6 +395,13 @@ namespace graphene { namespace chain {
        bool is_valid_muse( const std::string& base58str );
    };
 
+   class pubkey_comparator {
+   public:
+      inline bool operator()(const public_key_type& a, const public_key_type& b) const {
+         return a.key_data < b.key_data;
+      }
+   };
+
    struct extended_public_key_type
    {
       struct binary_key

libraries/chain/include/graphene/chain/sidechain_address_object.hpp

@@ -36,6 +36,15 @@ namespace graphene { namespace chain {
             deposit_address(""),
             withdraw_public_key(""),
             withdraw_address("") {}
+
+         inline string get_deposit_address() const {
+            if(sidechain_type::ethereum != sidechain)
+               return deposit_address;
+
+            auto deposit_address_lower = deposit_address;
+            std::transform(deposit_address_lower.begin(), deposit_address_lower.end(), deposit_address_lower.begin(), ::tolower);
+            return deposit_address_lower;
+         }
    };
 
    struct by_account;
@@ -76,7 +85,7 @@ namespace graphene { namespace chain {
          ordered_non_unique< tag<by_sidechain_and_deposit_address_and_expires>,
             composite_key<sidechain_address_object,
                member<sidechain_address_object, sidechain_type, &sidechain_address_object::sidechain>,
-               member<sidechain_address_object, string, &sidechain_address_object::deposit_address>,
+               const_mem_fun<sidechain_address_object, string, &sidechain_address_object::get_deposit_address>,
                member<sidechain_address_object, time_point_sec, &sidechain_address_object::expires>
             >
          >

libraries/chain/include/graphene/chain/sidechain_defs.hpp

@@ -1,7 +1,11 @@
 #pragma once
 
 #include <set>
+
+#include <graphene/chain/hardfork.hpp>
+
 #include <fc/reflect/reflect.hpp>
+#include <fc/time.hpp>
 
 namespace graphene { namespace chain {
 
@@ -14,9 +18,23 @@ enum class sidechain_type {
    hive
 };
 
-static const std::set<sidechain_type> active_sidechain_types = {sidechain_type::bitcoin, sidechain_type::ethereum, sidechain_type::hive};
+static const std::set<sidechain_type> all_sidechain_types = {sidechain_type::bitcoin, sidechain_type::ethereum, sidechain_type::hive};
 
-} }
+inline std::set<sidechain_type> active_sidechain_types(const fc::time_point_sec block_time) {
+   std::set<sidechain_type> active_sidechain_types{};
+
+   if (block_time >= HARDFORK_SON_TIME)
+      active_sidechain_types.insert(sidechain_type::bitcoin);
+   if (block_time >= HARDFORK_SON_FOR_HIVE_TIME)
+      active_sidechain_types.insert(sidechain_type::hive);
+   if (block_time >= HARDFORK_SON_FOR_ETHEREUM_TIME)
+      active_sidechain_types.insert(sidechain_type::ethereum);
+
+   return active_sidechain_types;
+}
+
+} // namespace chain
+} // namespace graphene
 
 FC_REFLECT_ENUM(graphene::chain::sidechain_type,
    (unknown)

libraries/chain/include/graphene/chain/sidechain_transaction_object.hpp

@@ -2,7 +2,7 @@
 #include <boost/multi_index/composite_key.hpp>
 #include <graphene/chain/protocol/types.hpp>
 #include <graphene/chain/sidechain_defs.hpp>
-#include <graphene/chain/son_info.hpp>
+#include <graphene/chain/son_sidechain_info.hpp>
 
 namespace graphene { namespace chain {
    using namespace graphene::db;
@@ -30,7 +30,7 @@ namespace graphene { namespace chain {
          sidechain_type sidechain = sidechain_type::unknown;
          object_id_type object_id;
          std::string transaction;
-         std::vector<son_info> signers;
+         std::vector<son_sidechain_info> signers;
          std::vector<std::pair<son_id_type, std::string>> signatures;
          std::string sidechain_transaction;
 

libraries/chain/include/graphene/chain/son_info.hpp

@@ -3,34 +3,40 @@
 #include <graphene/chain/sidechain_defs.hpp>
 
 namespace graphene { namespace chain {
-   using namespace graphene::db;
 
    /**
-    * @class son_info
-    * @brief tracks information about a SON info required to re/create primary wallet
-    * @ingroup object
+          * @class son_info
+          * @brief tracks information about a SON info required to re/create primary wallet
+          * @ingroup object
     */
    struct son_info {
       son_id_type son_id;
       weight_type weight = 0;
       public_key_type signing_key;
-      string public_key;
+      flat_map<sidechain_type, string> sidechain_public_keys;
 
-      bool operator==(const son_info& rhs) const {
+      bool operator==(const son_info& rhs) {
          bool son_sets_equal =
                (son_id == rhs.son_id) &&
                (weight == rhs.weight) &&
                (signing_key == rhs.signing_key) &&
-               (public_key == rhs.public_key);
+               (sidechain_public_keys.size() == rhs.sidechain_public_keys.size());
 
+         if (son_sets_equal) {
+            bool sidechain_public_keys_equal = true;
+            for (size_t i = 0; i < sidechain_public_keys.size(); i++) {
+               const auto lhs_scpk = sidechain_public_keys.nth(i);
+               const auto rhs_scpk = rhs.sidechain_public_keys.nth(i);
+               sidechain_public_keys_equal = sidechain_public_keys_equal &&
+                                             (lhs_scpk->first == rhs_scpk->first) &&
+                                             (lhs_scpk->second == rhs_scpk->second);
+            }
+            son_sets_equal = son_sets_equal && sidechain_public_keys_equal;
+         }
          return son_sets_equal;
       }
    };
 
 } }
 
-FC_REFLECT( graphene::chain::son_info,
-      (son_id)
-      (weight)
-      (signing_key)
-      (public_key) )
+FC_REFLECT( graphene::chain::son_info, (son_id) (weight) (signing_key) (sidechain_public_keys) )

libraries/chain/include/graphene/chain/son_object.hpp

@@ -65,7 +65,15 @@ namespace graphene { namespace chain {
 
          account_id_type son_account;
          flat_map<sidechain_type, vote_id_type> sidechain_vote_ids;
-         flat_map<sidechain_type, uint64_t> total_votes;
+         flat_map<sidechain_type, uint64_t> total_votes = []()
+         {
+            flat_map<sidechain_type, uint64_t> total_votes;
+            for(const auto& active_sidechain_type : all_sidechain_types)
+            {
+               total_votes[active_sidechain_type] = 0;
+            }
+            return total_votes;
+         }();
          string url;
          vesting_balance_id_type deposit;
          public_key_type signing_key;
@@ -74,7 +82,7 @@ namespace graphene { namespace chain {
          flat_map<sidechain_type, son_status> statuses = []()
          {
             flat_map<sidechain_type, son_status> statuses;
-            for(const auto& active_sidechain_type : active_sidechain_types)
+            for(const auto& active_sidechain_type : all_sidechain_types)
             {
                statuses[active_sidechain_type] = son_status::inactive;
             }
@@ -83,13 +91,15 @@ namespace graphene { namespace chain {
          flat_map<sidechain_type, string> sidechain_public_keys;
 
          void pay_son_fee(share_type pay, database& db);
-         bool has_valid_config()const;
-         bool has_valid_config(time_point_sec head_block_time)const;
+         bool has_valid_config(time_point_sec head_block_time, sidechain_type sidechain) const;
 
-         inline vote_id_type get_sidechain_vote_id(sidechain_type sidechain) const { return sidechain_vote_ids.at(sidechain); }
-         inline vote_id_type get_bitcoin_vote_id() const { return get_sidechain_vote_id(sidechain_type::bitcoin); }
-         inline vote_id_type get_hive_vote_id() const { return get_sidechain_vote_id(sidechain_type::hive); }
-         inline vote_id_type get_ethereum_vote_id() const { return get_sidechain_vote_id(sidechain_type::ethereum); }
+         inline optional<vote_id_type> get_sidechain_vote_id(sidechain_type sidechain) const { return sidechain_vote_ids.contains(sidechain) ? sidechain_vote_ids.at(sidechain) : optional<vote_id_type>{}; }
+         inline optional<vote_id_type> get_bitcoin_vote_id() const { return get_sidechain_vote_id(sidechain_type::bitcoin); }
+         inline optional<vote_id_type> get_hive_vote_id() const { return get_sidechain_vote_id(sidechain_type::hive); }
+         inline optional<vote_id_type> get_ethereum_vote_id() const { return get_sidechain_vote_id(sidechain_type::ethereum); }
+
+      private:
+         bool has_valid_config(sidechain_type sidechain) const;
    };
 
    struct by_account;
@@ -105,14 +115,14 @@ namespace graphene { namespace chain {
          ordered_unique< tag<by_account>,
             member<son_object, account_id_type, &son_object::son_account>
          >,
-         ordered_unique< tag<by_vote_id_bitcoin>,
-            const_mem_fun<son_object, vote_id_type, &son_object::get_bitcoin_vote_id>
+         ordered_non_unique< tag<by_vote_id_bitcoin>,
+            const_mem_fun<son_object, optional<vote_id_type>, &son_object::get_bitcoin_vote_id>
          >,
-         ordered_unique< tag<by_vote_id_hive>,
-            const_mem_fun<son_object, vote_id_type, &son_object::get_hive_vote_id>
+         ordered_non_unique< tag<by_vote_id_hive>,
+            const_mem_fun<son_object, optional<vote_id_type>, &son_object::get_hive_vote_id>
          >,
-         ordered_unique< tag<by_vote_id_ethereum>,
-            const_mem_fun<son_object, vote_id_type, &son_object::get_ethereum_vote_id>
+         ordered_non_unique< tag<by_vote_id_ethereum>,
+            const_mem_fun<son_object, optional<vote_id_type>, &son_object::get_ethereum_vote_id>
          >
       >
    >;

libraries/chain/include/graphene/chain/son_sidechain_info.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include <graphene/chain/protocol/types.hpp>
+#include <graphene/chain/sidechain_defs.hpp>
+
+namespace graphene { namespace chain {
+
+   /**
+    * @class son_sidechain_info
+    * @brief tracks information about a SON info required to re/create primary wallet
+    * @ingroup object
+    */
+   struct son_sidechain_info {
+      son_id_type son_id;
+      weight_type weight = 0;
+      public_key_type signing_key;
+      string public_key;
+
+      bool operator==(const son_sidechain_info& rhs) const {
+         bool son_sets_equal =
+               (son_id == rhs.son_id) &&
+               (weight == rhs.weight) &&
+               (signing_key == rhs.signing_key) &&
+               (public_key == rhs.public_key);
+
+         return son_sets_equal;
+      }
+   };
+
+} }
+
+FC_REFLECT( graphene::chain::son_sidechain_info, (son_id) (weight) (signing_key) (public_key) )

libraries/chain/include/graphene/chain/son_wallet_object.hpp

@@ -1,6 +1,6 @@
 #pragma once
 #include <graphene/chain/protocol/types.hpp>
-#include <graphene/chain/son_info.hpp>
+#include <graphene/chain/son_sidechain_info.hpp>
 #include <graphene/chain/sidechain_defs.hpp>
 
 namespace graphene { namespace chain {
@@ -21,7 +21,7 @@ namespace graphene { namespace chain {
          time_point_sec expires;
 
          flat_map<sidechain_type, string> addresses;
-         flat_map<sidechain_type, vector<son_info> > sons;
+         flat_map<sidechain_type, vector<son_sidechain_info> > sons;
    };
 
    struct by_valid_from;

libraries/chain/nft_lottery_evaluator.cpp

@@ -30,7 +30,7 @@ namespace graphene
 
                 auto lottery_options = lottery_md_obj.lottery_data->lottery_options;
                 FC_ASSERT(lottery_options.ticket_price.asset_id == op.amount.asset_id);
-                FC_ASSERT((double)op.amount.amount.value / lottery_options.ticket_price.amount.value == (double)op.tickets_to_buy);
+                FC_ASSERT(op.tickets_to_buy * lottery_options.ticket_price.amount.value == op.amount.amount.value);
                 return void_result();
             }
             FC_CAPTURE_AND_RETHROW((op))
@@ -142,4 +142,4 @@ namespace graphene
             FC_CAPTURE_AND_RETHROW((op))
         }
     } // namespace chain
-} // namespace graphene
+} // namespace graphene

libraries/chain/protocol/account.cpp

@@ -174,31 +174,37 @@ void account_options::validate() const
 {
    auto needed_witnesses = num_witness;
    auto needed_committee = num_committee;
-   FC_ASSERT( extensions.value.num_son.valid() , "Invalid son number" );
-   flat_map<sidechain_type, uint16_t> needed_sons = *extensions.value.num_son;
 
    for( vote_id_type id : votes )
       if( id.type() == vote_id_type::witness && needed_witnesses )
          --needed_witnesses;
       else if ( id.type() == vote_id_type::committee && needed_committee )
          --needed_committee;
-      else if ( id.type() == vote_id_type::son_bitcoin && needed_sons[sidechain_type::bitcoin] )
-         --needed_sons[sidechain_type::bitcoin];
-      else if ( id.type() == vote_id_type::son_hive && needed_sons[sidechain_type::hive] )
-         --needed_sons[sidechain_type::hive];
-      else if ( id.type() == vote_id_type::son_ethereum && needed_sons[sidechain_type::ethereum] )
-         --needed_sons[sidechain_type::ethereum];
 
    FC_ASSERT( needed_witnesses == 0,
               "May not specify fewer witnesses than the number voted for.");
    FC_ASSERT( needed_committee == 0,
               "May not specify fewer committee members than the number voted for.");
-   FC_ASSERT( needed_sons[sidechain_type::bitcoin] == 0,
-              "May not specify fewer Bitcoin SONs than the number voted for.");
-   FC_ASSERT( needed_sons[sidechain_type::hive] == 0,
-              "May not specify fewer Hive SONs than the number voted for.");
-   FC_ASSERT( needed_sons[sidechain_type::ethereum] == 0,
-             "May not specify fewer Ethereum SONs than the number voted for.");
+
+   if ( extensions.value.num_son.valid() )
+   {
+      flat_map<sidechain_type, uint16_t> needed_sons = *extensions.value.num_son;
+
+      for( vote_id_type id : votes )
+         if ( id.type() == vote_id_type::son_bitcoin && needed_sons[sidechain_type::bitcoin] )
+               --needed_sons[sidechain_type::bitcoin];
+         else if ( id.type() == vote_id_type::son_hive && needed_sons[sidechain_type::hive] )
+               --needed_sons[sidechain_type::hive];
+         else if ( id.type() == vote_id_type::son_ethereum && needed_sons[sidechain_type::ethereum] )
+               --needed_sons[sidechain_type::ethereum];
+
+      FC_ASSERT( needed_sons[sidechain_type::bitcoin] == 0,
+                "May not specify fewer Bitcoin SONs than the number voted for.");
+      FC_ASSERT( needed_sons[sidechain_type::hive] == 0,
+                "May not specify fewer Hive SONs than the number voted for.");
+      FC_ASSERT( needed_sons[sidechain_type::ethereum] == 0,
+                "May not specify fewer Ethereum SONs than the number voted for.");
+   }
 }
 
 void affiliate_reward_distribution::validate() const

libraries/chain/sidechain_address_evaluator.cpp

@@ -22,11 +22,14 @@ object_id_type add_sidechain_address_evaluator::do_apply(const sidechain_address
     const auto &sidechain_addresses_idx = db().get_index_type<sidechain_address_index>().indices().get<by_account_and_sidechain_and_expires>();
     const auto &addr_itr = sidechain_addresses_idx.find(std::make_tuple(op.sidechain_address_account, op.sidechain, time_point_sec::maximum()));
 
-    if (addr_itr != sidechain_addresses_idx.end())
-    {
-        db().modify(*addr_itr, [&](sidechain_address_object &sao) {
-            sao.expires = db().head_block_time();
-        });
+    if (addr_itr != sidechain_addresses_idx.end()) {
+       if (db().head_block_time() >= HARDFORK_SIDECHAIN_DELETE_TIME) {
+          db().remove(*addr_itr);
+       } else {
+          db().modify(*addr_itr, [&](sidechain_address_object &sao) {
+             sao.expires = db().head_block_time();
+          });
+       }
     }
 
     const auto& new_sidechain_address_object = db().create<sidechain_address_object>( [&]( sidechain_address_object& obj ){
@@ -105,10 +108,14 @@ void_result delete_sidechain_address_evaluator::do_apply(const sidechain_address
 { try {
     const auto& idx = db().get_index_type<sidechain_address_index>().indices().get<by_id>();
     auto sidechain_address = idx.find(op.sidechain_address_id);
-    if(sidechain_address != idx.end()) {
-        db().modify(*sidechain_address, [&](sidechain_address_object &sao) {
-            sao.expires = db().head_block_time();
-        });
+    if (sidechain_address != idx.end()) {
+       if (db().head_block_time() >= HARDFORK_SIDECHAIN_DELETE_TIME) {
+          db().remove(*sidechain_address);
+       } else {
+          db().modify(*sidechain_address, [&](sidechain_address_object &sao) {
+             sao.expires = db().head_block_time();
+          });
+       }
     }
     return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }

libraries/chain/sidechain_transaction_evaluator.cpp

@@ -11,7 +11,7 @@ namespace graphene { namespace chain {
 void_result sidechain_transaction_create_evaluator::do_evaluate(const sidechain_transaction_create_operation &op)
 { try {
    FC_ASSERT(db().head_block_time() >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK");
-   FC_ASSERT( op.payer == db().get_global_properties().parameters.son_account(), "SON paying account must be set as payer." );
+   FC_ASSERT(op.payer == db().get_global_properties().parameters.son_account(), "SON paying account must be set as payer.");
 
    FC_ASSERT((op.object_id.is<son_wallet_id_type>() || op.object_id.is<son_wallet_deposit_id_type>() || op.object_id.is<son_wallet_withdraw_id_type>()), "Invalid object id");
 
@@ -28,15 +28,26 @@ void_result sidechain_transaction_create_evaluator::do_evaluate(const sidechain_
 object_id_type sidechain_transaction_create_evaluator::do_apply(const sidechain_transaction_create_operation &op)
 { try {
    const auto &new_sidechain_transaction_object = db().create<sidechain_transaction_object>([&](sidechain_transaction_object &sto) {
+
       sto.timestamp = db().head_block_time();
       sto.sidechain = op.sidechain;
       sto.object_id = op.object_id;
       sto.transaction = op.transaction;
-      sto.signers = op.signers;
-      std::transform(op.signers.begin(), op.signers.end(), std::inserter(sto.signatures, sto.signatures.end()), [](const son_info &si) {
+      std::vector<son_sidechain_info> signers;
+      for(const auto& signer : op.signers){
+         son_sidechain_info ssi;
+         ssi.son_id = signer.son_id;
+         ssi.weight = signer.weight;
+         ssi.signing_key = signer.signing_key;
+         ssi.public_key = signer.sidechain_public_keys.at(op.sidechain);
+         signers.emplace_back(std::move(ssi));
+      }
+      sto.signers = std::move(signers);
+
+      std::transform(sto.signers.begin(), sto.signers.end(), std::inserter(sto.signatures, sto.signatures.end()), [](const son_sidechain_info &si) {
          return std::make_pair(si.son_id, std::string());
       });
-      for (const auto &si : op.signers) {
+      for (const auto &si : sto.signers) {
          sto.total_weight = sto.total_weight + si.weight;
       }
       sto.sidechain_transaction = "";

libraries/chain/son_evaluator.cpp

@@ -38,20 +38,29 @@ void_result create_son_evaluator::do_evaluate(const son_create_operation& op)
 
 object_id_type create_son_evaluator::do_apply(const son_create_operation& op)
 { try {
-    vote_id_type vote_id_bitcoin;
-    vote_id_type vote_id_hive;
-    vote_id_type vote_id_ethereum;
-    db().modify(db().get_global_properties(), [&vote_id_bitcoin, &vote_id_hive, &vote_id_ethereum](global_property_object& p) {
-        vote_id_bitcoin = get_next_vote_id(p, vote_id_type::son_bitcoin);
-        vote_id_hive = get_next_vote_id(p, vote_id_type::son_hive);
-        vote_id_ethereum = get_next_vote_id(p, vote_id_type::son_ethereum);
-    });
+    vote_id_type vote_id;
+    flat_map<sidechain_type, vote_id_type> vote_ids;
 
-    const auto& new_son_object = db().create<son_object>( [&]( son_object& obj ){
+    const auto now = db().head_block_time();
+    if( now < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+      db().modify(db().get_global_properties(), [&vote_id](global_property_object &p) {
+         vote_id = get_next_vote_id(p, vote_id_type::son_bitcoin);
+      });
+    }
+    else {
+      db().modify(db().get_global_properties(), [&vote_ids](global_property_object &p) {
+         vote_ids[sidechain_type::bitcoin] = get_next_vote_id(p, vote_id_type::son_bitcoin);
+         vote_ids[sidechain_type::hive] = get_next_vote_id(p, vote_id_type::son_hive);
+         vote_ids[sidechain_type::ethereum] = get_next_vote_id(p, vote_id_type::son_ethereum);
+      });
+    }
+
+    const auto& new_son_object = db().create<son_object>( [&]( son_object& obj ) {
         obj.son_account = op.owner_account;
-        obj.sidechain_vote_ids[sidechain_type::bitcoin] = vote_id_bitcoin;
-        obj.sidechain_vote_ids[sidechain_type::hive] = vote_id_hive;
-        obj.sidechain_vote_ids[sidechain_type::ethereum] = vote_id_ethereum;
+        if( now < HARDFORK_SON_FOR_ETHEREUM_TIME )
+           obj.sidechain_vote_ids[sidechain_type::bitcoin] = vote_id;
+        else
+           obj.sidechain_vote_ids = vote_ids;
         obj.url = op.url;
         obj.deposit = op.deposit;
         obj.signing_key = op.signing_key;
@@ -168,7 +177,7 @@ void_result son_heartbeat_evaluator::do_evaluate(const son_heartbeat_operation&
     fc::time_point_sec min_ts = db().head_block_time() - fc::seconds(5 * db().block_interval());
     // Account for server ntp sync difference
     fc::time_point_sec max_ts = db().head_block_time() + fc::seconds(5 * db().block_interval());
-    for(const auto& active_sidechain_type : active_sidechain_types) {
+    for(const auto& active_sidechain_type : active_sidechain_types(db().head_block_time())) {
       if(stats.last_active_timestamp.contains(active_sidechain_type))
          FC_ASSERT(op.ts > stats.last_active_timestamp.at(active_sidechain_type), "Heartbeat sent for sidechain = ${sidechain} without waiting minimum time", ("sidechain", active_sidechain_type));
       if(stats.last_down_timestamp.contains(active_sidechain_type))
@@ -195,7 +204,7 @@ object_id_type son_heartbeat_evaluator::do_apply(const son_heartbeat_operation&
            active_son_ids.reserve(active_sons.size());
            std::transform(active_sons.cbegin(), active_sons.cend(),
                           std::inserter(active_son_ids, active_son_ids.end()),
-                          [](const son_info &swi) {
+                          [](const son_sidechain_info &swi) {
                              return swi.son_id;
                           });
 
@@ -208,7 +217,7 @@ object_id_type son_heartbeat_evaluator::do_apply(const son_heartbeat_operation&
 
            if (itr->statuses.at(sidechain) == son_status::in_maintenance) {
               db().modify(itr->statistics(db()), [&](son_statistics_object &sso) {
-                 sso.current_interval_downtime[sidechain] += op.ts.sec_since_epoch() - sso.last_down_timestamp.at(sidechain).sec_since_epoch();
+                 sso.current_interval_downtime[sidechain] += op.ts.sec_since_epoch() - (sso.last_down_timestamp.contains(sidechain) ? sso.last_down_timestamp.at(sidechain).sec_since_epoch() : op.ts.sec_since_epoch());
                  sso.last_active_timestamp[sidechain] = op.ts;
               });
 
@@ -244,8 +253,9 @@ void_result son_report_down_evaluator::do_evaluate(const son_report_down_operati
           status_need_to_report_down = true;
     }
     FC_ASSERT(status_need_to_report_down, "Inactive/Deregistered/in_maintenance SONs cannot be reported on as down");
-    for(const auto& active_sidechain_type : active_sidechain_types) {
-      FC_ASSERT(op.down_ts >= stats.last_active_timestamp.at(active_sidechain_type), "sidechain = ${sidechain} down_ts should be greater than last_active_timestamp", ("sidechain", active_sidechain_type));
+    for(const auto& active_sidechain_type : active_sidechain_types(db().head_block_time())) {
+      if(stats.last_active_timestamp.contains(active_sidechain_type))
+         FC_ASSERT(op.down_ts >= stats.last_active_timestamp.at(active_sidechain_type), "sidechain = ${sidechain} down_ts should be greater than last_active_timestamp", ("sidechain", active_sidechain_type));
     }
     return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }

libraries/chain/son_object.cpp

@@ -6,24 +6,22 @@ namespace graphene { namespace chain {
       db.adjust_balance(son_account, pay);
    }
 
-   bool son_object::has_valid_config()const {
-      return ((std::string(signing_key).length() > 0) &&
-             (sidechain_public_keys.size() > 0) &&
-             (sidechain_public_keys.find( sidechain_type::bitcoin ) != sidechain_public_keys.end()) &&
-             (sidechain_public_keys.at(sidechain_type::bitcoin).length() > 0));
+   bool son_object::has_valid_config(sidechain_type sidechain) const {
+      return (sidechain_public_keys.find( sidechain ) != sidechain_public_keys.end()) &&
+         (sidechain_public_keys.at(sidechain).length() > 0);
    }
 
-   bool son_object::has_valid_config(time_point_sec head_block_time)const {
-      bool retval = has_valid_config();
+   bool son_object::has_valid_config(time_point_sec head_block_time, sidechain_type sidechain) const {
+      bool retval = (std::string(signing_key).length() > 0) && (sidechain_public_keys.size() > 0);
 
-      if (head_block_time >= HARDFORK_SON_FOR_HIVE_TIME) {
-          retval = retval &&
-                   (sidechain_public_keys.find( sidechain_type::hive ) != sidechain_public_keys.end()) &&
-                   (sidechain_public_keys.at(sidechain_type::hive).length() > 0);
-
-          retval = retval &&
-                   (sidechain_public_keys.find( sidechain_type::ethereum ) != sidechain_public_keys.end()) &&
-                   (sidechain_public_keys.at(sidechain_type::ethereum).length() > 0);
+      if (head_block_time < HARDFORK_SON_FOR_HIVE_TIME) {
+         retval = retval && has_valid_config(sidechain_type::bitcoin);
+      }
+      if (head_block_time >= HARDFORK_SON_FOR_HIVE_TIME && head_block_time < HARDFORK_SON_FOR_ETHEREUM_TIME) {
+         retval = retval && has_valid_config(sidechain_type::bitcoin) && has_valid_config(sidechain_type::hive);
+      }
+      else if (head_block_time >= HARDFORK_SON_FOR_ETHEREUM_TIME) {
+         retval = retval && has_valid_config(sidechain);
       }
 
       return retval;

libraries/chain/son_wallet_evaluator.cpp

@@ -7,8 +7,9 @@ namespace graphene { namespace chain {
 
 void_result recreate_son_wallet_evaluator::do_evaluate(const son_wallet_recreate_operation& op)
 { try{
-   FC_ASSERT(db().head_block_time() >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK");
-   FC_ASSERT( op.payer == db().get_global_properties().parameters.son_account(), "SON paying account must be set as payer." );
+   const auto now = db().head_block_time();
+   FC_ASSERT(now >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK");
+   FC_ASSERT(op.payer == db().get_global_properties().parameters.son_account(), "SON paying account must be set as payer.");
 
    const auto& idx = db().get_index_type<son_wallet_index>().indices().get<by_id>();
    auto itr = idx.rbegin();
@@ -16,7 +17,23 @@ void_result recreate_son_wallet_evaluator::do_evaluate(const son_wallet_recreate
    {
       // Compare current wallet SONs and to-be lists of active sons
       auto cur_wallet_sons = (*itr).sons;
-      auto new_wallet_sons = op.sons;
+      flat_map<sidechain_type, vector<son_sidechain_info> > new_wallet_sons;
+      if( now < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+         for(const auto& son : op.sons){
+            for(const auto& active_sidechain_type : active_sidechain_types(db().head_block_time())){
+               son_sidechain_info ssi;
+               ssi.son_id = son.son_id;
+               ssi.weight = son.weight;
+               ssi.signing_key = son.signing_key;
+               ssi.public_key = son.sidechain_public_keys.at(active_sidechain_type);
+               new_wallet_sons[active_sidechain_type].emplace_back(std::move(ssi));
+            }
+         }
+      }
+      else{
+         FC_ASSERT(op.extensions.value.sidechain_sons.valid(), "Sons is not valid");
+         new_wallet_sons = *op.extensions.value.sidechain_sons;
+      }
 
       bool son_sets_equal = (cur_wallet_sons.size() == new_wallet_sons.size());
       if (son_sets_equal) {
@@ -51,9 +68,26 @@ object_id_type recreate_son_wallet_evaluator::do_apply(const son_wallet_recreate
    }
 
    const auto& new_son_wallet_object = db().create<son_wallet_object>( [&]( son_wallet_object& obj ){
-      obj.valid_from = db().head_block_time();
+      const auto now = db().head_block_time();
+      obj.valid_from = now;
       obj.expires = time_point_sec::maximum();
-      obj.sons = op.sons;
+      if( now < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
+         flat_map<sidechain_type, vector<son_sidechain_info> > sons;
+         for(const auto& son : op.sons){
+            for(const auto& active_sidechain_type : active_sidechain_types(db().head_block_time())){
+               son_sidechain_info ssi;
+               ssi.son_id = son.son_id;
+               ssi.weight = son.weight;
+               ssi.signing_key = son.signing_key;
+               ssi.public_key = son.sidechain_public_keys.at(active_sidechain_type);
+               sons[active_sidechain_type].emplace_back(std::move(ssi));
+            }
+         }
+         obj.sons = std::move(sons);
+      }
+      else{
+         obj.sons = *op.extensions.value.sidechain_sons;
+      }
    });
    return new_son_wallet_object.id;
 } FC_CAPTURE_AND_RETHROW( (op) ) }
@@ -63,8 +97,19 @@ void_result update_son_wallet_evaluator::do_evaluate(const son_wallet_update_ope
    FC_ASSERT(db().head_block_time() >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK");
    FC_ASSERT( op.payer == db().get_global_properties().parameters.son_account(), "SON paying account must be set as payer." );
 
+   const son_wallet_id_type son_wallet_id = [&]{
+      if(db().head_block_time() >= HARDFORK_SON_FOR_ETHEREUM_TIME)
+      {
+         const auto ast = active_sidechain_types(db().head_block_time());
+         const auto id = (op.son_wallet_id.instance.value - std::distance(ast.begin(), ast.find(op.sidechain))) / ast.size();
+         return son_wallet_id_type{ id };
+      }
+
+      return op.son_wallet_id;
+   }();
+
    const auto& idx = db().get_index_type<son_wallet_index>().indices().get<by_id>();
-   FC_ASSERT( idx.find(op.son_wallet_id) != idx.end() );
+   FC_ASSERT( idx.find(son_wallet_id) != idx.end() );
    //auto itr = idx.find(op.son_wallet_id);
    //FC_ASSERT( itr->addresses.find(op.sidechain) == itr->addresses.end() ||
    //        itr->addresses.at(op.sidechain).empty(), "Sidechain wallet address already set");
@@ -73,8 +118,19 @@ void_result update_son_wallet_evaluator::do_evaluate(const son_wallet_update_ope
 
 object_id_type update_son_wallet_evaluator::do_apply(const son_wallet_update_operation& op)
 { try {
+   const son_wallet_id_type son_wallet_id = [&]{
+      if(db().head_block_time() >= HARDFORK_SON_FOR_ETHEREUM_TIME)
+      {
+         const auto ast = active_sidechain_types(db().head_block_time());
+         const auto id = (op.son_wallet_id.instance.value - std::distance(ast.begin(), ast.find(op.sidechain))) / ast.size();
+         return son_wallet_id_type{ id };
+      }
+
+      return op.son_wallet_id;
+   }();
+
    const auto& idx = db().get_index_type<son_wallet_index>().indices().get<by_id>();
-   auto itr = idx.find(op.son_wallet_id);
+   auto itr = idx.find(son_wallet_id);
    if (itr != idx.end())
    {
       if (itr->addresses.find(op.sidechain) == itr->addresses.end()) {

libraries/chain/son_wallet_withdraw_evaluator.cpp

@@ -10,12 +10,13 @@ namespace graphene { namespace chain {
 
 void_result create_son_wallet_withdraw_evaluator::do_evaluate(const son_wallet_withdraw_create_operation& op)
 { try {
-   FC_ASSERT(db().head_block_time() >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK");
-
+   const auto now = db().head_block_time();
+   FC_ASSERT(now >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK");
    const auto &son_idx = db().get_index_type<son_index>().indices().get<by_id>();
    const auto so = son_idx.find(op.son_id);
    FC_ASSERT(so != son_idx.end(), "SON not found");
    FC_ASSERT(so->son_account == op.payer, "Payer is not SON account owner");
+   FC_ASSERT(!(op.sidechain == sidechain_type::peerplays && now >= HARDFORK_SON_FOR_ETHEREUM_TIME), "Peerplays sidechain type is not allowed");
 
    const auto &ss_idx = db().get_index_type<son_stats_index>().indices().get<by_owner>();
    FC_ASSERT(ss_idx.find(op.son_id) != ss_idx.end(), "Statistic object for a given SON ID does not exists");
@@ -23,9 +24,17 @@ void_result create_son_wallet_withdraw_evaluator::do_evaluate(const son_wallet_w
    const auto &swwo_idx = db().get_index_type<son_wallet_withdraw_index>().indices().get<by_peerplays_uid>();
    const auto swwo = swwo_idx.find(op.peerplays_uid);
    if (swwo == swwo_idx.end()) {
+      const sidechain_type sidechain = [&op]{
+         if(op.sidechain == sidechain_type::peerplays){
+            return op.withdraw_sidechain;
+         }
+         else
+            return op.sidechain;
+      }();
+
       const auto &gpo = db().get_global_properties();
       bool expected = false;
-      for (auto &si : gpo.active_sons.at(op.sidechain)) {
+      for (auto &si : gpo.active_sons.at(sidechain)) {
          if (op.son_id == si.son_id) {
             expected = true;
             break;
@@ -76,8 +85,16 @@ object_id_type create_son_wallet_withdraw_evaluator::do_apply(const son_wallet_w
          swwo.withdraw_currency = op.withdraw_currency;
          swwo.withdraw_amount = op.withdraw_amount;
 
+         const sidechain_type sidechain = [&op]{
+            if(op.sidechain == sidechain_type::peerplays){
+               return op.withdraw_sidechain;
+            }
+            else
+               return op.sidechain;
+         }();
+
          const auto &gpo = db().get_global_properties();
-         for (auto &si : gpo.active_sons.at(op.sidechain)) {
+         for (auto &si : gpo.active_sons.at(sidechain)) {
             swwo.expected_reports.insert(std::make_pair(si.son_id, si.weight));
 
             auto stats_itr = db().get_index_type<son_stats_index>().indices().get<by_owner>().find(si.son_id);
@@ -138,13 +155,17 @@ object_id_type create_son_wallet_withdraw_evaluator::do_apply(const son_wallet_w
 
 void_result process_son_wallet_withdraw_evaluator::do_evaluate(const son_wallet_withdraw_process_operation& op)
 { try{
-   FC_ASSERT(db().head_block_time() >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK");
+   const auto now = db().head_block_time();
+   FC_ASSERT(now >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK");
    FC_ASSERT( op.payer == db().get_global_properties().parameters.son_account(), "SON paying account must be set as payer." );
 
    const auto& idx = db().get_index_type<son_wallet_withdraw_index>().indices().get<by_id>();
    const auto& itr = idx.find(op.son_wallet_withdraw_id);
    FC_ASSERT(itr != idx.end(), "Son wallet withdraw not found");
-   FC_ASSERT(db().get_global_properties().active_sons.at(itr->sidechain).size() >= db().get_chain_properties().immutable_parameters.min_son_count, "Min required voted SONs not present");
+   FC_ASSERT(!(itr->sidechain == sidechain_type::peerplays && now >= HARDFORK_SON_FOR_ETHEREUM_TIME), "Peerplays sidechain type is not allowed");
+   if(itr->sidechain != sidechain_type::peerplays) {
+      FC_ASSERT(db().get_global_properties().active_sons.at(itr->sidechain).size() >= db().get_chain_properties().immutable_parameters.min_son_count, "Min required voted SONs not present");
+   }
    FC_ASSERT(!itr->processed, "Son wallet withdraw is already processed");
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }

libraries/db/include/graphene/db/object_database.hpp

@@ -29,6 +29,7 @@
 #include <fc/log/logger.hpp>
 
 #include <map>
+#include <mutex>
 
 namespace graphene { namespace db {
 
@@ -144,6 +145,7 @@ namespace graphene { namespace db {
          fc::path get_data_dir()const { return _data_dir; }
 
          /** public for testing purposes only... should be private in practice. */
+         mutable std::mutex                     _undo_db_mutex;
          undo_database                          _undo_db;
      protected:
          template<typename IndexType>

libraries/plugins/account_history/account_history_plugin.cpp

@@ -85,6 +85,7 @@ void account_history_plugin_impl::update_account_histories( const signed_block&
       vector<optional< operation_history_object > >& hist = db.get_applied_operations();
       bool is_first = true;
       auto skip_oho_id = [&is_first,&db,this]() {
+         const std::lock_guard<std::mutex> undo_db_lock{db._undo_db_mutex};
          if( is_first && db._undo_db.enabled() ) // this ensures that the current id is rolled back on undo
          {
             db.remove( db.create<operation_history_object>( []( operation_history_object& obj) {} ) );

libraries/plugins/debug_witness/CMakeLists.txt

@@ -16,3 +16,4 @@ install( TARGETS
    LIBRARY DESTINATION lib
    ARCHIVE DESTINATION lib
 )
+INSTALL( FILES ${HEADERS} DESTINATION "include/graphene/debug_witness" )

libraries/plugins/debug_witness/debug_api.cpp

@@ -34,7 +34,9 @@ class debug_api_impl
 };
 
 debug_api_impl::debug_api_impl( graphene::app::application& _app ) : app( _app )
-{}
+{
+   // Nothing else to do
+}
 
 
 void debug_api_impl::debug_push_blocks( const std::string& src_filename, uint32_t count )

libraries/plugins/debug_witness/debug_witness.cpp

@@ -38,7 +38,10 @@ using std::vector;
 
 namespace bpo = boost::program_options;
 
-debug_witness_plugin::~debug_witness_plugin() {}
+debug_witness_plugin::~debug_witness_plugin()
+{
+   cleanup();
+}
 
 void debug_witness_plugin::plugin_set_program_options(
    boost::program_options::options_description& command_line_options,
@@ -62,7 +65,7 @@ void debug_witness_plugin::plugin_initialize(const boost::program_options::varia
    ilog("debug_witness plugin:  plugin_initialize() begin");
    _options = &options;
 
-   if( options.count("debug-private-key") )
+   if( options.count("debug-private-key") > 0 )
    {
       const std::vector<std::string> key_id_to_wif_pair_strings = options["debug-private-key"].as<std::vector<std::string>>();
       for (const std::string& key_id_to_wif_pair_string : key_id_to_wif_pair_strings)
@@ -100,7 +103,6 @@ void debug_witness_plugin::plugin_startup()
    _changed_objects_conn = db.changed_objects.connect([this](const std::vector<graphene::db::object_id_type>& ids, const fc::flat_set<graphene::chain::account_id_type>& impacted_accounts){ on_changed_objects(ids, impacted_accounts); });
    _removed_objects_conn = db.removed_objects.connect([this](const std::vector<graphene::db::object_id_type>& ids, const std::vector<const graphene::db::object*>& objs, const fc::flat_set<graphene::chain::account_id_type>& impacted_accounts){ on_removed_objects(ids, objs, impacted_accounts); });
 
-   return;
 }
 
 void debug_witness_plugin::on_changed_objects( const std::vector<graphene::db::object_id_type>& ids, const fc::flat_set<graphene::chain::account_id_type>& impacted_accounts )
@@ -155,11 +157,15 @@ void debug_witness_plugin::flush_json_object_stream()
 }
 
 void debug_witness_plugin::plugin_shutdown()
+{
+   cleanup();
+}
+
+void debug_witness_plugin::cleanup()
 {
    if( _json_object_stream )
    {
       _json_object_stream->close();
       _json_object_stream.reset();
    }
-   return;
 }

libraries/plugins/debug_witness/include/graphene/debug_witness/debug_witness.hpp

@@ -34,23 +34,25 @@ namespace graphene { namespace debug_witness_plugin {
 
 class debug_witness_plugin : public graphene::app::plugin {
 public:
-   ~debug_witness_plugin();
+   using graphene::app::plugin::plugin;
+   ~debug_witness_plugin() override;
 
    std::string plugin_name()const override;
 
-   virtual void plugin_set_program_options(
+   void plugin_set_program_options(
       boost::program_options::options_description &command_line_options,
       boost::program_options::options_description &config_file_options
       ) override;
 
-   virtual void plugin_initialize( const boost::program_options::variables_map& options ) override;
-   virtual void plugin_startup() override;
-   virtual void plugin_shutdown() override;
+   void plugin_initialize( const boost::program_options::variables_map& options ) override;
+   void plugin_startup() override;
+   void plugin_shutdown() override;
 
    void set_json_object_stream( const std::string& filename );
    void flush_json_object_stream();
 
 private:
+   void cleanup();
 
    void on_changed_objects( const std::vector<graphene::db::object_id_type>& ids, const fc::flat_set<graphene::chain::account_id_type>& impacted_accounts );
    void on_removed_objects( const std::vector<graphene::db::object_id_type>& ids, const std::vector<const graphene::db::object*> objs, const fc::flat_set<graphene::chain::account_id_type>& impacted_accounts );
@@ -58,7 +60,7 @@ private:
 
    boost::program_options::variables_map _options;
 
-   std::map<chain::public_key_type, fc::ecc::private_key> _private_keys;
+   std::map<chain::public_key_type, fc::ecc::private_key, chain::pubkey_comparator> _private_keys;
 
    std::shared_ptr< std::ofstream > _json_object_stream;
    boost::signals2::scoped_connection _applied_block_conn;

libraries/plugins/elasticsearch/elasticsearch_plugin.cpp

@@ -127,6 +127,7 @@ bool elasticsearch_plugin_impl::update_account_histories( const signed_block& b
    const vector<optional< operation_history_object > >& hist = db.get_applied_operations();
    bool is_first = true;
    auto skip_oho_id = [&is_first,&db,this]() {
+      const std::lock_guard<std::mutex> undo_db_lock{db._undo_db_mutex};
       if( is_first && db._undo_db.enabled() ) // this ensures that the current id is rolled back on undo
       {
          db.remove( db.create<operation_history_object>( []( operation_history_object& obj) {} ) );

libraries/plugins/peerplays_sidechain/CMakeLists.txt

@@ -16,6 +16,8 @@ add_library( peerplays_sidechain
              bitcoin/segwit_addr.cpp
              bitcoin/utils.cpp
              bitcoin/sign_bitcoin_transaction.cpp
+             bitcoin/libbitcoin_client.cpp
+             bitcoin/estimate_fee_external.cpp
              common/rpc_client.cpp
              common/utils.cpp
              ethereum/encoders.cpp
@@ -42,7 +44,7 @@ endif()
 unset(ENABLE_PEERPLAYS_ASSET_DEPOSITS)
 unset(ENABLE_PEERPLAYS_ASSET_DEPOSITS CACHE)
 
-target_link_libraries( peerplays_sidechain PRIVATE graphene_plugin sha3 zmq )
+target_link_libraries( peerplays_sidechain PRIVATE curl graphene_plugin sha3 zmq bitcoin-system bitcoin-protocol bitcoin-client bitcoin-explorer )
 target_include_directories( peerplays_sidechain
                             PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" )
 

libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_address.cpp

@@ -242,12 +242,12 @@ bytes btc_multisig_segwit_address::get_address_bytes(const bytes &script_hash) {
 }
 
 btc_weighted_multisig_address::btc_weighted_multisig_address(const std::vector<std::pair<fc::ecc::public_key, uint16_t>> &keys_data,
-                                                             network ntype) {
+                                                             network ntype, payment_type type) {
    network_type = ntype;
+   this->type = type;
    create_redeem_script(keys_data);
    create_witness_script();
    create_segwit_address();
-   type = payment_type::P2WSH;
 }
 
 void btc_weighted_multisig_address::create_redeem_script(const std::vector<std::pair<fc::ecc::public_key, uint16_t>> &keys_data) {
@@ -278,26 +278,43 @@ void btc_weighted_multisig_address::create_witness_script() {
    script_builder builder;
    builder << op::_0;
    builder << fc::sha256::hash(redeem_script_.data(), redeem_script_.size());
-
    witness_script_ = builder;
 }
 
 void btc_weighted_multisig_address::create_segwit_address() {
    std::string hrp;
+   address_types byte_version;
    switch (network_type) {
    case (network::mainnet):
       hrp = "bc";
+      byte_version = address_types::MAINNET_SCRIPT;
       break;
    case (network::testnet):
       hrp = "tb";
+      byte_version = address_types::TESTNET_SCRIPT;
       break;
    case (network::regtest):
       hrp = "bcrt";
+      byte_version = address_types::TESTNET_SCRIPT;
       break;
    }
-   fc::sha256 sh = fc::sha256::hash(&redeem_script_[0], redeem_script_.size());
-   std::vector<uint8_t> hash_data(sh.data(), sh.data() + sh.data_size());
-   address = segwit_addr::encode(hrp, 0, hash_data);
+
+   if (type == payment_type::P2WSH) {
+      fc::sha256 sh = fc::sha256::hash(&redeem_script_[0], redeem_script_.size());
+      std::vector<uint8_t> hash_data(sh.data(), sh.data() + sh.data_size());
+      address = segwit_addr::encode(hrp, 0, hash_data);
+   } else if (type == payment_type::P2SH_WSH) {
+      fc::sha256 hash256 = fc::sha256::hash(&witness_script_[0], witness_script_.size());
+      fc::ripemd160 hash160 = fc::ripemd160::hash(hash256.data(), hash256.data_size());
+      raw_address = bytes(hash160.data(), hash160.data() + hash160.data_size());
+      bytes address_bytes(1, byte_version); // 1 byte version
+      address_bytes.insert(address_bytes.end(), raw_address.begin(), raw_address.end());
+      fc::sha256 hash256_1 = fc::sha256::hash(fc::sha256::hash(address_bytes.data(), address_bytes.size()));
+      address_bytes.insert(address_bytes.end(), hash256_1.data(), hash256_1.data() + 4); // 4 byte checksum
+      address = fc::to_base58(address_bytes);
+   } else {
+      wlog("Unsupported payment type of address");
+   }
 }
 
 btc_one_or_m_of_n_multisig_address::btc_one_or_m_of_n_multisig_address(const fc::ecc::public_key &user_key_data,
@@ -353,12 +370,12 @@ void btc_one_or_m_of_n_multisig_address::create_segwit_address() {
 
 btc_one_or_weighted_multisig_address::btc_one_or_weighted_multisig_address(const fc::ecc::public_key &user_key_data,
                                                                            const std::vector<std::pair<fc::ecc::public_key, uint16_t>> &keys_data,
-                                                                           bitcoin_address::network ntype) {
+                                                                           bitcoin_address::network ntype, payment_type type) {
    network_type = ntype;
+   this->type = type;
    create_redeem_script(user_key_data, keys_data);
    create_witness_script();
    create_segwit_address();
-   type = payment_type::P2WSH;
 }
 
 void btc_one_or_weighted_multisig_address::create_redeem_script(const fc::ecc::public_key &user_key_data, const std::vector<std::pair<fc::ecc::public_key, uint16_t>> &keys_data) {
@@ -398,20 +415,39 @@ void btc_one_or_weighted_multisig_address::create_witness_script() {
 
 void btc_one_or_weighted_multisig_address::create_segwit_address() {
    std::string hrp;
+   address_types byte_version;
    switch (network_type) {
    case (network::mainnet):
+      byte_version = address_types::MAINNET_SCRIPT;
       hrp = "bc";
       break;
    case (network::testnet):
+      byte_version = address_types::TESTNET_SCRIPT;
       hrp = "tb";
       break;
    case (network::regtest):
+      byte_version = address_types::TESTNET_SCRIPT;
       hrp = "bcrt";
       break;
    }
-   fc::sha256 sh = fc::sha256::hash(&redeem_script_[0], redeem_script_.size());
-   std::vector<uint8_t> hash_data(sh.data(), sh.data() + sh.data_size());
-   address = segwit_addr::encode(hrp, 0, hash_data);
+
+   if (type == payment_type::P2WSH) {
+      fc::sha256 sh = fc::sha256::hash(&redeem_script_[0], redeem_script_.size());
+      std::vector<uint8_t> hash_data(sh.data(), sh.data() + sh.data_size());
+      address = segwit_addr::encode(hrp, 0, hash_data);
+   } else if (type == payment_type::P2SH_WSH) {
+      fc::sha256 hash256 = fc::sha256::hash(&witness_script_[0], witness_script_.size());
+      fc::ripemd160 hash160 = fc::ripemd160::hash(hash256.data(), hash256.data_size());
+      raw_address = bytes(hash160.data(), hash160.data() + hash160.data_size());
+
+      bytes address_bytes(1, byte_version); // 1 byte version test net
+      address_bytes.insert(address_bytes.end(), raw_address.begin(), raw_address.end());
+      fc::sha256 hash256_1 = fc::sha256::hash(fc::sha256::hash(address_bytes.data(), address_bytes.size()));
+      address_bytes.insert(address_bytes.end(), hash256_1.data(), hash256_1.data() + 4); // 4 byte checksum
+      address = fc::to_base58(address_bytes);
+   } else {
+      elog("Unsupported payment type of address");
+   }
 }
 
 btc_timelocked_one_or_weighted_multisig_address::btc_timelocked_one_or_weighted_multisig_address(const fc::ecc::public_key &user_key_data, uint32_t latency, const std::vector<std::pair<fc::ecc::public_key, uint16_t>> &keys_data, bitcoin_address::network ntype) :

libraries/plugins/peerplays_sidechain/bitcoin/bitcoin_transaction.cpp

@@ -152,7 +152,7 @@ void bitcoin_transaction_builder::add_in(payment_type type, tx_in txin, const by
       txin.scriptSig = script_code;
       break;
    default: {
-      if (txin.prevout.hash == fc::sha256("0000000000000000000000000000000000000000000000000000000000000000")) { //coinbase
+      if (txin.prevout.hash == fc::sha256("0000000000000000000000000000000000000000000000000000000000000000")) { // coinbase
          FC_ASSERT(script_code != bytes());
          txin.scriptSig = script_code;
       }

libraries/plugins/peerplays_sidechain/bitcoin/estimate_fee_external.cpp

@@ -0,0 +1,157 @@
+
+#include <graphene/peerplays_sidechain/bitcoin/estimate_fee_external.hpp>
+
+#include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
+
+#include <fc/log/logger.hpp>
+
+#include <iostream>
+
+namespace graphene {
+namespace peerplays_sidechain {
+
+static size_t writeFunction(void *ptr, size_t size, size_t nmemb, std::string *data) {
+   data->append((char *)ptr, size * nmemb);
+   return size * nmemb;
+}
+
+estimate_fee_external::estimate_fee_external() {
+   curl = curl_easy_init();
+}
+
+estimate_fee_external::~estimate_fee_external() {
+   curl_easy_cleanup(curl);
+}
+
+std::vector<std::pair<std::string, uint64_t>> estimate_fee_external::get_fee_external(uint16_t target_block) {
+
+   std::vector<std::pair<std::string, uint64_t>> estimate_fee_external_collection;
+   this->target_block = target_block;
+
+   for (auto &url_fee_parser : url_get_fee_parsers) {
+      response = get_response(url_fee_parser.first);
+      uint64_t fee = url_fee_parser.second();
+      std::string url_str = url_fee_parser.first;
+      if (fee != 0) {
+         estimate_fee_external_collection.emplace_back(std::make_pair(url_fee_parser.first, fee));
+      }
+   }
+
+   return estimate_fee_external_collection;
+}
+
+std::string estimate_fee_external::get_response(std::string url) {
+
+   std::string response;
+   if (curl) {
+      curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+      curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+      curl_easy_setopt(curl, CURLOPT_USERPWD, "user:pass");
+      curl_easy_setopt(curl, CURLOPT_USERAGENT, "curl/7.42.0");
+      curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L);
+      curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L);
+      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeFunction);
+      curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
+      curl_easy_perform(curl);
+   }
+   return response;
+}
+
+uint64_t estimate_fee_external::parse_and_get_fee_1() {
+   //"https://www.bitgo.com/api/v2/btc/tx/fee"
+
+   uint64_t founded_fee = 0;
+
+   if (response.empty()) {
+      return founded_fee;
+   }
+
+   std::stringstream response_ss(response);
+   boost::property_tree::ptree response_pt;
+   boost::property_tree::read_json(response_ss, response_pt);
+
+   for (const auto &tx_child : response_pt.get_child("feeByBlockTarget")) {
+      const auto &block_num = tx_child.first.data();
+      const auto &fee = tx_child.second.data();
+
+      founded_fee = std::stoi(fee);
+
+      if (std::stoi(block_num) >= target_block) {
+         return founded_fee;
+      }
+   }
+
+   return founded_fee;
+}
+
+uint64_t estimate_fee_external::parse_and_get_fee_2() {
+   // https://bitcoiner.live/api/fees/estimates/latest
+   uint64_t founded_fee = 0;
+
+   if (response.empty()) {
+      return founded_fee;
+   }
+
+   std::stringstream response_ss(response);
+   boost::property_tree::ptree response_pt;
+   boost::property_tree::read_json(response_ss, response_pt);
+
+   for (const auto &tx_child : response_pt.get_child("estimates")) {
+      const auto &time_str = tx_child.first.data();
+
+      auto time = std::stoi(time_str);
+      auto block_num = time / 30;
+
+      if (tx_child.second.count("sat_per_vbyte")) {
+         auto founded_fee_str = tx_child.second.get_child("sat_per_vbyte").data();
+         founded_fee = std::stoi(founded_fee_str) * 1000;
+      }
+
+      if (block_num >= target_block) {
+         return founded_fee;
+      }
+   }
+
+   return founded_fee;
+}
+
+uint64_t estimate_fee_external::parse_and_get_fee_3() {
+   // https://api.blockchain.info/mempool/fees
+
+   if (response.empty()) {
+      return 0;
+   }
+
+   std::stringstream response_ss(response);
+   boost::property_tree::ptree response_pt;
+   boost::property_tree::read_json(response_ss, response_pt);
+
+   if (response_pt.get_child("limits").count("min") && response_pt.get_child("limits").count("max")) {
+      auto limits_min_str = response_pt.get_child("limits.min").data();
+      auto limits_max_str = response_pt.get_child("limits.max").data();
+
+      auto limits_min = std::stoi(limits_min_str);
+      auto limits_max = std::stoi(limits_max_str);
+
+      auto priority_max = (limits_max - (limits_min - 1)) / 2;
+
+      if (response_pt.count("regular") && response_pt.count("priority")) {
+         auto regular_str = response_pt.get_child("regular").data();
+         auto priority_str = response_pt.get_child("priority").data();
+
+         auto regular = std::stoi(regular_str);
+         auto priority = std::stoi(priority_str);
+
+         if (target_block >= priority_max) {
+            return regular * 1000;
+         } else {
+            return priority * 1000;
+         }
+      }
+   }
+
+   return 0;
+}
+
+}} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/bitcoin/libbitcoin_client.cpp

@@ -0,0 +1,227 @@
+
+#include <graphene/peerplays_sidechain/bitcoin/libbitcoin_client.hpp>
+
+#include <system_error>
+
+#include <bitcoin/explorer/config/transaction.hpp>
+#include <bitcoin/system/config/hash256.hpp>
+
+#include <boost/xpressive/xpressive.hpp>
+
+#include <fc/crypto/hex.hpp>
+#include <fc/log/logger.hpp>
+
+namespace graphene { namespace peerplays_sidechain {
+
+libbitcoin_client::libbitcoin_client(std::string url) :
+      obelisk_client(LIBBITCOIN_SERVER_TIMEOUT, LIBBITCOIN_SERVER_RETRIES) {
+
+   std::string reg_expr = "^((?P<Protocol>https|http|tcp):\\/\\/)?(?P<Host>[a-zA-Z0-9\\-\\.]+)(:(?P<Port>\\d{1,5}))?(?P<Target>\\/.+)?";
+   boost::xpressive::sregex sr = boost::xpressive::sregex::compile(reg_expr);
+
+   boost::xpressive::smatch sm;
+
+   if (boost::xpressive::regex_search(url, sm, sr)) {
+      protocol = sm["Protocol"];
+      if (protocol.empty()) {
+         protocol = "tcp";
+      }
+
+      host = sm["Host"];
+      if (host.empty()) {
+         host + "localhost";
+      }
+
+      port = sm["Port"];
+      if (port.empty()) {
+         port = "9091";
+      }
+   }
+
+   uint16_t port_num = std::stoi(port);
+   std::string final_url = protocol + "://" + host;
+
+   libbitcoin::config::endpoint address(final_url, port_num);
+
+   libbitcoin::client::connection_type connection;
+   connection.retries = LIBBITCOIN_SERVER_RETRIES;
+   connection.server = address;
+
+   if (!obelisk_client.connect(connection)) {
+      elog("Can't connect libbitcoin for url: ${url}", ("url", final_url));
+   }
+
+   is_connected = true;
+}
+
+std::string libbitcoin_client::send_transaction(std::string tx) {
+
+   std::string res;
+
+   auto error_handler = [&](const std::error_code &ec) {
+      elog("error on sending bitcoin transaction ${error_code}", ("error_code", ec.message()));
+   };
+
+   auto result_handler = [&](libbitcoin::code result_code) {
+      ilog("result code on sending transaction ${result_code}", ("result_code", result_code.message()));
+      res = std::to_string(result_code.value());
+   };
+
+   libbitcoin::explorer::config::transaction transaction(tx);
+
+   libbitcoin::chain::transaction trx;
+
+   // This validates the tx, submits it to local tx pool, and notifies peers.
+   obelisk_client.transaction_pool_broadcast(error_handler, result_handler, transaction);
+   obelisk_client.wait();
+
+   return res;
+}
+
+libbitcoin::chain::output::list libbitcoin_client::get_transaction(std::string tx_id, std::string &tx_hash, uint32_t &confirmitions) {
+
+   libbitcoin::chain::output::list outs;
+
+   auto error_handler = [&](const std::error_code &ec) {
+      elog("error on fetch_trx_by_hash: ${hash} ${error_code}", ("hash", tx_id)("error_code", ec.message()));
+   };
+
+   auto transaction_handler = [&](const libbitcoin::chain::transaction &tx_handler) {
+      tx_hash = libbitcoin::config::hash256(tx_handler.hash(false)).to_string();
+      // TODO try to find this value (confirmitions)
+      confirmitions = 1;
+      outs = tx_handler.outputs();
+   };
+
+   libbitcoin::hash_digest hash = libbitcoin::config::hash256(tx_id);
+
+   // obelisk_client.blockchain_fetch_transaction (error_handler, transaction_handler,hash);
+   obelisk_client.blockchain_fetch_transaction2(error_handler, transaction_handler, hash);
+
+   obelisk_client.wait();
+
+   return outs;
+}
+
+std::vector<list_unspent_replay> libbitcoin_client::listunspent(std::string address, double amount) {
+   std::vector<list_unspent_replay> result;
+
+   auto error_handler = [&](const std::error_code &ec) {
+      elog("error on list_unspent ${error_code}", ("error_code", ec.message()));
+   };
+
+   auto replay_handler = [&](const libbitcoin::chain::points_value &points) {
+      for (auto &point : points.points) {
+         list_unspent_replay output;
+         output.hash = libbitcoin::config::hash256(point.hash()).to_string();
+         output.value = point.value();
+         output.index = point.index();
+         result.emplace_back(output);
+      }
+   };
+
+   libbitcoin::wallet::payment_address payment_address(address);
+   uint64_t satoshi = 100000000 * amount;
+
+   obelisk_client.blockchain_fetch_unspent_outputs(error_handler,
+                                                   replay_handler, payment_address, satoshi, libbitcoin::wallet::select_outputs::algorithm::individual);
+
+   obelisk_client.wait();
+
+   return result;
+}
+
+bool libbitcoin_client::get_is_test_net() {
+
+   bool result = false;
+
+   auto error_handler = [&](const std::error_code &ec) {
+      elog("error on fetching genesis block ${error_code}", ("error_code", ec.message()));
+   };
+
+   auto block_header_handler = [&](const libbitcoin::chain::header &block_header) {
+      std::string hash_str = libbitcoin::config::hash256(block_header.hash()).to_string();
+      if (hash_str == GENESIS_TESTNET_HASH || hash_str == GENESIS_REGTEST_HASH) {
+         result = true;
+      }
+   };
+
+   obelisk_client.blockchain_fetch_block_header(error_handler, block_header_handler, 0);
+
+   obelisk_client.wait();
+   return result;
+}
+
+uint64_t libbitcoin_client::get_fee_from_trx(libbitcoin::chain::transaction trx) {
+   bool general_fee_est_error = false;
+
+   if (trx.is_coinbase()) {
+      return 0;
+   }
+
+   const auto total_output_value = trx.total_output_value();
+   // get the inputs and from inputs previous outputs
+   std::map<libbitcoin::hash_digest, std::vector<uint32_t>> prev_out_trxs;
+   for (auto &ins : trx.inputs()) {
+      const auto &prev_out = ins.previous_output();
+      prev_out_trxs[prev_out.hash()].emplace_back(prev_out.index());
+   }
+
+   // fetch the trx to get total input value
+   uint64_t total_input_value = 0;
+   auto transaction_handler = [&](const libbitcoin::chain::transaction &tx_handler) {
+      std::vector<uint32_t> indexes = prev_out_trxs[tx_handler.hash()];
+
+      for (auto &index : indexes) {
+         total_input_value += tx_handler.outputs()[index].value();
+      }
+   };
+
+   auto error_handler = [&](const std::error_code &ec) {
+      elog("error on fetching trx ${error_code}", ("error_code", ec.message()));
+      general_fee_est_error = true;
+   };
+
+   for (const auto &iter : prev_out_trxs) {
+      if (general_fee_est_error) {
+         break;
+      }
+
+      obelisk_client.blockchain_fetch_transaction2(error_handler, transaction_handler, iter.first);
+      obelisk_client.wait();
+   }
+
+   if (total_input_value >= total_output_value) {
+      return total_input_value - total_output_value;
+   } else {
+      // something is really wrong if this happens,so we are going to mark as an error
+      elog("On fee estimation something is wrong in total inputs and total outputs for trx hash: ${hash}",
+           ("hash", libbitcoin::config::hash256(trx.hash()).to_string()));
+      return 0;
+   }
+}
+
+uint64_t libbitcoin_client::get_average_fee_from_trxs(std::vector<libbitcoin::chain::transaction> trx_list) {
+   std::vector<uint64_t> fee_per_trxs;
+
+   for (auto &trx : trx_list) {
+
+      uint64_t fee = get_fee_from_trx(trx);
+      if (fee > 0) {
+         fee_per_trxs.emplace_back(fee);
+      }
+   }
+
+   uint64_t average_estimated_fee = 0;
+
+   if (fee_per_trxs.size()) {
+      for (const auto &fee : fee_per_trxs) {
+         average_estimated_fee += fee;
+      }
+
+      average_estimated_fee /= fee_per_trxs.size();
+   }
+
+   return average_estimated_fee;
+}
+}} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/common/rpc_client.cpp

@@ -18,10 +18,40 @@
 
 namespace graphene { namespace peerplays_sidechain {
 
-rpc_client::rpc_client(std::string _url, std::string _user, std::string _password, bool _debug_rpc_calls) :
-      url(_url),
-      user(_user),
-      password(_password),
+struct rpc_reply {
+   uint16_t status;
+   std::string body;
+};
+
+class rpc_connection {
+public:
+   rpc_connection(const rpc_credentials &_credentials, bool _debug_rpc_calls);
+
+   std::string send_post_request(std::string method, std::string params, bool show_log);
+   std::string get_url() const;
+
+protected:
+   rpc_credentials credentials;
+   bool debug_rpc_calls;
+
+   std::string protocol;
+   std::string host;
+   std::string port;
+   std::string target;
+   std::string authorization;
+
+   uint32_t request_id;
+
+private:
+   rpc_reply send_post_request(std::string body, bool show_log);
+
+   boost::beast::net::io_context ioc;
+   boost::beast::net::ip::tcp::resolver resolver;
+   boost::asio::ip::basic_resolver_results<boost::asio::ip::tcp> results;
+};
+
+rpc_connection::rpc_connection(const rpc_credentials &_credentials, bool _debug_rpc_calls) :
+      credentials(_credentials),
       debug_rpc_calls(_debug_rpc_calls),
       request_id(0),
       resolver(ioc) {
@@ -31,7 +61,7 @@ rpc_client::rpc_client(std::string _url, std::string _user, std::string _passwor
 
    boost::xpressive::smatch sm;
 
-   if (boost::xpressive::regex_search(url, sm, sr)) {
+   if (boost::xpressive::regex_search(credentials.url, sm, sr)) {
       protocol = sm["Protocol"];
       if (protocol.empty()) {
          protocol = "http";
@@ -52,60 +82,84 @@ rpc_client::rpc_client(std::string _url, std::string _user, std::string _passwor
          target = "/";
       }
 
-      authorization = "Basic " + base64_encode(user + ":" + password);
+      authorization = "Basic " + base64_encode(credentials.user + ":" + credentials.password);
 
       results = resolver.resolve(host, port);
 
    } else {
-      elog("Invalid URL: ${url}", ("url", url));
+      elog("Invalid URL: ${url}", ("url", credentials.url));
    }
 }
 
+std::string rpc_connection::get_url() const {
+   return credentials.url;
+}
+
 std::string rpc_client::retrieve_array_value_from_reply(std::string reply_str, std::string array_path, uint32_t idx) {
-   std::stringstream ss(reply_str);
-   boost::property_tree::ptree json;
-   boost::property_tree::read_json(ss, json);
-   if (json.find("result") == json.not_found()) {
+   if (reply_str.empty()) {
+      wlog("RPC call ${function}, empty reply string", ("function", __FUNCTION__));
       return "";
    }
 
-   auto json_result = json.get_child_optional("result");
-   if (json_result) {
-      boost::property_tree::ptree array_ptree = json_result.get();
-      if (!array_path.empty()) {
-         array_ptree = json_result.get().get_child(array_path);
+   try {
+      std::stringstream ss(reply_str);
+      boost::property_tree::ptree json;
+      boost::property_tree::read_json(ss, json);
+      if (json.find("result") == json.not_found()) {
+         return "";
       }
-      uint32_t array_el_idx = -1;
-      for (const auto &array_el : array_ptree) {
-         array_el_idx = array_el_idx + 1;
-         if (array_el_idx == idx) {
-            std::stringstream ss_res;
-            boost::property_tree::json_parser::write_json(ss_res, array_el.second);
-            return ss_res.str();
+
+      auto json_result = json.get_child_optional("result");
+      if (json_result) {
+         boost::property_tree::ptree array_ptree = json_result.get();
+         if (!array_path.empty()) {
+            array_ptree = json_result.get().get_child(array_path);
+         }
+         uint32_t array_el_idx = -1;
+         for (const auto &array_el : array_ptree) {
+            array_el_idx = array_el_idx + 1;
+            if (array_el_idx == idx) {
+               std::stringstream ss_res;
+               boost::property_tree::json_parser::write_json(ss_res, array_el.second);
+               return ss_res.str();
+            }
          }
       }
+   } catch (const boost::property_tree::json_parser::json_parser_error &e) {
+      wlog("RPC call ${function} failed: ${e}", ("function", __FUNCTION__)("e", e.what()));
    }
 
    return "";
 }
 
 std::string rpc_client::retrieve_value_from_reply(std::string reply_str, std::string value_path) {
-   std::stringstream ss(reply_str);
-   boost::property_tree::ptree json;
-   boost::property_tree::read_json(ss, json);
-   if (json.find("result") == json.not_found()) {
+   if (reply_str.empty()) {
+      wlog("RPC call ${function}, empty reply string", ("function", __FUNCTION__));
       return "";
    }
 
-   auto json_result = json.get_child_optional("result");
-   if (json_result) {
-      return json_result.get().get<std::string>(value_path);
+   try {
+      std::stringstream ss(reply_str);
+      boost::property_tree::ptree json;
+      boost::property_tree::read_json(ss, json);
+      if (json.find("result") == json.not_found()) {
+         return "";
+      }
+
+      auto json_result = json.get_child_optional("result");
+      if (json_result) {
+         return json_result.get().get<std::string>(value_path);
+      }
+
+      return json.get<std::string>("result");
+   } catch (const boost::property_tree::json_parser::json_parser_error &e) {
+      wlog("RPC call ${function} failed: ${e}", ("function", __FUNCTION__)("e", e.what()));
    }
 
-   return json.get<std::string>("result");
+   return "";
 }
 
-std::string rpc_client::send_post_request(std::string method, std::string params, bool show_log) {
+std::string rpc_connection::send_post_request(std::string method, std::string params, bool show_log) {
    std::stringstream body;
 
    request_id = request_id + 1;
@@ -118,29 +172,33 @@ std::string rpc_client::send_post_request(std::string method, std::string params
 
    body << " }";
 
-   const auto reply = send_post_request(body.str(), show_log);
+   try {
+      const auto reply = send_post_request(body.str(), show_log);
 
-   if (reply.body.empty()) {
-      wlog("RPC call ${function} failed", ("function", __FUNCTION__));
-      return "";
-   }
+      if (reply.body.empty()) {
+         wlog("RPC call ${function} failed", ("function", __FUNCTION__));
+         return "";
+      }
 
-   std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
-   boost::property_tree::ptree json;
-   boost::property_tree::read_json(ss, json);
+      std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
+      boost::property_tree::ptree json;
+      boost::property_tree::read_json(ss, json);
 
-   if (json.count("error") && !json.get_child("error").empty()) {
-      wlog("RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body.str())("msg", ss.str()));
-   }
+      if (json.count("error") && !json.get_child("error").empty()) {
+         wlog("RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body.str())("msg", ss.str()));
+      }
 
-   if (reply.status == 200) {
-      return ss.str();
+      if (reply.status == 200) {
+         return ss.str();
+      }
+   } catch (const boost::system::system_error &e) {
+      elog("RPC call ${function} failed: ${e}", ("function", __FUNCTION__)("e", e.what()));
    }
 
    return "";
 }
 
-rpc_reply rpc_client::send_post_request(std::string body, bool show_log) {
+rpc_reply rpc_connection::send_post_request(std::string body, bool show_log) {
 
    // These object is used as a context for ssl connection
    boost::asio::ssl::context ctx(boost::asio::ssl::context::tlsv12_client);
@@ -215,7 +273,7 @@ rpc_reply rpc_client::send_post_request(std::string body, bool show_log) {
    reply.body = rbody;
 
    if (show_log) {
-      ilog("### Request URL:    ${url}", ("url", url));
+      ilog("### Request URL:    ${url}", ("url", credentials.url));
       ilog("### Request:        ${body}", ("body", body));
       ilog("### Response:       ${rbody}", ("rbody", rbody));
    }
@@ -223,4 +281,113 @@ rpc_reply rpc_client::send_post_request(std::string body, bool show_log) {
    return reply;
 }
 
+rpc_client::rpc_client(sidechain_type _sidechain, const std::vector<rpc_credentials> &_credentials, bool _debug_rpc_calls, bool _simulate_connection_reselection) :
+      sidechain(_sidechain),
+      debug_rpc_calls(_debug_rpc_calls),
+      simulate_connection_reselection(_simulate_connection_reselection) {
+   FC_ASSERT(_credentials.size());
+   for (size_t i = 0; i < _credentials.size(); i++)
+      connections.push_back(new rpc_connection(_credentials[i], _debug_rpc_calls));
+   n_active_conn = 0;
+   if (connections.size() > 1)
+      schedule_connection_selection();
+}
+
+void rpc_client::schedule_connection_selection() {
+   fc::time_point now = fc::time_point::now();
+   static const int64_t time_to_next_conn_selection = 10 * 1000 * 1000; // 10 sec
+   fc::time_point next_wakeup = now + fc::microseconds(time_to_next_conn_selection);
+   connection_selection_task = fc::schedule([this] {
+      select_connection();
+   },
+                                            next_wakeup, "SON RPC connection selection");
+}
+
+void rpc_client::select_connection() {
+   FC_ASSERT(connections.size() > 1);
+
+   const std::lock_guard<std::mutex> lock(conn_mutex);
+
+   static const int t_limit = 5 * 1000 * 1000, // 5 sec
+         quality_diff_threshold = 10 * 1000;   // 10 ms
+
+   int best_n = -1;
+   int best_quality = -1;
+
+   std::vector<uint64_t> head_block_numbers;
+   head_block_numbers.resize(connections.size());
+
+   std::vector<int> qualities;
+   qualities.resize(connections.size());
+
+   for (size_t n = 0; n < connections.size(); n++) {
+      rpc_connection &conn = *connections[n];
+      int quality = 0;
+      head_block_numbers[n] = std::numeric_limits<uint64_t>::max();
+
+      // ping n'th node
+      if (debug_rpc_calls)
+         ilog("### Ping ${sidechain} node #${n}, ${url}", ("sidechain", fc::reflector<sidechain_type>::to_string(sidechain))("n", n)("url", conn.get_url()));
+      fc::time_point t_sent = fc::time_point::now();
+      uint64_t head_block_number = ping(conn);
+      fc::time_point t_received = fc::time_point::now();
+      int t = (t_received - t_sent).count();
+
+      // evaluate n'th node reply quality and switch to it if it's better
+      if (head_block_number != std::numeric_limits<uint64_t>::max()) {
+         if (simulate_connection_reselection)
+            t += rand() % 10;
+         FC_ASSERT(t != -1);
+         head_block_numbers[n] = head_block_number;
+         if (t < t_limit)
+            quality = t_limit - t; // the less time, the higher quality
+
+         // look for the best quality
+         if (quality > best_quality) {
+            best_n = n;
+            best_quality = quality;
+         }
+      }
+      qualities[n] = quality;
+   }
+
+   FC_ASSERT(best_n != -1 && best_quality != -1);
+   if (best_n != n_active_conn) { // if the best client is not the current one, ...
+      uint64_t active_head_block_number = head_block_numbers[n_active_conn];
+      if ((active_head_block_number == std::numeric_limits<uint64_t>::max()      // ...and the current one has no known head block...
+           || head_block_numbers[best_n] >= active_head_block_number)            // ...or the best client's head is more recent than the current, ...
+          && best_quality > qualities[n_active_conn] + quality_diff_threshold) { // ...and the new client's quality exceeds current more than by threshold
+         n_active_conn = best_n;                                                 // ...then select new one
+         if (debug_rpc_calls)
+            ilog("### Reselected ${sidechain} node to #${n}, ${url}", ("sidechain", fc::reflector<sidechain_type>::to_string(sidechain))("n", n_active_conn)("url", connections[n_active_conn]->get_url()));
+      }
+   }
+
+   schedule_connection_selection();
+}
+
+rpc_connection &rpc_client::get_active_connection() const {
+   return *connections[n_active_conn];
+}
+
+std::string rpc_client::send_post_request(std::string method, std::string params, bool show_log) {
+   const std::lock_guard<std::mutex> lock(conn_mutex);
+   return send_post_request(get_active_connection(), method, params, show_log);
+}
+
+std::string rpc_client::send_post_request(rpc_connection &conn, std::string method, std::string params, bool show_log) {
+   return conn.send_post_request(method, params, show_log);
+}
+
+rpc_client::~rpc_client() {
+   try {
+      if (connection_selection_task.valid())
+         connection_selection_task.cancel_and_wait(__FUNCTION__);
+   } catch (fc::canceled_exception &) {
+      // Expected exception. Move along.
+   } catch (fc::exception &e) {
+      edump((e.to_detail_string()));
+   }
+}
+
 }} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/common/utils.cpp

@@ -1,5 +1,6 @@
 #include <graphene/peerplays_sidechain/common/utils.hpp>
 
+#include <boost/algorithm/string.hpp>
 #include <boost/archive/iterators/base64_from_binary.hpp>
 #include <boost/archive/iterators/binary_from_base64.hpp>
 #include <boost/archive/iterators/transform_width.hpp>
@@ -47,4 +48,17 @@ std::string object_id_to_string(graphene::chain::object_id_type id) {
    return object_id;
 }
 
+graphene::chain::object_id_type string_to_object_id(const std::string &id) {
+   std::vector<std::string> strs;
+   boost::split(strs, id, boost::is_any_of("."));
+   if (strs.size() != 3) {
+      elog("Wrong object_id format: ${id}", ("id", id));
+      return graphene::chain::object_id_type{};
+   }
+
+   auto s = boost::lexical_cast<int>(strs.at(0));
+   auto t = boost::lexical_cast<int>(strs.at(1));
+   return graphene::chain::object_id_type{(uint8_t)s, (uint8_t)t, boost::lexical_cast<uint64_t>(strs.at(2))};
+}
+
 }} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/ethereum/decoders.cpp

@@ -5,8 +5,51 @@
 
 namespace graphene { namespace peerplays_sidechain { namespace ethereum {
 
-//! rlp_decoder
+//! base_decoder
+boost::multiprecision::uint256_t base_decoder::decode_uint256(const std::string &value) {
+   boost::multiprecision::uint256_t result = 0;
 
+   boost::multiprecision::uint256_t power(1);
+   uint8_t digit;
+   int pos = value.size() - 1;
+   while (pos >= 0) {
+      digit = 0;
+      if ('0' <= value[pos] && value[pos] <= '9') {
+         digit = value[pos] - '0';
+      } else if ('a' <= value[pos] && value[pos] <= 'z') {
+         digit = value[pos] - 'a' + 10;
+      }
+      result += digit * power;
+      pos--;
+      power *= 16;
+   }
+
+   return result;
+}
+
+std::string base_decoder::decode_address(const std::string &value) {
+   return value.substr(24, 40);
+}
+
+//! deposit_erc20_decoder
+const std::string deposit_erc20_decoder::function_signature = "97feb926"; //! depositERC20(address,uint256)
+fc::optional<deposit_erc20_transaction> deposit_erc20_decoder::decode(const std::string &input) {
+   const auto input_without_0x = remove_0x(input);
+   if (function_signature != input_without_0x.substr(0, 8)) {
+      return fc::optional<deposit_erc20_transaction>{};
+   }
+   if (input_without_0x.size() != 136) {
+      return fc::optional<deposit_erc20_transaction>{};
+   }
+
+   deposit_erc20_transaction erc_20;
+   erc_20.token = add_0x(base_decoder::decode_address(input_without_0x.substr(8, 64)));
+   erc_20.amount = base_decoder::decode_uint256(input_without_0x.substr(72, 64));
+
+   return erc_20;
+}
+
+//! rlp_decoder
 namespace {
 const signed char p_util_hexdigit[256] =
       {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

libraries/plugins/peerplays_sidechain/ethereum/encoders.cpp

@@ -2,7 +2,6 @@
 
 #include <boost/algorithm/hex.hpp>
 #include <boost/format.hpp>
-#include <stdlib.h>
 
 #include <graphene/peerplays_sidechain/ethereum/utils.hpp>
 
@@ -19,13 +18,17 @@ std::string base_encoder::encode_address(const std::string &value) {
 
 std::string base_encoder::encode_string(const std::string &value) {
    std::string data = (boost::format("%x") % boost::io::group(std::setw(64), std::setfill('0'), value.size())).str();
-   data += boost::algorithm::hex(value) + std::string((64 - value.size() * 2 % 64), '0');
+   data += boost::algorithm::hex(value);
+   if (value.size() % 32 != 0) {
+      data += std::string((64 - value.size() * 2 % 64), '0');
+   }
    return data;
 }
 
 //! update_owners_encoder
-std::string update_owners_encoder::encode(const std::vector<std::pair<std::string, uint16_t>> &owners_weights, const std::string &object_id) const {
-   std::string data = "0x" + function_signature;
+const std::string update_owners_encoder::function_signature = "23ab6adf"; //! updateOwners((address,uint256)[],string)
+std::string update_owners_encoder::encode(const std::vector<std::pair<std::string, uint16_t>> &owners_weights, const std::string &object_id) {
+   std::string data = add_0x(function_signature);
    data += base_encoder::encode_uint256(64);
    data += base_encoder::encode_uint256((owners_weights.size() * 2 + 3) * 32);
    data += base_encoder::encode_uint256(owners_weights.size());
@@ -39,8 +42,9 @@ std::string update_owners_encoder::encode(const std::vector<std::pair<std::strin
 }
 
 //! withdrawal_encoder
-std::string withdrawal_encoder::encode(const std::string &to, boost::multiprecision::uint256_t amount, const std::string &object_id) const {
-   std::string data = "0x" + function_signature;
+const std::string withdrawal_encoder::function_signature = "e088747b"; //! withdraw(address,uint256,string)
+std::string withdrawal_encoder::encode(const std::string &to, boost::multiprecision::uint256_t amount, const std::string &object_id) {
+   std::string data = add_0x(function_signature);
    data += base_encoder::encode_address(to);
    data += base_encoder::encode_uint256(amount);
    data += base_encoder::encode_uint256(32 * 3);
@@ -49,6 +53,70 @@ std::string withdrawal_encoder::encode(const std::string &to, boost::multiprecis
    return data;
 }
 
+//! withdrawal_erc20_encoder
+const std::string withdrawal_erc20_encoder::function_signature = "483c0467"; //! withdrawERC20(address,address,uint256,string)
+std::string withdrawal_erc20_encoder::encode(const std::string &token, const std::string &to, boost::multiprecision::uint256_t amount, const std::string &object_id) {
+   std::string data = add_0x(function_signature);
+   data += base_encoder::encode_address(token);
+   data += base_encoder::encode_address(to);
+   data += base_encoder::encode_uint256(amount);
+   data += base_encoder::encode_uint256(32 * 4);
+   data += base_encoder::encode_string(object_id);
+
+   return data;
+}
+
+//! signature_encoder
+const std::string update_owners_function_signature = "9d608673";    //! updateOwners((bytes,(uint8,bytes32,bytes32))[])
+const std::string withdrawal_function_signature = "daac6c81";       //! withdraw((bytes,(uint8,bytes32,bytes32))[])
+const std::string withdrawal_erc20_function_signature = "d2bf2866"; //! withdrawERC20((bytes,(uint8,bytes32,bytes32))[])
+signature_encoder::signature_encoder(const std::string &function_hash) :
+      function_signature{function_hash} {
+}
+
+std::string signature_encoder::get_function_signature_from_transaction(const std::string &transaction) {
+   const std::string tr = remove_0x(transaction);
+   if (tr.substr(0, 8) == update_owners_encoder::function_signature)
+      return update_owners_function_signature;
+
+   if (tr.substr(0, 8) == withdrawal_encoder::function_signature)
+      return withdrawal_function_signature;
+
+   if (tr.substr(0, 8) == withdrawal_erc20_encoder::function_signature)
+      return withdrawal_erc20_function_signature;
+
+   return "";
+}
+
+std::string signature_encoder::encode(const std::vector<encoded_sign_transaction> &transactions) const {
+   std::string data = add_0x(function_signature);
+   data += base_encoder::encode_uint256(32);
+   data += base_encoder::encode_uint256(transactions.size());
+   size_t offset = (transactions.size()) * 32;
+   for (const auto &transaction : transactions) {
+      data += base_encoder::encode_uint256(offset);
+      const auto transaction_data = remove_0x(transaction.data);
+      offset += 5 * 32 + transaction_data.size() / 2;
+      if (transaction_data.size() / 2 % 32 != 0) {
+         offset += 32 - transaction_data.size() / 2 % 32;
+      }
+   }
+   for (const auto &transaction : transactions) {
+      data += base_encoder::encode_uint256(4 * 32);
+      data += base_encoder::encode_address(transaction.sign.v);
+      data += base_encoder::encode_address(transaction.sign.r);
+      data += base_encoder::encode_address(transaction.sign.s);
+      const auto transaction_data = remove_0x(transaction.data);
+      data += base_encoder::encode_uint256(transaction_data.size() / 2);
+      data += transaction_data;
+      if (transaction_data.size() % 64 != 0) {
+         data += std::string((64 - transaction_data.size() % 64), '0');
+      }
+   }
+
+   return data;
+}
+
 //! rlp_encoder
 std::string rlp_encoder::encode(const std::string &s) {
    return encode_rlp(hex2bytes(s));
@@ -69,8 +137,9 @@ std::string rlp_encoder::encode_length(int len, int offset) {
 
 std::string rlp_encoder::hex2bytes(const std::string &s) {
    std::string dest;
-   dest.resize(s.size() / 2);
-   hex2bin(s.c_str(), &dest[0]);
+   const auto s_final = s.size() % 2 == 0 ? s : "0" + s;
+   dest.resize(s_final.size() / 2);
+   hex2bin(s_final.c_str(), &dest[0]);
    return dest;
 }
 

libraries/plugins/peerplays_sidechain/ethereum/transaction.cpp

@@ -22,7 +22,43 @@ const secp256k1_context *eth_context() {
    return ctx;
 }
 
-//! transaction
+bytes keccak_hash(const std::string &data) {
+   bytes hash;
+   hash.resize(32);
+   const auto transaction_string = boost::algorithm::unhex(remove_0x(data));
+   keccak_256((const unsigned char *)transaction_string.data(), transaction_string.size(), (unsigned char *)hash.data());
+
+   return hash;
+}
+
+signature sign_hash(const bytes &hash, const std::string &chain_id, const std::string &private_key) {
+   const bytes priv_key = parse_hex(private_key);
+
+   int recid = 0;
+   secp256k1_ecdsa_recoverable_signature sig;
+   FC_ASSERT(secp256k1_ecdsa_sign_recoverable(eth_context(), &sig, (const unsigned char *)hash.data(), (const unsigned char *)priv_key.data(), NULL, NULL));
+   fc::ecc::compact_signature result;
+   FC_ASSERT(secp256k1_ecdsa_recoverable_signature_serialize_compact(eth_context(), (unsigned char *)result.begin() + 1, &recid, &sig));
+
+   unsigned int v = recid + from_hex<unsigned int>(chain_id) * 2 + 35;
+
+   bytes r;
+   for (int i = 1; i < 33; i++)
+      r.emplace_back((char)result.at(i));
+
+   bytes s;
+   for (int i = 33; i < 65; i++)
+      s.emplace_back((char)result.at(i));
+
+   signature eth_sig;
+   eth_sig.v = to_hex(v);
+   eth_sig.r = fc::to_hex((char *)&r[0], r.size());
+   eth_sig.s = fc::to_hex((char *)&s[0], s.size());
+
+   return eth_sig;
+}
+
+//! base_transaction
 
 base_transaction::base_transaction(const std::string &raw_tx) {
 }
@@ -70,12 +106,7 @@ raw_transaction::raw_transaction(const std::string &raw_tx) :
 }
 
 bytes raw_transaction::hash() const {
-   bytes hash;
-   hash.resize(32);
-   const auto transaction_string = boost::algorithm::unhex(remove_0x(serialize()));
-   keccak_256((const unsigned char *)transaction_string.data(), transaction_string.size(), (unsigned char *)hash.data());
-
-   return hash;
+   return keccak_hash(serialize());
 }
 
 signed_transaction raw_transaction::sign(const std::string &private_key) const {
@@ -88,27 +119,10 @@ signed_transaction raw_transaction::sign(const std::string &private_key) const {
    tr.value = value;
    tr.data = data;
 
-   const bytes priv_key = parse_hex(private_key);
-
-   int recid = 0;
-   secp256k1_ecdsa_recoverable_signature sig;
-   FC_ASSERT(secp256k1_ecdsa_sign_recoverable(eth_context(), &sig, (const unsigned char *)hash().data(), (const unsigned char *)priv_key.data(), NULL, NULL));
-   fc::ecc::compact_signature result;
-   FC_ASSERT(secp256k1_ecdsa_recoverable_signature_serialize_compact(eth_context(), (unsigned char *)result.begin() + 1, &recid, &sig));
-
-   bytes r;
-   for (int i = 1; i < 33; i++)
-      r.emplace_back((char)result.at(i));
-
-   bytes v = bytes{char(recid + from_hex<int>(chain_id) * 2 + 35)};
-
-   bytes s;
-   for (int i = 33; i < 65; i++)
-      s.emplace_back((char)result.at(i));
-
-   tr.r = fc::to_hex((char *)&r[0], r.size());
-   tr.v = fc::to_hex((char *)&v[0], v.size());
-   tr.s = fc::to_hex((char *)&s[0], s.size());
+   const auto sig = sign_hash(hash(), chain_id, private_key);
+   tr.v = sig.v;
+   tr.r = sig.r;
+   tr.s = sig.s;
 
    return tr;
 }
@@ -157,8 +171,8 @@ signed_transaction::signed_transaction(const std::string &raw_tx) :
 std::string signed_transaction::recover(const std::string &chain_id) const {
    fc::ecc::compact_signature input64;
    fc::from_hex(r, (char *)&input64.at(1), 32);
-   fc::from_hex(v, (char *)&input64.at(0), 1);
-   int recid = input64.at(0) - from_hex<int>(chain_id) * 2 - 35;
+   const int recid = from_hex<unsigned int>(v) - from_hex<unsigned int>(chain_id) * 2 - 35;
+   fc::from_hex(std::to_string(recid), (char *)&input64.at(0), 1);
    fc::from_hex(s, (char *)&input64.at(33), 32);
 
    secp256k1_ecdsa_recoverable_signature sig;
@@ -196,8 +210,8 @@ std::string signed_transaction::serialize() const {
                                   rlp_encoder::encode(remove_0x(value)) +
                                   rlp_encoder::encode(remove_0x(data)) +
                                   rlp_encoder::encode(remove_0x(v)) +
-                                  rlp_encoder::encode(remove_0x(r)) +
-                                  rlp_encoder::encode(remove_0x(s));
+                                  rlp_encoder::encode(remove_leading_00(remove_0x(r))) +
+                                  rlp_encoder::encode(remove_leading_00(remove_0x(s)));
 
    return add_0x(bytes2hex(rlp_encoder::encode_length(serialized.size(), 192) + serialized));
 }
@@ -220,9 +234,9 @@ void signed_transaction::deserialize(const std::string &raw_tx) {
    boost::algorithm::to_lower(data);
    v = add_0x(rlp_array.at(6));
    boost::algorithm::to_lower(v);
-   r = add_0x(rlp_array.at(7));
+   r = add_0x(add_leading_00(rlp_array.at(7)));
    boost::algorithm::to_lower(r);
-   s = add_0x(rlp_array.at(8));
+   s = add_0x(add_leading_00(rlp_array.at(8)));
    boost::algorithm::to_lower(s);
 }
 

libraries/plugins/peerplays_sidechain/ethereum/types.cpp

@@ -1,5 +1,36 @@
 #include <graphene/peerplays_sidechain/ethereum/types.hpp>
 
+#include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
+
 namespace graphene { namespace peerplays_sidechain { namespace ethereum {
 
+signature::signature(const std::string &sign) {
+   deserialize(sign);
+}
+
+std::string signature::serialize() const {
+   boost::property_tree::ptree pt;
+   pt.put("v", v);
+   pt.put("r", r);
+   pt.put("s", s);
+
+   std::stringstream ss;
+   boost::property_tree::json_parser::write_json(ss, pt);
+   return ss.str();
+}
+
+void signature::deserialize(const std::string &raw_tx) {
+   std::stringstream ss_tx(raw_tx);
+   boost::property_tree::ptree tx_json;
+   boost::property_tree::read_json(ss_tx, tx_json);
+
+   if (tx_json.count("v"))
+      v = tx_json.get<std::string>("v");
+   if (tx_json.count("r"))
+      r = tx_json.get<std::string>("r");
+   if (tx_json.count("s"))
+      s = tx_json.get<std::string>("s");
+}
+
 }}} // namespace graphene::peerplays_sidechain::ethereum

libraries/plugins/peerplays_sidechain/ethereum/utils.cpp

@@ -49,4 +49,24 @@ std::string remove_0x(const std::string &s) {
    return s;
 }
 
+std::string add_leading_00(const std::string &s) {
+   std::string result = s;
+
+   while (result.size() < 64) {
+      result = "00" + result;
+   }
+
+   return result;
+}
+
+std::string remove_leading_00(const std::string &s) {
+   std::string result = s;
+
+   while (result.size() > 1 && result.substr(0, 2) == "00") {
+      result = result.substr(2);
+   }
+
+   return result;
+}
+
 }}} // namespace graphene::peerplays_sidechain::ethereum

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/bitcoin_address.hpp

@@ -8,6 +8,14 @@ using namespace graphene::chain;
 namespace graphene { namespace peerplays_sidechain { namespace bitcoin {
 
 const bytes op_num = {0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f}; // OP_1 - OP_15
+enum address_types { MAINNET_SCRIPT = 5,
+                     TESTNET_SCRIPT = 196 };
+
+enum script_op {
+   OP_0 = 0x00,
+   OP_PUSH = 0x20,
+   OP_SIZE_34 = 0x22
+};
 
 class bitcoin_address {
 
@@ -96,9 +104,6 @@ private:
    void create_address();
 
 public:
-   enum address_types { MAINNET_SCRIPT = 5,
-                        TESTNET_SCRIPT = 196 };
-
    enum { OP_0 = 0x00,
           OP_EQUAL = 0x87,
           OP_HASH160 = 0xa9,
@@ -145,7 +150,7 @@ public:
    btc_weighted_multisig_address() = default;
 
    btc_weighted_multisig_address(const std::vector<std::pair<fc::ecc::public_key, uint16_t>> &keys_data,
-                                 network network_type = network::regtest);
+                                 network network_type = network::regtest, payment_type type = payment_type::P2SH_WSH);
 
    bytes get_redeem_script() const {
       return redeem_script_;
@@ -190,7 +195,7 @@ class btc_one_or_weighted_multisig_address : public bitcoin_address {
 public:
    btc_one_or_weighted_multisig_address() = default;
    btc_one_or_weighted_multisig_address(const fc::ecc::public_key &user_key_data, const std::vector<std::pair<fc::ecc::public_key, uint16_t>> &keys_data,
-                                        network network_type = network::regtest);
+                                        network network_type = network::regtest, payment_type type = payment_type::P2SH_WSH);
    bytes get_redeem_script() const {
       return redeem_script_;
    }

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/estimate_fee_external.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <curl/curl.h>
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+#include <vector>
+
+typedef std::function<uint64_t()> get_fee_func_type;
+
+namespace graphene { namespace peerplays_sidechain {
+
+class estimate_fee_external {
+public:
+   estimate_fee_external();
+   ~estimate_fee_external();
+   std::vector<std::pair<std::string, uint64_t>> get_fee_external(uint16_t target_block);
+
+private:
+   std::string get_response(std::string url);
+   // Here add your custom parser for external url. Take care of incremental name
+   // and populate the list of url_parsers bellow paired with the function
+   uint64_t parse_and_get_fee_1();
+   uint64_t parse_and_get_fee_2();
+   uint64_t parse_and_get_fee_3();
+
+   const std::map<std::string, get_fee_func_type> url_get_fee_parsers{
+         {"https://www.bitgo.com/api/v2/btc/tx/fee", std::bind(&estimate_fee_external::parse_and_get_fee_1, this)},
+         {"https://bitcoiner.live/api/fees/estimates/latest", std::bind(&estimate_fee_external::parse_and_get_fee_2, this)},
+         {"https://api.blockchain.info/mempool/fees", std::bind(&estimate_fee_external::parse_and_get_fee_3, this)}};
+
+   std::string response;
+   uint16_t target_block;
+   CURL *curl{nullptr};
+};
+
+}} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/libbitcoin_client.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <bitcoin/client/obelisk_client.hpp>
+#include <bitcoin/client/socket_stream.hpp>
+#include <bitcoin/system/chain/block.hpp>
+
+#include <boost/signals2.hpp>
+#include <mutex>
+
+#define LIBBITCOIN_SERVER_TIMEOUT (10)
+#define LIBBITCOIN_SERVER_RETRIES (100)
+#define DEAFULT_LIBBITCOIN_TRX_FEE (20000)
+#define MAX_TRXS_IN_MEMORY_POOL (30000)
+#define MIN_TRXS_IN_BUCKET (100)
+
+#define GENESIS_MAINNET_HASH "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
+#define GENESIS_TESTNET_HASH "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"
+#define GENESIS_REGTEST_HASH "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"
+
+namespace graphene { namespace peerplays_sidechain {
+
+typedef std::function<void(const libbitcoin::chain::block &)>
+      block_update_handler;
+
+struct list_unspent_replay {
+   std::string hash;
+   uint64_t value;
+   uint32_t index;
+};
+
+class libbitcoin_client {
+public:
+   libbitcoin_client(std::string url);
+   std::string send_transaction(const std::string tx);
+   libbitcoin::chain::output::list get_transaction(std::string tx_id, std::string &tx_hash, uint32_t &confirmitions);
+   std::vector<list_unspent_replay> listunspent(std::string address, double amount);
+   uint64_t get_average_fee_from_trxs(std::vector<libbitcoin::chain::transaction> trx_list);
+   uint64_t get_fee_from_trx(libbitcoin::chain::transaction trx);
+   bool get_is_test_net();
+
+private:
+   libbitcoin::client::obelisk_client obelisk_client;
+   libbitcoin::protocol::zmq::identifier id;
+
+   std::string protocol;
+   std::string host;
+   std::string port;
+   std::string url;
+
+   bool is_connected = false;
+};
+
+}} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/bitcoin/utils.hpp

@@ -1,4 +1,5 @@
 #pragma once
+
 #include <fc/crypto/elliptic.hpp>
 #include <fc/crypto/hex.hpp>
 #include <graphene/peerplays_sidechain/bitcoin/types.hpp>

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/common/rpc_client.hpp

@@ -3,44 +3,52 @@
 #include <cstdint>
 #include <string>
 
+#include <fc/thread/future.hpp>
+#include <fc/thread/thread.hpp>
+
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/beast/core.hpp>
 
+#include <graphene/peerplays_sidechain/defs.hpp>
+
 namespace graphene { namespace peerplays_sidechain {
 
-struct rpc_reply {
-   uint16_t status;
-   std::string body;
+class rpc_connection;
+
+struct rpc_credentials {
+   std::string url;
+   std::string user;
+   std::string password;
 };
 
 class rpc_client {
 public:
-   rpc_client(std::string _url, std::string _user, std::string _password, bool _debug_rpc_calls);
+   const sidechain_type sidechain;
+
+   rpc_client(sidechain_type _sidechain, const std::vector<rpc_credentials> &_credentials, bool _debug_rpc_calls, bool _simulate_connection_reselection);
+   ~rpc_client();
 
 protected:
-   std::string retrieve_array_value_from_reply(std::string reply_str, std::string array_path, uint32_t idx);
-   std::string retrieve_value_from_reply(std::string reply_str, std::string value_path);
+   bool debug_rpc_calls;
+   bool simulate_connection_reselection;
    std::string send_post_request(std::string method, std::string params, bool show_log);
 
-   std::string url;
-   std::string user;
-   std::string password;
-   bool debug_rpc_calls;
+   static std::string send_post_request(rpc_connection &conn, std::string method, std::string params, bool show_log);
 
-   std::string protocol;
-   std::string host;
-   std::string port;
-   std::string target;
-   std::string authorization;
-
-   uint32_t request_id;
+   static std::string retrieve_array_value_from_reply(std::string reply_str, std::string array_path, uint32_t idx);
+   static std::string retrieve_value_from_reply(std::string reply_str, std::string value_path);
 
 private:
-   rpc_reply send_post_request(std::string body, bool show_log);
+   std::vector<rpc_connection *> connections;
+   int n_active_conn;
+   fc::future<void> connection_selection_task;
+   std::mutex conn_mutex;
 
-   boost::beast::net::io_context ioc;
-   boost::beast::net::ip::tcp::resolver resolver;
-   boost::asio::ip::basic_resolver_results<boost::asio::ip::tcp> results;
+   rpc_connection &get_active_connection() const;
+
+   void select_connection();
+   void schedule_connection_selection();
+   virtual uint64_t ping(rpc_connection &conn) const = 0;
 };
 
 }} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/common/utils.hpp

@@ -8,5 +8,6 @@ std::string base64_encode(const std::string &s);
 std::string base64_decode(const std::string &s);
 
 std::string object_id_to_string(graphene::chain::object_id_type id);
+graphene::chain::object_id_type string_to_object_id(const std::string &id);
 
 }} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/defs.hpp

@@ -57,10 +57,16 @@ struct info_for_vin {
    bool resend = false;
 };
 
+enum class sidechain_event_type {
+   deposit,
+   withdrawal
+};
+
 struct sidechain_event_data {
    fc::time_point_sec timestamp;
    uint32_t block_num;
    sidechain_type sidechain;
+   sidechain_event_type type;
    std::string sidechain_uid;
    std::string sidechain_transaction_id;
    std::string sidechain_from;

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/decoders.hpp

@@ -1,10 +1,31 @@
 #pragma once
 
+#include <boost/multiprecision/cpp_int.hpp>
 #include <string>
 #include <vector>
 
+#include <fc/optional.hpp>
+
 namespace graphene { namespace peerplays_sidechain { namespace ethereum {
 
+class base_decoder {
+public:
+   static boost::multiprecision::uint256_t decode_uint256(const std::string &value);
+   static std::string decode_address(const std::string &value);
+};
+
+struct deposit_erc20_transaction {
+   std::string token;
+   boost::multiprecision::uint256_t amount;
+};
+
+class deposit_erc20_decoder {
+public:
+   static const std::string function_signature;
+
+   static fc::optional<deposit_erc20_transaction> decode(const std::string &input);
+};
+
 class rlp_decoder {
 private:
    enum RLP_constants {

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/encoders.hpp

@@ -4,8 +4,15 @@
 #include <string>
 #include <vector>
 
+#include <graphene/peerplays_sidechain/ethereum/types.hpp>
+
 namespace graphene { namespace peerplays_sidechain { namespace ethereum {
 
+struct encoded_sign_transaction {
+   std::string data;
+   signature sign;
+};
+
 class base_encoder {
 public:
    static std::string encode_uint256(boost::multiprecision::uint256_t value);
@@ -15,16 +22,34 @@ public:
 
 class update_owners_encoder {
 public:
-   const std::string function_signature = "23ab6adf"; //! updateOwners((address,uint256)[],string)
+   static const std::string function_signature;
 
-   std::string encode(const std::vector<std::pair<std::string, uint16_t>> &owners_weights, const std::string &object_id) const;
+   static std::string encode(const std::vector<std::pair<std::string, uint16_t>> &owners_weights, const std::string &object_id);
 };
 
 class withdrawal_encoder {
 public:
-   const std::string function_signature = "e088747b"; //! withdraw(address,uint256,string)
+   static const std::string function_signature;
 
-   std::string encode(const std::string &to, boost::multiprecision::uint256_t amount, const std::string &object_id) const;
+   static std::string encode(const std::string &to, boost::multiprecision::uint256_t amount, const std::string &object_id);
+};
+
+class withdrawal_erc20_encoder {
+public:
+   static const std::string function_signature;
+
+   static std::string encode(const std::string &token, const std::string &to, boost::multiprecision::uint256_t amount, const std::string &object_id);
+};
+
+class signature_encoder {
+public:
+   const std::string function_signature;
+
+   signature_encoder(const std::string &function_hash);
+
+   static std::string get_function_signature_from_transaction(const std::string &transaction);
+
+   std::string encode(const std::vector<encoded_sign_transaction> &transactions) const;
 };
 
 class rlp_encoder {
@@ -39,35 +64,4 @@ private:
    static void hex2bin(const char *src, char *target);
 };
 
-/*class ethereum_function_call_encoder {
-public:
-   enum operation_t {
-      OPERATION_CALL,
-      OPERATION_DELEGATE_CALL
-   };
-
-   static constexpr const char *const default_prev_addr = "0000000000000000000000000000000000000001";
-
-   std::string encode_function_signature(const std::string &function_signature);
-   std::string encode_address(const std::string &addr);
-   std::string encode_uint256(const std::string &value);
-   std::string encode_uint8(uint8_t value);
-   std::string encode_bytes(const std::string &values);
-};
-
-class safe_transaction_encoder {
-public:
-   static constexpr const char *const default_safe_tx_gas = "0";
-   static constexpr const char *const default_data_gas = "0";
-   static constexpr const char *const default_gas_price = "0";
-   static constexpr const char *const default_gas_token = "0000000000000000000000000000000000000000";
-   static constexpr const char *const default_refund_receiver = "0000000000000000000000000000000000000000";
-
-   std::string create_safe_address(const std::vector<std::string> &owner_addresses, uint32_t threshold);
-   std::string build_transaction(const std::string &safe_account_addr, const std::string &value, const std::string &data, uint8_t operation, const std::string &safeTxGas, const std::string &dataGas, const std::string &gasPrice, const std::string &gasToken, const std::string &refundReceiver);
-
-private:
-   ethereum_function_call_encoder m_ethereum_function_call_encoder;
-};*/
-
 }}} // namespace graphene::peerplays_sidechain::ethereum

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/transaction.hpp

@@ -8,6 +8,9 @@
 
 namespace graphene { namespace peerplays_sidechain { namespace ethereum {
 
+bytes keccak_hash(const std::string &data);
+signature sign_hash(const bytes &hash, const std::string &chain_id, const std::string &private_key);
+
 class base_transaction {
 public:
    base_transaction() = default;
@@ -75,89 +78,3 @@ public:
 };
 
 }}} // namespace graphene::peerplays_sidechain::ethereum
-
-// Example 1
-//{
-//  "blockHash": "0x64a6706ecaf5a97b7f3e047abb20ff223ce82c6994d80e68fdb1fdfb38d0209c",
-//  "blockNumber": "0xe5827c",
-//  "from": "0x8614c67e085f2334010f2a28e806c6f1cc176d12",
-//  "gas": "0x38822",
-//  "gasPrice": "0xce42cba69",
-//  "maxFeePerGas": "0xddb4d8d16",
-//  "maxPriorityFeePerGas": "0x3b9aca00",
-//  "hash": "0xeac92ea09fa8eb3ca2fb0d156cceb38ae69d4345869d41e8e49d5ecbcbb622dc",
-//  "input": "0x5ae401dc0000000000000000000000000000000000000000000000000000000062bb57cf00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000e4472b43f300000000000000000000000000000000000000000000000002514d9d7d7d8000000000000000000000000000000000000000000007dced93dd41fd3e1f9e80c200000000000000000000000000000000000000000000000000000000000000800000000000000000000000008614c67e085f2334010f2a28e806c6f1cc176d120000000000000000000000000000000000000000000000000000000000000002000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000059c12ed5aaf25adbc6e15f9cc9bab2dde03121500000000000000000000000000000000000000000000000000000000",
-//  "nonce": "0x32",
-//  "to": "0x68b3465833fb72a70ecdf485e0e4c7bd8665fc45",
-//  "transactionIndex": "0xb6",
-//  "value": "0x2514d9d7d7d8000",
-//  "type": "0x2",
-//  "accessList": [],
-//  "chainId": "0x1",
-//  "v": "0x1",
-//  "r": "0x2f8d6a9c737ed98792bafc903b8f1aa54adc731bd3cf9a8b25246a1c9095a28c",
-//  "s": "0x782c40e64b47a221a07612c822c08763f626e53c4b00b73f4c5ba86304c43f14"
-//}
-//
-//"0xf9021332850ce42cba69830388229468b3465833fb72a70ecdf485e0e4c7bd8665fc458802514d9d7d7d8000b901a45ae401dc0000000000000000000000000000000000000000000000000000000062bb57cf00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000e4472b43f300000000000000000000000000000000000000000000000002514d9d7d7d8000000000000000000000000000000000000000000007dced93dd41fd3e1f9e80c200000000000000000000000000000000000000000000000000000000000000800000000000000000000000008614c67e085f2334010f2a28e806c6f1cc176d120000000000000000000000000000000000000000000000000000000000000002000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000059c12ed5aaf25adbc6e15f9cc9bab2dde0312150000000000000000000000000000000000000000000000000000000001a02f8d6a9c737ed98792bafc903b8f1aa54adc731bd3cf9a8b25246a1c9095a28ca0782c40e64b47a221a07612c822c08763f626e53c4b00b73f4c5ba86304c43f14"
-//
-//{
-//  "nonce": 50,
-//  "gasPrice": {
-//    "_hex": "0x0ce42cba69"
-//  },
-//  "gasLimit": {
-//    "_hex": "0x038822"
-//  },
-//  "to": "0x68b3465833fb72a70ecdf485e0e4c7bd8665fc45",
-//  "value": {
-//    "_hex": "0x02514d9d7d7d8000"
-//  },
-//  "data": "0x5ae401dc0000000000000000000000000000000000000000000000000000000062bb57cf00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000e4472b43f300000000000000000000000000000000000000000000000002514d9d7d7d8000000000000000000000000000000000000000000007dced93dd41fd3e1f9e80c200000000000000000000000000000000000000000000000000000000000000800000000000000000000000008614c67e085f2334010f2a28e806c6f1cc176d120000000000000000000000000000000000000000000000000000000000000002000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000059c12ed5aaf25adbc6e15f9cc9bab2dde03121500000000000000000000000000000000000000000000000000000000",
-//  "v": 1,
-//  "r": "0x2f8d6a9c737ed98792bafc903b8f1aa54adc731bd3cf9a8b25246a1c9095a28c",
-//  "s": "0x782c40e64b47a221a07612c822c08763f626e53c4b00b73f4c5ba86304c43f14"
-//}
-
-// Example 2
-//{
-//  "blockHash": "0xe2ae3afd86dc7343c7fb753441447a0a51bb19499325ad6e278256f0cd1b5894",
-//  "blockNumber": "0xe58271",
-//  "from": "0xb895ade6d337fbb8cb97f2ea7da43106c7f5cc26",
-//  "gas": "0x5208",
-//  "gasPrice": "0xe6f3b322e",
-//  "maxFeePerGas": "0x1322455fd3",
-//  "maxPriorityFeePerGas": "0x53724e00",
-//  "hash": "0xed29b56e52ad2d452e25b8ec70c37f59d935cd6d0f8fe8e83b256f3ffdfd3fce",
-//  "input": "0x",
-//  "nonce": "0x37",
-//  "to": "0x176386b6ffc469ac049f9ec1f6cc0efd1d09b373",
-//  "transactionIndex": "0x8a",
-//  "value": "0x4563918244f40000",
-//  "type": "0x2",
-//  "accessList": [],
-//  "chainId": "0x1",
-//  "v": "0x0",
-//  "r": "0xdcc588257770e08660cb809e71b293f556cd5f5323e832d96ee896ff8830ca4c",
-//  "s": "0x28c7ce6a539d9318688687097a2db29e15c32ba8c085275fdd3dddf047d4bd1a"
-//}
-//
-//"0xf86c37850e6f3b322e82520894176386b6ffc469ac049f9ec1f6cc0efd1d09b373884563918244f400008000a0dcc588257770e08660cb809e71b293f556cd5f5323e832d96ee896ff8830ca4ca028c7ce6a539d9318688687097a2db29e15c32ba8c085275fdd3dddf047d4bd1a"
-//
-//{
-//  "nonce": 55,
-//  "gasPrice": {
-//    "_hex": "0x0e6f3b322e"
-//  },
-//  "gasLimit": {
-//    "_hex": "0x5208"
-//  },
-//  "to": "0x176386b6ffc469ac049f9ec1f6cc0efd1d09b373",
-//  "value": {
-//    "_hex": "0x4563918244f40000"
-//  },
-//  "data": "0x",
-//  "v": 0,
-//  "r": "0xdcc588257770e08660cb809e71b293f556cd5f5323e832d96ee896ff8830ca4c",
-//  "s": "0x28c7ce6a539d9318688687097a2db29e15c32ba8c085275fdd3dddf047d4bd1a"
-//}

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/types.hpp

@@ -9,4 +9,17 @@ typedef uint64_t network_id_type;
 
 using bytes = std::vector<char>;
 
+class signature {
+public:
+   std::string v;
+   std::string r;
+   std::string s;
+
+   signature() = default;
+   signature(const std::string &sign);
+
+   std::string serialize() const;
+   void deserialize(const std::string &sign);
+};
+
 }}} // namespace graphene::peerplays_sidechain::ethereum

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/ethereum/utils.hpp

@@ -14,13 +14,19 @@ std::string add_0x(const std::string &s);
 
 std::string remove_0x(const std::string &s);
 
+std::string add_leading_00(const std::string &s);
+
+std::string remove_leading_00(const std::string &s);
+
 template <typename T>
-std::string to_hex(const T &val) {
+std::string to_hex(const T &val, bool add_front_zero = true) {
    std::stringstream stream;
    stream << std::hex << val;
    std::string result(stream.str());
-   if (result.size() % 2)
-      result = "0" + result;
+   if (add_front_zero) {
+      if (result.size() % 2)
+         result = "0" + result;
+   }
    return result;
 }
 

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/hive/types.hpp

@@ -22,15 +22,15 @@ typedef fc::ecc::private_key private_key_type;
 typedef fc::sha256 chain_id_type;
 typedef std::string account_name_type;
 typedef fc::ripemd160 block_id_type;
-//typedef fc::ripemd160 checksum_type;
+// typedef fc::ripemd160 checksum_type;
 typedef fc::ripemd160 transaction_id_type;
 typedef fc::sha256 digest_type;
 typedef fc::ecc::compact_signature signature_type;
 typedef fc::safe<int64_t> share_type;
-//typedef safe<uint64_t> ushare_type;
-//typedef uint16_t weight_type;
-//typedef uint32_t contribution_id_type;
-//typedef fixed_string<32> custom_id_type;
+// typedef safe<uint64_t> ushare_type;
+// typedef uint16_t weight_type;
+// typedef uint32_t contribution_id_type;
+// typedef fixed_string<32> custom_id_type;
 
 struct public_key_type {
 

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/peerplays_sidechain_plugin.hpp

@@ -54,6 +54,7 @@ public:
    void log_son_proposal_retry(sidechain_type sidechain, int op_type, object_id_type object_id);
    bool can_son_participate(sidechain_type sidechain, int op_type, object_id_type object_id);
    std::map<sidechain_type, std::vector<std::string>> get_son_listener_log();
+   optional<asset> estimate_withdrawal_transaction_fee(sidechain_type sidechain);
 };
 
 }} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_api.hpp

@@ -26,9 +26,10 @@ public:
    std::shared_ptr<detail::sidechain_api_impl> my;
 
    std::map<sidechain_type, std::vector<std::string>> get_son_listener_log();
+   optional<asset> estimate_withdrawal_transaction_fee(sidechain_type sidechain);
 };
 
 }} // namespace graphene::peerplays_sidechain
 
 FC_API(graphene::peerplays_sidechain::sidechain_api,
-       (get_son_listener_log))
+       (get_son_listener_log)(estimate_withdrawal_transaction_fee))

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler.hpp

@@ -16,14 +16,17 @@
 namespace graphene { namespace peerplays_sidechain {
 
 class sidechain_net_handler {
+protected:
+   sidechain_net_handler(sidechain_type _sidechain, peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options);
+
 public:
-   sidechain_net_handler(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options);
    virtual ~sidechain_net_handler();
 
-   sidechain_type get_sidechain();
-   std::vector<std::string> get_sidechain_deposit_addresses();
-   std::vector<std::string> get_sidechain_withdraw_addresses();
-   std::string get_private_key(std::string public_key);
+   sidechain_type get_sidechain() const;
+   std::vector<std::string> get_sidechain_deposit_addresses() const;
+   std::vector<std::string> get_sidechain_withdraw_addresses() const;
+   std::vector<sidechain_transaction_object> get_sidechain_transaction_objects(sidechain_transaction_status status) const;
+   std::string get_private_key(std::string public_key) const;
 
    bool proposal_exists(int32_t operation_tag, const object_id_type &object_id, boost::optional<chain::operation &> proposal_op = boost::none);
    bool signer_expected(const sidechain_transaction_object &sto, son_id_type signer);
@@ -50,13 +53,15 @@ public:
 
    void add_to_son_listener_log(std::string trx_id);
    std::vector<std::string> get_son_listener_log();
+   virtual optional<asset> estimate_withdrawal_transaction_fee() const = 0;
 
 protected:
+   const sidechain_type sidechain;
    peerplays_sidechain_plugin &plugin;
    graphene::chain::database &database;
-   sidechain_type sidechain;
 
    bool debug_rpc_calls;
+   bool use_bitcoind_client;
 
    std::map<std::string, std::string> private_keys;
 

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler_bitcoin.hpp

@@ -1,18 +1,20 @@
 #pragma once
 
-#include <graphene/peerplays_sidechain/common/rpc_client.hpp>
 #include <graphene/peerplays_sidechain/sidechain_net_handler.hpp>
 
+#include <mutex>
 #include <string>
 #include <thread>
 #include <zmq_addon.hpp>
 
 #include <boost/signals2.hpp>
 
-#include <mutex>
-
 #include <fc/network/http/connection.hpp>
+
 #include <graphene/peerplays_sidechain/bitcoin/bitcoin_address.hpp>
+#include <graphene/peerplays_sidechain/bitcoin/estimate_fee_external.hpp>
+#include <graphene/peerplays_sidechain/bitcoin/libbitcoin_client.hpp>
+#include <graphene/peerplays_sidechain/common/rpc_client.hpp>
 
 namespace graphene { namespace peerplays_sidechain {
 
@@ -23,7 +25,27 @@ public:
    uint64_t amount_;
 };
 
-class bitcoin_rpc_client : public rpc_client {
+class btc_txin {
+public:
+   std::vector<std::string> tx_address;
+   uint64_t tx_amount;
+   uint64_t tx_vout;
+};
+
+class btc_tx {
+public:
+   std::string tx_txid;
+   uint32_t tx_confirmations;
+   std::vector<btc_txin> tx_in_list;
+};
+
+class block_data {
+public:
+   std::string block_hash;
+   libbitcoin::chain::block block;
+};
+
+class bitcoin_client_base {
 public:
    enum class multi_type {
       script,
@@ -41,14 +63,47 @@ public:
       std::string label;
    };
 
-public:
-   bitcoin_rpc_client(std::string _url, std::string _user, std::string _password, bool _debug_rpc_calls);
+   virtual uint64_t estimatesmartfee(uint16_t conf_target = 1) = 0;
+   virtual std::vector<info_for_vin> getblock(const block_data &block, int32_t verbosity = 2) = 0;
+   virtual btc_tx getrawtransaction(const std::string &txid, const bool verbose = false) = 0;
+   virtual void getnetworkinfo() = 0;
+   virtual std::string getblockchaininfo() = 0;
+   virtual std::vector<btc_txout> listunspent_by_address_and_amount(const std::string &address, double transfer_amount, const uint32_t minconf = 1, const uint32_t maxconf = 9999999) = 0;
+   virtual std::string sendrawtransaction(const std::string &tx_hex) = 0;
+   virtual void importmulti(const std::vector<multi_params> &address_or_script_array, const bool rescan = true) {
+      ;
+   };
+   virtual std::string loadwallet(const std::string &filename) {
+      return "";
+   };
+   virtual std::string walletlock() {
+      return "";
+   };
+   virtual bool walletpassphrase(const std::string &passphrase, uint32_t timeout = 60) {
+      return false;
+   };
 
-   std::string createwallet(const std::string &wallet_name);
-   uint64_t estimatesmartfee(uint16_t conf_target = 128);
-   std::string getblock(const std::string &block_hash, int32_t verbosity = 2);
-   std::string getrawtransaction(const std::string &txid, const bool verbose = false);
-   std::string getnetworkinfo();
+   void import_trx_to_memory_pool(const libbitcoin::chain::transaction &trx) {
+      std::unique_lock<std::mutex> lck(libbitcoin_event_mutex);
+      if (trx_memory_pool.size() < MAX_TRXS_IN_MEMORY_POOL) {
+         trx_memory_pool.emplace_back(trx);
+      }
+   }
+
+protected:
+   std::vector<libbitcoin::chain::transaction> trx_memory_pool;
+   std::mutex libbitcoin_event_mutex;
+};
+
+class bitcoin_rpc_client : public bitcoin_client_base, public rpc_client {
+public:
+public:
+   bitcoin_rpc_client(const std::vector<rpc_credentials> &_credentials, bool _debug_rpc_calls, bool _simulate_connection_reselection);
+
+   uint64_t estimatesmartfee(uint16_t conf_target = 1);
+   std::vector<info_for_vin> getblock(const block_data &block, int32_t verbosity = 2);
+   btc_tx getrawtransaction(const std::string &txid, const bool verbose = false);
+   void getnetworkinfo();
    std::string getblockchaininfo();
    void importmulti(const std::vector<multi_params> &address_or_script_array, const bool rescan = true);
    std::vector<btc_txout> listunspent(const uint32_t minconf = 1, const uint32_t maxconf = 9999999);
@@ -58,37 +113,88 @@ public:
    std::string walletlock();
    bool walletpassphrase(const std::string &passphrase, uint32_t timeout = 60);
 
+   virtual uint64_t ping(rpc_connection &conn) const override;
+
 private:
    std::string ip;
-   uint32_t rpc_port;
    std::string user;
    std::string password;
    std::string wallet_name;
    std::string wallet_password;
+   uint32_t bitcoin_major_version;
+};
+
+class bitcoin_libbitcoin_client : public bitcoin_client_base, public libbitcoin_client {
+public:
+   bitcoin_libbitcoin_client(std::string url);
+   uint64_t estimatesmartfee(uint16_t conf_target = 1);
+   std::vector<info_for_vin> getblock(const block_data &block, int32_t verbosity = 2);
+   btc_tx getrawtransaction(const std::string &txid, const bool verbose = false);
+   void getnetworkinfo();
+   std::string getblockchaininfo();
+   std::vector<btc_txout> listunspent_by_address_and_amount(const std::string &address, double transfer_amount, const uint32_t minconf = 1, const uint32_t maxconf = 9999999);
+   std::string sendrawtransaction(const std::string &tx_hex);
+
+private:
+   bool is_test_net = false;
+   std::unique_ptr<estimate_fee_external> estimate_fee_ext;
+   uint64_t current_internal_fee = DEAFULT_LIBBITCOIN_TRX_FEE;
 };
 
 // =============================================================================
 
-class zmq_listener {
+class zmq_listener_base {
 public:
-   zmq_listener(std::string _ip, uint32_t _zmq);
-   virtual ~zmq_listener();
+   virtual ~zmq_listener_base(){};
+   zmq_listener_base(std::string _ip, uint32_t _block_zmq_port, uint32_t _trx_zmq_port = 0) {
+      ip = _ip;
+      block_zmq_port = _block_zmq_port;
+      trx_zmq_port = _trx_zmq_port;
+      stopped = false;
+   };
+   virtual void start() = 0;
+   boost::signals2::signal<void(const block_data &)> block_event_received;
+   boost::signals2::signal<void(const libbitcoin::chain::transaction &)> trx_event_received;
 
+protected:
+   std::string ip;
+   uint32_t block_zmq_port;
+   uint32_t trx_zmq_port;
+   std::atomic_bool stopped;
+   std::thread block_thr;
+   std::thread trx_thr;
+};
+
+class zmq_listener : public zmq_listener_base {
+public:
+   zmq_listener(std::string _ip, uint32_t _block_zmq_port, uint32_t _trx_zmq_port = 0);
+   virtual ~zmq_listener();
    void start();
-   boost::signals2::signal<void(const std::string &)> event_received;
 
 private:
    void handle_zmq();
    std::vector<zmq::message_t> receive_multipart();
 
-   std::string ip;
-   uint32_t zmq_port;
-
    zmq::context_t ctx;
    zmq::socket_t socket;
+};
 
-   std::atomic_bool stopped;
-   std::thread thr;
+class zmq_listener_libbitcoin : public zmq_listener_base {
+public:
+   zmq_listener_libbitcoin(std::string _ip, uint32_t _block_zmq_port = 9093, uint32_t _trx_zmq_port = 9094);
+   virtual ~zmq_listener_libbitcoin();
+   void start();
+
+private:
+   void handle_block();
+   void handle_trx();
+
+   libbitcoin::protocol::zmq::context block_context;
+   libbitcoin::protocol::zmq::socket block_socket;
+   libbitcoin::protocol::zmq::poller block_poller;
+   libbitcoin::protocol::zmq::context trx_context;
+   libbitcoin::protocol::zmq::socket trx_socket;
+   libbitcoin::protocol::zmq::poller trx_poller;
 };
 
 // =============================================================================
@@ -106,18 +212,19 @@ public:
    std::string process_sidechain_transaction(const sidechain_transaction_object &sto);
    std::string send_sidechain_transaction(const sidechain_transaction_object &sto);
    bool settle_sidechain_transaction(const sidechain_transaction_object &sto, asset &settle_amount);
+   virtual optional<asset> estimate_withdrawal_transaction_fee() const override;
 
 private:
-   std::string ip;
-   uint32_t zmq_port;
-   uint32_t rpc_port;
-   std::string rpc_user;
-   std::string rpc_password;
+   std::vector<rpc_credentials> _rpc_credentials;
+   std::string libbitcoin_server_ip;
+   uint32_t libbitcoin_block_zmq_port;
+   uint32_t libbitcoin_trx_zmq_port;
+   uint32_t bitcoin_node_zmq_port;
    std::string wallet_name;
    std::string wallet_password;
 
-   std::unique_ptr<bitcoin_rpc_client> bitcoin_client;
-   std::unique_ptr<zmq_listener> listener;
+   std::unique_ptr<bitcoin_client_base> bitcoin_client;
+   std::unique_ptr<zmq_listener_base> listener;
 
    fc::future<void> on_changed_objects_task;
 
@@ -127,7 +234,7 @@ private:
    std::mutex event_handler_mutex;
    typedef std::lock_guard<decltype(event_handler_mutex)> scoped_lock;
 
-   std::string create_primary_wallet_address(const std::vector<son_info> &son_pubkeys);
+   std::string create_primary_wallet_address(const std::vector<son_sidechain_info> &son_pubkeys);
 
    std::string create_primary_wallet_transaction(const son_wallet_object &prev_swo, std::string new_sw_address);
    std::string create_deposit_transaction(const son_wallet_deposit_object &swdo);
@@ -137,9 +244,9 @@ private:
    std::string sign_transaction(const sidechain_transaction_object &sto);
    std::string send_transaction(const sidechain_transaction_object &sto);
 
-   void handle_event(const std::string &event_data);
+   void block_handle_event(const block_data &event_data);
+   void trx_handle_event(const libbitcoin::chain::transaction &event_data);
    std::string get_redeemscript_for_userdeposit(const std::string &user_address);
-   std::vector<info_for_vin> extract_info_from_block(const std::string &_block);
    void on_changed_objects(const vector<object_id_type> &ids, const flat_set<account_id_type> &accounts);
    void on_changed_objects_cb(const vector<object_id_type> &ids, const flat_set<account_id_type> &accounts);
 };

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler_ethereum.hpp

@@ -4,6 +4,7 @@
 
 #include <string>
 
+#include <boost/bimap.hpp>
 #include <boost/signals2.hpp>
 
 #include <graphene/peerplays_sidechain/common/rpc_client.hpp>
@@ -13,24 +14,30 @@ namespace graphene { namespace peerplays_sidechain {
 
 class ethereum_rpc_client : public rpc_client {
 public:
-   ethereum_rpc_client(const std::string &url, const std::string &user_name, const std::string &password, bool debug_rpc_calls);
+   ethereum_rpc_client(const std::vector<rpc_credentials> &credentials, bool debug_rpc_calls, bool simulate_connection_reselection);
 
-   std::string admin_node_info();
+   std::string eth_blockNumber();
    std::string eth_get_block_by_number(std::string block_number, bool full_block);
    std::string eth_get_logs(std::string wallet_contract_address);
+   std::string eth_chainId();
    std::string net_version();
    std::string eth_get_transaction_count(const std::string &params);
    std::string eth_gas_price();
+   std::string eth_estimateGas(const std::string &params);
 
    std::string get_chain_id();
    std::string get_network_id();
    std::string get_nonce(const std::string &address);
    std::string get_gas_price();
    std::string get_gas_limit();
+   std::string get_estimate_gas(const std::string &params);
 
    std::string eth_send_transaction(const std::string &params);
    std::string eth_send_raw_transaction(const std::string &params);
    std::string eth_get_transaction_receipt(const std::string &params);
+   std::string eth_get_transaction_by_hash(const std::string &params);
+
+   virtual uint64_t ping(rpc_connection &conn) const override;
 };
 
 class sidechain_net_handler_ethereum : public sidechain_net_handler {
@@ -46,19 +53,20 @@ public:
    std::string process_sidechain_transaction(const sidechain_transaction_object &sto);
    std::string send_sidechain_transaction(const sidechain_transaction_object &sto);
    bool settle_sidechain_transaction(const sidechain_transaction_object &sto, asset &settle_amount);
+   virtual optional<asset> estimate_withdrawal_transaction_fee() const override;
 
 private:
-   std::string rpc_url;
-   std::string rpc_user;
-   std::string rpc_password;
+   std::vector<rpc_credentials> _rpc_credentials;
    std::string wallet_contract_address;
+   using bimap_type = boost::bimap<std::string, std::string>;
+   bimap_type erc20_addresses;
 
    ethereum_rpc_client *rpc_client;
 
    ethereum::chain_id_type chain_id;
    ethereum::network_id_type network_id;
 
-   std::string create_primary_wallet_transaction(const std::vector<son_info> &son_pubkeys, const std::string &object_id);
+   std::string create_primary_wallet_transaction(const std::vector<son_sidechain_info> &son_pubkeys, const std::string &object_id);
    std::string create_deposit_transaction(const son_wallet_deposit_object &swdo);
    std::string create_withdrawal_transaction(const son_wallet_withdraw_object &swwo);
 
@@ -69,7 +77,7 @@ private:
    boost::signals2::signal<void(const std::string &)> event_received;
    void schedule_ethereum_listener();
    void ethereum_listener_loop();
-   void handle_event(const std::string &event_data);
+   void handle_event(const std::string &block_number);
 };
 
 }} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler_hive.hpp

@@ -13,7 +13,7 @@ namespace graphene { namespace peerplays_sidechain {
 
 class hive_rpc_client : public rpc_client {
 public:
-   hive_rpc_client(const std::string &url, const std::string &user_name, const std::string &password, bool debug_rpc_calls);
+   hive_rpc_client(const std::vector<rpc_credentials> &credentials, bool debug_rpc_calls, bool simulate_connection_reselection);
 
    std::string account_history_api_get_transaction(std::string transaction_id);
    std::string block_api_get_block(uint32_t block_number);
@@ -30,6 +30,8 @@ public:
    std::string get_head_block_time();
    std::string get_is_test_net();
    std::string get_last_irreversible_block_num();
+
+   virtual uint64_t ping(rpc_connection &conn) const override;
 };
 
 class sidechain_net_handler_hive : public sidechain_net_handler {
@@ -45,11 +47,11 @@ public:
    std::string process_sidechain_transaction(const sidechain_transaction_object &sto);
    std::string send_sidechain_transaction(const sidechain_transaction_object &sto);
    bool settle_sidechain_transaction(const sidechain_transaction_object &sto, asset &settle_amount);
+   virtual optional<asset> estimate_withdrawal_transaction_fee() const override;
 
 private:
-   std::string rpc_url;
-   std::string rpc_user;
-   std::string rpc_password;
+   std::vector<rpc_credentials> _rpc_credentials;
+
    std::string wallet_account_name;
 
    hive_rpc_client *rpc_client;

libraries/plugins/peerplays_sidechain/include/graphene/peerplays_sidechain/sidechain_net_handler_peerplays.hpp

@@ -19,6 +19,7 @@ public:
    std::string process_sidechain_transaction(const sidechain_transaction_object &sto);
    std::string send_sidechain_transaction(const sidechain_transaction_object &sto);
    bool settle_sidechain_transaction(const sidechain_transaction_object &sto, asset &settle_amount);
+   virtual optional<asset> estimate_withdrawal_transaction_fee() const override;
 
 private:
 };

libraries/plugins/peerplays_sidechain/peerplays_sidechain_plugin.cpp

@@ -48,6 +48,7 @@ public:
    void log_son_proposal_retry(sidechain_type sidechain, int op_type, object_id_type object_id);
    bool can_son_participate(sidechain_type sidechain, int op_type, object_id_type object_id);
    std::map<sidechain_type, std::vector<std::string>> get_son_listener_log();
+   optional<asset> estimate_withdrawal_transaction_fee(sidechain_type sidechain);
 
    void schedule_heartbeat_loop();
    void heartbeat_loop();
@@ -87,7 +88,9 @@ private:
    std::mutex access_db_mutex;
    std::mutex access_approve_prop_mutex;
    std::mutex access_son_down_prop_mutex;
+   std::mutex access_son_deregister_prop_mutex;
 
+   std::map<sidechain_type, bool> sidechain_enabled;
    std::map<sidechain_type, std::unique_ptr<sidechain_net_handler>> net_handlers;
    std::set<chain::son_id_type> sons;
    std::map<chain::public_key_type, fc::ecc::private_key> private_keys;
@@ -97,6 +100,7 @@ private:
    uint16_t retries_threshold = 150;
 
    bool first_block_skipped;
+   bool son_processing_enabled;
    void on_applied_block(const signed_block &b);
 };
 
@@ -113,19 +117,27 @@ peerplays_sidechain_plugin_impl::peerplays_sidechain_plugin_impl(peerplays_sidec
       sidechain_enabled_peerplays(false),
       current_son_id([] {
          std::map<sidechain_type, son_id_type> current_son_id;
-         for (const auto &active_sidechain_type : active_sidechain_types) {
+         for (const auto &active_sidechain_type : all_sidechain_types) {
             current_son_id.emplace(active_sidechain_type, son_id_type(std::numeric_limits<uint32_t>().max()));
          }
          return current_son_id;
       }()),
+      sidechain_enabled([] {
+         std::map<sidechain_type, bool> sidechain_enabled;
+         for (const auto &active_sidechain_type : all_sidechain_types) {
+            sidechain_enabled.emplace(active_sidechain_type, false);
+         }
+         return sidechain_enabled;
+      }()),
       net_handlers([] {
          std::map<sidechain_type, std::unique_ptr<sidechain_net_handler>> net_handlers;
-         for (const auto &active_sidechain_type : active_sidechain_types) {
+         for (const auto &active_sidechain_type : all_sidechain_types) {
             net_handlers.emplace(active_sidechain_type, nullptr);
          }
          return net_handlers;
       }()),
-      first_block_skipped(false) {
+      first_block_skipped(false),
+      son_processing_enabled(false) {
 }
 
 peerplays_sidechain_plugin_impl::~peerplays_sidechain_plugin_impl() {
@@ -133,18 +145,18 @@ peerplays_sidechain_plugin_impl::~peerplays_sidechain_plugin_impl() {
       if (_heartbeat_task.valid())
          _heartbeat_task.cancel_and_wait(__FUNCTION__);
    } catch (fc::canceled_exception &) {
-      //Expected exception. Move along.
+      // Expected exception. Move along.
    } catch (fc::exception &e) {
       edump((e.to_detail_string()));
    }
 
    try {
-      for (const auto &active_sidechain_type : active_sidechain_types) {
+      for (const auto &active_sidechain_type : all_sidechain_types) {
          if (_son_processing_task.count(active_sidechain_type) != 0 && _son_processing_task.at(active_sidechain_type).valid())
             _son_processing_task.at(active_sidechain_type).wait();
       }
    } catch (fc::canceled_exception &) {
-      //Expected exception. Move along.
+      // Expected exception. Move along.
    } catch (fc::exception &e) {
       edump((e.to_detail_string()));
    }
@@ -165,9 +177,14 @@ void peerplays_sidechain_plugin_impl::plugin_set_program_options(
    cli.add_options()("sidechain-retry-threshold", bpo::value<uint16_t>()->default_value(150), "Sidechain retry throttling threshold");
 
    cli.add_options()("debug-rpc-calls", bpo::value<bool>()->default_value(false), "Outputs RPC calls to console");
+   cli.add_options()("simulate-rpc-connection-reselection", bpo::value<bool>()->default_value(false), "Simulate RPC connection reselection by altering their response times by a random value");
 
    cli.add_options()("bitcoin-sidechain-enabled", bpo::value<bool>()->default_value(false), "Bitcoin sidechain handler enabled");
-   cli.add_options()("bitcoin-node-ip", bpo::value<string>()->default_value("127.0.0.1"), "IP address of Bitcoin node");
+   cli.add_options()("bitcoin-node-ip", bpo::value<vector<string>>()->composing()->multitoken()->DEFAULT_VALUE_VECTOR("127.0.0.1"), "IP address of Bitcoin node");
+   cli.add_options()("use-bitcoind-client", bpo::value<bool>()->default_value(false), "Use bitcoind client instead of libbitcoin client");
+   cli.add_options()("libbitcoin-server-ip", bpo::value<string>()->default_value("127.0.0.1"), "Libbitcoin server IP address");
+   cli.add_options()("libbitcoin-server-block-zmq-port", bpo::value<uint32_t>()->default_value(9093), "Block ZMQ port of libbitcoin server");
+   cli.add_options()("libbitcoin-server-trx-zmq-port", bpo::value<uint32_t>()->default_value(9094), "Trx ZMQ port of libbitcoin server");
    cli.add_options()("bitcoin-node-zmq-port", bpo::value<uint32_t>()->default_value(11111), "ZMQ port of Bitcoin node");
    cli.add_options()("bitcoin-node-rpc-port", bpo::value<uint32_t>()->default_value(8332), "RPC port of Bitcoin node");
    cli.add_options()("bitcoin-node-rpc-user", bpo::value<string>()->default_value("1"), "Bitcoin RPC user");
@@ -178,15 +195,17 @@ void peerplays_sidechain_plugin_impl::plugin_set_program_options(
                      "Tuple of [Bitcoin public key, Bitcoin private key] (may specify multiple times)");
 
    cli.add_options()("ethereum-sidechain-enabled", bpo::value<bool>()->default_value(false), "Ethereum sidechain handler enabled");
-   cli.add_options()("ethereum-node-rpc-url", bpo::value<string>()->default_value("127.0.0.1:8545"), "Ethereum node RPC URL [http[s]://]host[:port]");
+   cli.add_options()("ethereum-node-rpc-url", bpo::value<vector<string>>()->composing()->multitoken()->DEFAULT_VALUE_VECTOR("127.0.0.1:8545"), "Ethereum node RPC URL [http[s]://]host[:port]");
    cli.add_options()("ethereum-node-rpc-user", bpo::value<string>(), "Ethereum RPC user");
    cli.add_options()("ethereum-node-rpc-password", bpo::value<string>(), "Ethereum RPC password");
    cli.add_options()("ethereum-wallet-contract-address", bpo::value<string>(), "Ethereum wallet contract address");
+   cli.add_options()("ethereum-erc-20-address", bpo::value<vector<string>>()->composing()->multitoken(),
+                     "Tuple of [ERC-20 symbol, ERC-20 address] (may specify multiple times)");
    cli.add_options()("ethereum-private-key", bpo::value<vector<string>>()->composing()->multitoken()->DEFAULT_VALUE_VECTOR(std::make_pair("5fbbb31be52608d2f52247e8400b7fcaa9e0bc12", "9bedac2bd8fe2a6f6528e066c67fc8ac0622e96828d40c0e820d83c5bd2b0589")),
                      "Tuple of [Ethereum public key, Ethereum private key] (may specify multiple times)");
 
    cli.add_options()("hive-sidechain-enabled", bpo::value<bool>()->default_value(false), "Hive sidechain handler enabled");
-   cli.add_options()("hive-node-rpc-url", bpo::value<string>()->default_value("127.0.0.1:28090"), "Hive node RPC URL [http[s]://]host[:port]");
+   cli.add_options()("hive-node-rpc-url", bpo::value<vector<string>>()->composing()->multitoken()->DEFAULT_VALUE_VECTOR("127.0.0.1:28090"), "Hive node RPC URL [http[s]://]host[:port]");
    cli.add_options()("hive-node-rpc-user", bpo::value<string>(), "Hive node RPC user");
    cli.add_options()("hive-node-rpc-password", bpo::value<string>(), "Hive node RPC password");
    cli.add_options()("hive-wallet-account-name", bpo::value<string>(), "Hive wallet account name");
@@ -237,12 +256,14 @@ void peerplays_sidechain_plugin_impl::plugin_initialize(const boost::program_opt
    }
 
    sidechain_enabled_bitcoin = options.at("bitcoin-sidechain-enabled").as<bool>();
-   config_ready_bitcoin = options.count("bitcoin-node-ip") &&
-                          options.count("bitcoin-node-zmq-port") && options.count("bitcoin-node-rpc-port") &&
-                          options.count("bitcoin-node-rpc-user") && options.count("bitcoin-node-rpc-password") &&
-                          options.count("bitcoin-wallet-name") && options.count("bitcoin-wallet-password") &&
-                          options.count("bitcoin-private-key");
-   if (sidechain_enabled_bitcoin && !config_ready_bitcoin) {
+
+   config_ready_bitcoin = (((options.count("libbitcoin-server-ip") && options.count("libbitcoin-server-zmq-port")) ||
+                            (options.count("bitcoin-node-ip") && options.count("bitcoin-node-zmq-port") &&
+                             options.count("bitcoin-node-rpc-port") && options.count("bitcoin-node-rpc-user") &&
+                             options.count("bitcoin-node-rpc-password") && options.count("bitcoin-wallet-name") &&
+                             options.count("bitcoin-wallet-password"))) &&
+                           options.count("bitcoin-private-key"));
+   if (!config_ready_bitcoin) {
       wlog("Haven't set up Bitcoin sidechain parameters");
    }
 
@@ -273,6 +294,9 @@ void peerplays_sidechain_plugin_impl::plugin_initialize(const boost::program_opt
    if (sidechain_enabled_peerplays && !config_ready_peerplays) {
       wlog("Haven't set up Peerplays sidechain parameters");
    }
+
+   if (options.at("simulate-rpc-connection-reselection").as<bool>())
+      ilog("### RPC connection reselection will be simulated");
 }
 
 void peerplays_sidechain_plugin_impl::plugin_startup() {
@@ -288,21 +312,25 @@ void peerplays_sidechain_plugin_impl::plugin_startup() {
    sidechain_net_handler_factory net_handler_factory(plugin);
 
    if (sidechain_enabled_bitcoin && config_ready_bitcoin) {
+      sidechain_enabled.at(sidechain_type::bitcoin) = true;
       net_handlers.at(sidechain_type::bitcoin) = net_handler_factory.create_handler(sidechain_type::bitcoin, options);
       ilog("Bitcoin sidechain handler running");
    }
 
    if (sidechain_enabled_ethereum && config_ready_ethereum) {
+      sidechain_enabled.at(sidechain_type::ethereum) = true;
       net_handlers.at(sidechain_type::ethereum) = net_handler_factory.create_handler(sidechain_type::ethereum, options);
       ilog("Ethereum sidechain handler running");
    }
 
    if (sidechain_enabled_hive && config_ready_hive) {
+      sidechain_enabled.at(sidechain_type::hive) = true;
       net_handlers.at(sidechain_type::hive) = net_handler_factory.create_handler(sidechain_type::hive, options);
       ilog("Hive sidechain handler running");
    }
 
    if (sidechain_enabled_peerplays && config_ready_peerplays) {
+      sidechain_enabled.at(sidechain_type::peerplays) = true;
       net_handlers.at(sidechain_type::peerplays) = net_handler_factory.create_handler(sidechain_type::peerplays, options);
       ilog("Peerplays sidechain handler running");
    }
@@ -346,7 +374,7 @@ bool peerplays_sidechain_plugin_impl::is_active_son(sidechain_type sidechain, so
    set<son_id_type> active_son_ids;
    std::transform(gpo.active_sons.at(sidechain).cbegin(), gpo.active_sons.at(sidechain).cend(),
                   std::inserter(active_son_ids, active_son_ids.end()),
-                  [](const son_info &swi) {
+                  [](const son_sidechain_info &swi) {
                      return swi.son_id;
                   });
 
@@ -384,14 +412,14 @@ bool peerplays_sidechain_plugin_impl::is_son_down_op_valid(const chain::operatio
    const chain::global_property_object &gpo = d.get_global_properties();
    const chain::dynamic_global_property_object &dgpo = d.get_dynamic_global_properties();
    const auto &idx = d.get_index_type<chain::son_index>().indices().get<by_id>();
-   son_report_down_operation down_op = op.get<son_report_down_operation>();
-   auto son_obj = idx.find(down_op.son_id);
+   const son_report_down_operation down_op = op.get<son_report_down_operation>();
+   const auto son_obj = idx.find(down_op.son_id);
    if (son_obj == idx.end()) {
       return false;
    }
-   auto stats = son_obj->statistics(d);
-   fc::time_point_sec last_maintenance_time = dgpo.next_maintenance_time - gpo.parameters.maintenance_interval;
-   int64_t down_threshold = gpo.parameters.son_down_time();
+   const auto stats = son_obj->statistics(d);
+   const fc::time_point_sec last_maintenance_time = dgpo.next_maintenance_time - gpo.parameters.maintenance_interval;
+   const int64_t down_threshold = gpo.parameters.son_down_time();
 
    bool status_son_down_op_valid = true;
    for (const auto &status : son_obj->statuses) {
@@ -399,10 +427,12 @@ bool peerplays_sidechain_plugin_impl::is_son_down_op_valid(const chain::operatio
          status_son_down_op_valid = false;
    }
    if (status_son_down_op_valid) {
-      for (const auto &active_sidechain_type : active_sidechain_types) {
-         fc::time_point_sec last_active_ts = ((stats.last_active_timestamp.at(active_sidechain_type) > last_maintenance_time) ? stats.last_active_timestamp.at(active_sidechain_type) : last_maintenance_time);
-         if (((fc::time_point::now() - last_active_ts) <= fc::seconds(down_threshold))) {
-            status_son_down_op_valid = false;
+      for (const auto &active_sidechain_type : active_sidechain_types(d.head_block_time())) {
+         if (stats.last_active_timestamp.contains(active_sidechain_type)) {
+            const fc::time_point_sec last_active_ts = ((stats.last_active_timestamp.at(active_sidechain_type) > last_maintenance_time) ? stats.last_active_timestamp.at(active_sidechain_type) : last_maintenance_time);
+            if (((fc::time_point::now() - last_active_ts) <= fc::seconds(down_threshold))) {
+               status_son_down_op_valid = false;
+            }
          }
       }
    }
@@ -450,9 +480,11 @@ void peerplays_sidechain_plugin_impl::heartbeat_loop() {
 
       //! Check that son is active (at least for one sidechain_type)
       bool is_son_active = false;
-      for (const auto &active_sidechain_type : active_sidechain_types) {
-         if (is_active_son(active_sidechain_type, son_id))
-            is_son_active = true;
+      for (const auto &active_sidechain_type : active_sidechain_types(d.head_block_time())) {
+         if (sidechain_enabled.at(active_sidechain_type)) {
+            if (is_active_son(active_sidechain_type, son_id))
+               is_son_active = true;
+         }
       }
 
       if (is_son_active || status_in_maintenance) {
@@ -486,10 +518,17 @@ void peerplays_sidechain_plugin_impl::schedule_son_processing() {
 
    const auto next_wakeup = now + std::chrono::microseconds(time_to_next_son_processing);
 
-   for (const auto &active_sidechain_type : active_sidechain_types) {
+   for (const auto &active_sidechain_type : active_sidechain_types(plugin.database().head_block_time())) {
+      if (_son_processing_task.count(active_sidechain_type) != 0 && _son_processing_task.at(active_sidechain_type).wait_for(std::chrono::seconds{0}) != std::future_status::ready) {
+         wlog("Son doesn't process in time for sidechain: ${active_sidechain_type}", ("active_sidechain_type", active_sidechain_type));
+         _son_processing_task.at(active_sidechain_type).wait();
+      }
+
       _son_processing_task[active_sidechain_type] = std::async(std::launch::async, [this, next_wakeup, active_sidechain_type] {
-         std::this_thread::sleep_until(next_wakeup);
-         son_processing(active_sidechain_type);
+         if (sidechain_enabled.at(active_sidechain_type)) {
+            std::this_thread::sleep_until(next_wakeup);
+            son_processing(active_sidechain_type);
+         }
       });
    }
 }
@@ -501,11 +540,11 @@ void peerplays_sidechain_plugin_impl::son_processing(sidechain_type sidechain) {
       return;
    }
 
-   //fc::time_point now_fine = fc::time_point::now();
-   //fc::time_point_sec now = now_fine + fc::microseconds(500000);
-   //if (plugin.database().get_slot_time(1) < now) {
-   //   return; // Not synced
-   //}
+   // fc::time_point now_fine = fc::time_point::now();
+   // fc::time_point_sec now = now_fine + fc::microseconds(500000);
+   // if (plugin.database().get_slot_time(1) < now) {
+   //    return; // Not synced
+   // }
 
    const fc::time_point now_fine = fc::time_point::now();
    const fc::time_point_sec now = now_fine - fc::milliseconds(3000);
@@ -596,19 +635,35 @@ bool peerplays_sidechain_plugin_impl::can_son_participate(sidechain_type sidecha
 
 std::map<sidechain_type, std::vector<std::string>> peerplays_sidechain_plugin_impl::get_son_listener_log() {
    std::map<sidechain_type, std::vector<std::string>> result;
-   for (const auto &active_sidechain_type : active_sidechain_types) {
-      result.emplace(active_sidechain_type, net_handlers.at(active_sidechain_type)->get_son_listener_log());
+   for (const auto &active_sidechain_type : active_sidechain_types(plugin.database().head_block_time())) {
+      if (net_handlers.at(active_sidechain_type)) {
+         result.emplace(active_sidechain_type, net_handlers.at(active_sidechain_type)->get_son_listener_log());
+      }
    }
    return result;
 }
 
+optional<asset> peerplays_sidechain_plugin_impl::estimate_withdrawal_transaction_fee(sidechain_type sidechain) {
+   if (net_handlers.count(sidechain) == 0) {
+      wlog("No net handler for sidechain: ${sidechain}", ("sidechain", sidechain));
+      return optional<asset>();
+   }
+
+   if (!net_handlers.at(sidechain)) {
+      wlog("Net handler is null for sidechain: ${sidechain}", ("sidechain", sidechain));
+      return optional<asset>();
+   }
+
+   return net_handlers.at(sidechain)->estimate_withdrawal_transaction_fee();
+}
+
 void peerplays_sidechain_plugin_impl::approve_proposals(sidechain_type sidechain) {
    // prevent approving duplicate proposals with lock for parallel execution.
    // We can have the same propsals, but in the case of parallel execution we can run
    // into problem of approving the same propsal since it might happens that previous
    // approved proposal didn't have time or chance to populate the list of available
    // active proposals which is consulted here in the code.
-   std::lock_guard<std::mutex> lck(access_approve_prop_mutex);
+   const std::lock_guard<std::mutex> lck{access_approve_prop_mutex};
    auto check_approve_proposal = [&](const chain::son_id_type &son_id, const chain::proposal_object &proposal) {
       if (!is_valid_son_proposal(proposal)) {
          return;
@@ -658,7 +713,7 @@ void peerplays_sidechain_plugin_impl::approve_proposals(sidechain_type sidechain
 }
 
 void peerplays_sidechain_plugin_impl::create_son_down_proposals(sidechain_type sidechain) {
-   std::lock_guard<std::mutex> lck(access_son_down_prop_mutex);
+   const std::lock_guard<std::mutex> lck{access_son_down_prop_mutex};
    auto create_son_down_proposal = [&](chain::son_id_type son_id, fc::time_point_sec last_active_ts) {
       chain::database &d = plugin.database();
       const chain::global_property_object &gpo = d.get_global_properties();
@@ -671,7 +726,7 @@ void peerplays_sidechain_plugin_impl::create_son_down_proposals(sidechain_type s
       proposal_create_operation proposal_op;
       proposal_op.fee_paying_account = get_current_son_object(sidechain).son_account;
       proposal_op.proposed_ops.emplace_back(op_wrapper(son_down_op));
-      uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
+      const uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
       proposal_op.expiration_time = time_point_sec(d.head_block_time().sec_since_epoch() + lifetime);
       return proposal_op;
    };
@@ -680,19 +735,27 @@ void peerplays_sidechain_plugin_impl::create_son_down_proposals(sidechain_type s
    const chain::global_property_object &gpo = d.get_global_properties();
    const chain::dynamic_global_property_object &dgpo = d.get_dynamic_global_properties();
    const auto &idx = d.get_index_type<chain::son_index>().indices().get<by_id>();
-   std::set<son_id_type> sons_being_reported_down = d.get_sons_being_reported_down();
-   chain::son_id_type my_son_id = get_current_son_id(sidechain);
+   const std::set<son_id_type> sons_being_reported_down = d.get_sons_being_reported_down();
+   const chain::son_id_type my_son_id = get_current_son_id(sidechain);
 
    //! Fixme - check this part of the code
    for (auto son_inf : gpo.active_sons.at(sidechain)) {
       if (my_son_id == son_inf.son_id || (sons_being_reported_down.find(son_inf.son_id) != sons_being_reported_down.end())) {
          continue;
       }
-      auto son_obj = idx.find(son_inf.son_id);
-      auto stats = son_obj->statistics(d);
-      fc::time_point_sec last_maintenance_time = dgpo.next_maintenance_time - gpo.parameters.maintenance_interval;
-      fc::time_point_sec last_active_ts = ((stats.last_active_timestamp.at(sidechain) > last_maintenance_time) ? stats.last_active_timestamp.at(sidechain) : last_maintenance_time);
-      int64_t down_threshold = gpo.parameters.son_down_time();
+
+      const auto son_obj = idx.find(son_inf.son_id);
+      const auto stats = son_obj->statistics(d);
+      const fc::time_point_sec last_maintenance_time = dgpo.next_maintenance_time - gpo.parameters.maintenance_interval;
+      const fc::time_point_sec last_active_ts = [&stats, &sidechain, &last_maintenance_time] {
+         fc::time_point_sec last_active_ts;
+         if (stats.last_active_timestamp.contains(sidechain)) {
+            last_active_ts = (stats.last_active_timestamp.at(sidechain) > last_maintenance_time) ? stats.last_active_timestamp.at(sidechain) : last_maintenance_time;
+         } else
+            last_active_ts = last_maintenance_time;
+         return last_active_ts;
+      }();
+      const int64_t down_threshold = gpo.parameters.son_down_time();
 
       bool status_son_down_valid = true;
       for (const auto &status : son_obj->statuses) {
@@ -722,6 +785,7 @@ void peerplays_sidechain_plugin_impl::create_son_down_proposals(sidechain_type s
 }
 
 void peerplays_sidechain_plugin_impl::create_son_deregister_proposals(sidechain_type sidechain) {
+   const std::lock_guard<std::mutex> lck{access_son_deregister_prop_mutex};
    chain::database &d = plugin.database();
    std::set<son_id_type> sons_to_be_dereg = d.get_sons_to_be_deregistered();
    chain::son_id_type my_son_id = get_current_son_id(sidechain);
@@ -760,40 +824,65 @@ void peerplays_sidechain_plugin_impl::create_son_deregister_proposals(sidechain_
 }
 
 void peerplays_sidechain_plugin_impl::process_proposals(sidechain_type sidechain) {
-   net_handlers.at(sidechain)->process_proposals();
+   if (net_handlers.at(sidechain)) {
+      net_handlers.at(sidechain)->process_proposals();
+   }
 }
 
 void peerplays_sidechain_plugin_impl::process_active_sons_change(sidechain_type sidechain) {
-   net_handlers.at(sidechain)->process_active_sons_change();
+   if (net_handlers.at(sidechain)) {
+      net_handlers.at(sidechain)->process_active_sons_change();
+   }
 }
 
 void peerplays_sidechain_plugin_impl::create_deposit_addresses(sidechain_type sidechain) {
-   net_handlers.at(sidechain)->create_deposit_addresses();
+   if (net_handlers.at(sidechain)) {
+      net_handlers.at(sidechain)->create_deposit_addresses();
+   }
 }
 
 void peerplays_sidechain_plugin_impl::process_deposits(sidechain_type sidechain) {
-   net_handlers.at(sidechain)->process_deposits();
+   if (net_handlers.at(sidechain)) {
+      net_handlers.at(sidechain)->process_deposits();
+   }
 }
 
 void peerplays_sidechain_plugin_impl::process_withdrawals(sidechain_type sidechain) {
-   net_handlers.at(sidechain)->process_withdrawals();
+   if (net_handlers.at(sidechain)) {
+      net_handlers.at(sidechain)->process_withdrawals();
+   }
 }
 
 void peerplays_sidechain_plugin_impl::process_sidechain_transactions(sidechain_type sidechain) {
-   net_handlers.at(sidechain)->process_sidechain_transactions();
+   if (net_handlers.at(sidechain)) {
+      net_handlers.at(sidechain)->process_sidechain_transactions();
+   }
 }
 
 void peerplays_sidechain_plugin_impl::send_sidechain_transactions(sidechain_type sidechain) {
-   net_handlers.at(sidechain)->send_sidechain_transactions();
+   if (net_handlers.at(sidechain)) {
+      net_handlers.at(sidechain)->send_sidechain_transactions();
+   }
 }
 
 void peerplays_sidechain_plugin_impl::settle_sidechain_transactions(sidechain_type sidechain) {
-   net_handlers.at(sidechain)->settle_sidechain_transactions();
+   if (net_handlers.at(sidechain)) {
+      net_handlers.at(sidechain)->settle_sidechain_transactions();
+   }
 }
 
 void peerplays_sidechain_plugin_impl::on_applied_block(const signed_block &b) {
    if (first_block_skipped) {
-      schedule_son_processing();
+      if (son_processing_enabled) {
+         schedule_son_processing();
+      } else {
+         const fc::time_point now_fine = fc::time_point::now();
+         const fc::time_point_sec now = now_fine + fc::microseconds(500000);
+         if (plugin.database().get_slot_time(1) >= now) {
+            son_processing_enabled = true;
+            schedule_son_processing();
+         }
+      }
    } else {
       first_block_skipped = true;
    }
@@ -881,4 +970,8 @@ std::map<sidechain_type, std::vector<std::string>> peerplays_sidechain_plugin::g
    return my->get_son_listener_log();
 }
 
+optional<asset> peerplays_sidechain_plugin::estimate_withdrawal_transaction_fee(sidechain_type sidechain) {
+   return my->estimate_withdrawal_transaction_fee(sidechain);
+}
+
 }} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/sidechain_api.cpp

@@ -12,6 +12,7 @@ public:
    std::shared_ptr<graphene::peerplays_sidechain::peerplays_sidechain_plugin> get_plugin();
 
    std::map<sidechain_type, std::vector<std::string>> get_son_listener_log();
+   optional<asset> estimate_withdrawal_transaction_fee(sidechain_type sidechain);
 
 private:
    app::application &app;
@@ -32,6 +33,10 @@ std::map<sidechain_type, std::vector<std::string>> sidechain_api_impl::get_son_l
    return get_plugin()->get_son_listener_log();
 }
 
+optional<asset> sidechain_api_impl::estimate_withdrawal_transaction_fee(sidechain_type sidechain) {
+   return get_plugin()->estimate_withdrawal_transaction_fee(sidechain);
+}
+
 } // namespace detail
 
 sidechain_api::sidechain_api(graphene::app::application &_app) :
@@ -45,4 +50,8 @@ std::map<sidechain_type, std::vector<std::string>> sidechain_api::get_son_listen
    return my->get_son_listener_log();
 }
 
+optional<asset> sidechain_api::estimate_withdrawal_transaction_fee(sidechain_type sidechain) {
+   return my->estimate_withdrawal_transaction_fee(sidechain);
+}
+
 }} // namespace graphene::peerplays_sidechain

libraries/plugins/peerplays_sidechain/sidechain_net_handler.cpp

@@ -9,7 +9,8 @@
 
 namespace graphene { namespace peerplays_sidechain {
 
-sidechain_net_handler::sidechain_net_handler(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options) :
+sidechain_net_handler::sidechain_net_handler(sidechain_type _sidechain, peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options) :
+      sidechain(_sidechain),
       plugin(_plugin),
       database(_plugin.database()) {
 
@@ -21,11 +22,11 @@ sidechain_net_handler::sidechain_net_handler(peerplays_sidechain_plugin &_plugin
 sidechain_net_handler::~sidechain_net_handler() {
 }
 
-sidechain_type sidechain_net_handler::get_sidechain() {
+sidechain_type sidechain_net_handler::get_sidechain() const {
    return sidechain;
 }
 
-std::vector<std::string> sidechain_net_handler::get_sidechain_deposit_addresses() {
+std::vector<std::string> sidechain_net_handler::get_sidechain_deposit_addresses() const {
    std::vector<std::string> result;
 
    const auto &sidechain_addresses_idx = database.get_index_type<sidechain_address_index>();
@@ -38,7 +39,7 @@ std::vector<std::string> sidechain_net_handler::get_sidechain_deposit_addresses(
    return result;
 }
 
-std::vector<std::string> sidechain_net_handler::get_sidechain_withdraw_addresses() {
+std::vector<std::string> sidechain_net_handler::get_sidechain_withdraw_addresses() const {
    std::vector<std::string> result;
 
    const auto &sidechain_addresses_idx = database.get_index_type<sidechain_address_index>();
@@ -51,7 +52,20 @@ std::vector<std::string> sidechain_net_handler::get_sidechain_withdraw_addresses
    return result;
 }
 
-std::string sidechain_net_handler::get_private_key(std::string public_key) {
+std::vector<sidechain_transaction_object> sidechain_net_handler::get_sidechain_transaction_objects(sidechain_transaction_status status) const {
+   std::vector<sidechain_transaction_object> result;
+
+   const auto &idx = database.get_index_type<sidechain_transaction_index>().indices().get<by_sidechain_and_status>();
+   const auto &idx_range = idx.equal_range(std::make_tuple(sidechain, status));
+   std::for_each(idx_range.first, idx_range.second,
+                 [&result](const sidechain_transaction_object &sto) {
+                    result.push_back(sto);
+                 });
+
+   return result;
+}
+
+std::string sidechain_net_handler::get_private_key(std::string public_key) const {
    auto private_key_itr = private_keys.find(public_key);
    if (private_key_itr != private_keys.end()) {
       return private_key_itr->second;
@@ -170,29 +184,32 @@ void sidechain_net_handler::sidechain_event_data_received(const sidechain_event_
 
    bool enable_peerplays_asset_deposits = false;
 #ifdef ENABLE_PEERPLAYS_ASSET_DEPOSITS
-   //enable_peerplays_asset_deposits = (sed.sidechain == sidechain_type::peerplays) &&
-   //                                  (sed.sidechain_currency.compare("BTC") != 0) &&
-   //                                  (sed.sidechain_currency.compare("ETH") != 0) &&
-   //                                  (sed.sidechain_currency.compare("HBD") != 0) &&
-   //                                  (sed.sidechain_currency.compare("HIVE") != 0);
+   // enable_peerplays_asset_deposits = (sed.sidechain == sidechain_type::peerplays) &&
+   //                                   (sed.sidechain_currency.compare("BTC") != 0) &&
+   //                                   (sed.sidechain_currency.compare("ETH") != 0) &&
+   //                                   (sed.sidechain_currency.compare("HBD") != 0) &&
+   //                                   (sed.sidechain_currency.compare("HIVE") != 0);
 #endif
 
-   bool deposit_condition = (sed.peerplays_to == gpo.parameters.son_account()) &&
-                            (((sed.sidechain == sidechain_type::bitcoin) && (sed.sidechain_currency.compare("BTC") == 0)) ||
-                             ((sed.sidechain == sidechain_type::ethereum) && (sed.sidechain_currency.compare("ETH") == 0)) ||
-                             ((sed.sidechain == sidechain_type::hive) && (sed.sidechain_currency.compare("HBD") == 0)) ||
-                             ((sed.sidechain == sidechain_type::hive) && (sed.sidechain_currency.compare("HIVE") == 0)) ||
-                             enable_peerplays_asset_deposits);
+   const bool deposit_condition = (sed.peerplays_to == gpo.parameters.son_account()) &&
+                                  (sed.sidechain == sidechain) &&
+                                  (sed.type == sidechain_event_type::deposit) &&
+                                  (((sed.sidechain == sidechain_type::bitcoin) && (sed.sidechain_currency.compare("BTC") == 0)) ||
+                                   ((sed.sidechain == sidechain_type::ethereum) && (!sed.sidechain_currency.empty())) ||
+                                   ((sed.sidechain == sidechain_type::hive) && (sed.sidechain_currency.compare("HBD") == 0)) ||
+                                   ((sed.sidechain == sidechain_type::hive) && (sed.sidechain_currency.compare("HIVE") == 0)) ||
+                                   enable_peerplays_asset_deposits);
 
-   bool withdraw_condition = (sed.peerplays_to == gpo.parameters.son_account()) && (sed.sidechain == sidechain) && //! Fixme -> sidechain_type::peerplays
-                             ((sed.sidechain_currency == object_id_to_string(gpo.parameters.btc_asset())) ||
-                              (sed.sidechain_currency == object_id_to_string(gpo.parameters.eth_asset())) ||
-                              (sed.sidechain_currency == object_id_to_string(gpo.parameters.hbd_asset())) ||
-                              (sed.sidechain_currency == object_id_to_string(gpo.parameters.hive_asset())));
+   const bool withdraw_condition = (sed.peerplays_to == gpo.parameters.son_account()) &&
+                                   (sed.sidechain == sidechain) &&
+                                   (sed.type == sidechain_event_type::withdrawal) &&
+                                   (((sed.sidechain == sidechain_type::bitcoin) && (sed.sidechain_currency == object_id_to_string(gpo.parameters.btc_asset()))) ||
+                                    ((sed.sidechain == sidechain_type::ethereum) && (!sed.sidechain_currency.empty())) ||
+                                    ((sed.sidechain == sidechain_type::hive) && (sed.sidechain_currency == object_id_to_string(gpo.parameters.hbd_asset()))) ||
+                                    ((sed.sidechain == sidechain_type::hive) && (sed.sidechain_currency == object_id_to_string(gpo.parameters.hive_asset()))));
 
    // Deposit request
    if (deposit_condition) {
-
       for (son_id_type son_id : plugin.get_sons()) {
          if (plugin.is_active_son(sidechain, son_id)) {
 
@@ -256,7 +273,17 @@ void sidechain_net_handler::sidechain_event_data_received(const sidechain_event_
          withdraw_currency_price = database.get<asset_object>(database.get_global_properties().parameters.hive_asset()).options.core_exchange_rate;
       }
       if (withdraw_currency.empty()) {
-         return;
+         //! This is ERC-20 withdrawal
+         const auto asset_object_id = string_to_object_id(sed.sidechain_currency);
+         const auto &assets_by_id = database.get_index_type<asset_index>().indices().get<by_id>();
+         const auto asset_itr = assets_by_id.find(asset_object_id);
+         if (asset_itr == assets_by_id.end()) {
+            wlog("Could not find asset: ${asset_object_id}", ("asset_object_id", asset_object_id));
+            return;
+         }
+
+         withdraw_currency = asset_itr->symbol;
+         withdraw_currency_price = asset_itr->options.core_exchange_rate;
       }
 
       for (son_id_type son_id : plugin.get_sons()) {
@@ -424,7 +451,7 @@ void sidechain_net_handler::process_deposits() {
       if (swdo.id == object_id_type(0, 0, 0) || !plugin.can_son_participate(sidechain, chain::operation::tag<chain::son_wallet_deposit_process_operation>::value, swdo.id)) {
          return;
       }
-      //Ignore the deposits which are not valid anymore, considered refunds.
+      // Ignore the deposits which are not valid anymore, considered refunds.
       const auto &sidechain_addresses_idx = database.get_index_type<sidechain_address_index>().indices().get<by_sidechain_and_deposit_address_and_expires>();
       const auto &addr_itr = sidechain_addresses_idx.find(std::make_tuple(sidechain, swdo.sidechain_from, time_point_sec::maximum()));
       if (addr_itr == sidechain_addresses_idx.end()) {
@@ -473,10 +500,9 @@ void sidechain_net_handler::process_withdrawals() {
 }
 
 void sidechain_net_handler::process_sidechain_transactions() {
-   const auto &idx = database.get_index_type<sidechain_transaction_index>().indices().get<by_sidechain_and_status>();
-   const auto &idx_range = idx.equal_range(std::make_tuple(sidechain, sidechain_transaction_status::valid));
+   const auto stos = get_sidechain_transaction_objects(sidechain_transaction_status::valid);
 
-   std::for_each(idx_range.first, idx_range.second, [&](const sidechain_transaction_object &sto) {
+   std::for_each(stos.cbegin(), stos.cend(), [&](const sidechain_transaction_object &sto) {
       if ((sto.id == object_id_type(0, 0, 0)) || !signer_expected(sto, plugin.get_current_son_id(sidechain))) {
          return;
       }
@@ -520,10 +546,9 @@ void sidechain_net_handler::process_sidechain_transactions() {
 }
 
 void sidechain_net_handler::send_sidechain_transactions() {
-   const auto &idx = database.get_index_type<sidechain_transaction_index>().indices().get<by_sidechain_and_status>();
-   const auto &idx_range = idx.equal_range(std::make_tuple(sidechain, sidechain_transaction_status::complete));
+   const auto stos = get_sidechain_transaction_objects(sidechain_transaction_status::complete);
 
-   std::for_each(idx_range.first, idx_range.second, [&](const sidechain_transaction_object &sto) {
+   std::for_each(stos.cbegin(), stos.cend(), [&](const sidechain_transaction_object &sto) {
       if (sto.id == object_id_type(0, 0, 0)) {
          return;
       }
@@ -555,10 +580,9 @@ void sidechain_net_handler::send_sidechain_transactions() {
 }
 
 void sidechain_net_handler::settle_sidechain_transactions() {
-   const auto &idx = database.get_index_type<sidechain_transaction_index>().indices().get<by_sidechain_and_status>();
-   const auto &idx_range = idx.equal_range(std::make_tuple(sidechain, sidechain_transaction_status::sent));
+   const auto stos = get_sidechain_transaction_objects(sidechain_transaction_status::sent);
 
-   std::for_each(idx_range.first, idx_range.second, [&](const sidechain_transaction_object &sto) {
+   std::for_each(stos.cbegin(), stos.cend(), [&](const sidechain_transaction_object &sto) {
       if (sto.id == object_id_type(0, 0, 0)) {
          return;
       }
@@ -653,9 +677,10 @@ void sidechain_net_handler::on_applied_block(const signed_block &b) {
                continue;
             }
 
-            bool is_tracked_asset =
+            const bool is_tracked_asset =
                   ((sidechain == sidechain_type::bitcoin) && (transfer_op.amount.asset_id == gpo.parameters.btc_asset())) ||
                   ((sidechain == sidechain_type::ethereum) && (transfer_op.amount.asset_id == gpo.parameters.eth_asset())) ||
+                  ((sidechain == sidechain_type::ethereum) && (transfer_op.amount.asset_id != gpo.parameters.btc_asset()) && (transfer_op.amount.asset_id != gpo.parameters.hbd_asset()) && (transfer_op.amount.asset_id != gpo.parameters.hive_asset()) && (transfer_op.amount.asset_id != asset_id_type())) ||
                   ((sidechain == sidechain_type::hive) && (transfer_op.amount.asset_id == gpo.parameters.hbd_asset())) ||
                   ((sidechain == sidechain_type::hive) && (transfer_op.amount.asset_id == gpo.parameters.hive_asset()));
 
@@ -681,7 +706,8 @@ void sidechain_net_handler::on_applied_block(const signed_block &b) {
             sidechain_event_data sed;
             sed.timestamp = database.head_block_time();
             sed.block_num = database.head_block_num();
-            sed.sidechain = sidechain; //! Fixme -> sidechain_type::peerplays
+            sed.sidechain = sidechain;
+            sed.type = sidechain_event_type::withdrawal;
             sed.sidechain_uid = sidechain_uid;
             sed.sidechain_transaction_id = trx.id().str();
             sed.sidechain_from = sidechain_from;

libraries/plugins/peerplays_sidechain/sidechain_net_handler_ethereum.cpp

@@ -14,8 +14,9 @@
 #include <graphene/chain/account_object.hpp>
 #include <graphene/chain/protocol/son_wallet.hpp>
 #include <graphene/chain/sidechain_transaction_object.hpp>
-#include <graphene/chain/son_info.hpp>
+#include <graphene/chain/son_sidechain_info.hpp>
 #include <graphene/chain/son_wallet_object.hpp>
+#include <graphene/peerplays_sidechain/ethereum/decoders.hpp>
 #include <graphene/peerplays_sidechain/ethereum/encoders.hpp>
 #include <graphene/peerplays_sidechain/ethereum/transaction.hpp>
 #include <graphene/peerplays_sidechain/ethereum/utils.hpp>
@@ -24,25 +25,30 @@
 
 namespace graphene { namespace peerplays_sidechain {
 
-ethereum_rpc_client::ethereum_rpc_client(const std::string &url, const std::string &user_name, const std::string &password, bool debug_rpc_calls) :
-      rpc_client(url, user_name, password, debug_rpc_calls) {
+ethereum_rpc_client::ethereum_rpc_client(const std::vector<rpc_credentials> &credentials, bool debug_rpc_calls, bool simulate_connection_reselection) :
+      rpc_client(sidechain_type::ethereum, credentials, debug_rpc_calls, simulate_connection_reselection) {
 }
 
-std::string ethereum_rpc_client::admin_node_info() {
-   return send_post_request("admin_nodeInfo", "", debug_rpc_calls);
+std::string ethereum_rpc_client::eth_blockNumber() {
+   const std::string reply_str = send_post_request("eth_blockNumber", "", debug_rpc_calls);
+   return retrieve_value_from_reply(reply_str, "");
 }
 
 std::string ethereum_rpc_client::eth_get_block_by_number(std::string block_number, bool full_block) {
-   std::string params = "[ \"" + block_number + "\", " + (full_block ? "true" : "false") + "]";
+   const std::string params = "[ \"" + block_number + "\", " + (full_block ? "true" : "false") + "]";
    return send_post_request("eth_getBlockByNumber", params, debug_rpc_calls);
 }
 
 std::string ethereum_rpc_client::eth_get_logs(std::string wallet_contract_address) {
-   std::string params = "[{\"address\": \"" + wallet_contract_address + "\"}]";
-   std::string reply_str = send_post_request("eth_getLogs", params, debug_rpc_calls);
+   const std::string params = "[{\"address\": \"" + wallet_contract_address + "\"}]";
+   const std::string reply_str = send_post_request("eth_getLogs", params, debug_rpc_calls);
    return retrieve_value_from_reply(reply_str, "");
 }
 
+std::string ethereum_rpc_client::eth_chainId() {
+   return send_post_request("eth_chainId", "", debug_rpc_calls);
+}
+
 std::string ethereum_rpc_client::net_version() {
    return send_post_request("net_version", "", debug_rpc_calls);
 }
@@ -55,29 +61,38 @@ std::string ethereum_rpc_client::eth_gas_price() {
    return send_post_request("eth_gasPrice", "", debug_rpc_calls);
 }
 
+std::string ethereum_rpc_client::eth_estimateGas(const std::string &params) {
+   return send_post_request("eth_estimateGas", params, debug_rpc_calls);
+}
+
 std::string ethereum_rpc_client::get_chain_id() {
-   std::string reply_str = net_version();
-   return retrieve_value_from_reply(reply_str, "");
+   const std::string reply_str = eth_chainId();
+   const auto chain_id_string = retrieve_value_from_reply(reply_str, "");
+   return chain_id_string.empty() ? "" : std::to_string(ethereum::from_hex<long long>(chain_id_string));
 }
 
 std::string ethereum_rpc_client::get_network_id() {
-   std::string reply_str = admin_node_info();
-   return retrieve_value_from_reply(reply_str, "protocols.eth.network");
+   const std::string reply_str = net_version();
+   return retrieve_value_from_reply(reply_str, "");
 }
 
 std::string ethereum_rpc_client::get_nonce(const std::string &address) {
-   std::string reply_str = eth_get_transaction_count("[\"" + address + "\", \"latest\"]");
-   const auto nonce_val = ethereum::from_hex<boost::multiprecision::uint256_t>(retrieve_value_from_reply(reply_str, ""));
-   return nonce_val == 0 ? ethereum::add_0x("0") : ethereum::add_0x(ethereum::to_hex(nonce_val));
+   const std::string reply_str = eth_get_transaction_count("[\"" + address + "\", \"pending\"]");
+   const auto nonce_string = retrieve_value_from_reply(reply_str, "");
+   if (!nonce_string.empty()) {
+      const auto nonce_val = ethereum::from_hex<boost::multiprecision::uint256_t>(nonce_string);
+      return nonce_val == 0 ? ethereum::add_0x("0") : ethereum::add_0x(ethereum::to_hex(nonce_val));
+   }
+   return "";
 }
 
 std::string ethereum_rpc_client::get_gas_price() {
-   std::string reply_str = eth_gas_price();
+   const std::string reply_str = eth_gas_price();
    return retrieve_value_from_reply(reply_str, "");
 }
 
 std::string ethereum_rpc_client::get_gas_limit() {
-   std::string reply_str = eth_get_block_by_number("latest", false);
+   const std::string reply_str = eth_get_block_by_number("latest", false);
    if (!reply_str.empty()) {
       std::stringstream ss(reply_str);
       boost::property_tree::ptree json;
@@ -90,6 +105,11 @@ std::string ethereum_rpc_client::get_gas_limit() {
    return std::string{};
 }
 
+std::string ethereum_rpc_client::get_estimate_gas(const std::string &params) {
+   const std::string reply_str = eth_estimateGas(params);
+   return retrieve_value_from_reply(reply_str, "");
+}
+
 std::string ethereum_rpc_client::eth_send_transaction(const std::string &params) {
    return send_post_request("eth_sendTransaction", "[" + params + "]", debug_rpc_calls);
 }
@@ -102,20 +122,33 @@ std::string ethereum_rpc_client::eth_get_transaction_receipt(const std::string &
    return send_post_request("eth_getTransactionReceipt", "[\"" + params + "\"]", debug_rpc_calls);
 }
 
+std::string ethereum_rpc_client::eth_get_transaction_by_hash(const std::string &params) {
+   return send_post_request("eth_getTransactionByHash", "[\"" + params + "\"]", debug_rpc_calls);
+}
+
+uint64_t ethereum_rpc_client::ping(rpc_connection &conn) const {
+   std::string reply = send_post_request(conn, "eth_blockNumber", "", debug_rpc_calls);
+   if (!reply.empty())
+      return ethereum::from_hex<uint64_t>(retrieve_value_from_reply(reply, ""));
+   return std::numeric_limits<uint64_t>::max();
+}
+
 sidechain_net_handler_ethereum::sidechain_net_handler_ethereum(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options) :
-      sidechain_net_handler(_plugin, options) {
-   sidechain = sidechain_type::ethereum;
+      sidechain_net_handler(sidechain_type::ethereum, _plugin, options) {
 
    if (options.count("debug-rpc-calls")) {
       debug_rpc_calls = options.at("debug-rpc-calls").as<bool>();
    }
+   bool simulate_connection_reselection = options.at("simulate-rpc-connection-reselection").as<bool>();
 
-   rpc_url = options.at("ethereum-node-rpc-url").as<std::string>();
+   std::vector<std::string> rpc_urls = options.at("ethereum-node-rpc-url").as<std::vector<std::string>>();
+   std::string rpc_user;
    if (options.count("ethereum-node-rpc-user")) {
       rpc_user = options.at("ethereum-node-rpc-user").as<std::string>();
    } else {
       rpc_user = "";
    }
+   std::string rpc_password;
    if (options.count("ethereum-node-rpc-password")) {
       rpc_password = options.at("ethereum-node-rpc-password").as<std::string>();
    } else {
@@ -124,6 +157,21 @@ sidechain_net_handler_ethereum::sidechain_net_handler_ethereum(peerplays_sidecha
 
    wallet_contract_address = options.at("ethereum-wallet-contract-address").as<std::string>();
 
+   if (options.count("ethereum-erc-20-address")) {
+      const std::vector<std::string> symbol_addresses = options["ethereum-erc-20-address"].as<std::vector<std::string>>();
+      for (const std::string &itr : symbol_addresses) {
+         auto itr_pair = graphene::app::dejsonify<std::pair<std::string, std::string>>(itr, 5);
+         ilog("ERC-20 symbol: ${symbol}, address: ${address}", ("symbol", itr_pair.first)("address", itr_pair.second));
+         if (!itr_pair.first.length() || !itr_pair.second.length()) {
+            FC_THROW("Invalid symbol address pair.");
+         }
+
+         auto address = itr_pair.second;
+         std::transform(address.begin(), address.end(), address.begin(), ::tolower);
+         erc20_addresses.insert(bimap_type::value_type{itr_pair.first, address});
+      }
+   }
+
    if (options.count("ethereum-private-key")) {
       const std::vector<std::string> pub_priv_keys = options["ethereum-private-key"].as<std::vector<std::string>>();
       for (const std::string &itr_key_pair : pub_priv_keys) {
@@ -136,20 +184,35 @@ sidechain_net_handler_ethereum::sidechain_net_handler_ethereum(peerplays_sidecha
       }
    }
 
-   rpc_client = new ethereum_rpc_client(rpc_url, rpc_user, rpc_password, debug_rpc_calls);
+   for (size_t i = 0; i < rpc_urls.size(); i++) {
+      rpc_credentials creds;
+      creds.url = rpc_urls[i];
+      creds.user = rpc_user;
+      creds.password = rpc_password;
+      _rpc_credentials.push_back(creds);
+   }
+   FC_ASSERT(!_rpc_credentials.empty());
 
-   std::string chain_id_str = rpc_client->get_chain_id();
+   rpc_client = new ethereum_rpc_client(_rpc_credentials, debug_rpc_calls, simulate_connection_reselection);
+
+   const std::string chain_id_str = rpc_client->get_chain_id();
    if (chain_id_str.empty()) {
-      elog("No Ethereum node running at ${url}", ("url", rpc_url));
+      elog("No Ethereum node running at ${url}", ("url", _rpc_credentials[0].url));
       FC_ASSERT(false);
    }
    chain_id = std::stoll(chain_id_str);
-   std::string network_id_str = rpc_client->get_network_id();
+
+   const std::string network_id_str = rpc_client->get_network_id();
+   if (network_id_str.empty()) {
+      elog("No Ethereum node running at ${url}", ("url", _rpc_credentials[0].url));
+      FC_ASSERT(false);
+   }
    network_id = std::stoll(network_id_str);
 
    ilog("Running on Ethereum network, chain id ${chain_id_str}, network id ${network_id_str}", ("chain_id_str", chain_id_str)("network_id_str", network_id_str));
 
-   last_block_received = 0;
+   const auto block_number = rpc_client->eth_blockNumber();
+   last_block_received = !block_number.empty() ? ethereum::from_hex<uint64_t>(block_number) : 0;
    schedule_ethereum_listener();
    event_received.connect([this](const std::string &event_data) {
       std::thread(&sidechain_net_handler_ethereum::handle_event, this, event_data).detach();
@@ -160,6 +223,7 @@ sidechain_net_handler_ethereum::~sidechain_net_handler_ethereum() {
 }
 
 bool sidechain_net_handler_ethereum::process_proposal(const proposal_object &po) {
+
    ilog("Proposal to process: ${po}, SON id ${son_id}", ("po", po.id)("son_id", plugin.get_current_son_id(sidechain)));
 
    bool should_approve = false;
@@ -188,13 +252,16 @@ bool sidechain_net_handler_ethereum::process_proposal(const proposal_object &po)
    case chain::operation::tag<chain::son_wallet_update_operation>::value: {
       bool address_ok = false;
       bool transaction_ok = false;
-      son_wallet_id_type swo_id = op_obj_idx_0.get<son_wallet_update_operation>().son_wallet_id;
+      const son_wallet_id_type swo_id = op_obj_idx_0.get<son_wallet_update_operation>().son_wallet_id;
+      const auto ast = active_sidechain_types(database.head_block_time());
+      const auto id = (swo_id.instance.value - std::distance(ast.begin(), ast.find(sidechain))) / ast.size();
+      const son_wallet_id_type op_id{id};
       const auto &idx = database.get_index_type<son_wallet_index>().indices().get<by_id>();
-      const auto swo = idx.find(swo_id);
+      const auto swo = idx.find(op_id);
       if (swo != idx.end()) {
 
-         auto active_sons = gpo.active_sons.at(sidechain);
-         vector<son_info> wallet_sons = swo->sons.at(sidechain);
+         const auto active_sons = gpo.active_sons.at(sidechain);
+         const vector<son_sidechain_info> wallet_sons = swo->sons.at(sidechain);
 
          bool son_sets_equal = (active_sons.size() == wallet_sons.size());
 
@@ -209,8 +276,10 @@ bool sidechain_net_handler_ethereum::process_proposal(const proposal_object &po)
          }
 
          if (po.proposed_transaction.operations.size() >= 2) {
-            object_id_type object_id = op_obj_idx_1.get<sidechain_transaction_create_operation>().object_id;
-            std::string op_tx_str = op_obj_idx_1.get<sidechain_transaction_create_operation>().transaction;
+            const object_id_type object_id = op_obj_idx_1.get<sidechain_transaction_create_operation>().object_id;
+            const auto id = (object_id.instance() - std::distance(ast.begin(), ast.find(sidechain))) / ast.size();
+            const object_id_type obj_id{object_id.space(), object_id.type(), id};
+            const std::string op_tx_str = op_obj_idx_1.get<sidechain_transaction_create_operation>().transaction;
 
             const auto &st_idx = database.get_index_type<sidechain_transaction_index>().indices().get<by_object_id>();
             const auto st = st_idx.find(object_id);
@@ -218,9 +287,9 @@ bool sidechain_net_handler_ethereum::process_proposal(const proposal_object &po)
 
                std::string tx_str = "";
 
-               if (object_id.is<son_wallet_id_type>()) {
+               if (obj_id.is<son_wallet_id_type>()) {
                   const auto &idx = database.get_index_type<son_wallet_index>().indices().get<by_id>();
-                  const auto swo = idx.find(object_id);
+                  const auto swo = idx.find(obj_id);
                   if (swo != idx.end()) {
                      tx_str = create_primary_wallet_transaction(gpo.active_sons.at(sidechain), object_id.operator std::string());
                   }
@@ -240,64 +309,65 @@ bool sidechain_net_handler_ethereum::process_proposal(const proposal_object &po)
 
    case chain::operation::tag<chain::son_wallet_deposit_process_operation>::value: {
       bool process_ok = false;
-      son_wallet_deposit_id_type swdo_id = op_obj_idx_0.get<son_wallet_deposit_process_operation>().son_wallet_deposit_id;
+      const son_wallet_deposit_id_type swdo_id = op_obj_idx_0.get<son_wallet_deposit_process_operation>().son_wallet_deposit_id;
       const auto &idx = database.get_index_type<son_wallet_deposit_index>().indices().get<by_id>();
       const auto swdo = idx.find(swdo_id);
       if (swdo != idx.end()) {
 
-         //std::string swdo_txid = swdo->sidechain_transaction_id;
-         //std::string swdo_sidechain_from = swdo->sidechain_from;
-         //std::string swdo_sidechain_currency = swdo->sidechain_currency;
-         //uint64_t swdo_sidechain_amount = swdo->sidechain_amount.value;
-         //uint64_t swdo_op_idx = std::stoll(swdo->sidechain_uid.substr(swdo->sidechain_uid.find_last_of("-")));
-         //
-         //std::string tx_str = rpc_client->account_history_api_get_transaction(swdo_txid);
-         //if (tx_str != "") {
-         //
-         //   std::stringstream ss_tx(tx_str);
-         //   boost::property_tree::ptree tx;
-         //   boost::property_tree::read_json(ss_tx, tx);
-         //
-         //   uint64_t op_idx = -1;
-         //   for (const auto &ops : tx.get_child("result.operations")) {
-         //      const auto &op = ops.second;
-         //      op_idx = op_idx + 1;
-         //      if (op_idx == swdo_op_idx) {
-         //         std::string operation_type = op.get<std::string>("type");
-         //
-         //         if (operation_type == "transfer_operation") {
-         //            const auto &op_value = op.get_child("value");
-         //
-         //            std::string sidechain_from = op_value.get<std::string>("from");
-         //
-         //            const auto &amount_child = op_value.get_child("amount");
-         //
-         //            uint64_t amount = amount_child.get<uint64_t>("amount");
-         //            std::string nai = amount_child.get<std::string>("nai");
-         //            std::string sidechain_currency = "";
-         //            if ((nai == "@@000000013" /*?? HBD*/) || (nai == "@@000000013" /*TBD*/)) {
-         //               sidechain_currency = "HBD";
-         //            }
-         //            if ((nai == "@@000000021") /*?? HIVE*/ || (nai == "@@000000021" /*TESTS*/)) {
-         //               sidechain_currency = "HIVE";
-         //            }
-         //
-         //            std::string memo = op_value.get<std::string>("memo");
-         //            boost::trim(memo);
-         //            if (!memo.empty()) {
-         //               sidechain_from = memo;
-         //            }
-         //
-         //            process_ok = (swdo_sidechain_from == sidechain_from) &&
-         //                         (swdo_sidechain_currency == sidechain_currency) &&
-         //                         (swdo_sidechain_amount == amount);
-         //         }
-         //      }
-         //   }
-         //}
-      }
+         const std::string swdo_txid = swdo->sidechain_transaction_id;
+         const std::string swdo_sidechain_from = swdo->sidechain_from;
+         const std::string swdo_sidechain_currency = swdo->sidechain_currency;
+         const uint64_t swdo_sidechain_amount = swdo->sidechain_amount.value;
 
-      process_ok = true;
+         const std::string tx_str = rpc_client->eth_get_transaction_by_hash(swdo_txid);
+         if (tx_str != "") {
+
+            std::stringstream ss_tx(tx_str);
+            boost::property_tree::ptree tx;
+            boost::property_tree::read_json(ss_tx, tx);
+
+            if (tx.get<std::string>("result") != "null") {
+
+               const std::string sidechain_from = tx.get<std::string>("result.from");
+               const std::string sidechain_to = tx.get<std::string>("result.to");
+
+               std::string cmp_sidechain_to = sidechain_to;
+               std::transform(cmp_sidechain_to.begin(), cmp_sidechain_to.end(), cmp_sidechain_to.begin(), ::toupper);
+               std::string cmp_wallet_contract_address = wallet_contract_address;
+               std::transform(cmp_wallet_contract_address.begin(), cmp_wallet_contract_address.end(), cmp_wallet_contract_address.begin(), ::toupper);
+
+               //! Check whether it is ERC-20 token deposit
+               std::string symbol;
+               boost::multiprecision::uint256_t amount;
+               bool error_in_deposit = false;
+               const auto deposit_erc_20 = ethereum::deposit_erc20_decoder::decode(tx.get<std::string>("result.input"));
+               if (deposit_erc_20.valid()) {
+                  std::string cmp_token = deposit_erc_20->token;
+                  std::transform(cmp_token.begin(), cmp_token.end(), cmp_token.begin(), ::tolower);
+
+                  const auto it = erc20_addresses.right.find(cmp_token);
+                  if (it == erc20_addresses.right.end()) {
+                     wlog("No erc-20 token with address: ${address}", ("address", cmp_token));
+                     error_in_deposit = true;
+                  }
+                  symbol = it->second;
+                  amount = deposit_erc_20->amount;
+               } else {
+                  symbol = "ETH";
+                  const std::string value_s = tx.get<std::string>("result.value");
+                  amount = boost::multiprecision::uint256_t{value_s};
+                  amount = amount / 100000;
+                  amount = amount / 100000;
+               }
+
+               process_ok = (!error_in_deposit) &&
+                            (swdo_sidechain_from == sidechain_from) &&
+                            (cmp_sidechain_to == cmp_wallet_contract_address) &&
+                            (swdo_sidechain_currency == symbol) &&
+                            (swdo_sidechain_amount == fc::safe<uint64_t>{amount}.value);
+            }
+         }
+      }
 
       should_approve = process_ok;
       break;
@@ -306,23 +376,23 @@ bool sidechain_net_handler_ethereum::process_proposal(const proposal_object &po)
    case chain::operation::tag<chain::son_wallet_withdraw_process_operation>::value: {
       bool process_ok = false;
       bool transaction_ok = false;
-      son_wallet_withdraw_id_type swwo_id = op_obj_idx_0.get<son_wallet_withdraw_process_operation>().son_wallet_withdraw_id;
+      const son_wallet_withdraw_id_type swwo_id = op_obj_idx_0.get<son_wallet_withdraw_process_operation>().son_wallet_withdraw_id;
       const auto &idx = database.get_index_type<son_wallet_withdraw_index>().indices().get<by_id>();
       const auto swwo = idx.find(swwo_id);
       if (swwo != idx.end()) {
-         uint32_t swwo_block_num = swwo->block_num;
-         std::string swwo_peerplays_transaction_id = swwo->peerplays_transaction_id;
-         uint32_t swwo_op_idx = std::stoll(swwo->peerplays_uid.substr(swwo->peerplays_uid.find_last_of("-") + 1));
+         const uint32_t swwo_block_num = swwo->block_num;
+         const std::string swwo_peerplays_transaction_id = swwo->peerplays_transaction_id;
+         const uint32_t swwo_op_idx = std::stoll(swwo->peerplays_uid.substr(swwo->peerplays_uid.find_last_of("-") + 1));
 
          const auto &block = database.fetch_block_by_number(swwo_block_num);
 
          for (const auto &tx : block->transactions) {
             if (tx.id().str() == swwo_peerplays_transaction_id) {
-               operation op = tx.operations[swwo_op_idx];
-               transfer_operation t_op = op.get<transfer_operation>();
+               const operation op = tx.operations[swwo_op_idx];
+               const transfer_operation t_op = op.get<transfer_operation>();
 
-               price asset_price = database.get<asset_object>(t_op.amount.asset_id).options.core_exchange_rate;
-               asset peerplays_asset = asset(t_op.amount.amount * asset_price.base.amount / asset_price.quote.amount);
+               const price asset_price = database.get<asset_object>(t_op.amount.asset_id).options.core_exchange_rate;
+               const asset peerplays_asset = asset(t_op.amount.amount * asset_price.base.amount / asset_price.quote.amount);
 
                process_ok = (t_op.to == gpo.parameters.son_account()) &&
                             (swwo->peerplays_from == t_op.from) &&
@@ -331,8 +401,8 @@ bool sidechain_net_handler_ethereum::process_proposal(const proposal_object &po)
             }
          }
 
-         object_id_type object_id = op_obj_idx_1.get<sidechain_transaction_create_operation>().object_id;
-         std::string op_tx_str = op_obj_idx_1.get<sidechain_transaction_create_operation>().transaction;
+         const object_id_type object_id = op_obj_idx_1.get<sidechain_transaction_create_operation>().object_id;
+         const std::string op_tx_str = op_obj_idx_1.get<sidechain_transaction_create_operation>().transaction;
 
          const auto &st_idx = database.get_index_type<sidechain_transaction_index>().indices().get<by_object_id>();
          const auto st = st_idx.find(object_id);
@@ -359,9 +429,9 @@ bool sidechain_net_handler_ethereum::process_proposal(const proposal_object &po)
 
    case chain::operation::tag<chain::sidechain_transaction_sign_operation>::value: {
       should_approve = true;
-      son_id_type signer = op_obj_idx_0.get<sidechain_transaction_sign_operation>().signer;
-      std::string signature = op_obj_idx_0.get<sidechain_transaction_sign_operation>().signature;
-      sidechain_transaction_id_type sidechain_transaction_id = op_obj_idx_0.get<sidechain_transaction_sign_operation>().sidechain_transaction_id;
+      const son_id_type signer = op_obj_idx_0.get<sidechain_transaction_sign_operation>().signer;
+      const std::string signature = op_obj_idx_0.get<sidechain_transaction_sign_operation>().signature;
+      const sidechain_transaction_id_type sidechain_transaction_id = op_obj_idx_0.get<sidechain_transaction_sign_operation>().sidechain_transaction_id;
       const auto &st_idx = database.get_index_type<sidechain_transaction_index>().indices().get<by_id>();
       const auto sto = st_idx.find(sidechain_transaction_id);
       if (sto == st_idx.end()) {
@@ -399,38 +469,68 @@ void sidechain_net_handler_ethereum::process_primary_wallet() {
    const auto &active_sw = swi.rbegin();
    if (active_sw != swi.rend()) {
 
+      const auto &prev_sw = std::next(active_sw);
+      if (prev_sw != swi.rend() && active_sw->sons.at(sidechain) == prev_sw->sons.at(sidechain))
+         return;
+
       if ((active_sw->addresses.find(sidechain) == active_sw->addresses.end()) ||
           (active_sw->addresses.at(sidechain).empty())) {
 
-         if (proposal_exists(chain::operation::tag<chain::son_wallet_update_operation>::value, active_sw->id)) {
+         const auto ast = active_sidechain_types(database.head_block_time());
+         const auto id = active_sw->id.instance() * ast.size() + std::distance(ast.begin(), ast.find(sidechain));
+         const object_id_type op_id{active_sw->id.space(), active_sw->id.type(), id};
+
+         if (proposal_exists(chain::operation::tag<chain::son_wallet_update_operation>::value, op_id)) {
             return;
          }
 
-         if (!plugin.can_son_participate(sidechain, chain::operation::tag<chain::son_wallet_update_operation>::value, active_sw->id)) {
+         if (!plugin.can_son_participate(sidechain, chain::operation::tag<chain::son_wallet_update_operation>::value, op_id)) {
             return;
          }
 
          const chain::global_property_object &gpo = database.get_global_properties();
          proposal_create_operation proposal_op;
          proposal_op.fee_paying_account = plugin.get_current_son_object(sidechain).son_account;
-         uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
+         const uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
          proposal_op.expiration_time = time_point_sec(database.head_block_time().sec_since_epoch() + lifetime);
 
          son_wallet_update_operation swu_op;
          swu_op.payer = gpo.parameters.son_account();
-         swu_op.son_wallet_id = active_sw->id;
+         swu_op.son_wallet_id = op_id;
          swu_op.sidechain = sidechain;
          swu_op.address = wallet_contract_address;
          proposal_op.proposed_ops.emplace_back(swu_op);
 
-         std::string tx_str = create_primary_wallet_transaction(gpo.active_sons.at(sidechain), active_sw->id.operator std::string());
+         const auto signers = [this, &prev_sw, &active_sw, &swi] {
+            std::vector<son_sidechain_info> signers;
+            //! Check if we don't have any previous set of active SONs use the current one
+            if (prev_sw != swi.rend()) {
+               if (!prev_sw->sons.at(sidechain).empty())
+                  signers = prev_sw->sons.at(sidechain);
+               else
+                  signers = active_sw->sons.at(sidechain);
+            } else {
+               signers = active_sw->sons.at(sidechain);
+            }
+
+            return signers;
+         }();
+
+         std::string tx_str = create_primary_wallet_transaction(gpo.active_sons.at(sidechain), op_id.operator std::string());
          if (!tx_str.empty()) {
             sidechain_transaction_create_operation stc_op;
             stc_op.payer = gpo.parameters.son_account();
-            stc_op.object_id = active_sw->id;
+            stc_op.object_id = op_id;
             stc_op.sidechain = sidechain;
             stc_op.transaction = tx_str;
-            stc_op.signers = gpo.active_sons.at(sidechain);
+            for (const auto &signer : signers) {
+               son_info si;
+               si.son_id = signer.son_id;
+               si.weight = signer.weight;
+               si.signing_key = signer.signing_key;
+               si.sidechain_public_keys[sidechain] = signer.public_key;
+               stc_op.signers.emplace_back(std::move(si));
+            }
             proposal_op.proposed_ops.emplace_back(stc_op);
          }
 
@@ -440,7 +540,7 @@ void sidechain_net_handler_ethereum::process_primary_wallet() {
             database.push_transaction(trx, database::validation_steps::skip_block_size_check);
             if (plugin.app().p2p_node())
                plugin.app().p2p_node()->broadcast(net::trx_message(trx));
-            plugin.log_son_proposal_retry(sidechain, chain::operation::tag<chain::son_wallet_update_operation>::value, active_sw->id);
+            plugin.log_son_proposal_retry(sidechain, chain::operation::tag<chain::son_wallet_update_operation>::value, op_id);
          } catch (fc::exception &e) {
             elog("Sending proposal for son wallet update operation failed with exception ${e}", ("e", e.what()));
             return;
@@ -453,14 +553,26 @@ void sidechain_net_handler_ethereum::process_sidechain_addresses() {
 }
 
 bool sidechain_net_handler_ethereum::process_deposit(const son_wallet_deposit_object &swdo) {
+
+   if (proposal_exists(chain::operation::tag<chain::son_wallet_deposit_process_operation>::value, swdo.id)) {
+      return false;
+   }
+
    const chain::global_property_object &gpo = database.get_global_properties();
 
-   price asset_price = database.get<asset_object>(database.get_global_properties().parameters.eth_asset()).options.core_exchange_rate;
-   asset asset_to_issue = asset(swdo.peerplays_asset.amount * asset_price.quote.amount / asset_price.base.amount, database.get_global_properties().parameters.eth_asset());
+   const auto &assets_by_symbol = database.get_index_type<asset_index>().indices().get<by_symbol>();
+   const auto asset_itr = assets_by_symbol.find(swdo.sidechain_currency);
+   if (asset_itr == assets_by_symbol.end()) {
+      wlog("Could not find asset: ${symbol}", ("symbol", swdo.sidechain_currency));
+      return false;
+   }
+
+   const price asset_price = asset_itr->options.core_exchange_rate;
+   const asset asset_to_issue = asset(swdo.peerplays_asset.amount * asset_price.quote.amount / asset_price.base.amount, asset_itr->get_id());
 
    proposal_create_operation proposal_op;
    proposal_op.fee_paying_account = plugin.get_current_son_object(sidechain).son_account;
-   uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
+   const uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
    proposal_op.expiration_time = time_point_sec(database.head_block_time().sec_since_epoch() + lifetime);
 
    son_wallet_deposit_process_operation swdp_op;
@@ -503,7 +615,7 @@ bool sidechain_net_handler_ethereum::process_withdrawal(const son_wallet_withdra
 
       proposal_create_operation proposal_op;
       proposal_op.fee_paying_account = plugin.get_current_son_object(sidechain).son_account;
-      uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
+      const uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3;
       proposal_op.expiration_time = time_point_sec(database.head_block_time().sec_since_epoch() + lifetime);
 
       son_wallet_withdraw_process_operation swwp_op;
@@ -516,7 +628,14 @@ bool sidechain_net_handler_ethereum::process_withdrawal(const son_wallet_withdra
       stc_op.object_id = swwo.id;
       stc_op.sidechain = sidechain;
       stc_op.transaction = tx_str;
-      stc_op.signers = gpo.active_sons.at(sidechain);
+      for (const auto &signer : gpo.active_sons.at(sidechain)) {
+         son_info si;
+         si.son_id = signer.son_id;
+         si.weight = signer.weight;
+         si.signing_key = signer.signing_key;
+         si.sidechain_public_keys[sidechain] = signer.public_key;
+         stc_op.signers.emplace_back(std::move(si));
+      }
       proposal_op.proposed_ops.emplace_back(stc_op);
 
       signed_transaction trx = database.create_signed_transaction(plugin.get_private_key(plugin.get_current_son_id(sidechain)), proposal_op);
@@ -541,33 +660,70 @@ std::string sidechain_net_handler_ethereum::process_sidechain_transaction(const
 std::string sidechain_net_handler_ethereum::send_sidechain_transaction(const sidechain_transaction_object &sto) {
    boost::property_tree::ptree pt;
    boost::property_tree::ptree pt_array;
+
+   std::vector<ethereum::encoded_sign_transaction> transactions;
    for (const auto &signature : sto.signatures) {
-      const auto &transaction = signature.second;
 
       //! Check if we have this signed transaction, if not, don't send it
-      if (transaction.empty())
+      if (signature.second.empty())
          continue;
 
+      ethereum::encoded_sign_transaction transaction{sto.transaction, ethereum::signature{signature.second}};
+      transactions.emplace_back(transaction);
+   }
+
+   const auto &current_son = plugin.get_current_son_object(sidechain);
+   FC_ASSERT(current_son.sidechain_public_keys.contains(sidechain), "No public keys for current son: ${account_id}", ("account_id", current_son.son_account));
+   const auto &public_key = current_son.sidechain_public_keys.at(sidechain);
+
+   const auto function_signature = ethereum::signature_encoder::get_function_signature_from_transaction(sto.transaction);
+   if (function_signature.empty()) {
+      elog("Function signature is empty for transaction id ${id}, transaction ${transaction}", ("id", sto.id)("transaction", sto.transaction));
+      return std::string{}; //! Return empty string, as we have error in sending
+   }
+
+   const ethereum::signature_encoder encoder{function_signature};
 #ifdef SEND_RAW_TRANSACTION
-      const std::string sidechain_transaction = rpc_client->eth_send_raw_transaction(transaction);
+   const auto data = encoder.encode(transactions);
+   const std::string params = "[{\"from\":\"" + ethereum::add_0x(public_key) + "\", \"to\":\"" + wallet_contract_address + "\", \"data\":\"" + data + "\"}]";
+
+   ethereum::raw_transaction raw_tr;
+   raw_tr.nonce = rpc_client->get_nonce(ethereum::add_0x(public_key));
+   raw_tr.gas_price = rpc_client->get_gas_price();
+   raw_tr.gas_limit = rpc_client->get_estimate_gas(params);
+   if (raw_tr.gas_limit.empty())
+      raw_tr.gas_limit = rpc_client->get_gas_limit();
+   raw_tr.to = wallet_contract_address;
+   raw_tr.value = "";
+   raw_tr.data = data;
+   raw_tr.chain_id = ethereum::add_0x(ethereum::to_hex(chain_id));
+
+   const auto sign_tr = raw_tr.sign(get_private_key(public_key));
+   const std::string sidechain_transaction = rpc_client->eth_send_raw_transaction(sign_tr.serialize());
 #else
-      const std::string sidechain_transaction = rpc_client->eth_send_transaction(transaction);
+   ethereum::transaction raw_tr;
+   raw_tr.data = encoder.encode(transactions);
+   raw_tr.to = wallet_contract_address;
+   raw_tr.from = ethereum::add_0x(public_key);
+
+   const auto sign_tr = raw_tr.sign(get_private_key(public_key));
+   const std::string sidechain_transaction = rpc_client->eth_send_transaction(sign_tr.serialize());
 #endif
 
-      std::stringstream ss_tx(sidechain_transaction);
-      boost::property_tree::ptree tx_json;
-      boost::property_tree::read_json(ss_tx, tx_json);
-      if (tx_json.count("result") && !tx_json.count("error")) {
-         boost::property_tree::ptree node;
-         node.put("transaction", transaction);
-         node.put("transaction_receipt", tx_json.get<std::string>("result"));
-         pt_array.push_back(std::make_pair("", node));
-      } else {
-         //! Fixme
-         //! How should we proceed with error in eth_send_transaction
-         elog("Error in eth_send_transaction for transaction ${id}, transaction ${transaction}", ("id", sto.id)("transaction", transaction));
-         return std::string{}; //! Return empty string, as we have error in sending
-      }
+   std::stringstream ss_tx(sidechain_transaction);
+   boost::property_tree::ptree tx_json;
+   boost::property_tree::read_json(ss_tx, tx_json);
+   if (tx_json.count("result") && !tx_json.count("error")) {
+      boost::property_tree::ptree node;
+      node.put("transaction", sto.transaction);
+      node.put("sidechain_transaction", sidechain_transaction);
+      node.put("transaction_receipt", tx_json.get<std::string>("result"));
+      pt_array.push_back(std::make_pair("", node));
+   } else {
+      //! Fixme
+      //! How should we proceed with error in eth_send_transaction
+      elog("Error in eth send transaction for transaction id ${id}, transaction ${transaction}, sidechain_transaction ${sidechain_transaction}", ("id", sto.id)("transaction", sto.transaction)("sidechain_transaction", sidechain_transaction));
+      return std::string{}; //! Return empty string, as we have error in sending
    }
    pt.add_child("result_array", pt_array);
 
@@ -601,8 +757,8 @@ bool sidechain_net_handler_ethereum::settle_sidechain_transaction(const sidechai
       if ("0x1" == json_receipt.get<std::string>("result.status")) {
          count += 1;
          //! Fixme - compare data somehow?
-         //if( sto.transaction == entry_receipt.second.get<std::string>("data") ) {
-         //}
+         // if( sto.transaction == entry_receipt.second.get<std::string>("data") ) {
+         // }
       }
    }
 
@@ -610,30 +766,83 @@ bool sidechain_net_handler_ethereum::settle_sidechain_transaction(const sidechai
    if (count != json.get_child("result_array").size()) {
       wlog("Not all receipts received for transaction ${id}", ("id", sto.id));
       return false;
-   } else
+   } else {
+      if (sto.object_id.is<son_wallet_id_type>()) {
+         settle_amount = asset(0, database.get_global_properties().parameters.eth_asset());
+      }
+
+      if (sto.object_id.is<son_wallet_withdraw_id_type>()) {
+         auto swwo = database.get<son_wallet_withdraw_object>(sto.object_id);
+         const auto &assets_by_symbol = database.get_index_type<asset_index>().indices().get<by_symbol>();
+         const auto asset_itr = assets_by_symbol.find(swwo.withdraw_currency);
+         if (asset_itr == assets_by_symbol.end()) {
+            wlog("Could not find asset: ${symbol}", ("symbol", swwo.withdraw_currency));
+            return false;
+         }
+         settle_amount = asset(swwo.withdraw_amount, asset_itr->get_id());
+      }
+
       return true;
+   }
 
    return false;
 }
 
-std::string sidechain_net_handler_ethereum::create_primary_wallet_transaction(const std::vector<son_info> &son_pubkeys, const std::string &object_id) {
+optional<asset> sidechain_net_handler_ethereum::estimate_withdrawal_transaction_fee() const {
+   const auto &gpo = database.get_global_properties();
+   if (gpo.active_sons.at(sidechain).empty()) {
+      wlog("No active sons for sidechain: ${sidechain}", ("sidechain", sidechain));
+      return optional<asset>{};
+   }
+
+   const auto &active_son = gpo.active_sons.at(sidechain).at(0);
+   const auto &s_idx = database.get_index_type<son_index>().indices().get<by_id>();
+   const auto son = s_idx.find(active_son.son_id);
+   if (son == s_idx.end()) {
+      wlog("Can't find son for id: ${son_id}", ("son_id", active_son.son_id));
+      return optional<asset>{};
+   }
+
+   if (!son->sidechain_public_keys.contains(sidechain)) {
+      wlog("No public keys for current son: ${account_id}", ("account_id", son->son_account));
+      return optional<asset>{};
+   }
+
+   const auto &public_key = son->sidechain_public_keys.at(sidechain);
+   const auto data = ethereum::withdrawal_encoder::encode(public_key, boost::multiprecision::uint256_t{1} * boost::multiprecision::uint256_t{10000000000}, "0");
+   const std::string params = "[{\"from\":\"" + ethereum::add_0x(public_key) + "\", \"to\":\"" + wallet_contract_address + "\", \"data\":\"" + data + "\"}]";
+
+   const auto estimate_gas = ethereum::from_hex<int64_t>(rpc_client->get_estimate_gas(params));
+   const auto gas_price = ethereum::from_hex<int64_t>(rpc_client->get_gas_price());
+   const auto eth_gas_fee = double(estimate_gas * gas_price) / double{1000000000000000000};
+
+   const auto asset = database.get<asset_object>(database.get_global_properties().parameters.eth_asset());
+   return asset.amount_from_string(std::to_string(eth_gas_fee));
+}
+
+std::string sidechain_net_handler_ethereum::create_primary_wallet_transaction(const std::vector<son_sidechain_info> &son_pubkeys, const std::string &object_id) {
    std::vector<std::pair<std::string, uint16_t>> owners_weights;
    for (auto &son : son_pubkeys) {
       const std::string pub_key_str = son.public_key;
       owners_weights.emplace_back(std::make_pair(pub_key_str, son.weight));
    }
 
-   const ethereum::update_owners_encoder encoder;
-   return encoder.encode(owners_weights, object_id);
-}
-
-std::string sidechain_net_handler_ethereum::create_deposit_transaction(const son_wallet_deposit_object &swdo) {
-   return "Deposit-Transaction";
+   return ethereum::update_owners_encoder::encode(owners_weights, object_id);
 }
 
 std::string sidechain_net_handler_ethereum::create_withdrawal_transaction(const son_wallet_withdraw_object &swwo) {
-   const ethereum::withdrawal_encoder encoder;
-   return encoder.encode(swwo.withdraw_address.substr(2), swwo.withdraw_amount.value * 10000000000, swwo.id.operator std::string());
+   if (swwo.withdraw_currency == "ETH") {
+      return ethereum::withdrawal_encoder::encode(ethereum::remove_0x(swwo.withdraw_address), boost::multiprecision::uint256_t{swwo.withdraw_amount.value} * boost::multiprecision::uint256_t{10000000000}, swwo.id.operator std::string());
+   } else {
+      const auto it = erc20_addresses.left.find(swwo.withdraw_currency);
+      if (it == erc20_addresses.left.end()) {
+         elog("No erc-20 token: ${symbol}", ("symbol", swwo.withdraw_currency));
+         return "";
+      }
+      return ethereum::withdrawal_erc20_encoder::encode(ethereum::remove_0x(it->second), ethereum::remove_0x(swwo.withdraw_address), boost::multiprecision::uint256_t{swwo.withdraw_amount.value}, swwo.id.operator std::string());
+   }
+
+   return "";
 }
 
 std::string sidechain_net_handler_ethereum::sign_transaction(const sidechain_transaction_object &sto) {
@@ -642,32 +851,18 @@ std::string sidechain_net_handler_ethereum::sign_transaction(const sidechain_tra
 
    const auto &public_key = current_son.sidechain_public_keys.at(sidechain);
 
-#ifdef SEND_RAW_TRANSACTION
-   ethereum::raw_transaction raw_tr;
-   raw_tr.nonce = rpc_client->get_nonce(ethereum::add_0x(public_key));
-   raw_tr.gas_price = rpc_client->get_gas_price();
-   raw_tr.gas_limit = rpc_client->get_gas_limit();
-   raw_tr.to = wallet_contract_address;
-   raw_tr.value = "";
-   raw_tr.data = sto.transaction;
-   raw_tr.chain_id = ethereum::add_0x(ethereum::to_hex(chain_id));
+   //! We need to change v value according to chain_id
+   auto signature = ethereum::sign_hash(ethereum::keccak_hash(sto.transaction), ethereum::add_0x(ethereum::to_hex(chain_id)), get_private_key(public_key));
+   signature.v = ethereum::to_hex(ethereum::from_hex<unsigned int>(signature.v) - 2 * chain_id - 35 + 27);
 
-   const auto sign_tr = raw_tr.sign(get_private_key(public_key));
-   return sign_tr.serialize();
-#else
-   ethereum::transaction sign_transaction;
-   sign_transaction.data = sto.transaction;
-   sign_transaction.to = wallet_contract_address;
-   sign_transaction.from = "0x" + public_key;
-   return sign_transaction.sign(get_private_key(public_key)).serialize();
-#endif
+   return signature.serialize();
 }
 
 void sidechain_net_handler_ethereum::schedule_ethereum_listener() {
-   fc::time_point now = fc::time_point::now();
-   int64_t time_to_next = 5000;
+   const fc::time_point now = fc::time_point::now();
+   const int64_t time_to_next = 5000;
 
-   fc::time_point next_wakeup(now + fc::milliseconds(time_to_next));
+   const fc::time_point next_wakeup(now + fc::milliseconds(time_to_next));
 
    _listener_task = fc::schedule([this] {
       ethereum_listener_loop();
@@ -678,39 +873,50 @@ void sidechain_net_handler_ethereum::schedule_ethereum_listener() {
 void sidechain_net_handler_ethereum::ethereum_listener_loop() {
    schedule_ethereum_listener();
 
-   std::string reply = rpc_client->eth_get_block_by_number("latest", false);
-   //std::string reply = rpc_client->eth_get_logs(wallet_contract_address);
+   const auto reply = rpc_client->eth_blockNumber();
+
    if (!reply.empty()) {
-      std::stringstream ss(reply);
-      boost::property_tree::ptree json;
-      boost::property_tree::read_json(ss, json);
-      if (json.count("result")) {
-         std::string head_block_number_s = json.get<std::string>("result.number");
-         uint64_t head_block_number = std::strtoul(head_block_number_s.c_str(), nullptr, 16);
-         if (head_block_number != last_block_received) {
-            std::string event_data = std::to_string(head_block_number);
-            handle_event(event_data);
-            last_block_received = head_block_number;
+      const uint64_t head_block_number = ethereum::from_hex<uint64_t>(reply);
+
+      if (head_block_number != last_block_received) {
+         //! Check that current block number is greater than last one
+         if (head_block_number < last_block_received) {
+            wlog("Head block ${head_block_number} is greater than last received block ${last_block_received}", ("head_block_number", head_block_number)("last_block_received", last_block_received));
+            return;
          }
+
+         //! Send event data for all blocks that passed
+         for (uint64_t i = last_block_received + 1; i <= head_block_number; ++i) {
+            const std::string block_number = ethereum::add_0x(ethereum::to_hex(i, false));
+            handle_event(block_number);
+         }
+
+         last_block_received = head_block_number;
       }
    }
 }
 
-void sidechain_net_handler_ethereum::handle_event(const std::string &event_data) {
-   std::string block = rpc_client->eth_get_block_by_number("latest", true);
+void sidechain_net_handler_ethereum::handle_event(const std::string &block_number) {
+   const std::string block = rpc_client->eth_get_block_by_number(block_number, true);
    if (block != "") {
-      add_to_son_listener_log("BLOCK   : " + event_data);
+      add_to_son_listener_log("BLOCK   : " + block_number);
       std::stringstream ss(block);
       boost::property_tree::ptree block_json;
       boost::property_tree::read_json(ss, block_json);
 
+      if (block_json.get<string>("result") == "null") {
+         wlog("No data for block ${block_number}", ("block_number", block_number));
+         return;
+      }
+
       size_t tx_idx = -1;
       for (const auto &tx_child : block_json.get_child("result.transactions")) {
-         boost::property_tree::ptree tx = tx_child.second;
+         const boost::property_tree::ptree tx = tx_child.second;
          tx_idx = tx_idx + 1;
 
+         const std::string to = tx.get<std::string>("to");
          std::string from = tx.get<std::string>("from");
-         std::string to = tx.get<std::string>("to");
+         std::transform(from.begin(), from.end(), from.begin(), ::tolower);
 
          std::string cmp_to = to;
          std::transform(cmp_to.begin(), cmp_to.end(), cmp_to.begin(), ::toupper);
@@ -719,10 +925,35 @@ void sidechain_net_handler_ethereum::handle_event(const std::string &event_data)
 
          if (cmp_to == cmp_wallet_contract_address) {
 
-            std::string value_s = tx.get<std::string>("value");
-            boost::multiprecision::uint256_t amount(value_s);
-            amount = amount / 100000;
-            amount = amount / 100000;
+            //! Check whether it is ERC-20 token deposit
+            std::string symbol;
+            boost::multiprecision::uint256_t amount;
+            const auto deposit_erc_20 = ethereum::deposit_erc20_decoder::decode(tx.get<std::string>("input"));
+            if (deposit_erc_20.valid()) {
+               std::string cmp_token = deposit_erc_20->token;
+               std::transform(cmp_token.begin(), cmp_token.end(), cmp_token.begin(), ::tolower);
+
+               const auto it = erc20_addresses.right.find(cmp_token);
+               if (it == erc20_addresses.right.end()) {
+                  wlog("No erc-20 token with address: ${address}", ("address", cmp_token));
+                  continue;
+               }
+               symbol = it->second;
+               amount = deposit_erc_20->amount;
+            } else {
+               symbol = "ETH";
+               const std::string value_s = tx.get<std::string>("value");
+               amount = boost::multiprecision::uint256_t{value_s};
+               amount = amount / 100000;
+               amount = amount / 100000;
+            }
+
+            const auto &assets_by_symbol = database.get_index_type<asset_index>().indices().get<by_symbol>();
+            const auto asset_itr = assets_by_symbol.find(symbol);
+            if (asset_itr == assets_by_symbol.end()) {
+               wlog("Could not find asset: ${symbol}", ("symbol", symbol));
+               continue;
+            }
 
             const auto &sidechain_addresses_idx = database.get_index_type<sidechain_address_index>().indices().get<by_sidechain_and_deposit_address_and_expires>();
             const auto &addr_itr = sidechain_addresses_idx.find(std::make_tuple(sidechain, from, time_point_sec::maximum()));
@@ -733,22 +964,22 @@ void sidechain_net_handler_ethereum::handle_event(const std::string &event_data)
             std::stringstream ss;
             ss << "ethereum"
                << "-" << tx.get<std::string>("hash") << "-" << tx_idx;
-            std::string sidechain_uid = ss.str();
 
             sidechain_event_data sed;
             sed.timestamp = database.head_block_time();
             sed.block_num = database.head_block_num();
             sed.sidechain = sidechain;
-            sed.sidechain_uid = sidechain_uid;
+            sed.type = sidechain_event_type::deposit;
+            sed.sidechain_uid = ss.str();
             sed.sidechain_transaction_id = tx.get<std::string>("hash");
             sed.sidechain_from = from;
             sed.sidechain_to = to;
-            sed.sidechain_currency = "ETH";
+            sed.sidechain_currency = symbol;
             sed.sidechain_amount = amount;
             sed.peerplays_from = addr_itr->sidechain_address_account;
             sed.peerplays_to = database.get_global_properties().parameters.son_account();
-            price eth_price = database.get<asset_object>(database.get_global_properties().parameters.eth_asset()).options.core_exchange_rate;
-            sed.peerplays_asset = asset(sed.sidechain_amount * eth_price.base.amount / eth_price.quote.amount);
+            const price price = asset_itr->options.core_exchange_rate;
+            sed.peerplays_asset = asset(sed.sidechain_amount * price.base.amount / price.quote.amount);
 
             add_to_son_listener_log("TRX     : " + sed.sidechain_transaction_id);
 

libraries/plugins/peerplays_sidechain/sidechain_net_handler_hive.cpp

@@ -20,7 +20,7 @@
 #include <graphene/chain/account_object.hpp>
 #include <graphene/chain/protocol/fee_schedule.hpp>
 #include <graphene/chain/protocol/son_wallet.hpp>
-#include <graphene/chain/son_info.hpp>
+#include <graphene/chain/son_sidechain_info.hpp>
 #include <graphene/chain/son_wallet_object.hpp>
 #include <graphene/peerplays_sidechain/common/utils.hpp>
 #include <graphene/peerplays_sidechain/hive/asset.hpp>
@@ -30,17 +30,17 @@
 
 namespace graphene { namespace peerplays_sidechain {
 
-hive_rpc_client::hive_rpc_client(const std::string &url, const std::string &user_name, const std::string &password, bool debug_rpc_calls) :
-      rpc_client(url, user_name, password, debug_rpc_calls) {
+hive_rpc_client::hive_rpc_client(const std::vector<rpc_credentials> &credentials, bool debug_rpc_calls, bool simulate_connection_reselection) :
+      rpc_client(sidechain_type::hive, credentials, debug_rpc_calls, simulate_connection_reselection) {
 }
 
 std::string hive_rpc_client::account_history_api_get_transaction(std::string transaction_id) {
-   std::string params = "{ \"id\": \"" + transaction_id + "\" }";
+   const std::string params = "{ \"id\": \"" + transaction_id + "\" }";
    return send_post_request("account_history_api.get_transaction", params, debug_rpc_calls);
 }
 
 std::string hive_rpc_client::block_api_get_block(uint32_t block_number) {
-   std::string params = "{ \"block_num\": " + std::to_string(block_number) + " }";
+   const std::string params = "{ \"block_num\": " + std::to_string(block_number) + " }";
    return send_post_request("block_api.get_block", params, debug_rpc_calls);
 }
 
@@ -57,7 +57,7 @@ std::string hive_rpc_client::condenser_api_get_accounts(std::vector<std::string>
 }
 
 std::string hive_rpc_client::condenser_api_get_config() {
-   std::string params = "[]";
+   static const std::string params = "[]";
    return send_post_request("condenser_api.get_config", params, debug_rpc_calls);
 }
 
@@ -70,7 +70,7 @@ std::string hive_rpc_client::database_api_get_version() {
 }
 
 std::string hive_rpc_client::network_broadcast_api_broadcast_transaction(std::string htrx) {
-   std::string params = "{ \"trx\": " + htrx + ", \"max_block_age\": -1 }";
+   const std::string params = "{ \"trx\": " + htrx + ", \"max_block_age\": -1 }";
    return send_post_request("network_broadcast_api.broadcast_transaction", params, debug_rpc_calls);
 }
 
@@ -88,44 +88,58 @@ std::string hive_rpc_client::get_account_memo_key(std::string account) {
 }
 
 std::string hive_rpc_client::get_chain_id() {
-   std::string reply_str = database_api_get_version();
+   const std::string reply_str = database_api_get_version();
    return retrieve_value_from_reply(reply_str, "chain_id");
 }
 
 std::string hive_rpc_client::get_head_block_id() {
-   std::string reply_str = database_api_get_dynamic_global_properties();
+   const std::string reply_str = database_api_get_dynamic_global_properties();
    return retrieve_value_from_reply(reply_str, "head_block_id");
 }
 
 std::string hive_rpc_client::get_head_block_time() {
-   std::string reply_str = database_api_get_dynamic_global_properties();
+   const std::string reply_str = database_api_get_dynamic_global_properties();
    return retrieve_value_from_reply(reply_str, "time");
 }
 
 std::string hive_rpc_client::get_is_test_net() {
-   std::string reply_str = condenser_api_get_config();
+   const std::string reply_str = condenser_api_get_config();
    return retrieve_value_from_reply(reply_str, "IS_TEST_NET");
 }
 
 std::string hive_rpc_client::get_last_irreversible_block_num() {
-   std::string reply_str = database_api_get_dynamic_global_properties();
+   const std::string reply_str = database_api_get_dynamic_global_properties();
    return retrieve_value_from_reply(reply_str, "last_irreversible_block_num");
 }
 
+uint64_t hive_rpc_client::ping(rpc_connection &conn) const {
+   const std::string reply = send_post_request(conn, "database_api.get_dynamic_global_properties", "", debug_rpc_calls);
+   if (!reply.empty()) {
+      std::stringstream ss(reply);
+      boost::property_tree::ptree json;
+      boost::property_tree::read_json(ss, json);
+      if (json.count("result"))
+         return json.get<uint64_t>("result.head_block_number");
+   }
+   return std::numeric_limits<uint64_t>::max();
+}
+
 sidechain_net_handler_hive::sidechain_net_handler_hive(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options) :
-      sidechain_net_handler(_plugin, options) {
-   sidechain = sidechain_type::hive;
+      sidechain_net_handler(sidechain_type::hive, _plugin, options) {
 
    if (options.count("debug-rpc-calls")) {
       debug_rpc_calls = options.at("debug-rpc-calls").as<bool>();
    }
+   bool simulate_connection_reselection = options.at("simulate-rpc-connection-reselection").as<bool>();
 
-   rpc_url = options.at("hive-node-rpc-url").as<std::string>();
+   std::vector<std::string> rpc_urls = options.at("hive-node-rpc-url").as<std::vector<std::string>>();
+   std::string rpc_user;
    if (options.count("hive-rpc-user")) {
       rpc_user = options.at("hive-rpc-user").as<std::string>();
    } else {
       rpc_user = "";
    }
+   std::string rpc_password;
    if (options.count("hive-rpc-password")) {
       rpc_password = options.at("hive-rpc-password").as<std::string>();
    } else {
@@ -146,16 +160,25 @@ sidechain_net_handler_hive::sidechain_net_handler_hive(peerplays_sidechain_plugi
       }
    }
 
-   rpc_client = new hive_rpc_client(rpc_url, rpc_user, rpc_password, debug_rpc_calls);
+   for (size_t i = 0; i < rpc_urls.size(); i++) {
+      rpc_credentials creds;
+      creds.url = rpc_urls[i];
+      creds.user = rpc_user;
+      creds.password = rpc_password;
+      _rpc_credentials.push_back(creds);
+   }
+   FC_ASSERT(!_rpc_credentials.empty());
 
-   std::string chain_id_str = rpc_client->get_chain_id();
+   rpc_client = new hive_rpc_client(_rpc_credentials, debug_rpc_calls, simulate_connection_reselection);
+
+   const std::string chain_id_str = rpc_client->get_chain_id();
    if (chain_id_str.empty()) {
-      elog("No Hive node running at ${url}", ("url", rpc_url));
+      elog("No Hive node running at ${url}", ("url", _rpc_credentials[0].url));
       FC_ASSERT(false);
    }
    chain_id = chain_id_type(chain_id_str);
 
-   std::string is_test_net = rpc_client->get_is_test_net();
+   const std::string is_test_net = rpc_client->get_is_test_net();
    network_type = is_test_net.compare("true") == 0 ? hive::network::testnet : hive::network::mainnet;
    if (network_type == hive::network::mainnet) {
       ilog("Running on Hive mainnet, chain id ${chain_id_str}", ("chain_id_str", chain_id_str));
@@ -180,7 +203,8 @@ sidechain_net_handler_hive::~sidechain_net_handler_hive() {
 }
 
 bool sidechain_net_handler_hive::process_proposal(const proposal_object &po) {
-   //ilog("Proposal to process: ${po}, SON id ${son_id}", ("po", po.id)("son_id", plugin.get_current_son_id(sidechain)));
+
+   ilog("Proposal to process: ${po}, SON id ${son_id}", ("po", po.id)("son_id", plugin.get_current_son_id(sidechain)));
 
    bool should_approve = false;
 
@@ -209,12 +233,15 @@ bool sidechain_net_handler_hive::process_proposal(const proposal_object &po) {
       bool address_ok = false;
       bool transaction_ok = false;
       son_wallet_id_type swo_id = op_obj_idx_0.get<son_wallet_update_operation>().son_wallet_id;
+      const auto ast = active_sidechain_types(database.head_block_time());
+      const auto id = (swo_id.instance.value - std::distance(ast.begin(), ast.find(sidechain))) / ast.size();
+      const son_wallet_id_type op_id{id};
       const auto &idx = database.get_index_type<son_wallet_index>().indices().get<by_id>();
-      const auto swo = idx.find(swo_id);
+      const auto swo = idx.find(op_id);
       if (swo != idx.end()) {
 
-         auto active_sons = gpo.active_sons.at(sidechain);
-         vector<son_info> wallet_sons = swo->sons.at(sidechain);
+         const auto &active_sons = gpo.active_sons.at(sidechain);
+         const auto &wallet_sons = swo->sons.at(sidechain);
 
          bool son_sets_equal = (active_sons.size() == wallet_sons.size());
 
@@ -229,7 +256,9 @@ bool sidechain_net_handler_hive::process_proposal(const proposal_object &po) {
          }
 
          if (po.proposed_transaction.operations.size() >= 2) {
-            object_id_type object_id = op_obj_idx_1.get<sidechain_transaction_create_operation>().object_id;
+            const object_id_type object_id = op_obj_idx_1.get<sidechain_transaction_create_operation>().object_id;
+            const auto id = (object_id.instance() - std::distance(ast.begin(), ast.find(sidechain))) / ast.size();
+            const object_id_type obj_id{object_id.space(), object_id.type(), id};
             std::string op_tx_str = op_obj_idx_1.get<sidechain_transaction_create_operation>().transaction;
 
             const auto &st_idx = database.get_index_type<sidechain_transaction_index>().indices().get<by_object_id>();
@@ -238,9 +267,9 @@ bool sidechain_net_handler_hive::process_proposal(const proposal_object &po) {
 
                std::string tx_str = "";
 
-               if (object_id.is<son_wallet_id_type>()) {
+               if (obj_id.is<son_wallet_id_type>()) {
                   const auto &idx = database.get_index_type<son_wallet_index>().indices().get<by_id>();
-                  const auto swo = idx.find(object_id);
+                  const auto swo = idx.find(obj_id);
                   if (swo != idx.end()) {
 
                      std::stringstream ss_trx(boost::algorithm::unhex(op_tx_str));
@@ -254,15 +283,16 @@ bool sidechain_net_handler_hive::process_proposal(const proposal_object &po) {
                         account_auths[wallet_son.public_key] = wallet_son.weight;
                      }
 
-                     std::string memo_key = rpc_client->get_account_memo_key(wallet_account_name);
+                     const std::string memo_key = rpc_client->get_account_memo_key(wallet_account_name);
 
-                     hive::authority active;
-                     active.weight_threshold = total_weight * 2 / 3 + 1;
-                     active.account_auths = account_auths;
+                     hive::authority a;
+                     a.weight_threshold = total_weight * 2 / 3 + 1;
+                     a.account_auths = account_auths;
 
                      hive::account_update_operation auo;
                      auo.account = wallet_account_name;
-                     auo.active = active;
+                     auo.owner = a;
+                     auo.active = a;
                      auo.memo_key = op_trx.operations[0].get<hive::account_update_operation>().memo_key;
 
                      hive::signed_transaction htrx;
@@ -303,7 +333,7 @@ bool sidechain_net_handler_hive::process_proposal(const proposal_object &po) {
          uint64_t swdo_sidechain_amount = swdo->sidechain_amount.value;
          uint64_t swdo_op_idx = std::stoll(swdo->sidechain_uid.substr(swdo->sidechain_uid.find_last_of("-")));
 
-         std::string tx_str = rpc_client->account_history_api_get_transaction(swdo_txid);
+         const std::string tx_str = rpc_client->account_history_api_get_transaction(swdo_txid);
          if (tx_str != "") {
 
             std::stringstream ss_tx(tx_str);
@@ -478,10 +508,22 @@ void sidechain_net_handler_hive::process_primary_wallet() {
    const auto &active_sw = swi.rbegin();
    if (active_sw != swi.rend()) {
 
+      const auto &prev_sw = std::next(active_sw);
+      if (prev_sw != swi.rend() && active_sw->sons.at(sidechain) == prev_sw->sons.at(sidechain))
+         return;
+
       if ((active_sw->addresses.find(sidechain) == active_sw->addresses.end()) ||
           (active_sw->addresses.at(sidechain).empty())) {
 
-         if (proposal_exists(chain::operation::tag<chain::son_wallet_update_operation>::value, active_sw->id)) {
+         const auto ast = active_sidechain_types(database.head_block_time());
+         const auto id = active_sw->id.instance() * ast.size() + std::distance(ast.begin(), ast.find(sidechain));
+         const object_id_type op_id{active_sw->id.space(), active_sw->id.type(), id};
+
+         if (proposal_exists(chain::operation::tag<chain::son_wallet_update_operation>::value, op_id)) {
+            return;
+         }
+
+         if (!plugin.can_son_participate(sidechain, chain::operation::tag<chain::son_wallet_update_operation>::value, op_id)) {
             return;
          }
 
@@ -495,25 +537,26 @@ void sidechain_net_handler_hive::process_primary_wallet() {
             account_auths[active_son.public_key] = active_son.weight;
          }
 
-         std::string memo_key = rpc_client->get_account_memo_key(wallet_account_name);
+         const std::string memo_key = rpc_client->get_account_memo_key(wallet_account_name);
 
          if (memo_key.empty()) {
             return;
          }
 
-         hive::authority active;
-         active.weight_threshold = total_weight * 2 / 3 + 1;
-         active.account_auths = account_auths;
+         hive::authority a;
+         a.weight_threshold = total_weight * 2 / 3 + 1;
+         a.account_auths = account_auths;
 
          hive::account_update_operation auo;
          auo.account = wallet_account_name;
-         auo.active = active;
+         auo.owner = a;
+         auo.active = a;
          auo.memo_key = hive::public_key_type(memo_key);
 
-         std::string block_id_str = rpc_client->get_head_block_id();
+         const std::string block_id_str = rpc_client->get_head_block_id();
          hive::block_id_type head_block_id(block_id_str);
 
-         std::string head_block_time_str = rpc_client->get_head_block_time();
+         const std::string head_block_time_str = rpc_client->get_head_block_time();
          time_point head_block_time = fc::time_point_sec::from_iso_string(head_block_time_str);
 
          hive::signed_transaction htrx;
@@ -536,19 +579,40 @@ void sidechain_net_handler_hive::process_primary_wallet() {
 
          son_wallet_update_operation swu_op;
          swu_op.payer = gpo.parameters.son_account();
-         swu_op.son_wallet_id = active_sw->id;
+         swu_op.son_wallet_id = op_id;
          swu_op.sidechain = sidechain;
          swu_op.address = wallet_account_name;
 
          proposal_op.proposed_ops.emplace_back(swu_op);
 
+         const auto signers = [this, &prev_sw, &active_sw, &swi] {
+            std::vector<son_sidechain_info> signers;
+            //! Check if we don't have any previous set of active SONs use the current one
+            if (prev_sw != swi.rend()) {
+               if (!prev_sw->sons.at(sidechain).empty())
+                  signers = prev_sw->sons.at(sidechain);
+               else
+                  signers = active_sw->sons.at(sidechain);
+            } else {
+               signers = active_sw->sons.at(sidechain);
+            }
+
+            return signers;
+         }();
+
          sidechain_transaction_create_operation stc_op;
          stc_op.payer = gpo.parameters.son_account();
-         stc_op.object_id = active_sw->id;
+         stc_op.object_id = op_id;
          stc_op.sidechain = sidechain;
          stc_op.transaction = tx_str;
-         stc_op.signers = gpo.active_sons.at(sidechain);
-
+         for (const auto &signer : signers) {
+            son_info si;
+            si.son_id = signer.son_id;
+            si.weight = signer.weight;
+            si.signing_key = signer.signing_key;
+            si.sidechain_public_keys[sidechain] = signer.public_key;
+            stc_op.signers.emplace_back(std::move(si));
+         }
          proposal_op.proposed_ops.emplace_back(stc_op);
 
          signed_transaction trx = database.create_signed_transaction(plugin.get_private_key(plugin.get_current_son_id(sidechain)), proposal_op);
@@ -603,6 +667,11 @@ void sidechain_net_handler_hive::process_sidechain_addresses() {
 }
 
 bool sidechain_net_handler_hive::process_deposit(const son_wallet_deposit_object &swdo) {
+
+   if (proposal_exists(chain::operation::tag<chain::son_wallet_deposit_process_operation>::value, swdo.id)) {
+      return false;
+   }
+
    const chain::global_property_object &gpo = database.get_global_properties();
 
    price asset_price;
@@ -649,6 +718,11 @@ bool sidechain_net_handler_hive::process_deposit(const son_wallet_deposit_object
 }
 
 bool sidechain_net_handler_hive::process_withdrawal(const son_wallet_withdraw_object &swwo) {
+
+   if (proposal_exists(chain::operation::tag<chain::son_wallet_withdraw_process_operation>::value, swwo.id)) {
+      return false;
+   }
+
    const chain::global_property_object &gpo = database.get_global_properties();
 
    //=====
@@ -668,10 +742,10 @@ bool sidechain_net_handler_hive::process_withdrawal(const son_wallet_withdraw_ob
    t_op.amount.symbol = symbol;
    t_op.memo = "";
 
-   std::string block_id_str = rpc_client->get_head_block_id();
+   const std::string block_id_str = rpc_client->get_head_block_id();
    hive::block_id_type head_block_id(block_id_str);
 
-   std::string head_block_time_str = rpc_client->get_head_block_time();
+   const std::string head_block_time_str = rpc_client->get_head_block_time();
    time_point head_block_time = fc::time_point_sec::from_iso_string(head_block_time_str);
 
    hive::signed_transaction htrx;
@@ -704,7 +778,14 @@ bool sidechain_net_handler_hive::process_withdrawal(const son_wallet_withdraw_ob
    stc_op.object_id = swwo.id;
    stc_op.sidechain = sidechain;
    stc_op.transaction = tx_str;
-   stc_op.signers = gpo.active_sons.at(sidechain);
+   for (const auto &signer : gpo.active_sons.at(sidechain)) {
+      son_info si;
+      si.son_id = signer.son_id;
+      si.weight = signer.weight;
+      si.signing_key = signer.signing_key;
+      si.sidechain_public_keys[sidechain] = signer.public_key;
+      stc_op.signers.emplace_back(std::move(si));
+   }
    proposal_op.proposed_ops.emplace_back(stc_op);
 
    signed_transaction trx = database.create_signed_transaction(plugin.get_private_key(plugin.get_current_son_id(sidechain)), proposal_op);
@@ -727,7 +808,7 @@ std::string sidechain_net_handler_hive::process_sidechain_transaction(const side
    hive::signed_transaction htrx;
    fc::raw::unpack(ss_trx, htrx, 1000);
 
-   std::string chain_id_str = rpc_client->get_chain_id();
+   const std::string chain_id_str = rpc_client->get_chain_id();
    const hive::chain_id_type chain_id(chain_id_str);
 
    fc::optional<fc::ecc::private_key> privkey = graphene::utilities::wif_to_key(get_private_key(plugin.get_current_son_object(sidechain).sidechain_public_keys.at(sidechain)));
@@ -770,21 +851,21 @@ bool sidechain_net_handler_hive::settle_sidechain_transaction(const sidechain_tr
       return false;
    }
 
-   std::string tx_str = rpc_client->account_history_api_get_transaction(sto.sidechain_transaction);
+   const std::string tx_str = rpc_client->account_history_api_get_transaction(sto.sidechain_transaction);
    if (tx_str != "") {
 
       std::stringstream ss_tx(tx_str);
       boost::property_tree::ptree tx_json;
       boost::property_tree::read_json(ss_tx, tx_json);
 
-      //const chain::global_property_object &gpo = database.get_global_properties();
+      // const chain::global_property_object &gpo = database.get_global_properties();
 
       std::string tx_txid = tx_json.get<std::string>("result.transaction_id");
       uint32_t tx_block_num = tx_json.get<uint32_t>("result.block_num");
-      uint32_t last_irreversible_block = std::stoul(rpc_client->get_last_irreversible_block_num());
+      const uint32_t last_irreversible_block = std::stoul(rpc_client->get_last_irreversible_block_num());
 
-      //std::string tx_address = addr.get_address();
-      //int64_t tx_amount = -1;
+      // std::string tx_address = addr.get_address();
+      // int64_t tx_amount = -1;
 
       if (tx_block_num <= last_irreversible_block) {
          if (sto.object_id.is<son_wallet_withdraw_id_type>()) {
@@ -802,6 +883,11 @@ bool sidechain_net_handler_hive::settle_sidechain_transaction(const sidechain_tr
    return false;
 }
 
+optional<asset> sidechain_net_handler_hive::estimate_withdrawal_transaction_fee() const {
+   wlog("estimate_withdrawal_transaction_fee not implemented for sidechain: ${sidechain}", ("sidechain", sidechain));
+   return optional<asset>{};
+}
+
 void sidechain_net_handler_hive::schedule_hive_listener() {
    fc::time_point now = fc::time_point::now();
    int64_t time_to_next = 1000;
@@ -817,7 +903,7 @@ void sidechain_net_handler_hive::schedule_hive_listener() {
 void sidechain_net_handler_hive::hive_listener_loop() {
    schedule_hive_listener();
 
-   std::string reply = rpc_client->database_api_get_dynamic_global_properties();
+   const std::string reply = rpc_client->database_api_get_dynamic_global_properties();
    if (!reply.empty()) {
       std::stringstream ss(reply);
       boost::property_tree::ptree json;
@@ -832,19 +918,19 @@ void sidechain_net_handler_hive::hive_listener_loop() {
       }
    }
 
-   //std::string reply = rpc_client->get_last_irreversible_block_num();
-   //if (!reply.empty()) {
-   //   uint64_t last_irreversible_block = std::stoul(reply);
-   //   if (last_irreversible_block != last_block_received) {
-   //      std::string event_data = std::to_string(last_irreversible_block);
-   //      handle_event(event_data);
-   //      last_block_received = last_irreversible_block;
-   //   }
-   //}
+   // std::string reply = rpc_client->get_last_irreversible_block_num();
+   // if (!reply.empty()) {
+   //    uint64_t last_irreversible_block = std::stoul(reply);
+   //    if (last_irreversible_block != last_block_received) {
+   //       std::string event_data = std::to_string(last_irreversible_block);
+   //       handle_event(event_data);
+   //       last_block_received = last_irreversible_block;
+   //    }
+   // }
 }
 
 void sidechain_net_handler_hive::handle_event(const std::string &event_data) {
-   std::string block = rpc_client->block_api_get_block(std::atoll(event_data.c_str()));
+   const std::string block = rpc_client->block_api_get_block(std::atoll(event_data.c_str()));
    if (block != "") {
       add_to_son_listener_log("BLOCK   : " + event_data);
       std::stringstream ss(block);
@@ -874,7 +960,7 @@ void sidechain_net_handler_hive::handle_event(const std::string &event_data) {
                   const auto &amount_child = op_value.get_child("amount");
 
                   uint64_t amount = amount_child.get<uint64_t>("amount");
-                  //uint64_t precision = amount_child.get<uint64_t>("precision");
+                  // uint64_t precision = amount_child.get<uint64_t>("precision");
                   std::string nai = amount_child.get<std::string>("nai");
                   std::string sidechain_currency = "";
                   price sidechain_currency_price = {};
@@ -924,6 +1010,7 @@ void sidechain_net_handler_hive::handle_event(const std::string &event_data) {
                   sed.timestamp = database.head_block_time();
                   sed.block_num = database.head_block_num();
                   sed.sidechain = sidechain;
+                  sed.type = sidechain_event_type::deposit;
                   sed.sidechain_uid = sidechain_uid;
                   sed.sidechain_transaction_id = transaction_id;
                   sed.sidechain_from = from;

libraries/plugins/peerplays_sidechain/sidechain_net_handler_peerplays.cpp

@@ -23,17 +23,16 @@
 namespace graphene { namespace peerplays_sidechain {
 
 sidechain_net_handler_peerplays::sidechain_net_handler_peerplays(peerplays_sidechain_plugin &_plugin, const boost::program_options::variables_map &options) :
-      sidechain_net_handler(_plugin, options) {
-   sidechain = sidechain_type::peerplays;
-   //const auto &assets_by_symbol = database.get_index_type<asset_index>().indices().get<by_symbol>();
-   //const auto get_asset_id = [&assets_by_symbol](const string &symbol) {
-   //   auto asset_itr = assets_by_symbol.find(symbol);
-   //   FC_ASSERT(asset_itr != assets_by_symbol.end(), "Unable to find asset '${sym}'", ("sym", symbol));
-   //   return asset_itr->get_id();
-   //};
-   //tracked_assets.push_back(get_asset_id("PBTC"));
-   //tracked_assets.push_back(get_asset_id("PETH"));
-   //tracked_assets.push_back(get_asset_id("PEOS"));
+      sidechain_net_handler(sidechain_type::peerplays, _plugin, options) {
+   // const auto &assets_by_symbol = database.get_index_type<asset_index>().indices().get<by_symbol>();
+   // const auto get_asset_id = [&assets_by_symbol](const string &symbol) {
+   //    auto asset_itr = assets_by_symbol.find(symbol);
+   //    FC_ASSERT(asset_itr != assets_by_symbol.end(), "Unable to find asset '${sym}'", ("sym", symbol));
+   //    return asset_itr->get_id();
+   // };
+   // tracked_assets.push_back(get_asset_id("PBTC"));
+   // tracked_assets.push_back(get_asset_id("PETH"));
+   // tracked_assets.push_back(get_asset_id("PEOS"));
 
    if (options.count("peerplays-private-key")) {
       const std::vector<std::string> pub_priv_keys = options["peerplays-private-key"].as<std::vector<std::string>>();
@@ -197,7 +196,14 @@ bool sidechain_net_handler_peerplays::process_deposit(const son_wallet_deposit_o
       stc_op.object_id = swdo.id;
       stc_op.sidechain = sidechain;
       stc_op.transaction = tx_str;
-      stc_op.signers = gpo.active_sons.at(sidechain);
+      for (const auto &signer : gpo.active_sons.at(sidechain)) {
+         son_info si;
+         si.son_id = signer.son_id;
+         si.weight = signer.weight;
+         si.signing_key = signer.signing_key;
+         si.sidechain_public_keys[sidechain] = signer.public_key;
+         stc_op.signers.emplace_back(std::move(si));
+      }
 
       proposal_create_operation proposal_op;
       proposal_op.fee_paying_account = plugin.get_current_son_object(sidechain).son_account;
@@ -278,8 +284,8 @@ bool sidechain_net_handler_peerplays::settle_sidechain_transaction(const sidecha
    }
 
    if (sto.object_id.is<son_wallet_deposit_id_type>()) {
-      //auto swdo = database.get<son_wallet_deposit_object>(sto.object_id);
-      //settle_amount = asset(swdo.sidechain_amount, swdo.sidechain_currency);
+      // auto swdo = database.get<son_wallet_deposit_object>(sto.object_id);
+      // settle_amount = asset(swdo.sidechain_amount, swdo.sidechain_currency);
    }
 
    if (sto.object_id.is<son_wallet_withdraw_id_type>()) {
@@ -290,4 +296,9 @@ bool sidechain_net_handler_peerplays::settle_sidechain_transaction(const sidecha
    return true;
 }
 
+optional<asset> sidechain_net_handler_peerplays::estimate_withdrawal_transaction_fee() const {
+   wlog("estimate_withdrawal_transaction_fee not implemented for sidechain: ${sidechain}", ("sidechain", sidechain));
+   return optional<asset>{};
+}
+
 }} // namespace graphene::peerplays_sidechain

libraries/wallet/generate_api_documentation.pl

@@ -44,13 +44,37 @@ for my $class (@{$doxydocs->{classes}})
       if ($member->{kind} eq 'function')
       {
         my @params = map { join(' ', cleanupDoxygenType($_->{type}), $_->{declaration_name}) } @{$member->{parameters}};
-        my $briefDescription = sprintf("%40s %s(%s)\n", cleanupDoxygenType($member->{type}), $member->{name}, join(', ', @params));
-        my $escapedBriefDescription = "\"" . escapeStringForC($briefDescription) . "\"";
-        my %paramInfo = map { $_->{declaration_name} => { type => $_->{type}} } @{$member->{parameters}};
+        my $callDescription = sprintf("%40s %s(%s)\n", cleanupDoxygenType($member->{type}), $member->{name}, join(', ', @params));
+        my $escapedBriefDescription = "\"" . escapeStringForC($callDescription) . "\"";
+        my %paramInfo = map { $_->{declaration_name} => { type => explainCType(cleanupDoxygenType($_->{type})) } } @{$member->{parameters}};
         my $escapedDetailedDescription = "\"\"\n";
-        if ($member->{detailed}->{doc})
+        my $doc = $member->{detailed}->{doc};
+        if ($doc)
         {
-          my $docString = formatDocComment($member->{detailed}->{doc}, \%paramInfo);
+          my $briefDescr = formatDocComment($member->{brief}->{doc});  # get from the proper place
+          unless ($briefDescr =~ /\w/)           # if not provided (API author forgot to add '@brief' comment),
+          {
+            for (my $i = 0; $i < @{$doc}; ++$i) # then look inside 'detailed' section
+            {
+              my $docElement = $doc->[$i];
+              if ($docElement->{type} eq 'text' and $docElement->{content} =~ /\w+/)  # use first meaningful line as brief description
+              {
+                $briefDescr = $docElement->{content};
+                $briefDescr =~ s/^\s+|\s+$//g;
+                splice @{$doc}, $i, 1;  # this section shouldn't be used twice
+                last;
+              }
+            }
+          }
+
+          my $cmdSyntax = $member->{name};
+          my $cmdArgs = join(' ', map { $_->{declaration_name} } @{$member->{parameters}});
+          $cmdSyntax .= " $cmdArgs" if $cmdArgs;
+
+          my $docString;
+          $docString .= $briefDescr;
+          $docString .= "\n\n" . formatDocComment($doc, \%paramInfo, $cmdSyntax);
+
           for my $line (split(/\n/, $docString))
           {
             $escapedDetailedDescription .=  "                \"" .  escapeStringForC($line . "\n") . "\"\n";
@@ -96,62 +120,86 @@ sub cleanupDoxygenType
   return $type;
 }
 
+sub explainCType
+{
+  my($type) = @_;
+  $type =~ s/\b\w+:://g;                    # remove namespaces
+  $type =~ s/^(?:optional|api)<(.+)>$/$1/;  # disregard optional<> and some other templates
+  $type =~ s/^const\s+(.+)/$1/;  # strip const modifier
+  $type =~ s/^(.+)&/$1/;         # strip references
+  $type =~ s/\s+$/$1/;
+  $type =~ s/\b(u?int(8|16|32|64)_t|int|unsigned)\b/integer/;  # spare the user from width and signedness
+  $type =~ s/\bbool\b/boolean/;      # they're not C++ people
+  $type =~ s/^(?:vector|set|flat_set)<(.+)>$/[$1, ...]/;    # represent as JSon-like array notation
+  $type =~ s/^map<(.+)\s*,\s*(.+)>$/{$1: $2, ...}/;         # same for map
+  $type =~ s/^flat_map<(.+)\s*,\s*(.+)>$/[[$1, $2], ...]/;  # same for flat_map
+  $type =~ s/^time_point_sec$/time, e.g. 2021-12-25T14:30:05/;
+  return $type;
+}
+
 sub formatDocComment
 {
-  my($doc, $paramInfo) = @_;
+  my($doc, $paramInfo, $cmdSyntax) = @_;
 
   my $bodyDocs = '';
+  my $notes = '';
+  my $see = '';
   my $paramDocs = '';
   my $returnDocs = '';
 
   for (my $i = 0; $i < @{$doc}; ++$i)
   {
-    if ($doc->[$i] eq 'params')
+    my $docElement = $doc->[$i];
+
+    if ($docElement->{params})
     {
       $paramDocs .= "Parameters:\n";
-      @parametersList = @{$doc->[$i + 1]};
-      for my $parameter (@parametersList)
+      for my $parameter (@{$docElement->{params}})
       {
         my $declname = $parameter->{parameters}->[0]->{name};
         my $decltype = cleanupDoxygenType($paramInfo->{$declname}->{type});
-        $paramDocs .= Text::Wrap::fill('    ', '        ', "$declname: " . formatDocComment($parameter->{doc}) . " (type: $decltype)") . "\n";
+        $paramDocs .= Text::Wrap::fill('    ', '        ', "$declname ($decltype):  " . formatDocComment($parameter->{doc})) . "\n";
       }
-      ++$i;
     }
-    elsif ($doc->[$i]->{return})
+    elsif ($docElement->{return})
     {
-      $returnDocs .= "Returns\n";
-      $returnDocs .= Text::Wrap::fill('    ','        ', formatDocComment($doc->[$i]->{return})) . "\n";
+      $returnDocs .= "Returns:\n";
+      $returnDocs .= Text::Wrap::fill('    ','        ', formatDocComment($docElement->{return})) . "\n";
     }
-    else
+    elsif ($docElement->{note})
     {
-      my $docElement = $doc->[$i];
-      if ($docElement->{type} eq 'text' or $docElement->{type} eq 'url')
-      {
-        $bodyDocs .= $docElement->{content};
-      }
-      elsif ($docElement->{type} eq 'parbreak')
-      {
-        $bodyDocs .= "\n\n";
-      }
-      elsif ($docElement->{type} eq 'style' and $docElement->{style} eq 'code')
-      {
-        $bodyDocs .= "'";
-      }
+      $notes .= Text::Wrap::fill('    ','        ', "Note: ".formatDocComment($docElement->{note})) . "\n";
+    }
+    elsif ($docElement->{see})
+    {
+      $see .= Text::Wrap::fill('    ','        ', "See: ".formatDocComment($docElement->{see})) . "\n";
+    }
+    elsif ($docElement->{type} eq 'text' or $docElement->{type} eq 'url')
+    {
+      $bodyDocs .= $docElement->{content};
+    }
+    elsif ($docElement->{type} eq 'parbreak')
+    {
+      $bodyDocs .= "\n\n";
+    }
+    elsif ($docElement->{type} eq 'style' and $docElement->{style} eq 'code')
+    {
+      $bodyDocs .= "'";
     }
   }
 
   $bodyDocs =~ s/^\s+|\s+$//g;
   $bodyDocs = Text::Wrap::fill('', '', $bodyDocs);
 
-  $paramDocs =~ s/^\s+|\s+$//g;
+  $notes      =~ s/^\s+|\s+$//g;
+  $see        =~ s/^\s+|\s+$//g;
+  $paramDocs  =~ s/^\s+|\s+$//g;
   $returnDocs =~ s/^\s+|\s+$//g;
 
-  my $result = Text::Wrap::fill('', '', $bodyDocs);
-  $result .= "\n\n" . $paramDocs if $paramDocs;
-  $result .= "\n\n" . $returnDocs if $returnDocs;
-  
-  return $result;
+  my $cmdDocs;
+  $cmdDocs = "Command:\n" . Text::Wrap::fill('    ','        ', $cmdSyntax) if $cmdSyntax;
+
+  return join "\n\n", grep {$_} ($bodyDocs, $notes, $see, $cmdDocs, $paramDocs, $returnDocs);
 }
 
 sub escapeCharForCString

libraries/wallet/include/graphene/wallet/wallet.hpp

@@ -84,6 +84,32 @@ typedef multi_index_container<
    >
 > key_label_index_type;
 
+/* How to write doxygen docs
+ *
+ * Good
+ * / ** Returns the block chain's rapidly-changing properties.
+ *  *
+ *  * The returned object contains information that changes every block interval
+ *  * such as the head block number, the next witness, etc.
+ *  * /
+ *
+ * Bad, no empty line
+ * / ** Returns the block chain's rapidly-changing properties.
+ *  * The returned object contains information that changes every block interval
+ *  * such as the head block number, the next witness, etc.
+ *  * /
+ *
+ * Better, using @brief tag
+ * / **
+ *  * @brief Returns the block chain's rapidly-changing properties.
+ *  * Long description text 1
+ *  * Long description text 2
+ *  * @param param1 param1 description
+ *  * @param param2 param2 description
+ *  * @returns return value description
+ *  * /
+ *  string get_rapidly_changing_properties(int32_t interval, string chain_id)
+ */
 
 struct wallet_data
 {
@@ -165,17 +191,6 @@ struct worker_vote_delta
    flat_set<worker_id_type> vote_abstain;
 };
 
-struct signed_block_with_info : public signed_block
-{
-   signed_block_with_info();
-   signed_block_with_info( const signed_block& block );
-   signed_block_with_info( const signed_block_with_info& block ) = default;
-
-   block_id_type block_id;
-   public_key_type signing_key;
-   vector< transaction_id_type > transaction_ids;
-};
-
 struct vesting_balance_object_with_info : public vesting_balance_object
 {
    vesting_balance_object_with_info();
@@ -237,18 +252,37 @@ class wallet_api
 
       fc::ecc::private_key derive_private_key(const std::string& prefix_string, int sequence_number) const;
 
+      /** Returns info about head block, chain_id, maintenance, participation, current active witnesses and
+       * committee members.
+       * @returns runtime info about the blockchain
+       */
       variant                           info();
       /** Returns info such as client version, git version of graphene/fc, version of boost, openssl.
        * @returns compile time info and client and dependencies versions
        */
       variant_object                    about() const;
-      optional<signed_block_with_info>    get_block( uint32_t num );
+      /** Returns info about a specified block.
+       * @param num height of the block to retrieve
+       * @returns info about the block, or null if not found
+       */
+      optional<signed_block>              get_block( uint32_t num );
+      /** Returns info about a specified block, with some extra info.
+       * @param num height of the block to retrieve
+       * @returns info about the block, or null if not found
+       */
+      optional<signed_block_with_info>    get_block2( uint32_t num );
+      /** Get signed blocks
+       * @param block_num_from The lowest block number
+       * @param block_num_to The highest block number
+       * @returns A list of signed blocks from block_num_from till block_num_to
+       */
       vector<optional<signed_block>>      get_blocks(uint32_t block_num_from, uint32_t block_num_to)const;
       /** Returns the number of accounts registered on the blockchain
        * @returns the number of registered accounts
        */
       uint64_t                          get_account_count()const;
       /** Lists all accounts controlled by this wallet.
+       *
        * This returns a list of the full account objects for all accounts whose private keys
        * we possess.
        * @returns a list of account objects
@@ -324,12 +358,42 @@ class wallet_api
 
       vector<account_balance_object> list_core_accounts()const;
 
+      /** Get OHLCV data of a trading pair in a time range
+       * @param symbol Asset symbol or ID in a trading pair
+       * @param symbol2 The other asset symbol or ID in the trading pair
+       * @param bucket Length of each time bucket in seconds.
+       * Note: it need to be within result of get_market_history_buckets() API, otherwise no data will be returned
+       * @param start The start of a time range, E.G. "2018-01-01T00:00:00"
+       * @param end The end of the time range
+       * @return A list of OHLCV data, in "least recent first" order.
+       * If there are more than 200 records in the specified time range, the first 200 records will be returned.
+       */
       vector<bucket_object>             get_market_history(string symbol, string symbol2, uint32_t bucket, fc::time_point_sec start, fc::time_point_sec end)const;
+
+      /** Get limit orders in a given market
+       * @param a symbol or ID of asset being sold
+       * @param b symbol or ID of asset being purchased
+       * @param limit Maximum number of orders to retrieve
+       * @return The limit orders, ordered from least price to greatest
+       */
       vector<limit_order_object>        get_limit_orders(string a, string b, uint32_t limit)const;
+
+      /** Get call orders (aka margin positions) for a given asset
+       * @param a symbol or ID of the debt asset
+       * @param limit Maximum number of orders to retrieve
+       * @return The call orders, ordered from earliest to be called to latest
+       */
       vector<call_order_object>         get_call_orders(string a, uint32_t limit)const;
+
+      /** Get forced settlement orders in a given asset
+       * @param a Symbol or ID of asset being settled
+       * @param limit Maximum number of orders to retrieve
+       * @return The settle orders, ordered from earliest settlement date to latest
+       */
       vector<force_settlement_object>   get_settle_orders(string a, uint32_t limit)const;
 
       /** Returns the block chain's slowly-changing settings.
+       *
        * This object contains all of the properties of the blockchain that are fixed
        * or that change only once per maintenance interval (daily) such as the
        * current list of witnesses, committee_members, block interval, etc.
@@ -339,6 +403,7 @@ class wallet_api
       global_property_object            get_global_properties() const;
 
       /** Returns the block chain's rapidly-changing properties.
+       *
        * The returned object contains information that changes every block interval
        * such as the head block number, the next witness, etc.
        * @see \c get_global_properties() for less-frequently changing properties
@@ -354,6 +419,7 @@ class wallet_api
       account_object                    get_account(string account_name_or_id) const;
 
       /** Returns information about the given asset.
+       *
        * @param asset_name_or_id the symbol or id of the asset in question
        * @returns the information about the asset stored in the block chain
        */
@@ -368,6 +434,7 @@ class wallet_api
       asset_bitasset_data_object        get_bitasset_data(string asset_name_or_id)const;
 
       /** Lookup the id of a named account.
+       *
        * @param account_name_or_id the name of the account to look up
        * @returns the id of the named account
        */
@@ -375,6 +442,7 @@ class wallet_api
 
       /**
        * Lookup the id of a named asset.
+       *
        * @param asset_name_or_id the symbol of an asset to look up
        * @returns the id of the given asset
        */
@@ -405,42 +473,90 @@ class wallet_api
       /**
        * Get the WIF private key corresponding to a public key.  The
        * private key must already be in the wallet.
+       * @param pubkey a public key in Base58 format
+       * @return the WIF private key
        */
       string                            get_private_key( public_key_type pubkey )const;
 
       /**
        * @ingroup Transaction Builder API
+       *
+       * Create a new transaction builder.
+       * @return handle of the new transaction builder
        */
       transaction_handle_type begin_builder_transaction();
+
       /**
        * @ingroup Transaction Builder API
+       *
+       * Append a new operation to a transaction builder.
+       * @param transaction_handle handle of the transaction builder
+       * @param op the operation in JSON format
        */
       void add_operation_to_builder_transaction(transaction_handle_type transaction_handle, const operation& op);
+
       /**
        * @ingroup Transaction Builder API
+       *
+       * Replace an operation in a transaction builder with a new operation.
+       * @param handle handle of the transaction builder
+       * @param operation_index the index of the old operation in the builder to be replaced
+       * @param new_op the new operation in JSON format
        */
       void replace_operation_in_builder_transaction(transaction_handle_type handle,
                                                     unsigned operation_index,
                                                     const operation& new_op);
+
       /**
        * @ingroup Transaction Builder API
+       *
+       * Calculate and update fees for the operations in a transaction builder.
+       * @param handle handle of the transaction builder
+       * @param fee_asset symbol or ID of an asset that to be used to pay fees
+       * @return total fees
        */
       asset set_fees_on_builder_transaction(transaction_handle_type handle, string fee_asset = GRAPHENE_SYMBOL);
+
       /**
        * @ingroup Transaction Builder API
+       *
+       * Show content of a transaction builder.
+       * @param handle handle of the transaction builder
+       * @return a transaction
        */
       transaction preview_builder_transaction(transaction_handle_type handle);
+
       /**
        * @ingroup Transaction Builder API
+       *
+       * Sign the transaction in a transaction builder and optionally broadcast to the network.
+       * @param transaction_handle handle of the transaction builder
+       * @param broadcast whether to broadcast the signed transaction to the network
+       * @return a signed transaction
        */
       signed_transaction sign_builder_transaction(transaction_handle_type transaction_handle, bool broadcast = true);
+
       /** Broadcast signed transaction
        * @param tx signed transaction
        * @returns the transaction ID along with the signed transaction.
        */
       pair<transaction_id_type,signed_transaction> broadcast_transaction(signed_transaction tx);
+
       /**
        * @ingroup Transaction Builder API
+       *
+       * Create a proposal containing the operations in a transaction builder (create a new proposal_create
+       * operation, then replace the transaction builder with the new operation), then sign the transaction
+       * and optionally broadcast to the network.
+       *
+       * Note: this command is buggy because unable to specify proposer. It will be deprecated in a future release.
+       *       Please use \c propose_builder_transaction2() instead.
+       *
+       * @param handle handle of the transaction builder
+       * @param expiration when the proposal will expire
+       * @param review_period_seconds review period of the proposal in seconds
+       * @param broadcast whether to broadcast the signed transaction to the network
+       * @return a signed transaction
        */
       signed_transaction propose_builder_transaction(
           transaction_handle_type handle,
@@ -449,6 +565,20 @@ class wallet_api
           bool broadcast = true
          );
 
+      /**
+       * @ingroup Transaction Builder API
+       *
+       * Create a proposal containing the operations in a transaction builder (create a new proposal_create
+       * operation, then replace the transaction builder with the new operation), then sign the transaction
+       * and optionally broadcast to the network.
+       *
+       * @param handle handle of the transaction builder
+       * @param account_name_or_id name or ID of the account who would pay fees for creating the proposal
+       * @param expiration when the proposal will expire
+       * @param review_period_seconds review period of the proposal in seconds
+       * @param broadcast whether to broadcast the signed transaction to the network
+       * @return a signed transaction
+       */
       signed_transaction propose_builder_transaction2(
          transaction_handle_type handle,
          string account_name_or_id,
@@ -459,6 +589,9 @@ class wallet_api
 
       /**
        * @ingroup Transaction Builder API
+       *
+       * Destroy a transaction builder.
+       * @param handle handle of the transaction builder
        */
       void remove_builder_transaction(transaction_handle_type handle);
 
@@ -496,6 +629,11 @@ class wallet_api
        *
        * The wallet must be either 'new' or 'unlocked' to
        * execute this command.
+       *
+       * When used in command line, if typed "set_password" without a password followed, the user will be prompted
+       * to input a password without echo.
+       *
+       * @param password a new password
        * @ingroup Wallet Management
        */
       void    set_password(string password);
@@ -577,7 +715,7 @@ class wallet_api
      /**
       * Derive any number of *possible* owner keys from a given brain key.
       *
-      * NOTE: These keys may or may not match with the owner keys of any account.
+      * @note These keys may or may not match with the owner keys of any account.
       * This function is merely intended to assist with account or key recovery.
       *
       * @see suggest_brain_key()
@@ -591,7 +729,8 @@ class wallet_api
      /**
       * Determine whether a textual representation of a public key
       * (in Base-58 format) is *currently* linked
-      * to any *registered* (i.e. non-stealth) account on the blockchain
+      * to any *registered* (i.e. non-stealth) account on the blockchain.
+      *
       * @param public_key Public key
       * @return Whether a public key is known
       */
@@ -629,13 +768,35 @@ class wallet_api
        */
       bool import_key(string account_name_or_id, string wif_key);
 
+      /** Imports accounts from Peerplays 0.x wallet file.
+       * Current wallet file must be unlocked to perform the import.
+       *
+       * @param filename the Peerplays 0.x wallet file to import
+       * @param password the password to encrypt the Peerplays 0.x wallet file
+       * @returns a map containing the accounts found and whether imported
+       */
       map<string, bool> import_accounts( string filename, string password );
 
+      /** Imports from a Peerplays 0.x wallet file, find keys that were bound to a given account name on the
+       * Peerplays 0.x chain, rebind them to an account name on the 2.0 chain.
+       * Current wallet file must be unlocked to perform the import.
+       *
+       * @param filename the Peerplays 0.x wallet file to import
+       * @param password the password to encrypt the Peerplays 0.x wallet file
+       * @param src_account_name name of the account on Peerplays 0.x chain
+       * @param dest_account_name name of the account on Peerplays 2.0 chain,
+       *                          can be same or different to \c src_account_name
+       * @returns whether the import has succeeded
+       */
       bool import_account_keys( string filename, string password, string src_account_name, string dest_account_name );
 
       /**
        * This call will construct transaction(s) that will claim all balances controled
        * by wif_keys and deposit them into the given account.
+       *
+       * @param account_name_or_id name or ID of an account that to claim balances to
+       * @param wif_keys private WIF keys of balance objects to claim balances from
+       * @param broadcast true to broadcast the transaction on the network
        */
       vector< signed_transaction > import_balance( string account_name_or_id, const vector<string>& wif_keys, bool broadcast );
 
@@ -682,7 +843,7 @@ class wallet_api
                                           uint32_t referrer_percent,
                                           bool broadcast = false);
 
-      /** Updates account public keys
+      /** Updates account public keys.
        *
        * @param name the name of the existing account
        * @param old_owner the owner key for the named account to be replaced
@@ -700,7 +861,8 @@ class wallet_api
                                              bool broadcast = false);
 
       /**
-       * This method updates the key of an authority for an exisiting account.
+       * Updates the key of an authority for an exisiting account.
+
        * Warning: You can create impossible authorities using this method. The method
        * will fail if you create an impossible owner authority, but will allow impossible
        * active and posting authorities.
@@ -719,6 +881,7 @@ class wallet_api
 
       /**
        *  Upgrades an account to prime status.
+       *
        *  This makes the account holder a 'lifetime member'.
        *
        *  @todo there is no option for annual membership
@@ -773,7 +936,16 @@ class wallet_api
 
       /**
        *  This method works just like transfer, except it always broadcasts and
-       *  returns the transaction ID along with the signed transaction.
+       *  returns the transaction ID (hash) along with the signed transaction.
+       * @param from the name or id of the account sending the funds
+       * @param to the name or id of the account receiving the funds
+       * @param amount the amount to send (in nominal units -- to send half of a BTS, specify 0.5)
+       * @param asset_symbol the symbol or id of the asset to send
+       * @param memo a memo to attach to the transaction.  The memo will be encrypted in the
+       *             transaction and readable for the receiver.  There is no length limit
+       *             other than the limit imposed by maximum transaction size, but transaction
+       *             increase with transaction size
+       * @returns the transaction ID (hash) along with the signed transaction transferring funds
        */
       pair<transaction_id_type,signed_transaction> transfer2(string from,
                                                              string to,
@@ -786,7 +958,9 @@ class wallet_api
 
 
       /**
-       *  This method is used to convert a JSON transaction to its transactin ID.
+       * This method is used to convert a JSON transaction to its transactin ID.
+       * @param trx a JSON transaction
+       * @return the ID (hash) of the transaction
        */
       transaction_id_type get_transaction_id( const signed_transaction& trx )const { return trx.id(); }
 
@@ -794,16 +968,24 @@ class wallet_api
       /** These methods are used for stealth transfers */
       ///@{
       /**
-       *  This method can be used to set the label for a public key
+       *  Set the label for a public key
        *
        *  @note No two keys can have the same label.
        *
        *  @return true if the label was set, otherwise false
        */
-      bool                        set_key_label( public_key_type, string label );
-      string                      get_key_label( public_key_type )const;
+      bool                        set_key_label( public_key_type key, string label );
 
-      /** @return the public key associated with the given label */
+      /** Get label of a public key.
+       * @param key a public key
+       * @return the label if already set by \c set_key_label(), or an empty string if not set
+       */
+      string                      get_key_label( public_key_type key )const;
+
+      /* Get the public key associated with a given label.
+       * @param label a label
+       * @return the public key associated with the given label
+       */
       public_key_type             get_public_key( string label )const;
       ///@}
 
@@ -918,7 +1100,7 @@ class wallet_api
       signed_transaction borrow_asset(string borrower_name, string amount_to_borrow, string asset_symbol,
                                       string amount_of_collateral, bool broadcast = false);
 
-      /** Cancel an existing order
+      /** Cancel an existing order.
        *
        * @param order_id the id of order to be cancelled
        * @param broadcast true to broadcast the transaction on the network
@@ -978,6 +1160,7 @@ class wallet_api
                                      bool broadcast = false);
 
       /** Update the core options on an asset.
+       *
        * There are a number of options which all assets in the network use. These options are
        * enumerated in the asset_object::asset_options struct. This command is used to update
        * these options for an existing asset.
@@ -1184,6 +1367,7 @@ class wallet_api
                                          bool broadcast = false);
 
       /** Lists all witnesses registered in the blockchain.
+       *
        * This returns a list of all account names that own witnesses, and the associated witness id,
        * sorted by name.  This lists witnesses whether they are currently voted in or not.
        *
@@ -1214,6 +1398,7 @@ class wallet_api
       map<string, committee_member_id_type>       list_committee_members(const string& lowerbound, uint32_t limit);
 
       /** Lists all workers in the blockchain.
+       *
        * This returns a list of all account names that own worker, and the associated worker id,
        * sorted by name.  This lists workers whether they are currently voted in or not.
        *
@@ -1355,6 +1540,7 @@ class wallet_api
                                               bool broadcast = false);
 
       /** Lists all SONs in the blockchain.
+       *
        * This returns a list of all account names that own SON, and the associated SON id,
        * sorted by name.  This lists SONs whether they are currently voted in or not.
        *
@@ -1369,18 +1555,31 @@ class wallet_api
        */
       map<string, son_id_type> list_sons(const string& lowerbound, uint32_t limit);
 
-      /** Lists active at the moment SONs.
-       * This returns a list of all account names that own active SON, and the associated SON id,
-       * sorted by name.
-       * @returns a list of active SONs mapping SON names to SON ids
+      /**
+       * @brief Get list of active sons
+       * @return List of active SONs
        */
-      map<string, son_id_type> list_active_sons();
+      flat_map<sidechain_type, vector<son_sidechain_info>> get_active_sons();
+
+      /**
+       * @brief Get list of active sons
+       * @param sidechain Sidechain type [bitcoin|ethereum|hive]
+       * @return List of active SONs
+       */
+      vector<son_sidechain_info> get_active_sons_by_sidechain(sidechain_type sidechain);
 
       /**
        * @brief Get SON network status
-       * @return SON network status description
+       * @return SON network status description for a given sidechain type
        */
-      map<son_id_type, string>  get_son_network_status();
+      map<sidechain_type, map<son_id_type, string>> get_son_network_status();
+
+      /**
+       * @brief Get SON network status
+       * @param sidechain Sidechain type [bitcoin|ethereum|hive]
+       * @return SON network status description for a given sidechain type
+       */
+      map<son_id_type, string> get_son_network_status_by_sidechain(sidechain_type sidechain);
 
       /**
        * @brief Get active SON wallet
@@ -1483,6 +1682,7 @@ class wallet_api
        * @param url Same as for create_witness.  The empty string makes it remain the same.
        * @param block_signing_key The new block signing public key.  The empty string makes it remain the same.
        * @param broadcast true if you wish to broadcast the transaction.
+       * @return the signed transaction
        */
       signed_transaction update_witness(string witness_name,
                                         string url,
@@ -1501,6 +1701,7 @@ class wallet_api
        * @param url Any text
        * @param worker_settings {"type" : "burn"|"refund"|"vesting", "pay_vesting_period_days" : x}
        * @param broadcast true if you wish to broadcast the transaction.
+       * @return the signed transaction
        */
       signed_transaction create_worker(
          string owner_account,
@@ -1519,6 +1720,7 @@ class wallet_api
        * @param account The account which will pay the fee and update votes.
        * @param delta {"vote_for" : [...], "vote_against" : [...], "vote_abstain" : [...]}
        * @param broadcast true if you wish to broadcast the transaction.
+       * @return the signed transaction
        */
       signed_transaction update_worker_votes(
          string account,
@@ -1533,7 +1735,7 @@ class wallet_api
        * @param asset_symbol the symbol of the asset to vest
        * @param vesting_type "normal", "gpos" or "son"
        * @param broadcast true to broadcast the transaction on the network
-       * @returns the signed transaction registering a vesting object
+       * @return the signed transaction registering a vesting object
        */
       signed_transaction create_vesting_balance(string owner_account,
                                         string amount,
@@ -1545,6 +1747,7 @@ class wallet_api
        * Get information about a vesting balance object.
        *
        * @param account_name An account name, account ID, or vesting balance object ID.
+       * @return a list of vesting balance objects with additional info
        */
       vector< vesting_balance_object_with_info > get_vesting_balances( string account_name );
 
@@ -1555,6 +1758,7 @@ class wallet_api
        * @param amount The amount to withdraw.
        * @param asset_symbol The symbol of the asset to withdraw.
        * @param broadcast true if you wish to broadcast the transaction
+       * @return the signed transaction
        */
       signed_transaction withdraw_vesting(
          string witness_name,
@@ -1562,13 +1766,13 @@ class wallet_api
          string asset_symbol,
          bool broadcast = false);
 
-      /**
-       * Withdraw a GPOS vesting balance.
+      /** Withdraw a GPOS vesting balance.
        *
        * @param account_name The account name of the witness/user, also accepts account ID or vesting balance ID type.
        * @param amount The amount to withdraw.
        * @param asset_symbol The symbol of the asset to withdraw.
        * @param broadcast true if you wish to broadcast the transaction
+       * @return the signed transaction
        */
       signed_transaction withdraw_GPOS_vesting_balance(
          string account_name,
@@ -1928,6 +2132,13 @@ class wallet_api
          bool broadcast /* = false */
          );
 
+      /**
+       * Returns the order book for the market base:quote.
+       * @param base symbol or ID of the base asset
+       * @param quote symbol or ID of the quote asset
+       * @param limit depth of the order book to retrieve, for bids and asks each, capped at 50
+       * @return Order book of the market
+       */
       order_book get_order_book( const string& base, const string& quote, unsigned limit = 50);
 
       asset get_total_matched_bet_amount_for_betting_market_group(betting_market_group_id_type group_id);
@@ -2354,9 +2565,29 @@ class wallet_api
 
       /**
        * @brief Returns all tokens
+       * @param limit the maximum number of NFT objects to return (max: 100)
+       * @param lower_id ID of the first NFT object to include in the list.
        * @return Returns vector of NFT objects, empty vector if none
        */
-      vector<nft_object> nft_get_all_tokens() const;
+      vector<nft_object> nft_get_all_tokens(uint32_t limit, optional<nft_id_type> lower_id) const;
+
+      /**
+       * @brief Returns all tokens owned by owner
+       * @param owner NFT owner account ID
+       * @param limit the maximum number of NFT objects to return (max: 100)
+       * @param lower_id ID of the first NFT object to include in the list.
+       * @return Returns vector of NFT objects, empty vector if none
+       */
+      vector<nft_object> nft_get_tokens_by_owner(account_id_type owner, uint32_t limit, optional<nft_id_type> lower_id) const;
+
+      /**
+       * @brief Returns all NFT metadata objects owned by owner
+       * @param owner NFT owner account ID
+       * @param limit the maximum number of NFT metadata objects to return (max: 100)
+       * @param lower_id ID of the first NFT metadata object to include in the list.
+       * @return Returns vector of NFT metadata objects, empty vector if none
+       */
+      vector<nft_metadata_object> nft_get_metadata_by_owner(account_id_type owner, uint32_t limit, optional<nft_metadata_id_type> lower_id) const;
       signed_transaction nft_lottery_buy_ticket( nft_metadata_id_type lottery, account_id_type buyer, uint64_t tickets_to_buy, bool broadcast );
 
       signed_transaction create_offer(set<nft_id_type> item_ids,
@@ -2459,6 +2690,19 @@ class wallet_api
        */
       std::map<sidechain_type, std::vector<std::string>> get_son_listener_log() const;
 
+      /**
+       * @brief Estimate transaction fee for withdrawal
+       * @param sidechain Sidechain type (bitcoin, HIVE, etc)
+       * @return Transaction fee
+       */
+      optional<asset> estimate_withdrawal_transaction_fee(sidechain_type sidechain) const;
+
+      /**
+       * @brief Estimate gas fee for withdrawal transaction for ETH
+       * @return Gas fee in ETH
+       */
+      std::string eth_estimate_withdrawal_transaction_fee() const;
+
       fc::signal<void(bool)> lock_changed;
       std::shared_ptr<detail::wallet_api_impl> my;
       void encrypt_keys();
@@ -2512,9 +2756,6 @@ FC_REFLECT( graphene::wallet::worker_vote_delta,
    (vote_abstain)
 )
 
-FC_REFLECT_DERIVED( graphene::wallet::signed_block_with_info, (graphene::chain::signed_block),
-   (block_id)(signing_key)(transaction_ids) )
-
 FC_REFLECT_DERIVED( graphene::wallet::vesting_balance_object_with_info, (graphene::chain::vesting_balance_object),
    (allowed_withdraw)(allowed_withdraw_time) )
 
@@ -2598,8 +2839,10 @@ FC_API( graphene::wallet::wallet_api,
         (update_son_vesting_balances)
         (activate_deregistered_son)
         (list_sons)
-        (list_active_sons)
+        (get_active_sons)
+        (get_active_sons_by_sidechain)
         (get_son_network_status)
+        (get_son_network_status_by_sidechain)
         (request_son_maintenance)
         (cancel_request_son_maintenance)
         (get_active_son_wallet)
@@ -2630,6 +2873,7 @@ FC_API( graphene::wallet::wallet_api,
         (get_account)
         (get_account_id)
         (get_block)
+        (get_block2)
         (get_blocks)
         (get_account_count)
         (get_account_history)
@@ -2711,6 +2955,8 @@ FC_API( graphene::wallet::wallet_api,
         (nft_get_approved)
         (nft_is_approved_for_all)
         (nft_get_all_tokens)
+        (nft_get_tokens_by_owner)
+        (nft_get_metadata_by_owner)
         (nft_lottery_buy_ticket)
         (create_offer)
         (create_bid)
@@ -2757,4 +3003,6 @@ FC_API( graphene::wallet::wallet_api,
         (get_voters_by_id)
         (get_voters)
         (get_son_listener_log)
+        (estimate_withdrawal_transaction_fee)
+        (eth_estimate_withdrawal_transaction_fee)
       )

libraries/wallet/wallet.cpp

@@ -2230,99 +2230,25 @@ public:
          return sign_transaction( tx, broadcast );
    } FC_CAPTURE_AND_RETHROW( (owner_account) ) }
 
-   //! Fixme - do we need to specify sidechain_type as params here?
-   map<string, son_id_type> list_active_sons()
-   {
-      try
-      {
-         const global_property_object& gpo = get_global_properties();
-         set<son_id_type> son_ids_set;
-         for(const auto& active_sidechain_type : active_sidechain_types)
-         {
-            std::transform(gpo.active_sons.at(active_sidechain_type).cbegin(), gpo.active_sons.at(active_sidechain_type).cend(),
-                           std::inserter(son_ids_set, son_ids_set.end()),
-                           [](const son_info &swi) {
-                              return swi.son_id;
-                           });
-         }
-         vector<son_id_type> son_ids;
-         son_ids.reserve(son_ids_set.size());
-         for(const auto& son_id : son_ids_set)
-         {
-            son_ids.emplace_back(son_id);
-         }
+   flat_map<sidechain_type, vector<son_sidechain_info>> get_active_sons()
+   { try {
+       return _remote_db->get_active_sons();
+   } FC_CAPTURE_AND_RETHROW() }
 
-         std::vector<fc::optional<son_object>> son_objects = _remote_db->get_sons(son_ids);
-         vector<std::string> owners;
-         for(auto obj: son_objects)
-         {
-            std::string acc_id = account_id_to_string(obj->son_account);
-            owners.push_back(acc_id);
-         }
-         vector< optional< account_object> > accs = _remote_db->get_accounts(owners);
-         std::remove_if(son_objects.begin(), son_objects.end(),
-                        [](const fc::optional<son_object>& obj) -> bool { return obj.valid(); });
-         map<string, son_id_type> result;
-         std::transform(accs.begin(), accs.end(), son_objects.begin(),
-                        std::inserter(result, result.end()),
-                        [](fc::optional<account_object>& acct, fc::optional<son_object> son) {
-                           FC_ASSERT(acct, "Invalid active SONs list in global properties.");
-                           return std::make_pair<string, son_id_type>(string(acct->name), std::move(son->id));
-                        });
-         return result;
-      }
-      FC_CAPTURE_AND_RETHROW()
-   }
+   vector<son_sidechain_info> get_active_sons_by_sidechain(sidechain_type sidechain)
+   { try {
+       return _remote_db->get_active_sons_by_sidechain(sidechain);
+   } FC_CAPTURE_AND_RETHROW() }
 
-   //! Fixme - do we need to specify sidechain_type as params here?
-   map<son_id_type, string> get_son_network_status()
-   {
-      try
-      {
-         const global_property_object& gpo = get_global_properties();
+   map<sidechain_type, map<son_id_type, string>> get_son_network_status()
+   { try {
+       return _remote_db->get_son_network_status();
+   } FC_CAPTURE_AND_RETHROW() }
 
-         set<son_id_type> son_ids_set;
-         for(const auto& active_sidechain_type : active_sidechain_types) {
-            std::transform(gpo.active_sons.at(active_sidechain_type).cbegin(), gpo.active_sons.at(active_sidechain_type).cend(),
-                           std::inserter(son_ids_set, son_ids_set.end()),
-                           [](const son_info &swi) {
-               return swi.son_id;
-            });
-         }
-         vector<son_id_type> son_ids;
-         son_ids.reserve(son_ids_set.size());
-         std::transform(son_ids_set.cbegin(), son_ids_set.cend(),
-                        std::inserter(son_ids, son_ids.end()),
-                        [](const son_id_type& sit) {
-            return sit;
-         });
-
-         map<son_id_type, string> result;
-         std::vector<fc::optional<son_object>> son_objects = _remote_db->get_sons(son_ids);
-         for(auto son_obj: son_objects) {
-            string status;
-            if (son_obj) {
-               son_statistics_object sso = get_object(son_obj->statistics);
-               for(const auto& active_sidechain_type : active_sidechain_types) {
-                  if (sso.last_active_timestamp.at(active_sidechain_type) + fc::seconds(gpo.parameters.son_heartbeat_frequency()) > time_point::now()) {
-                     status = "[OK, regular SON heartbeat for sidechain " + std::to_string(static_cast<unsigned int>(active_sidechain_type)) + "] ";
-                  } else {
-                     if (sso.last_active_timestamp.at(active_sidechain_type) + fc::seconds(gpo.parameters.son_down_time()) > time_point::now()) {
-                        status = "[OK, irregular SON heartbeat, but not triggering SON down proposal for sidechain " + std::to_string(static_cast<unsigned int>(active_sidechain_type)) + "] ";
-                     } else {
-                        status = "[NOT OK, irregular SON heartbeat, triggering SON down proposal for sidechain " + std::to_string(static_cast<unsigned int>(active_sidechain_type)) + "] ";
-                     }
-                  }
-               }
-            } else {
-               status = "NOT OK, invalid SON id";
-            }
-            result[son_obj->id] = status;
-         }
-         return result;
-      }
-      FC_CAPTURE_AND_RETHROW()
-   }
+   map<son_id_type, string> get_son_network_status_by_sidechain(sidechain_type sidechain)
+   { try {
+       return _remote_db->get_son_network_status_by_sidechain(sidechain);
+   } FC_CAPTURE_AND_RETHROW() }
 
    optional<son_wallet_object> get_active_son_wallet()
    { try {
@@ -2847,21 +2773,34 @@ public:
       FC_ASSERT(son_obj, "Account ${son} is not registered as a son", ("son", son));
       FC_ASSERT(sidechain == sidechain_type::bitcoin || sidechain == sidechain_type::hive || sidechain == sidechain_type::ethereum, "Unexpected sidechain type");
 
+      bool update_vote_time = false;
       if (approve)
       {
-         auto insert_result = voting_account_object.options.votes.insert(son_obj->get_sidechain_vote_id(sidechain));
-         if (!insert_result.second)
-            FC_THROW("Account ${account} has already voted for son ${son} for sidechain ${sidechain}", ("account", voting_account)("son", son)("sidechain", sidechain));
+         FC_ASSERT(son_obj->get_sidechain_vote_id(sidechain).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", sidechain)("son", *son_obj));
+         account_id_type stake_account = get_account_id(voting_account);
+         const auto gpos_info = _remote_db->get_gpos_info(stake_account);
+         const auto vesting_subperiod = _remote_db->get_global_properties().parameters.gpos_subperiod();
+         const auto gpos_start_time = fc::time_point_sec(_remote_db->get_global_properties().parameters.gpos_period_start());
+         const auto subperiod_start_time = gpos_start_time.sec_since_epoch() + (gpos_info.current_subperiod - 1) * vesting_subperiod;
+
+         auto insert_result = voting_account_object.options.votes.insert(*son_obj->get_sidechain_vote_id(sidechain));
+         if (!insert_result.second && (gpos_info.last_voted_time.sec_since_epoch() >= subperiod_start_time))
+            FC_THROW("Account ${account} was already voting for son ${son} in the current GPOS sub-period", ("account", voting_account)("son", son));
+         else
+            update_vote_time = true;   //Allow user to vote in each sub-period(Update voting time, which is reference in calculating VF)
       }
       else
       {
-         unsigned votes_removed = voting_account_object.options.votes.erase(son_obj->get_sidechain_vote_id(sidechain));
+         FC_ASSERT(son_obj->get_sidechain_vote_id(sidechain).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", sidechain)("son", *son_obj));
+         unsigned votes_removed = voting_account_object.options.votes.erase(*son_obj->get_sidechain_vote_id(sidechain));
          if (!votes_removed)
             FC_THROW("Account ${account} has already unvoted for son ${son} for sidechain ${sidechain}", ("account", voting_account)("son", son)("sidechain", sidechain));
       }
+      
       account_update_operation account_update_op;
       account_update_op.account = voting_account_object.id;
       account_update_op.new_options = voting_account_object.options;
+      account_update_op.extensions.value.update_last_voting_time = update_vote_time;
 
       signed_transaction tx;
       tx.operations.push_back( account_update_op );
@@ -2893,7 +2832,8 @@ public:
          FC_ASSERT(son_obj, "Account ${son} is not registered as a son", ("son", son));
          FC_ASSERT(sidechain == sidechain_type::bitcoin || sidechain == sidechain_type::hive || sidechain == sidechain_type::ethereum, "Unexpected sidechain type");
 
-         auto insert_result = voting_account_object.options.votes.insert(son_obj->get_sidechain_vote_id(sidechain));
+         FC_ASSERT(son_obj->get_sidechain_vote_id(sidechain).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", sidechain)("son", *son_obj));
+         auto insert_result = voting_account_object.options.votes.insert(*son_obj->get_sidechain_vote_id(sidechain));
          if (!insert_result.second)
             FC_THROW("Account ${account} was already voting for SON ${son}", ("account", voting_account)("son", son));
       }
@@ -2904,7 +2844,8 @@ public:
          FC_ASSERT(son_obj, "Account ${son} is not registered as a son", ("son", son));
          FC_ASSERT(sidechain == sidechain_type::bitcoin || sidechain == sidechain_type::hive || sidechain == sidechain_type::ethereum, "Unexpected sidechain type");
 
-         unsigned votes_removed = voting_account_object.options.votes.erase(son_obj->get_sidechain_vote_id(sidechain));
+         FC_ASSERT(son_obj->get_sidechain_vote_id(sidechain).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", sidechain)("son", *son_obj));
+         unsigned votes_removed = voting_account_object.options.votes.erase(*son_obj->get_sidechain_vote_id(sidechain));
          if (!votes_removed)
             FC_THROW("Account ${account} is already not voting for SON ${son}", ("account", voting_account)("son", son));
       }
@@ -3365,6 +3306,25 @@ public:
          return sign_transaction(trx, broadcast);
    } FC_CAPTURE_AND_RETHROW((order_id)) }
 
+   sidechain_type get_sidechain_type_from_asset(asset_id_type asset_id) const
+   {
+      const auto& gpo = _remote_db->get_global_properties();
+
+      if(asset_id == gpo.parameters.btc_asset())
+         return sidechain_type::bitcoin;
+
+      if(asset_id == gpo.parameters.eth_asset())
+         return sidechain_type::ethereum;
+
+      if(asset_id == gpo.parameters.hbd_asset())
+         return sidechain_type::hive;
+
+      if(asset_id == gpo.parameters.hive_asset())
+         return sidechain_type::hive;
+
+      return sidechain_type::unknown;
+   }
+
    signed_transaction transfer(string from, string to, string amount,
                                string asset_symbol, string memo, bool broadcast = false)
    { try {
@@ -3397,6 +3357,19 @@ public:
       set_operation_fees( tx, _remote_db->get_global_properties().parameters.current_fees);
       tx.validate();
 
+      //! For sidechain withdrawal check if amount is greater than fee
+      if(to_id == _remote_db->get_global_properties().parameters.son_account()) {
+         const auto sidechain = get_sidechain_type_from_asset(asset_obj->id);
+         const auto transaction_fee = estimate_withdrawal_transaction_fee(sidechain);
+
+         if(transaction_fee) {
+            if (*transaction_fee >= xfer_op.amount) {
+               FC_THROW("Transaction fee: ${sidechain_fee}, is greater than or equal to the transferred amount ${amount}",
+                        ("sidechain_fee", get_asset(transaction_fee->asset_id).amount_to_pretty_string(transaction_fee->amount))("amount", get_asset(xfer_op.amount.asset_id).amount_to_pretty_string(xfer_op.amount.amount)));
+            }
+         }
+      }
+
       return sign_transaction(tx, broadcast);
    } FC_CAPTURE_AND_RETHROW( (from)(to)(amount)(asset_symbol)(memo)(broadcast) ) }
 
@@ -4144,7 +4117,7 @@ public:
          "to access the debug API on the node you are connecting to.\n"
          "\n"
          "To fix this problem:\n"
-         "- Please ensure you are running debug_node, not witness_node.\n"
+         "- Please ensure you enable debug_witness plugin in witness_node.\n"
          "- Please follow the instructions in README.md to set up an apiaccess file.\n"
          "\n";
       }
@@ -4296,6 +4269,31 @@ public:
       FC_CAPTURE_AND_RETHROW()
    }
 
+   optional<asset> estimate_withdrawal_transaction_fee(sidechain_type sidechain)
+   {
+      use_sidechain_api();
+      try
+      {
+         return (*_remote_sidechain)->estimate_withdrawal_transaction_fee(sidechain);
+      }
+      FC_CAPTURE_AND_RETHROW()
+   }
+
+   std::string eth_estimate_withdrawal_transaction_fee()
+   {
+      try
+      {
+         const auto transaction_fee = estimate_withdrawal_transaction_fee(sidechain_type::ethereum);
+         if(transaction_fee)
+         {
+            return get_asset(transaction_fee->asset_id).amount_to_pretty_string(transaction_fee->amount);
+         }
+
+         return "Can't get fee value";
+      }
+      FC_CAPTURE_AND_RETHROW()
+   }
+
    string                  _wallet_filename;
    wallet_data             _wallet;
 
@@ -4566,11 +4564,16 @@ bool wallet_api::copy_wallet_file(string destination_filename)
    return my->copy_wallet_file(destination_filename);
 }
 
-optional<signed_block_with_info> wallet_api::get_block(uint32_t num)
+optional<signed_block> wallet_api::get_block(uint32_t num)
 {
    return my->_remote_db->get_block(num);
 }
 
+optional<signed_block_with_info> wallet_api::get_block2(uint32_t num)
+{
+   return my->_remote_db->get_block2(num);
+}
+
 vector<optional<signed_block>> wallet_api::get_blocks(uint32_t block_num_from, uint32_t block_num_to) const
 {
    return my->_remote_db->get_blocks(block_num_from, block_num_to);
@@ -5306,16 +5309,26 @@ map<string, son_id_type> wallet_api::list_sons(const string& lowerbound, uint32_
    return my->_remote_db->lookup_son_accounts(lowerbound, limit);
 }
 
-map<string, son_id_type> wallet_api::list_active_sons()
+flat_map<sidechain_type, vector<son_sidechain_info>> wallet_api::get_active_sons()
 {
-    return my->list_active_sons();
+    return my->get_active_sons();
 }
 
-map<son_id_type, string> wallet_api::get_son_network_status()
+vector<son_sidechain_info> wallet_api::get_active_sons_by_sidechain(sidechain_type sidechain)
+{
+    return my->get_active_sons_by_sidechain(sidechain);
+}
+
+map<sidechain_type, map<son_id_type, string>> wallet_api::get_son_network_status()
 {
     return my->get_son_network_status();
 }
 
+map<son_id_type, string> wallet_api::get_son_network_status_by_sidechain(sidechain_type sidechain)
+{
+    return my->get_son_network_status_by_sidechain(sidechain);
+}
+
 optional<son_wallet_object> wallet_api::get_active_son_wallet()
 {
     return my->get_active_son_wallet();
@@ -5770,54 +5783,12 @@ string wallet_api::gethelp(const string& method)const
    std::stringstream ss;
    ss << "\n";
 
-   if( method == "import_key" )
-   {
-      ss << "usage: import_key ACCOUNT_NAME_OR_ID  WIF_PRIVATE_KEY\n\n";
-      ss << "example: import_key \"1.3.11\" 5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3\n";
-      ss << "example: import_key \"usera\" 5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3\n";
-   }
-   else if( method == "transfer" )
-   {
-      ss << "usage: transfer FROM TO AMOUNT SYMBOL \"memo\" BROADCAST\n\n";
-      ss << "example: transfer \"1.3.11\" \"1.3.4\" 1000.03 CORE \"memo\" true\n";
-      ss << "example: transfer \"usera\" \"userb\" 1000.123 CORE \"memo\" true\n";
-   }
-   else if( method == "create_account_with_brain_key" )
-   {
-      ss << "usage: create_account_with_brain_key BRAIN_KEY ACCOUNT_NAME REGISTRAR REFERRER BROADCAST\n\n";
-      ss << "example: create_account_with_brain_key \"my really long brain key\" \"newaccount\" \"1.3.11\" \"1.3.11\" true\n";
-      ss << "example: create_account_with_brain_key \"my really long brain key\" \"newaccount\" \"someaccount\" \"otheraccount\" true\n";
-      ss << "\n";
-      ss << "This method should be used if you would like the wallet to generate new keys derived from the brain key.\n";
-      ss << "The BRAIN_KEY will be used as the owner key, and the active key will be derived from the BRAIN_KEY.  Use\n";
-      ss << "register_account if you already know the keys you know the public keys that you would like to register.\n";
-
-   }
-   else if( method == "register_account" )
-   {
-      ss << "usage: register_account ACCOUNT_NAME OWNER_PUBLIC_KEY ACTIVE_PUBLIC_KEY REGISTRAR REFERRER REFERRER_PERCENT BROADCAST\n\n";
-      ss << "example: register_account \"newaccount\" \"CORE6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV\" \"CORE6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV\" \"1.3.11\" \"1.3.11\" 50 true\n";
-      ss << "\n";
-      ss << "Use this method to register an account for which you do not know the private keys.";
-   }
-   else if( method == "create_asset" )
-   {
-      ss << "usage: ISSUER SYMBOL PRECISION_DIGITS OPTIONS BITASSET_OPTIONS BROADCAST\n\n";
-      ss << "PRECISION_DIGITS: the number of digits after the decimal point\n\n";
-      ss << "Example value of OPTIONS: \n";
-      ss << fc::json::to_pretty_string( graphene::chain::asset_options() );
-      ss << "\nExample value of BITASSET_OPTIONS: \n";
-      ss << fc::json::to_pretty_string( graphene::chain::bitasset_options() );
-      ss << "\nBITASSET_OPTIONS may be null\n";
-   }
+   std::string doxygenHelpString = my->method_documentation.get_detailed_description(method);
+   if (!doxygenHelpString.empty())
+      ss << doxygenHelpString;
    else
-   {
-      std::string doxygenHelpString = my->method_documentation.get_detailed_description(method);
-      if (!doxygenHelpString.empty())
-         ss << doxygenHelpString;
-      else
-         ss << "No help defined for method " << method << "\n";
-   }
+      ss << "No help defined for method " << method << "\n";
+
 
    return ss.str();
 }
@@ -7076,9 +7047,28 @@ bool wallet_api::nft_is_approved_for_all(string owner_account_id_or_name, string
    return my->_remote_db->nft_is_approved_for_all(owner_account.id, operator_account.id);
 }
 
-vector<nft_object> wallet_api::nft_get_all_tokens() const
+vector<nft_object> wallet_api::nft_get_all_tokens(uint32_t limit, optional<nft_id_type> lower_id) const
 {
-   return my->_remote_db->nft_get_all_tokens();
+   nft_id_type lb_id;
+   if(lower_id)
+      lb_id = *lower_id;
+   return my->_remote_db->nft_get_all_tokens(lb_id, limit);
+}
+
+vector<nft_object> wallet_api::nft_get_tokens_by_owner(account_id_type owner, uint32_t limit, optional<nft_id_type> lower_id) const
+{
+   nft_id_type lb_id;
+   if(lower_id)
+      lb_id = *lower_id;
+   return my->_remote_db->nft_get_tokens_by_owner(owner, lb_id, limit);
+}
+
+vector<nft_metadata_object> wallet_api::nft_get_metadata_by_owner(account_id_type owner, uint32_t limit, optional<nft_metadata_id_type> lower_id) const
+{
+   nft_metadata_id_type lb_id;
+   if(lower_id)
+      lb_id = *lower_id;
+   return my->_remote_db->nft_get_metadata_by_owner(owner, lb_id, limit);
 }
 
 signed_transaction wallet_api::nft_lottery_buy_ticket( nft_metadata_id_type lottery, account_id_type buyer, uint64_t tickets_to_buy, bool broadcast )
@@ -7319,10 +7309,6 @@ vector<account_role_object> wallet_api::get_account_roles_by_owner(string owner_
    account_object owner_account = my->get_account(owner_account_id_or_name);
    return my->_remote_db->get_account_roles_by_owner(owner_account.id);
 }
-// default ctor necessary for FC_REFLECT
-signed_block_with_info::signed_block_with_info()
-{
-}
 
 order_book wallet_api::get_order_book( const string& base, const string& quote, unsigned limit )
 {
@@ -7379,15 +7365,14 @@ std::map<sidechain_type, std::vector<std::string>> wallet_api::get_son_listener_
    return my->get_son_listener_log();
 }
 
-// default ctor necessary for FC_REFLECT
-signed_block_with_info::signed_block_with_info( const signed_block& block )
-   : signed_block( block )
+optional<asset> wallet_api::estimate_withdrawal_transaction_fee(sidechain_type sidechain) const
 {
-   block_id = id();
-   signing_key = signee();
-   transaction_ids.reserve( transactions.size() );
-   for( const processed_transaction& tx : transactions )
-      transaction_ids.push_back( tx.id() );
+   return my->estimate_withdrawal_transaction_fee(sidechain);
+}
+
+std::string wallet_api::eth_estimate_withdrawal_transaction_fee() const
+{
+   return my->eth_estimate_withdrawal_transaction_fee();
 }
 
 vesting_balance_object_with_info::vesting_balance_object_with_info()

programs/CMakeLists.txt

@@ -3,7 +3,6 @@ if( BUILD_PEERPLAYS_PROGRAMS )
   add_subdirectory( cli_wallet )
   add_subdirectory( genesis_util )
   add_subdirectory( witness_node )
-  add_subdirectory( debug_node )
   add_subdirectory( js_operation_serializer )
   add_subdirectory( size_checker )
 endif( BUILD_PEERPLAYS_PROGRAMS )

programs/debug_node/CMakeLists.txt

@@ -1,21 +0,0 @@
-add_executable( debug_node main.cpp )
-if( UNIX AND NOT APPLE )
-  set(rt_library rt )
-endif()
-
-find_package( Gperftools QUIET )
-if( GPERFTOOLS_FOUND )
-    message( STATUS "Found gperftools; compiling debug_node with TCMalloc")
-    list( APPEND PLATFORM_SPECIFIC_LIBS tcmalloc )
-endif()
-
-target_link_libraries( debug_node
-                       PRIVATE graphene_app graphene_egenesis_full ${PLATFORM_SPECIFIC_LIBS} )
-
-install( TARGETS
-   debug_node
-
-   RUNTIME DESTINATION bin
-   LIBRARY DESTINATION lib
-   ARCHIVE DESTINATION lib
-)

programs/debug_node/README.md

@@ -1,104 +0,0 @@
-
-Introduction
-------------
-
-The `debug_node` is a tool to allow developers to run many interesting sorts of "what-if" tests using state from a production blockchain.
-Like "what happens if I produce enough blocks for the next hardfork time to arrive?" or "what would happen if this account (which I don't have a private key for) did this transaction?"
-
-Setup
------
-
-Be sure you've built the right build targets:
-
-    $ make get_dev_key debug_node cli_wallet witness_node
-
-Use the `get_dev_key` utility to generate a keypair:
-
-    $ programs/genesis_util/get_dev_key "" nathan
-    [{"private_key":"5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3","public_key":"BTS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV","address":"BTSFAbAx7yuxt725qSZvfwWqkdCwp9ZnUama"}]
-
-Obtain a copy of the blockchain in `block_db` directory:
-    $ programs/witness_node/witness_node --data-dir data/mydatadir
-    # ... wait for chain to sync
-    ^C
-    $ cp -Rp data/mydatadir/blockchain/database/block_num_to_block ./block_db
-
-Set up a new datadir with the following `config.ini` settings:
-
-    # setup API endpoint
-    rpc-endpoint = 127.0.0.1:8090
-    # setting this to empty effectively disables the p2p network
-    seed-nodes = []
-    # set apiaccess.json so we can set up
-    api-access = "data/debug_datadir/api-access.json"
-
-Then set up `data/debug_datadir/api-access.json` to allow access to the debug API like this:
-
-    {
-       "permission_map" :
-       [
-          [
-             "bytemaster",
-             {
-                "password_hash_b64" : "9e9GF7ooXVb9k4BoSfNIPTelXeGOZ5DrgOYMj94elaY=",
-                "password_salt_b64" : "INDdM6iCi/8=",
-                "allowed_apis" : ["database_api", "network_broadcast_api", "history_api", "network_node_api", "debug_api"]
-             }
-          ],
-          [
-             "*",
-             {
-                "password_hash_b64" : "*",
-                "password_salt_b64" : "*",
-                "allowed_apis" : ["database_api", "network_broadcast_api", "history_api"]
-             }
-          ]
-       ]
-    }
-
-See [here](https://github.com/cryptonomex/graphene#accessing-restricted-apis) for more detail on the `api-access.json` format.
-
-Once that is set up, run `debug_node` against your newly prepared datadir:
-
-    programs/debug_node/debug_node --data-dir data/debug_datadir
-
-Run `cli_wallet` to connect to the `debug_node` port, using the username and password to access the new `debug_api` (and also a different wallet file):
-
-    programs/cli_wallet/cli_wallet -s 127.0.0.1:8090 -w debug.wallet -u bytemaster -p supersecret
-
-Example usage
--------------
-
-Load some blocks from the datadir:
-
-    dbg_push_blocks block_db 20000
-
-Note, when pushing a very large number of blocks sometimes `cli_wallet` hangs and you must Ctrl+C and restart it (leaving the `debug_node` running).
-
-Generate (fake) blocks with our own private key:
-
-    dbg_generate_blocks 5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3 1000
-
-Update `angel` account to be controlled by our own private key and generate a (fake) transfer:
-
-    dbg_update_object {"_action":"update", "id":"1.2.1090", "active":{"weight_threshold":1,"key_auths":[["BTS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",1]]}}
-    import_key angel 5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3
-    transfer angel init0 999999 BTS "" true
-
-How it works
-------------
-
-The commands work by creating diff(s) from the main chain that are applied to the local chain at specified block height(s).  It lets you easily check out "what-if"
-scenarios in a fantasy debug toy world forked from the real chain, e.g. "if we take all of the blocks until today, then generate a bunch more until a hardfork time
-in the future arrives, does the chain stay up?  Can I do transactions X, Y, and Z in the wallet after the hardfork?"  Anyone connecting to this node sees the same
-fantasy world, so you can e.g. make changes with the `cli_wallet` and see them exist in other `cli_wallet` instances (or GUI wallets or API scripts).
-
-Limitations
------------
-
-The main limitations are:
-
-- No export format for the diffs, so you can't really [1] connect multiple `debug_node` to each other.
-- Once faked block(s) or tx(s) have been produced on your chain, you can't really [1] stream blocks or tx's from the main network to your chain.
-
-[1] It should theoretically be possible, but it's non-trivial and totally untested.

programs/debug_node/main.cpp

@@ -1,307 +0,0 @@
-/*
- * Copyright (c) 2015 Cryptonomex, Inc., and contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-#include <graphene/app/application.hpp>
-
-#include <graphene/debug_witness/debug_witness.hpp>
-#include <graphene/account_history/account_history_plugin.hpp>
-#include <graphene/market_history/market_history_plugin.hpp>
-
-#include <fc/exception/exception.hpp>
-#include <fc/thread/thread.hpp>
-#include <fc/interprocess/signals.hpp>
-#include <fc/log/console_appender.hpp>
-#include <fc/log/file_appender.hpp>
-#include <fc/log/logger.hpp>
-#include <fc/log/logger_config.hpp>
-
-#include <boost/filesystem.hpp>
-
-#include <boost/property_tree/ptree.hpp>
-#include <boost/property_tree/ini_parser.hpp>
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/split.hpp>
-
-#include <iostream>
-#include <fstream>
-
-#ifdef WIN32
-# include <signal.h>
-#else
-# include <csignal>
-#endif
-
-using namespace graphene;
-namespace bpo = boost::program_options;
-
-void write_default_logging_config_to_stream(std::ostream& out);
-fc::optional<fc::logging_config> load_logging_config_from_ini_file(const fc::path& config_ini_filename);
-
-int main(int argc, char** argv) {
-   app::application* node = new app::application();
-   fc::oexception unhandled_exception;
-   try {
-      bpo::options_description app_options("Graphene Witness Node");
-      bpo::options_description cfg_options("Graphene Witness Node");
-      app_options.add_options()
-            ("help,h", "Print this help message and exit.")
-            ("data-dir,d", bpo::value<boost::filesystem::path>()->default_value("witness_node_data_dir"), "Directory containing databases, configuration file, etc.")
-            ;
-
-      bpo::variables_map options;
-
-      auto witness_plug = node->register_plugin<debug_witness_plugin::debug_witness_plugin>();
-      auto history_plug = node->register_plugin<account_history::account_history_plugin>();
-      auto market_history_plug = node->register_plugin<market_history::market_history_plugin>();
-
-      try
-      {
-         bpo::options_description cli, cfg;
-         node->set_program_options(cli, cfg);
-         app_options.add(cli);
-         cfg_options.add(cfg);
-         bpo::store(bpo::parse_command_line(argc, argv, app_options), options);
-      }
-      catch (const boost::program_options::error& e)
-      {
-        std::cerr << "Error parsing command line: " << e.what() << "\n";
-        return 1;
-      }
-
-      if( options.count("help") )
-      {
-         std::cout << app_options << "\n";
-         return 0;
-      }
-
-      fc::path data_dir;
-      if( options.count("data-dir") )
-      {
-         data_dir = options["data-dir"].as<boost::filesystem::path>();
-         if( data_dir.is_relative() )
-            data_dir = fc::current_path() / data_dir;
-      }
-
-      fc::path config_ini_path = data_dir / "config.ini";
-      if( fc::exists(config_ini_path) )
-      {
-         // get the basic options
-         bpo::store(bpo::parse_config_file<char>(config_ini_path.preferred_string().c_str(), cfg_options, true), options);
-
-         // try to get logging options from the config file.
-         try
-         {
-            fc::optional<fc::logging_config> logging_config = load_logging_config_from_ini_file(config_ini_path);
-            if (logging_config)
-               fc::configure_logging(*logging_config);
-         }
-         catch (const fc::exception&)
-         {
-            wlog("Error parsing logging config from config file ${config}, using default config", ("config", config_ini_path.preferred_string()));
-         }
-      }
-      else 
-      {
-         ilog("Writing new config file at ${path}", ("path", config_ini_path));
-         if( !fc::exists(data_dir) )
-            fc::create_directories(data_dir);
-
-         std::ofstream out_cfg(config_ini_path.preferred_string());
-         for( const boost::shared_ptr<bpo::option_description> od : cfg_options.options() )
-         {
-            if( !od->description().empty() )
-               out_cfg << "# " << od->description() << "\n";
-            boost::any store;
-            if( !od->semantic()->apply_default(store) )
-               out_cfg << "# " << od->long_name() << " = \n";
-            else {
-               auto example = od->format_parameter();
-               if( example.empty() )
-                  // This is a boolean switch
-                  out_cfg << od->long_name() << " = " << "false\n";
-               else {
-                  // The string is formatted "arg (=<interesting part>)"
-                  example.erase(0, 6);
-                  example.erase(example.length()-1);
-                  out_cfg << od->long_name() << " = " << example << "\n";
-               }
-            }
-            out_cfg << "\n";
-         }
-         write_default_logging_config_to_stream(out_cfg);
-         out_cfg.close(); 
-         // read the default logging config we just wrote out to the file and start using it
-         fc::optional<fc::logging_config> logging_config = load_logging_config_from_ini_file(config_ini_path);
-         if (logging_config)
-            fc::configure_logging(*logging_config);
-      }
-
-      bpo::notify(options);
-      node->initialize(data_dir, options);
-      node->initialize_plugins( options );
-
-      node->startup();
-      node->startup_plugins();
-
-      fc::promise<int>::ptr exit_promise = new fc::promise<int>("UNIX Signal Handler");
-
-      fc::set_signal_handler([&exit_promise](int signal) {
-         elog( "Caught SIGINT attempting to exit cleanly" );
-         exit_promise->set_value(signal);
-      }, SIGINT);
-
-      fc::set_signal_handler([&exit_promise](int signal) {
-         elog( "Caught SIGTERM attempting to exit cleanly" );
-         exit_promise->set_value(signal);
-      }, SIGTERM);
-
-      ilog("Started witness node on a chain with ${h} blocks.", ("h", node->chain_database()->head_block_num()));
-      ilog("Chain ID is ${id}", ("id", node->chain_database()->get_chain_id()) );
-
-      int signal = exit_promise->wait();
-      ilog("Exiting from signal ${n}", ("n", signal));
-      node->shutdown_plugins();
-      node->shutdown();
-      delete node;
-      return 0;
-   } catch( const fc::exception& e ) {
-      // deleting the node can yield, so do this outside the exception handler
-      unhandled_exception = e;
-   }
-
-   if (unhandled_exception)
-   {
-      elog("Exiting with error:\n${e}", ("e", unhandled_exception->to_detail_string()));
-      node->shutdown();
-      delete node;
-      return 1;
-   }
-}
-
-// logging config is too complicated to be parsed by boost::program_options, 
-// so we do it by hand
-//
-// Currently, you can only specify the filenames and logging levels, which
-// are all most users would want to change.  At a later time, options can
-// be added to control rotation intervals, compression, and other seldom-
-// used features
-void write_default_logging_config_to_stream(std::ostream& out)
-{
-   out << "# declare an appender named \"stderr\" that writes messages to the console\n"
-          "[log.console_appender.stderr]\n"
-          "stream=std_error\n\n"
-          "# declare an appender named \"p2p\" that writes messages to p2p.log\n"
-          "[log.file_appender.p2p]\n"
-          "filename=logs/p2p/p2p.log\n"
-          "# filename can be absolute or relative to this config file\n\n"
-          "# route any messages logged to the default logger to the \"stderr\" logger we\n"
-          "# declared above, if they are info level are higher\n"
-          "[logger.default]\n"
-          "level=info\n"
-          "appenders=stderr\n\n"
-          "# route messages sent to the \"p2p\" logger to the p2p appender declared above\n"
-          "[logger.p2p]\n"
-          "level=info\n"
-          "appenders=p2p\n\n";
-}
-
-fc::optional<fc::logging_config> load_logging_config_from_ini_file(const fc::path& config_ini_filename)
-{
-   try
-   {
-      fc::logging_config logging_config;
-      bool found_logging_config = false;
-
-      boost::property_tree::ptree config_ini_tree;
-      boost::property_tree::ini_parser::read_ini(config_ini_filename.preferred_string().c_str(), config_ini_tree);
-      for (const auto& section : config_ini_tree)
-      {
-         const std::string& section_name = section.first;
-         const boost::property_tree::ptree& section_tree = section.second;
-
-         const std::string console_appender_section_prefix = "log.console_appender.";
-         const std::string file_appender_section_prefix = "log.file_appender.";
-         const std::string logger_section_prefix = "logger.";
-
-         if (boost::starts_with(section_name, console_appender_section_prefix))
-         {
-            std::string console_appender_name = section_name.substr(console_appender_section_prefix.length());
-            std::string stream_name = section_tree.get<std::string>("stream");
-
-            // construct a default console appender config here
-            // stdout/stderr will be taken from ini file, everything else hard-coded here
-            fc::console_appender::config console_appender_config;
-            console_appender_config.level_colors.emplace_back(
-               fc::console_appender::level_color(fc::log_level::debug, 
-                                                 fc::console_appender::color::green));
-            console_appender_config.level_colors.emplace_back(
-               fc::console_appender::level_color(fc::log_level::warn, 
-                                                 fc::console_appender::color::brown));
-            console_appender_config.level_colors.emplace_back(
-               fc::console_appender::level_color(fc::log_level::error, 
-                                                 fc::console_appender::color::cyan));
-            console_appender_config.stream = fc::variant(stream_name, 1).as<fc::console_appender::stream::type>(1);
-            logging_config.appenders.push_back(fc::appender_config(console_appender_name, "console", fc::variant(console_appender_config, 20)));
-            found_logging_config = true;
-         }
-         else if (boost::starts_with(section_name, file_appender_section_prefix))
-         {
-            std::string file_appender_name = section_name.substr(file_appender_section_prefix.length());
-            fc::path file_name = section_tree.get<std::string>("filename");
-            if (file_name.is_relative())
-               file_name = fc::absolute(config_ini_filename).parent_path() / file_name;
-            
-
-            // construct a default file appender config here
-            // filename will be taken from ini file, everything else hard-coded here
-            fc::file_appender::config file_appender_config;
-            file_appender_config.filename = file_name;
-            file_appender_config.flush = true;
-            file_appender_config.rotate = true;
-            file_appender_config.rotation_interval = fc::hours(1);
-            file_appender_config.rotation_limit = fc::days(1);
-            logging_config.appenders.push_back(fc::appender_config(file_appender_name, "file", fc::variant(file_appender_config, 20)));
-            found_logging_config = true;
-         }
-         else if (boost::starts_with(section_name, logger_section_prefix))
-         {
-            std::string logger_name = section_name.substr(logger_section_prefix.length());
-            std::string level_string = section_tree.get<std::string>("level");
-            std::string appenders_string = section_tree.get<std::string>("appenders");
-            fc::logger_config logger_config(logger_name);
-            logger_config.level = fc::variant(level_string, 1).as<fc::log_level>(1);
-            boost::split(logger_config.appenders, appenders_string, 
-                         boost::is_any_of(" ,"), 
-                         boost::token_compress_on);
-            logging_config.loggers.push_back(logger_config);
-            found_logging_config = true;
-         }
-      }
-      if (found_logging_config)
-         return logging_config;
-      else
-         return fc::optional<fc::logging_config>();
-   }
-   FC_RETHROW_EXCEPTIONS(warn, "")
-}