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
@@ -44,12 +46,11 @@ test-mainnet:
 
 dockerize-mainnet:
   stage: dockerize
-  dependencies:
-    - test-mainnet
   variables:
     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 .
@@ -58,8 +59,6 @@ dockerize-mainnet:
     - docker rmi $IMAGE
   tags:
     - builder
-  when:
-    manual
   timeout:
     3h
 
@@ -80,12 +79,27 @@ build-testnet:
       - build/libraries/
       - build/programs/
       - build/tests/
+  when: manual
   tags:
     - builder
-  when:
+
-    manual
+deploy-testnet:
-  timeout:
+  stage: deploy
-    3h
+  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
@@ -105,8 +119,6 @@ test-testnet:
 
 dockerize-testnet:
   stage: dockerize
-  dependencies:
-    - test-testnet
   variables:
     IMAGE: $CI_REGISTRY_IMAGE/testnet/$CI_COMMIT_REF_SLUG:$CI_COMMIT_SHA
   before_script:
@@ -123,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

.gitmodules

@@ -5,5 +5,5 @@
 [submodule "libraries/fc"]
 	path = libraries/fc
 	url = https://gitlab.com/PBSA/tools-libs/peerplays-fc.git
-	branch = latest-fc
+	branch = develop
 	ignore = dirty

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 \
-      libboost1.67-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 && \
+    wget https://github.com/zeromq/cppzmq/archive/refs/tags/v4.9.0.tar.gz && \
-    unzip v4.3.4.zip && \
+    tar -xzvf v4.9.0.tar.gz && \
-    cd libzmq-4.3.4 && \
+    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 && \
+    wget https://github.com/Perl/perl5/archive/refs/tags/v5.30.0.tar.gz && \
-    unzip v4.8.1.zip && \
+    tar -xvf v5.30.0.tar.gz && \
-    cd cppzmq-4.8.1 && \
+    cd perl5-5.30.0 && \
-    mkdir build && \
+    ./Configure -des && \
-    cd build && \
-    cmake .. && \
     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/src/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/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 'http://sourceforge.net/projects/boost/files/boost/1.67.0/boost_1_67_0.tar.bz2/download' -O boost_1_67_0.tar.bz2 && \
+    wget https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.gz && \
-    tar xjf boost_1_67_0.tar.bz2 && \
+    tar -xzf boost_1_72_0.tar.gz && \
-    cd boost_1_67_0/ && \
+    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 && \
+    wget https://github.com/Kitware/CMake/releases/download/v3.24.2/cmake-3.24.2-linux-x86_64.sh && \
-    chmod 755 ./cmake-3.23.1-linux-x86_64.sh && \
+    chmod 755 ./cmake-3.24.2-linux-x86_64.sh && \
-    ./cmake-3.23.1-linux-x86_64.sh --prefix=/usr/ --skip-license && \
+    ./cmake-3.24.2-linux-x86_64.sh --prefix=/usr --skip-license && \
-    cmake --version
+    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 && \
+    wget https://github.com/zeromq/cppzmq/archive/refs/tags/v4.9.0.tar.gz && \
-    unzip v4.3.4.zip && \
+    tar -xzvf v4.9.0.tar.gz && \
-    cd libzmq-4.3.4 && \
+    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 && \
+    wget https://github.com/Perl/perl5/archive/refs/tags/v5.30.0.tar.gz && \
-    unzip v4.8.1.zip && \
+    tar -xvf v5.30.0.tar.gz && \
-    cd cppzmq-4.8.1 && \
+    cd perl5-5.30.0 && \
-    mkdir build && \
+    ./Configure -des && \
-    cd build && \
-    cmake .. && \
     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/src/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/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 \
+    autoconf bash bison build-essential ca-certificates dnsutils expect flex git \
-    dnsutils doxygen expect git graphviz libboost-all-dev libbz2-dev \
+    graphviz libbz2-dev libcurl4-openssl-dev libncurses-dev libpcre3-dev \
-    libcurl4-openssl-dev libncurses-dev libsnappy-dev \
+    libsnappy-dev libsodium-dev libssl-dev libtool libzip-dev locales lsb-release \
-    libssl-dev libtool libzip-dev locales lsb-release mc nano net-tools ntp \
+    mc nano net-tools ntp openssh-server pkg-config python3 python3-jinja2 sudo \
-    openssh-server pkg-config perl 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
+wget https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.gz
-unzip v4.3.4.zip
+tar -xzf boost_1_72_0.tar.gz boost_1_72_0
-cd libzmq-4.3.4
+cd boost_1_72_0
-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 'http://sourceforge.net/projects/boost/files/boost/1.67.0/boost_1_67_0.tar.bz2/download' -O boost_1_67_0.tar.bz2
-tar xjf boost_1_67_0.tar.bz2
-cd boost_1_67_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
+wget https://github.com/Kitware/CMake/releases/download/v3.24.2/cmake-3.24.2-linux-x86_64.sh
-chmod 755 ./cmake-3.23.1-linux-x86_64.sh
+chmod 755 ./cmake-3.24.2-linux-x86_64.sh
-sudo ./cmake-3.23.1-linux-x86_64.sh --prefix=/usr/ --skip-license
+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
+wget https://github.com/zeromq/libzmq/archive/refs/tags/v4.3.4.tar.gz
-unzip v4.3.4.zip
+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
+wget https://github.com/zeromq/cppzmq/archive/refs/tags/v4.9.0.tar.gz
-unzip v4.8.1.zip
+tar -xzvf v4.9.0.tar.gz
-cd cppzmq-4.8.1
+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/CMakeLists.txt

@@ -5,6 +5,7 @@ add_subdirectory( egenesis )
 add_subdirectory( fc )
 add_subdirectory( net )
 add_subdirectory( plugins )
+add_subdirectory( sha3 )
 add_subdirectory( time )
 add_subdirectory( utilities )
 add_subdirectory( wallet )

libraries/app/api.cpp

@@ -45,7 +45,6 @@ template class fc::api<graphene::app::block_api>;
 template class fc::api<graphene::app::network_broadcast_api>;
 template class fc::api<graphene::app::network_node_api>;
 template class fc::api<graphene::app::history_api>;
-template class fc::api<graphene::app::crypto_api>;
 template class fc::api<graphene::app::asset_api>;
 template class fc::api<graphene::debug_witness::debug_api>;
 template class fc::api<graphene::app::login_api>;
@@ -90,8 +89,6 @@ void login_api::enable_api(const std::string &api_name) {
       _history_api = std::make_shared<history_api>(_app);
    } else if (api_name == "network_node_api") {
       _network_node_api = std::make_shared<network_node_api>(std::ref(_app));
-   } else if (api_name == "crypto_api") {
-      _crypto_api = std::make_shared<crypto_api>();
    } else if (api_name == "asset_api") {
       _asset_api = std::make_shared<asset_api>(_app);
    } else if (api_name == "debug_api") {
@@ -289,11 +286,6 @@ fc::api<history_api> login_api::history() const {
    return *_history_api;
 }
 
-fc::api<crypto_api> login_api::crypto() const {
-   FC_ASSERT(_crypto_api);
-   return *_crypto_api;
-}
-
 fc::api<asset_api> login_api::asset() const {
    FC_ASSERT(_asset_api);
    return *_asset_api;
@@ -522,55 +514,6 @@ vector<bucket_object> history_api::get_market_history(std::string asset_a, std::
    FC_CAPTURE_AND_RETHROW((asset_a)(asset_b)(bucket_seconds)(start)(end))
 }
 
-crypto_api::crypto_api(){};
-
-commitment_type crypto_api::blind(const blind_factor_type &blind, uint64_t value) {
-   return fc::ecc::blind(blind, value);
-}
-
-blind_factor_type crypto_api::blind_sum(const std::vector<blind_factor_type> &blinds_in, uint32_t non_neg) {
-   return fc::ecc::blind_sum(blinds_in, non_neg);
-}
-
-bool crypto_api::verify_sum(const std::vector<commitment_type> &commits_in, const std::vector<commitment_type> &neg_commits_in, int64_t excess) {
-   return fc::ecc::verify_sum(commits_in, neg_commits_in, excess);
-}
-
-verify_range_result crypto_api::verify_range(const commitment_type &commit, const std::vector<char> &proof) {
-   verify_range_result result;
-   result.success = fc::ecc::verify_range(result.min_val, result.max_val, commit, proof);
-   return result;
-}
-
-std::vector<char> crypto_api::range_proof_sign(uint64_t min_value,
-                                               const commitment_type &commit,
-                                               const blind_factor_type &commit_blind,
-                                               const blind_factor_type &nonce,
-                                               int8_t base10_exp,
-                                               uint8_t min_bits,
-                                               uint64_t actual_value) {
-   return fc::ecc::range_proof_sign(min_value, commit, commit_blind, nonce, base10_exp, min_bits, actual_value);
-}
-
-verify_range_proof_rewind_result crypto_api::verify_range_proof_rewind(const blind_factor_type &nonce,
-                                                                       const commitment_type &commit,
-                                                                       const std::vector<char> &proof) {
-   verify_range_proof_rewind_result result;
-   result.success = fc::ecc::verify_range_proof_rewind(result.blind_out,
-                                                       result.value_out,
-                                                       result.message_out,
-                                                       nonce,
-                                                       result.min_val,
-                                                       result.max_val,
-                                                       const_cast<commitment_type &>(commit),
-                                                       proof);
-   return result;
-}
-
-range_proof_info crypto_api::range_get_info(const std::vector<char> &proof) {
-   return fc::ecc::range_get_info(proof);
-}
-
 // asset_api
 asset_api::asset_api(graphene::app::application &app) :
       _app(app),

libraries/app/application.cpp

@@ -362,7 +362,6 @@ public:
             wild_access.allowed_apis.push_back("database_api");
             wild_access.allowed_apis.push_back("network_broadcast_api");
             wild_access.allowed_apis.push_back("history_api");
-            wild_access.allowed_apis.push_back("crypto_api");
             wild_access.allowed_apis.push_back("bookie_api");
             wild_access.allowed_apis.push_back("affiliate_stats_api");
             wild_access.allowed_apis.push_back("sidechain_api");
@@ -765,6 +764,10 @@ public:
       FC_CAPTURE_AND_RETHROW((block_id))
    }
 
+   virtual fc::time_point_sec get_last_known_hardfork_time() override {
+      return _chain_db->_hardfork_times[_chain_db->_hardfork_times.size() - 1];
+   }
+
    /**
     * 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()
@@ -914,6 +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("debug_witness") && !wanted.count("witness")) // explicitly requested delayed_node or debug_witness functionality suppresses witness functions
       wanted.insert("witness");
    wanted.insert("bookie");
 
@@ -946,7 +950,7 @@ void application::startup() {
 }
 
 std::shared_ptr<abstract_plugin> application::get_plugin(const string &name) const {
-   return my->_active_plugins[name];
+   return is_plugin_enabled(name) ? my->_active_plugins[name] : nullptr;
 }
 
 bool application::is_plugin_enabled(const string &name) const {

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();
@@ -237,9 +253,6 @@ public:
    // Proposed transactions
    vector<proposal_object> get_proposed_transactions(const std::string account_id_or_name) const;
 
-   // Blinded balances
-   vector<blinded_balance_object> get_blinded_balances(const flat_set<commitment_type> &commitments) const;
-
    // Tournaments
    vector<tournament_object> get_tournaments_in_state(tournament_state state, uint32_t limit) const;
    vector<tournament_object> get_tournaments(tournament_id_type stop, unsigned limit, tournament_id_type start);
@@ -268,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_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;
+   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;
@@ -290,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;
@@ -529,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);
 }
@@ -1851,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                                                      //
@@ -2086,7 +2186,9 @@ vector<variant> database_api_impl::lookup_vote_ids(const vector<vote_id_type> &v
    const auto &committee_idx = _db.get_index_type<committee_member_index>().indices().get<by_vote_id>();
    const auto &for_worker_idx = _db.get_index_type<worker_index>().indices().get<by_vote_for>();
    const auto &against_worker_idx = _db.get_index_type<worker_index>().indices().get<by_vote_against>();
-   const auto &son_idx = _db.get_index_type<son_index>().indices().get<by_vote_id>();
+   const auto &son_bictoin_idx = _db.get_index_type<son_index>().indices().get<by_vote_id_bitcoin>();
+   const auto &son_hive_idx = _db.get_index_type<son_index>().indices().get<by_vote_id_hive>();
+   const auto &son_ethereum_idx = _db.get_index_type<son_index>().indices().get<by_vote_id_ethereum>();
 
    vector<variant> result;
    result.reserve(votes.size());
@@ -2095,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;
@@ -2103,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;
@@ -2111,26 +2213,45 @@ 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());
             }
          }
          break;
       }
-      case vote_id_type::son: {
+      case vote_id_type::son_bitcoin: {
-         auto itr = son_idx.find(id);
+         auto itr = son_bictoin_idx.find(id);
-         if (itr != son_idx.end())
+         if (itr != son_bictoin_idx.end())
+            result.emplace_back(variant(*itr, 5));
+         else
+            result.emplace_back(variant());
+         break;
+      }
+      case vote_id_type::son_hive: {
+         auto itr = son_hive_idx.find(id);
+         if (itr != son_hive_idx.end())
+            result.emplace_back(variant(*itr, 5));
+         else
+            result.emplace_back(variant());
+         break;
+      }
+      case vote_id_type::son_ethereum: {
+         auto itr = son_ethereum_idx.find(id);
+         if (itr != son_ethereum_idx.end())
             result.emplace_back(variant(*itr, 5));
          else
             result.emplace_back(variant());
          break;
       }
-
       case vote_id_type::VOTE_TYPE_COUNT:
          break; // supress unused enum value warnings
       default:
@@ -2155,12 +2276,24 @@ vector<vote_id_type> database_api_impl::get_votes_ids(const string &account_name
 votes_info database_api_impl::get_votes(const string &account_name_or_id) const {
    votes_info result;
 
-   const auto &votes_ids = get_votes_ids(account_name_or_id);
+   const auto votes_ids = get_votes_ids(account_name_or_id);
-   const auto &committee_ids = get_votes_objects<committee_member_index, by_vote_id>(votes_ids);
+   const auto committee_ids = get_votes_objects<committee_member_index, by_vote_id>(votes_ids);
-   const auto &witness_ids = get_votes_objects<witness_index, by_vote_id>(votes_ids);
+   const auto witness_ids = get_votes_objects<witness_index, by_vote_id>(votes_ids);
-   const auto &for_worker_ids = get_votes_objects<worker_index, by_vote_for>(votes_ids);
+   const auto for_worker_ids = get_votes_objects<worker_index, by_vote_for>(votes_ids);
-   const auto &against_worker_ids = get_votes_objects<worker_index, by_vote_against>(votes_ids);
+   const auto against_worker_ids = get_votes_objects<worker_index, by_vote_against>(votes_ids);
-   const auto &son_ids = get_votes_objects<son_index, by_vote_id>(votes_ids, 5);
+   const auto son_ids = [this, &votes_ids]() {
+      flat_map<sidechain_type, vector<variant>> son_ids;
+      const auto son_bitcoin_ids = get_votes_objects<son_index, by_vote_id_bitcoin>(votes_ids, 5);
+      if (!son_bitcoin_ids.empty())
+         son_ids[sidechain_type::bitcoin] = std::move(son_bitcoin_ids);
+      const auto son_hive_ids = get_votes_objects<son_index, by_vote_id_hive>(votes_ids, 5);
+      if (!son_hive_ids.empty())
+         son_ids[sidechain_type::hive] = std::move(son_hive_ids);
+      const auto son_ethereum_ids = get_votes_objects<son_index, by_vote_id_ethereum>(votes_ids, 5);
+      if (!son_ethereum_ids.empty())
+         son_ids[sidechain_type::ethereum] = std::move(son_ethereum_ids);
+      return son_ids;
+   }();
 
    //! Fill votes info
    if (!committee_ids.empty()) {
@@ -2204,11 +2337,17 @@ votes_info database_api_impl::get_votes(const string &account_name_or_id) const
    }
 
    if (!son_ids.empty()) {
-      vector<votes_info_object> votes_for_sons;
+      flat_map<sidechain_type, vector<votes_info_object>> votes_for_sons;
-      votes_for_sons.reserve(son_ids.size());
+      for (const auto &son_sidechain_ids : son_ids) {
-      for (const auto &son : son_ids) {
+         const auto &sidechain = son_sidechain_ids.first;
+         const auto &sidechain_ids = son_sidechain_ids.second;
+         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.emplace_back(votes_info_object{son_obj.vote_id, 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);
    }
@@ -2382,12 +2521,16 @@ voters_info database_api_impl::get_voters(const string &account_name_or_id) cons
 
    //! Info for son voters
    if (son_object) {
-      const auto &son_voters = get_voters_by_id(son_object->vote_id);
+      flat_map<sidechain_type, voters_info_object> voters_for_son;
-      voters_info_object voters_for_son;
+      for (const auto &vote_id : son_object->sidechain_vote_ids) {
-      voters_for_son.vote_id = son_object->vote_id;
+         const auto &son_voters = get_voters_by_id(vote_id.second);
-      voters_for_son.voters.reserve(son_voters.size());
+         voters_info_object voters_for_sidechain_son;
+         voters_for_sidechain_son.vote_id = vote_id.second;
+         voters_for_sidechain_son.voters.reserve(son_voters.size());
          for (const auto &voter : son_voters) {
-         voters_for_son.voters.emplace_back(voter.get_id());
+            voters_for_sidechain_son.voters.emplace_back(voter.get_id());
+         }
+         voters_for_son[vote_id.first] = std::move(voters_for_sidechain_son);
       }
       result.voters_for_son = std::move(voters_for_son);
    }
@@ -2650,29 +2793,6 @@ vector<proposal_object> database_api_impl::get_proposed_transactions(const std::
    return result;
 }
 
-//////////////////////////////////////////////////////////////////////
-//                                                                  //
-// Blinded balances                                                 //
-//                                                                  //
-//////////////////////////////////////////////////////////////////////
-
-vector<blinded_balance_object> database_api::get_blinded_balances(const flat_set<commitment_type> &commitments) const {
-   return my->get_blinded_balances(commitments);
-}
-
-vector<blinded_balance_object> database_api_impl::get_blinded_balances(const flat_set<commitment_type> &commitments) const {
-   vector<blinded_balance_object> result;
-   result.reserve(commitments.size());
-   const auto &bal_idx = _db.get_index_type<blinded_balance_index>();
-   const auto &by_commitment_idx = bal_idx.indices().get<by_commitment>();
-   for (const auto &c : commitments) {
-      auto itr = by_commitment_idx.find(c);
-      if (itr != by_commitment_idx.end())
-         result.push_back(*itr);
-   }
-   return result;
-}
-
 //////////////////////////////////////////////////////////////////////
 //                                                                  //
 // Tournament methods                                               //
@@ -2975,8 +3095,8 @@ uint64_t database_api::nft_get_total_supply(const nft_metadata_id_type nft_metad
 }
 
 uint64_t database_api_impl::nft_get_total_supply(const nft_metadata_id_type nft_metadata_id) const {
-   const auto &idx_nft_md = _db.get_index_type<nft_metadata_index>().indices().get<by_id>();
+   const auto &idx_nft = _db.get_index_type<nft_index>().indices().get<by_metadata>();
-   return idx_nft_md.size();
+   return idx_nft.count(nft_metadata_id);
 }
 
 nft_object database_api::nft_token_by_index(const nft_metadata_id_type nft_metadata_id, const uint64_t token_idx) const {
@@ -3013,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 {
+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();
+   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.reserve(limit);
-      result.push_back(*itr);
+   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 {
+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);
+   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.reserve(limit);
-      result.push_back(*itr);
+   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;
 }
 

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

@@ -289,33 +289,6 @@ private:
    std::function<void(const variant &)> _on_pending_transaction;
 };
 
-class crypto_api {
-public:
-   crypto_api();
-
-   fc::ecc::commitment_type blind(const fc::ecc::blind_factor_type &blind, uint64_t value);
-
-   fc::ecc::blind_factor_type blind_sum(const std::vector<blind_factor_type> &blinds_in, uint32_t non_neg);
-
-   bool verify_sum(const std::vector<commitment_type> &commits_in, const std::vector<commitment_type> &neg_commits_in, int64_t excess);
-
-   verify_range_result verify_range(const fc::ecc::commitment_type &commit, const std::vector<char> &proof);
-
-   std::vector<char> range_proof_sign(uint64_t min_value,
-                                      const commitment_type &commit,
-                                      const blind_factor_type &commit_blind,
-                                      const blind_factor_type &nonce,
-                                      int8_t base10_exp,
-                                      uint8_t min_bits,
-                                      uint64_t actual_value);
-
-   verify_range_proof_rewind_result verify_range_proof_rewind(const blind_factor_type &nonce,
-                                                              const fc::ecc::commitment_type &commit,
-                                                              const std::vector<char> &proof);
-
-   range_proof_info range_get_info(const std::vector<char> &proof);
-};
-
 /**
  * @brief
  */
@@ -359,7 +332,6 @@ extern template class fc::api<graphene::app::block_api>;
 extern template class fc::api<graphene::app::network_broadcast_api>;
 extern template class fc::api<graphene::app::network_node_api>;
 extern template class fc::api<graphene::app::history_api>;
-extern template class fc::api<graphene::app::crypto_api>;
 extern template class fc::api<graphene::app::asset_api>;
 extern template class fc::api<graphene::debug_witness::debug_api>;
 
@@ -394,8 +366,6 @@ public:
    fc::api<history_api> history() const;
    /// @brief Retrieve the network node API
    fc::api<network_node_api> network_node() const;
-   /// @brief Retrieve the cryptography API
-   fc::api<crypto_api> crypto() const;
    /// @brief Retrieve the asset API
    fc::api<asset_api> asset() const;
    /// @brief Retrieve the debug API (if available)
@@ -417,7 +387,6 @@ private:
    optional<fc::api<network_broadcast_api>> _network_broadcast_api;
    optional<fc::api<network_node_api>> _network_node_api;
    optional<fc::api<history_api>> _history_api;
-   optional<fc::api<crypto_api>> _crypto_api;
    optional<fc::api<asset_api>> _asset_api;
    optional<fc::api<graphene::debug_witness::debug_api>> _debug_api;
    optional<fc::api<graphene::bookie::bookie_api>> _bookie_api;
@@ -475,15 +444,6 @@ FC_API(graphene::app::network_node_api,
       (subscribe_to_pending_transactions)
       (unsubscribe_from_pending_transactions))
 
-FC_API(graphene::app::crypto_api,
-      (blind)
-      (blind_sum)
-      (verify_sum)
-      (verify_range)
-      (range_proof_sign)
-      (verify_range_proof_rewind)
-      (range_get_info))
-
 FC_API(graphene::app::asset_api,
       (get_asset_holders)
       (get_asset_holders_count)
@@ -496,7 +456,6 @@ FC_API(graphene::app::login_api,
       (database)
       (history)
       (network_node)
-      (crypto)
       (asset)
       (debug)
       (bookie)

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;
@@ -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
@@ -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      //
    /////////////////////////
@@ -877,15 +919,6 @@ public:
     */
    vector<proposal_object> get_proposed_transactions(const std::string account_id_or_name) const;
 
-   //////////////////////
-   // Blinded balances //
-   //////////////////////
-
-   /**
-    *  @return the set of blinded balance objects by commitment ID
-    */
-   vector<blinded_balance_object> get_blinded_balances(const flat_set<commitment_type> &commitments) const;
-
    /////////////////
    // Tournaments //
    /////////////////
@@ -1010,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 //
@@ -1047,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));
@@ -1069,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)
@@ -1158,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)
@@ -1198,9 +1249,6 @@ FC_API(graphene::app::database_api,
    // Proposed transactions
    (get_proposed_transactions)
 
-   // Blinded balances
-   (get_blinded_balances)
-
    // Tournaments
    (get_tournaments_in_state)
    (get_tournaments_by_state)
@@ -1231,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,
@@ -62,10 +109,47 @@ void verify_account_votes( const database& db, const account_options& options )
    const auto& gpo = db.get_global_properties();
    const auto& chain_params = gpo.parameters;
 
+   FC_ASSERT( db.find_object(options.voting_account), "Invalid proxy account specified." );
+
    FC_ASSERT( options.num_witness <= chain_params.maximum_witness_count,
               "Voted for more witnesses than currently allowed (${c})", ("c", chain_params.maximum_witness_count) );
    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" );
+
+   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;
@@ -179,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;
@@ -278,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) ) }
@@ -317,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

@@ -34,8 +34,9 @@ namespace graphene { namespace chain {
 void_result transfer_to_blind_evaluator::do_evaluate( const transfer_to_blind_operation& o )
 { try {
   const auto& d = db();
-
+  if( d.head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME )
-   const auto& atype = o.amount.asset_id(db()); 
+  {
+     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) );
@@ -45,12 +46,15 @@ void_result transfer_to_blind_evaluator::do_evaluate( const transfer_to_blind_op
         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 )
 { try {
+  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
@@ -58,49 +62,53 @@ void_result transfer_to_blind_evaluator::do_apply( const transfer_to_blind_opera
         obj.confidential_supply += o.amount.amount;
         FC_ASSERT(obj.confidential_supply >= 0);
      });
-   for( const auto& out : o.outputs )
+     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()
 {
-   if( db().head_block_time() >= HARDFORK_563_TIME )
+  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 {
   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 )
+     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 )
 { try {
+  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 )
+     for (const auto &in : o.inputs) {
-   {
         auto itr = cidx.find(in.commitment);
         FC_ASSERT(itr != cidx.end());
         db().remove(*itr);
@@ -110,51 +118,54 @@ void_result transfer_from_blind_evaluator::do_apply( const transfer_from_blind_o
         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()
 {
-   if( db().head_block_time() >= HARDFORK_563_TIME )
+  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 {
   const auto& d = db();
-   o.fee.asset_id(db());  // verify fee is a legit asset 
+  if( d.head_block_time() < HARDFORK_SON_FOR_ETHEREUM_TIME ) {
-   const auto& bbi = db().get_index_type<blinded_balance_index>();
+     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 &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 )
+     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 )
 { try {
+  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 )
+     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 )
+     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;
@@ -166,16 +177,19 @@ void_result blind_transfer_evaluator::do_apply( const blind_transfer_operation&
         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()
 {
-   if( db().head_block_time() >= HARDFORK_563_TIME )
+  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,11 +162,14 @@ void database::check_transaction_for_duplicated_operations(const signed_transact
       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);
    for (auto& digest: proposed_operations_digests)
@@ -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() )
+   {
+      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);
+   {
+      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,24 +527,26 @@ 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.
    //
+   {
+      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 )
    {
+      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 )
+         if (new_total_size >= maximum_block_size) {
-      {
             postponed_tx_count++;
             continue;
          }
 
-      try
+         try {
-      {
             auto temp_session = _undo_db.start_undo_session();
             processed_transaction ptx = _apply_transaction(tx);
             temp_session.merge();
@@ -531,20 +556,23 @@ signed_block database::_generate_block(
             // their size)
             total_block_size += fc::raw::pack_size(ptx);
             pending_block.transactions.push_back(ptx);
-      }
+         } catch (const fc::exception &e) {
-      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) );
    }
 
+   {
+      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 {
+   {
+      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,8 +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);
-      if(global_props.active_sons.size() > 0) {
+
-         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);
+         }
       }
    }
 
@@ -739,11 +776,15 @@ void database::_apply_block( const signed_block& next_block )
    // TODO:  figure out if we could collapse this function into
    // update_global_dynamic_data() as perhaps these methods only need
    // to be called for header validation?
+
    update_maintenance_flag( maint_needed );
    if (global_props.parameters.witness_schedule_algorithm == GRAPHENE_WITNESS_SHUFFLED_ALGORITHM) {
       update_witness_schedule();
-      if(global_props.active_sons.size() > 0) {
+
-         update_son_schedule();
+      for(const auto& active_sidechain_type : active_sidechain_types(dynamic_global_props.time)) {
+         if(global_props.active_sons.at(active_sidechain_type).size() > 0) {
+            update_son_schedule(active_sidechain_type);
+         }
       }
    }
 

libraries/chain/db_getter.cpp

@@ -222,18 +222,33 @@ std::set<son_id_type> database::get_sons_to_be_deregistered()
 
    for( auto& son : son_idx )
    {
-      if(son.status == son_status::in_maintenance)
+      bool need_to_be_deregistered = true;
+      for(const auto& status : son.statuses)
+      {
+         const auto& sidechain = status.first;
+         if(status.second != son_status::in_maintenance)
+            need_to_be_deregistered = false;
+
+         if(need_to_be_deregistered)
          {
             auto stats = son.statistics(*this);
+
             // 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 >= fc::seconds(get_global_properties().parameters.son_deregister_time()))
+            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;
+               }
+            }
+         }
+      }
+
+      if(need_to_be_deregistered)
       {
          ret.insert(son.id);
       }
    }
-   }
    return ret;
 }
 
@@ -289,28 +304,50 @@ bool database::is_son_dereg_valid( son_id_type son_id )
       return false;
    }
 
-   return (son->status == son_status::in_maintenance &&
+   bool status_son_dereg_valid = true;
-                (head_block_time() - son->statistics(*this).last_down_timestamp >= fc::seconds(get_global_properties().parameters.son_deregister_time())));
+   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(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;
+            }
+         }
+      }
    }
 
-bool database::is_son_active( son_id_type son_id )
+   return status_son_dereg_valid;
+}
+
+bool database::is_son_active( sidechain_type type, son_id_type son_id )
 {
    const auto& son_idx = get_index_type<son_index>().indices().get< by_id >();
    auto son = son_idx.find( son_id );
-   if(son == son_idx.end())
+   if(son == son_idx.end()) {
-   {
       return false;
    }
 
    const global_property_object& gpo = get_global_properties();
+   if(!gpo.active_sons.contains(type)) {
+      return false;
+   }
+
+   const auto& gpo_as = gpo.active_sons.at(type);
    vector<son_id_type> active_son_ids;
-   active_son_ids.reserve(gpo.active_sons.size());
+   active_son_ids.reserve(gpo_as.size());
-   std::transform(gpo.active_sons.begin(), gpo.active_sons.end(),
+   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;
    });
 
+   if(active_son_ids.empty()) {
+      return false;
+   }
+
    auto it_son = std::find(active_son_ids.begin(), active_son_ids.end(), son_id);
    return (it_son != active_son_ids.end());
 }
@@ -349,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)
+      if (head_block_time() < HARDFORK_SON_TIME)
-         return false;
-   }
-
-   if (post_son_hf_symbols.find(symbol) != post_son_hf_symbols.end())
-   {
-      if (now >= HARDFORK_SON_TIME)
          return false;
    }
    return true;
 }
 
-} }
+}
+
+}

libraries/chain/db_init.cpp

@@ -329,9 +329,53 @@ void database::initialize_evaluators()
    register_evaluator<random_number_store_evaluator>();
 }
 
+
+void database::initialize_hardforks()
+{
+  _hardfork_times.emplace_back(HARDFORK_357_TIME);
+  _hardfork_times.emplace_back(HARDFORK_359_TIME);
+  _hardfork_times.emplace_back(HARDFORK_385_TIME);
+  _hardfork_times.emplace_back(HARDFORK_409_TIME);
+  _hardfork_times.emplace_back(HARDFORK_413_TIME);
+  _hardfork_times.emplace_back(HARDFORK_415_TIME);
+  _hardfork_times.emplace_back(HARDFORK_416_TIME);
+  _hardfork_times.emplace_back(HARDFORK_419_TIME);
+  _hardfork_times.emplace_back(HARDFORK_436_TIME);
+  _hardfork_times.emplace_back(HARDFORK_445_TIME);
+  _hardfork_times.emplace_back(HARDFORK_453_TIME);
+  _hardfork_times.emplace_back(HARDFORK_480_TIME);
+  _hardfork_times.emplace_back(HARDFORK_483_TIME);
+  _hardfork_times.emplace_back(HARDFORK_516_TIME);
+  _hardfork_times.emplace_back(HARDFORK_533_TIME);
+  _hardfork_times.emplace_back(HARDFORK_538_TIME);
+  _hardfork_times.emplace_back(HARDFORK_555_TIME);
+  _hardfork_times.emplace_back(HARDFORK_563_TIME);
+  _hardfork_times.emplace_back(HARDFORK_572_TIME);
+  _hardfork_times.emplace_back(HARDFORK_599_TIME);
+  _hardfork_times.emplace_back(HARDFORK_607_TIME);
+  _hardfork_times.emplace_back(HARDFORK_613_TIME);
+  _hardfork_times.emplace_back(HARDFORK_615_TIME);
+  _hardfork_times.emplace_back(HARDFORK_999_TIME);
+  _hardfork_times.emplace_back(HARDFORK_1000_TIME);
+  _hardfork_times.emplace_back(HARDFORK_1001_TIME);
+  _hardfork_times.emplace_back(HARDFORK_5050_1_TIME);
+  _hardfork_times.emplace_back(HARDFORK_CORE_429_TIME);
+  _hardfork_times.emplace_back(HARDFORK_GPOS_TIME);
+  _hardfork_times.emplace_back(HARDFORK_NFT_TIME);
+  _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_SON_FOR_ETHEREUM_TIME);
+  _hardfork_times.emplace_back(HARDFORK_SWEEPS_TIME);
+
+  std::sort(_hardfork_times.begin(), _hardfork_times.end());
+}
+
 void database::initialize_indexes()
 {
    reset_indexes();
+
+   const std::lock_guard<std::mutex> undo_db_lock{_undo_db_mutex};
    _undo_db.set_max_size(GRAPHENE_MIN_UNDO_HISTORY);
 
    //Protocol object indexes
@@ -432,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; }
@@ -1058,8 +1104,9 @@ void database::init_genesis(const genesis_state_type& genesis_state)
    FC_ASSERT( _p_witness_schedule_obj->id == witness_schedule_id_type() );
 
       // Initialize witness schedule
+
 #ifndef NDEBUG
-   const son_schedule_object& sso =
+   const son_schedule_object& ssobitcoin =
 #endif
    create<son_schedule_object>([&](son_schedule_object& _sso)
    {
@@ -1068,24 +1115,64 @@ void database::init_genesis(const genesis_state_type& genesis_state)
 
       witness_scheduler_rng rng(_sso.rng_seed.begin(), GRAPHENE_NEAR_SCHEDULE_CTR_IV);
 
-      auto init_witnesses = get_global_properties().active_witnesses;
+      auto init_bitcoin_sons = get_global_properties().active_sons.at(sidechain_type::bitcoin);
 
       _sso.scheduler = son_scheduler();
-      _sso.scheduler._min_token_count = std::max(int(init_witnesses.size()) / 2, 1);
+      _sso.scheduler._min_token_count = std::max(int(init_bitcoin_sons.size()) / 2, 1);
-
 
       _sso.last_scheduling_block = 0;
 
       _sso.recent_slots_filled = fc::uint128::max_value();
    });
-   assert( sso.id == son_schedule_id_type() );
+   assert( ssobitcoin.id == son_schedule_id_type(get_son_schedule_id(sidechain_type::bitcoin)) );
+
+#ifndef NDEBUG
+   const son_schedule_object& ssoethereum =
+#endif
+   create<son_schedule_object>([&](son_schedule_object& _sso)
+   {
+      // for scheduled
+      memset(_sso.rng_seed.begin(), 0, _sso.rng_seed.size());
+
+      witness_scheduler_rng rng(_sso.rng_seed.begin(), GRAPHENE_NEAR_SCHEDULE_CTR_IV);
+
+      auto init_ethereum_sons = get_global_properties().active_sons.at(sidechain_type::ethereum);
+
+      _sso.scheduler = son_scheduler();
+      _sso.scheduler._min_token_count = std::max(int(init_ethereum_sons.size()) / 2, 1);
+
+      _sso.last_scheduling_block = 0;
+
+      _sso.recent_slots_filled = fc::uint128::max_value();
+   });
+   assert( ssoethereum.id == son_schedule_id_type(get_son_schedule_id(sidechain_type::ethereum)) );
+
+#ifndef NDEBUG
+   const son_schedule_object& ssohive =
+#endif
+   create<son_schedule_object>([&](son_schedule_object& _sso)
+   {
+      // for scheduled
+      memset(_sso.rng_seed.begin(), 0, _sso.rng_seed.size());
+
+      witness_scheduler_rng rng(_sso.rng_seed.begin(), GRAPHENE_NEAR_SCHEDULE_CTR_IV);
+
+      auto init_hive_sons = get_global_properties().active_sons.at(sidechain_type::hive);
+
+      _sso.scheduler = son_scheduler();
+      _sso.scheduler._min_token_count = std::max(int(init_hive_sons.size()) / 2, 1);
+
+      _sso.last_scheduling_block = 0;
+
+      _sso.recent_slots_filled = fc::uint128::max_value();
+   });
+   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

@@ -78,25 +78,34 @@ vector<std::reference_wrapper<const typename Index::object_type>> database::sort
 }
 
 template<>
-vector<std::reference_wrapper<const son_object>> database::sort_votable_objects<son_index>(size_t count) const
+vector<std::reference_wrapper<const son_object>> database::sort_votable_objects<son_index>(sidechain_type sidechain, size_t count) const
 {
    const auto& all_sons = get_index_type<son_index>().indices().get< by_id >();
    std::vector<std::reference_wrapper<const son_object>> refs;
    for( auto& son : all_sons )
    {
-      if(son.has_valid_config(head_block_time()) && son.status != 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](const son_object& a, const son_object& b)->bool {
+      [this, sidechain](const son_object& a, const son_object& b)->bool {
-      share_type oa_vote = _vote_tally_buffer[a.vote_id];
+         FC_ASSERT(sidechain == sidechain_type::bitcoin ||
-      share_type ob_vote = _vote_tally_buffer[b.vote_id];
+                   sidechain == sidechain_type::ethereum ||
+                   sidechain == sidechain_type::hive,
+                   "Unexpected sidechain type");
+
+         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;
-      return a.vote_id < b.vote_id;
+
+         return a.get_sidechain_vote_id(sidechain) < b.get_sidechain_vote_id(sidechain);
    });
 
    refs.resize(count, refs.front());
@@ -161,6 +170,7 @@ struct worker_pay_visitor
          worker.pay_worker(pay, db);
       }
 };
+
 void database::update_worker_votes()
 {
    auto& idx = get_index_type<worker_index>();
@@ -176,63 +186,95 @@ void database::update_worker_votes()
    }
 }
 
-void database::pay_sons()
+void database::hotfix_2024()
 {
-   time_point_sec now = head_block_time();
+   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()))) {
+   if( dpo.son_budget.value > 0 && ((now - dpo.last_son_payout_time) >= fc::seconds(get_global_properties().parameters.son_pay_time())))
-      auto sons = sort_votable_objects<son_index>(get_global_properties().parameters.maximum_son_count());
+   {
+      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 )
       {
-         total_votes += _vote_tally_buffer[son.vote_id];
+         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)];
       }
-      int8_t bits_to_drop = std::max(int(boost::multiprecision::detail::find_msb(total_votes)) - 15, 0);
+      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 ) {
-         uint16_t weight = std::max((son_votes >> bits_to_drop), uint64_t(1) );
+         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 ) {
-         int8_t bits_to_drop = std::max(int(boost::multiprecision::detail::find_msb(son_votes)) - 15, 0);
+         const int8_t bits_to_drop = std::max(int(boost::multiprecision::detail::find_msb(son_votes)) - 15, 0);
-         uint16_t weight = std::max((son_votes >> bits_to_drop), uint64_t(1) );
+         const uint16_t weight = std::max((son_votes >> bits_to_drop), uint64_t(1) );
          return weight;
       };
+
       uint64_t weighted_total_txs_signed = 0;
-      share_type son_budget = dpo.son_budget;
+      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](const object& o) {
+      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>();
-         auto son_obj = idx.find( s.owner );
+         const auto son_obj = idx.find( s.owner );
-         auto son_weight = get_weight(_vote_tally_buffer[son_obj->vote_id]);
+         uint16_t son_weight = 0;
-         if( now < HARDFORK_SON2_TIME ) {
+         FC_ASSERT(son_obj->get_sidechain_vote_id(st).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", st)("son", *son_obj));
-            son_weight = get_weight_before_son2_hf(_vote_tally_buffer[son_obj->vote_id]);
+         if( now >= HARDFORK_SON2_TIME ) {
+            son_weight += get_weight(_vote_tally_buffer[*son_obj->get_sidechain_vote_id(st)]);
          }
-         uint64_t txs_signed = 0;
+         else {
-         for (const auto &ts : s.txs_signed) {
+            son_weight += get_weight_before_son2_hf(_vote_tally_buffer[*son_obj->get_sidechain_vote_id(st)]);
-            txs_signed = txs_signed + ts.second;
          }
-         weighted_total_txs_signed += (txs_signed * son_weight);
+         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](const object& o) {
+      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);
-         uint64_t txs_signed = 0;
+         const uint64_t txs_signed_bitcoin = s.txs_signed.contains(sidechain_type::bitcoin) ? s.txs_signed.at(sidechain_type::bitcoin) : 0;
-         for (const auto &ts : s.txs_signed) {
+         const uint64_t txs_signed_hive = s.txs_signed.contains(sidechain_type::hive) ? s.txs_signed.at(sidechain_type::hive) : 0;
-            txs_signed = txs_signed + ts.second;
-         }
 
-         if(txs_signed > 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 );
-            auto son_weight = get_weight(_vote_tally_buffer[son_obj->vote_id]);
+            uint16_t son_weight = 0;
-            if( now < HARDFORK_SON2_TIME ) {
+            FC_ASSERT(son_obj->get_sidechain_vote_id(st).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", st)("son", *son_obj));
-               son_weight = get_weight_before_son2_hf(_vote_tally_buffer[son_obj->vote_id]);
+            if( now >= HARDFORK_SON2_TIME ) {
+               son_weight += get_weight(_vote_tally_buffer[*son_obj->get_sidechain_vote_id(st)]);
             }
-            share_type pay = (txs_signed * son_weight * son_budget.value)/weighted_total_txs_signed;
+            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);
@@ -245,12 +287,14 @@ void database::pay_sons()
             //Reset the tx counter in each son statistics object
             modify( s, [&]( son_statistics_object& _s)
             {
-               for (const auto &ts : s.txs_signed) {
+               if(_s.txs_signed.contains(sidechain_type::bitcoin))
-                  _s.txs_signed.at(ts.first) = 0;
+                  _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 )
       {
@@ -259,122 +303,228 @@ void database::pay_sons()
    }
 }
 
-void database::update_son_metrics(const vector<son_info>& curr_active_sons)
+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())))
+   {
+      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;
+         /// 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;
+         size_t son_count = 0;
+         if( stake_target > 0 )
+         {
+            while( (son_count < _son_count_histogram_buffer.at(active_sidechain_type).size() - 1)
+                   && (stake_tally <= stake_target) )
+            {
+               stake_tally += _son_count_histogram_buffer.at(active_sidechain_type)[++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 )
+         {
+            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)];
+         }
+         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);
+
+            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);
+               uint16_t son_weight = 0;
+               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))
+                     _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;
+      });
+   }
+}
+
+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;
+      const auto& _curr_active_sidechain_sons = curr_active_sidechain_sons.second;
+
       vector<son_id_type> current_sons;
 
-   current_sons.reserve(curr_active_sons.size());
+      current_sons.reserve(_curr_active_sidechain_sons.size());
-   std::transform(curr_active_sons.begin(), curr_active_sons.end(),
+      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;
                      });
 
       const auto &son_idx = get_index_type<son_index>().indices().get<by_id>();
-   for( auto& son : son_idx )
+      for (auto &son : son_idx) {
-   {
          auto &stats = son.statistics(*this);
          bool is_active_son = (std::find(current_sons.begin(), current_sons.end(), son.id) != current_sons.end());
-      modify( stats, [&]( son_statistics_object& _stats )
+         modify(stats, [&](son_statistics_object &_stats) {
-      {
             if (is_active_son) {
-            _stats.total_voted_time = _stats.total_voted_time + get_global_properties().parameters.maintenance_interval;
+               _stats.total_voted_time[sidechain] = _stats.total_voted_time[sidechain] + get_global_properties().parameters.maintenance_interval;
-         }
-         _stats.total_downtime += _stats.current_interval_downtime;
-         _stats.current_interval_downtime = 0;
-         for (const auto &str : _stats.sidechain_txs_reported) {
-            _stats.sidechain_txs_reported.at(str.first) = 0;
             }
+            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;
          });
       }
    }
+}
 
-void database::update_son_statuses(const vector<son_info>& curr_active_sons, const 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;
+
       vector<son_id_type> current_sons, new_sons;
       vector<son_id_type> sons_to_remove, sons_to_add;
       const auto &idx = get_index_type<son_index>().indices().get<by_id>();
 
-   current_sons.reserve(curr_active_sons.size());
+      if(curr_active_sons.contains(sidechain)) {
-   std::transform(curr_active_sons.begin(), curr_active_sons.end(),
+         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;
                         });
+      }
 
-   new_sons.reserve(new_active_sons.size());
+      new_sons.reserve(new_active_sons.at(sidechain).size());
-   std::transform(new_active_sons.begin(), new_active_sons.end(),
+      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;
                      });
 
       // find all cur_active_sons members that is not in new_active_sons
       for_each(current_sons.begin(), current_sons.end(),
-            [&sons_to_remove, &new_sons](const son_id_type& si)
+               [&sons_to_remove, &new_sons](const son_id_type &si) {
-            {
                   if (std::find(new_sons.begin(), new_sons.end(), si) ==
-                     new_sons.end())
+                      new_sons.end()) {
-               {
                      sons_to_remove.push_back(si);
                   }
-            }
+               });
-   );
 
-   for( const auto& sid : sons_to_remove )
+      for (const auto &sid : sons_to_remove) {
-   {
          auto son = idx.find(sid);
          if (son == idx.end()) // SON is deleted already
             continue;
          // keep maintenance status for nodes becoming inactive
-      if(son->status == son_status::active)
+         if (son->statuses.at(sidechain) == son_status::active) {
-      {
             modify(*son, [&](son_object &obj) {
-                  obj.status = son_status::inactive;
+               obj.statuses.at(sidechain) = son_status::inactive;
             });
          }
       }
 
       // find all new_active_sons members that is not in cur_active_sons
       for_each(new_sons.begin(), new_sons.end(),
-            [&sons_to_add, &current_sons](const son_id_type& si)
+               [&sons_to_add, &current_sons](const son_id_type &si) {
-            {
                   if (std::find(current_sons.begin(), current_sons.end(), si) ==
-                     current_sons.end())
+                      current_sons.end()) {
-               {
                      sons_to_add.push_back(si);
                   }
-            }
+               });
-   );
 
-   for( const auto& sid : sons_to_add )
+      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->status == son_status::inactive)
+         if (son->statuses.at(sidechain) == son_status::inactive) {
-      {
             modify(*son, [&](son_object &obj) {
-                  obj.status = son_status::active;
+               obj.statuses.at(sidechain) = son_status::active;
             });
          }
       }
 
-   ilog("New SONS");
+      ilog("New SONS for sidechain = ${sidechain}", ("sidechain", sidechain));
       for (size_t i = 0; i < new_sons.size(); i++) {
          auto son = idx.find(new_sons[i]);
          if (son == idx.end()) // SON is deleted already
             continue;
-      ilog( "${s}, status = ${ss}, total_votes = ${sv}", ("s", new_sons[i])("ss", son->status)("sv", son->total_votes) );
+         ilog("${s}, status = ${ss}, total_votes = ${sv}", ("s", new_sons[i])("ss", son->statuses.at(sidechain))("sv", son->total_votes));
+      }
    }
 
-   if( sons_to_remove.size() > 0 )
+   //! Remove inactive sons (when all sidechain inactive)
-   {
+   vector<son_id_type> sons_to_remove;
+   const auto &idx = get_index_type<son_index>().indices().get<by_id>();
+   for(const auto& son : idx) {
+      bool inactive_son = true;
+      for(const auto& status : son.statuses) {
+         if (status.second != son_status::inactive)
+            inactive_son = false;
+      }
+      if (inactive_son)
+         sons_to_remove.emplace_back(son.id);
+   }
+   if (sons_to_remove.size() > 0) {
       remove_inactive_son_proposals(sons_to_remove);
    }
 }
 
-void database::update_son_wallet(const 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;
 
@@ -387,8 +537,16 @@ void database::update_son_wallet(const vector<son_info>& new_active_sons)
 
       bool wallet_son_sets_equal = (cur_wallet_sons.size() == new_active_sons.size());
       if (wallet_son_sets_equal) {
-         for( size_t i = 0; i < cur_wallet_sons.size(); i++ ) {
+         for( const auto& cur_wallet_sidechain_sons : cur_wallet_sons ) {
-            wallet_son_sets_equal = wallet_son_sets_equal && cur_wallet_sons.at(i) == new_active_sons.at(i);
+            const auto& sidechain = cur_wallet_sidechain_sons.first;
+            const auto& _cur_wallet_sidechain_sons = cur_wallet_sidechain_sons.second;
+
+            wallet_son_sets_equal = wallet_son_sets_equal && (_cur_wallet_sidechain_sons.size() == new_active_sons.at(sidechain).size());
+            if (wallet_son_sets_equal) {
+               for (size_t i = 0; i < _cur_wallet_sidechain_sons.size(); i++) {
+                  wallet_son_sets_equal = wallet_son_sets_equal && (_cur_wallet_sidechain_sons.at(i) == new_active_sons.at(sidechain).at(i));
+               }
+            }
          }
       }
 
@@ -401,14 +559,24 @@ void database::update_son_wallet(const vector<son_info>& new_active_sons)
       }
    }
 
-   should_recreate_pw = should_recreate_pw && (new_active_sons.size() >= get_chain_properties().immutable_parameters.min_son_count);
+   bool should_recreate_pw_sidechain = false;
+   for(const auto& new_active_sidechain_sons : new_active_sons) {
+      if(new_active_sidechain_sons.second.size() >= get_chain_properties().immutable_parameters.min_son_count)
+         should_recreate_pw_sidechain = true;
+   }
+   should_recreate_pw = should_recreate_pw && should_recreate_pw_sidechain;
 
    if (should_recreate_pw) {
       // Create new son_wallet_object, to initiate wallet recreation
       create<son_wallet_object>( [&]( son_wallet_object& obj ) {
          obj.valid_from = head_block_time();
          obj.expires = time_point_sec::maximum();
-         obj.sons.insert(obj.sons.end(), new_active_sons.begin(), new_active_sons.end());
+         for(const auto& new_active_sidechain_sons : new_active_sons){
+            const auto& sidechain = new_active_sidechain_sons.first;
+            const auto& _new_active_sidechain_sons = new_active_sidechain_sons.second;
+
+            obj.sons[sidechain].insert(obj.sons[sidechain].end(), _new_active_sidechain_sons.cbegin(), _new_active_sidechain_sons.cend());
+         }
       });
    }
 }
@@ -665,43 +833,70 @@ void database::update_active_sons()
    }
 
    assert( _son_count_histogram_buffer.size() > 0 );
-   share_type stake_target = (_total_voting_stake-_son_count_histogram_buffer[0]) / 2;
+#ifndef NDEBUG
+   for( const auto& son_count_histogram_buffer : _son_count_histogram_buffer ){
+      assert( son_count_histogram_buffer.second.size() > 0 );
+   }
+#endif
+
+   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)
-
       share_type stake_tally = 0;
-
+      son_count[active_sidechain_type] = 0;
-   size_t son_count = 0;
       if( stake_target > 0 )
       {
-      while( (son_count < _son_count_histogram_buffer.size() - 1)
+         while( (son_count.at(active_sidechain_type) < _son_count_histogram_buffer.at(active_sidechain_type).size() - 1)
                 && (stake_tally <= stake_target) )
          {
-         stake_tally += _son_count_histogram_buffer[++son_count];
+               stake_tally += _son_count_histogram_buffer.at(active_sidechain_type)[ ++son_count[active_sidechain_type] ];
+         }
       }
    }
 
    const global_property_object& gpo = get_global_properties();
-   const chain_parameters& cp = gpo.parameters;
+   const chain_property_object& cpo = get_chain_properties();
-   auto sons = sort_votable_objects<son_index>(cp.maximum_son_count());
-
    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 : supported_active_sidechain_types)
+   {
+      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>(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 )
    {
-      if(son.status == son_status::request_maintenance)
+      for(const auto& status: son.statuses)
+      {
+         const auto& sidechain = status.first;
+         if(status.second == son_status::in_maintenance)
          {
             auto &stats = son.statistics(*this);
             modify(stats, [&](son_statistics_object &_s) {
-               _s.last_down_timestamp = head_block_time();
+               _s.last_down_timestamp[sidechain] = head_block_time();
             });
          }
-      modify( son, [local_vote_buffer_ref]( son_object& obj ){
+      }
-              obj.total_votes = local_vote_buffer_ref[obj.vote_id];
+
-              if(obj.status == son_status::request_maintenance)
+      modify( son, [this]( son_object& obj ){
-                 obj.status = son_status::in_maintenance;
+         for(const auto& sidechain_vote_id : obj.sidechain_vote_ids ){
+            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)
+         {
+            if (status.second == son_status::request_maintenance)
+               status.second = son_status::in_maintenance;
+         }
       });
    }
 
@@ -710,21 +905,24 @@ void database::update_active_sons()
    {
       modify( get(gpo.parameters.son_account()), [&]( account_object& a )
       {
+         set<account_id_type> account_ids;
+         for(const auto& sidechain_sons : sons)
+         {
+            for( const son_object& son : sidechain_sons.second )
+            {
+               account_ids.emplace(son.son_account);
+            }
+         }
+
          if( head_block_time() < HARDFORK_533_TIME )
          {
-            map<account_id_type, uint64_t> weights;
             a.active.weight_threshold = 0;
             a.active.account_auths.clear();
 
-            for( const son_object& son : sons )
+            for( const auto& account_id : account_ids )
-            {
-               weights.emplace(son.son_account, uint64_t(1));
-            }
-
-            for( const auto& weight : weights )
             {
                // Ensure that everyone has at least one vote. Zero weights aren't allowed.
-               a.active.account_auths[weight.first] += 1;
+               a.active.account_auths[account_id] += 1;
                a.active.weight_threshold += 1;
             }
 
@@ -735,8 +933,10 @@ void database::update_active_sons()
          else
          {
             vote_counter vc;
-            for( const son_object& son : sons )
+            for( const auto& account_id : account_ids )
-               vc.add( son.son_account, UINT64_C(1) );
+            {
+               vc.add(account_id, UINT64_C(1));
+            }
             vc.finish_2_3( a.active );
          }
       } );
@@ -744,22 +944,37 @@ void database::update_active_sons()
 
 
    // Compare current and to-be lists of active sons
-   auto cur_active_sons = gpo.active_sons;
+   const auto cur_active_sons = gpo.active_sons;
-   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 son_object& son : sons ) {
+   for( const auto& sidechain_sons : sons ){
-      son_info swi;
+      const auto& sidechain = sidechain_sons.first;
+      const auto& sons_array = sidechain_sons.second;
+
+      new_active_sons[sidechain].reserve(sons_array.size());
+      for( const son_object& son : sons_array ) {
+         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.sidechain_public_keys = son.sidechain_public_keys;
+         if (son.sidechain_public_keys.find(sidechain) != son.sidechain_public_keys.end())
-      new_active_sons.push_back(swi);
+            swi.public_key = son.sidechain_public_keys.at(sidechain);
+         new_active_sons[sidechain].push_back(swi);
+      }
    }
 
    bool son_sets_equal = (cur_active_sons.size() == new_active_sons.size());
    if (son_sets_equal) {
-      for( size_t i = 0; i < cur_active_sons.size(); i++ ) {
+      for( const auto& cur_active_sidechain_sons : cur_active_sons ){
-         son_sets_equal = son_sets_equal && cur_active_sons.at(i) == new_active_sons.at(i);
+         const auto& sidechain = cur_active_sidechain_sons.first;
+         const auto& _cur_active_sidechain_sons = cur_active_sidechain_sons.second;
+
+         son_sets_equal = son_sets_equal && (_cur_active_sidechain_sons.size() == new_active_sons.at(sidechain).size());
+         if (son_sets_equal) {
+            for (size_t i = 0; i < _cur_active_sidechain_sons.size(); i++) {
+               son_sets_equal = son_sets_equal && (_cur_active_sidechain_sons.at(i) == new_active_sons.at(sidechain).at(i));
+            }
+         }
       }
    }
 
@@ -774,28 +989,38 @@ void database::update_active_sons()
    modify(gpo, [&]( global_property_object& gp ){
       gp.active_sons.clear();
       gp.active_sons.reserve(new_active_sons.size());
-      gp.active_sons.insert(gp.active_sons.end(), new_active_sons.begin(), new_active_sons.end());
+      for( const auto& new_active_sidechain_sons : new_active_sons ) {
+         const auto& sidechain = new_active_sidechain_sons.first;
+         const auto& _new_active_sidechain_sons = new_active_sidechain_sons.second;
+
+         gp.active_sons[sidechain].reserve(_new_active_sidechain_sons.size());
+         gp.active_sons[sidechain].insert(gp.active_sons[sidechain].end(), _new_active_sidechain_sons.cbegin(), _new_active_sidechain_sons.cend());
+      }
    });
 
-   const son_schedule_object& sso = son_schedule_id_type()(*this);
+   for(const auto& active_sidechain_type : supported_active_sidechain_types)
-   modify(sso, [&](son_schedule_object& _sso)
+   {
+      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)
       {
          flat_set<son_id_type> active_sons;
-      active_sons.reserve(gpo.active_sons.size());
+         active_sons.reserve(gpo.active_sons.at(active_sidechain_type).size());
-      std::transform(gpo.active_sons.begin(), gpo.active_sons.end(),
+         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.size() == 0 && new_active_sons.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.size(); ++i )
+            for( size_t i=0; i<new_active_sons.at(active_sidechain_type).size(); ++i )
                _sso.scheduler.produce_schedule(rng);
          }
       });
+   }
 } FC_CAPTURE_AND_RETHROW() }
 
 void database::initialize_budget_record( fc::time_point_sec now, budget_record& rec )const
@@ -1335,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();
+      const auto now = db.head_block_time();
-      if(now.sec_since_epoch() >= (period_start + vesting_period))
+      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();
       }
    }
 }
@@ -1940,7 +2167,7 @@ void database::perform_son_tasks()
                               asset_issuer_permission_flags::override_authority;
             a.options.core_exchange_rate.base.amount = 100000;
             a.options.core_exchange_rate.base.asset_id = asset_id_type(0);
-            a.options.core_exchange_rate.quote.amount = 2500; // CoinMarketCap approx value
+            a.options.core_exchange_rate.quote.amount = 2500;
             a.options.core_exchange_rate.quote.asset_id = a.id;
             a.options.whitelist_authorities.clear(); // accounts allowed to use asset, if not empty
             a.options.blacklist_authorities.clear(); // accounts who can blacklist other accounts to use asset, if white_list flag is set
@@ -1954,6 +2181,40 @@ void database::perform_son_tasks()
                gpo.pending_parameters->extensions.value.btc_asset = btc_asset.get_id();
       });
    }
+   // create ETH asset here because son_account is the issuer of the ETH
+   if (gpo.parameters.eth_asset() == asset_id_type() && head_block_time() >= HARDFORK_SON_FOR_ETHEREUM_TIME)
+   {
+      const asset_dynamic_data_object& dyn_asset =
+         create<asset_dynamic_data_object>([](asset_dynamic_data_object& a) {
+            a.current_supply = 0;
+         });
+
+      const asset_object& eth_asset =
+         create<asset_object>( [&gpo, &dyn_asset]( asset_object& a ) {
+            a.symbol = "ETH";
+            a.precision = 8;
+            a.issuer = gpo.parameters.son_account();
+            a.options.max_supply = GRAPHENE_MAX_SHARE_SUPPLY;
+            a.options.market_fee_percent = 500; // 5%
+            a.options.issuer_permissions = UIA_ASSET_ISSUER_PERMISSION_MASK;
+            a.options.flags = asset_issuer_permission_flags::charge_market_fee |
+                              asset_issuer_permission_flags::override_authority;
+            a.options.core_exchange_rate.base.amount = 100000;
+            a.options.core_exchange_rate.base.asset_id = asset_id_type(0);
+            a.options.core_exchange_rate.quote.amount = 2500;
+            a.options.core_exchange_rate.quote.asset_id = a.id;
+            a.options.whitelist_authorities.clear(); // accounts allowed to use asset, if not empty
+            a.options.blacklist_authorities.clear(); // accounts who can blacklist other accounts to use asset, if white_list flag is set
+            a.options.whitelist_markets.clear(); // might be traded with
+            a.options.blacklist_markets.clear(); // might not be traded with
+            a.dynamic_asset_data_id = dyn_asset.id;
+         });
+      modify( gpo, [&eth_asset]( global_property_object& gpo ) {
+            gpo.parameters.extensions.value.eth_asset = eth_asset.get_id();
+            if( gpo.pending_parameters )
+               gpo.pending_parameters->extensions.value.eth_asset = eth_asset.get_id();
+      });
+   }
    // create HBD asset here because son_account is the issuer of the HBD
    if (gpo.parameters.hbd_asset() == asset_id_type() && head_block_time() >= HARDFORK_SON_FOR_HIVE_TIME)
    {
@@ -1974,7 +2235,7 @@ void database::perform_son_tasks()
                               asset_issuer_permission_flags::override_authority;
             a.options.core_exchange_rate.base.amount = 100000;
             a.options.core_exchange_rate.base.asset_id = asset_id_type(0);
-            a.options.core_exchange_rate.quote.amount = 2500; // CoinMarketCap approx value
+            a.options.core_exchange_rate.quote.amount = 2500;
             a.options.core_exchange_rate.quote.asset_id = a.id;
             a.options.whitelist_authorities.clear(); // accounts allowed to use asset, if not empty
             a.options.blacklist_authorities.clear(); // accounts who can blacklist other accounts to use asset, if white_list flag is set
@@ -2008,7 +2269,7 @@ void database::perform_son_tasks()
                               asset_issuer_permission_flags::override_authority;
             a.options.core_exchange_rate.base.amount = 100000;
             a.options.core_exchange_rate.base.asset_id = asset_id_type(0);
-            a.options.core_exchange_rate.quote.amount = 2500; // CoinMarketCap approx value
+            a.options.core_exchange_rate.quote.amount = 2500;
             a.options.core_exchange_rate.quote.asset_id = a.id;
             a.options.whitelist_authorities.clear(); // accounts allowed to use asset, if not empty
             a.options.blacklist_authorities.clear(); // accounts who can blacklist other accounts to use asset, if white_list flag is set
@@ -2022,25 +2283,75 @@ 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;
       });
    }
+
+   if( (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 = GRAPHENE_DEFAULT_MAX_SONS;
+      });
+   }
 }
 
 void database::perform_chain_maintenance(const signed_block& next_block, const global_property_object& global_props)
@@ -2067,7 +2378,9 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g
          d._vote_tally_buffer.resize(props.next_available_vote_id);
          d._witness_count_histogram_buffer.resize(props.parameters.maximum_witness_count / 2 + 1);
          d._committee_count_histogram_buffer.resize(props.parameters.maximum_committee_count / 2 + 1);
-         d._son_count_histogram_buffer.resize(props.parameters.maximum_son_count() / 2 + 1);
+         for( auto& son_count_histogram_buffer : d._son_count_histogram_buffer ){
+            son_count_histogram_buffer.second.resize(props.parameters.maximum_son_count() / 2 + 1);
+         }
          d._total_voting_stake = 0;
 
          auto balance_type = vesting_balance_type::normal;
@@ -2167,17 +2480,24 @@ 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;
             }
-            if( opinion_account.options.num_son <= props.parameters.maximum_son_count() )
+
+            if ( opinion_account.options.extensions.value.num_son.valid() )
             {
-               uint16_t offset = std::min(size_t(opinion_account.options.num_son/2),
+               for(const auto& num_sidechain_son : *opinion_account.options.extensions.value.num_son) {
-                                          d._son_count_histogram_buffer.size() - 1);
+                  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[offset] += voting_stake;
+                     d._son_count_histogram_buffer.at(sidechain)[offset] += voting_stake;
+                  }
+               }
             }
 
             d._total_voting_stake += voting_stake;
@@ -2192,10 +2512,20 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g
    private:
       vector<uint64_t>& target;
    };
+   struct clear_canary_map {
+      clear_canary_map(flat_map<sidechain_type, vector<uint64_t> >& target): target(target){}
+      ~clear_canary_map() {
+         for(auto& sidechain_target : target){
+            sidechain_target.second.clear();
+         }
+      }
+   private:
+      flat_map<sidechain_type, vector<uint64_t> >& target;
+   };
    clear_canary a(_witness_count_histogram_buffer),
                 b(_committee_count_histogram_buffer),
-                d(_son_count_histogram_buffer),
                 c(_vote_tally_buffer);
+   clear_canary_map d{_son_count_histogram_buffer};
 
    perform_son_tasks();
    update_top_n_authorities(*this);
@@ -2203,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();
 
@@ -2267,13 +2598,17 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g
             p.pending_parameters->extensions.value.hbd_asset = p.parameters.extensions.value.hbd_asset;
          if( !p.pending_parameters->extensions.value.hive_asset.valid() )
             p.pending_parameters->extensions.value.hive_asset = p.parameters.extensions.value.hive_asset;
+         if( !p.pending_parameters->extensions.value.eth_asset.valid() )
+            p.pending_parameters->extensions.value.eth_asset = p.parameters.extensions.value.eth_asset;
 
          // the following parameters are not allowed to be changed. So take what is in global property
-         p.pending_parameters->extensions.value.hive_asset = p.parameters.extensions.value.hive_asset;
-         p.pending_parameters->extensions.value.hbd_asset = p.parameters.extensions.value.hbd_asset;
-         p.pending_parameters->extensions.value.btc_asset = p.parameters.extensions.value.btc_asset;
-         p.pending_parameters->extensions.value.son_account = p.parameters.extensions.value.son_account;
          p.pending_parameters->extensions.value.gpos_period_start = p.parameters.extensions.value.gpos_period_start;
+         p.pending_parameters->extensions.value.son_account = p.parameters.extensions.value.son_account;
+         p.pending_parameters->extensions.value.btc_asset = p.parameters.extensions.value.btc_asset;
+         p.pending_parameters->extensions.value.maximum_son_count = p.parameters.extensions.value.maximum_son_count;
+         p.pending_parameters->extensions.value.hbd_asset = p.parameters.extensions.value.hbd_asset;
+         p.pending_parameters->extensions.value.hive_asset = p.parameters.extensions.value.hive_asset;
+         p.pending_parameters->extensions.value.eth_asset = p.parameters.extensions.value.eth_asset;
 
          p.parameters = std::move(*p.pending_parameters);
          p.pending_parameters.reset();

libraries/chain/db_management.cpp

@@ -44,6 +44,7 @@ database::database() :
 {
    initialize_indexes();
    initialize_evaluators();
+   initialize_hardforks();
 }
 
 database::~database()

libraries/chain/db_notify.cpp

@@ -203,27 +203,10 @@ struct get_impacted_account_visitor
       _impacted.insert( op.issuer );
    }
 
-   void operator()( const transfer_to_blind_operation& op )
+   //! We don't use this operations
-   {
+   void operator()( const transfer_to_blind_operation& op ){}
-      _impacted.insert( op.from );
+   void operator()( const blind_transfer_operation& op ){}
-      for( const auto& out : op.outputs )
+   void operator()( const transfer_from_blind_operation& op ){}
-         add_authority_accounts( _impacted, out.owner );
-   }
-
-   void operator()( const blind_transfer_operation& op )
-   {
-      for( const auto& in : op.inputs )
-         add_authority_accounts( _impacted, in.owner );
-      for( const auto& out : op.outputs )
-         add_authority_accounts( _impacted, out.owner );
-   }
-
-   void operator()( const transfer_from_blind_operation& op )
-   {
-      _impacted.insert( op.to );
-      for( const auto& in : op.inputs )
-         add_authority_accounts( _impacted, in.owner );
-   }
 
    void operator()( const asset_settle_cancel_operation& op )
    {

libraries/chain/db_witness_schedule.cpp

@@ -74,21 +74,32 @@ witness_id_type database::get_scheduled_witness( uint32_t slot_num )const
    return wid;
 }
 
-son_id_type database::get_scheduled_son( uint32_t slot_num )const
+unsigned_int database::get_son_schedule_id( sidechain_type type )const
+{
+   static const map<sidechain_type, unsigned_int> schedule_map = {
+      { sidechain_type::bitcoin, 0 },
+      { sidechain_type::ethereum, 1 },
+      { sidechain_type::hive, 2 }
+   };
+
+   return schedule_map.at(type);
+}
+
+son_id_type database::get_scheduled_son( sidechain_type type, uint32_t slot_num )const
 {
    son_id_type sid;
    const global_property_object& gpo = get_global_properties();
    if (gpo.parameters.witness_schedule_algorithm == GRAPHENE_WITNESS_SHUFFLED_ALGORITHM)
    {
        const dynamic_global_property_object& dpo = get_dynamic_global_properties();
-       const son_schedule_object& sso = son_schedule_id_type()(*this);
+       const son_schedule_object& sso = son_schedule_id_type(get_son_schedule_id(type))(*this);
        uint64_t current_aslot = dpo.current_aslot + slot_num;
        return sso.current_shuffled_sons[ current_aslot % sso.current_shuffled_sons.size() ];
    }
    if (gpo.parameters.witness_schedule_algorithm == GRAPHENE_WITNESS_SCHEDULED_ALGORITHM &&
        slot_num != 0 )
    {
-       const son_schedule_object& sso = son_schedule_id_type()(*this);
+      const son_schedule_object& sso = son_schedule_id_type(get_son_schedule_id(type))(*this);
        // ask the near scheduler who goes in the given slot
        bool slot_is_near = sso.scheduler.get_slot(slot_num-1, sid);
        if(! slot_is_near)
@@ -189,22 +200,25 @@ void database::update_witness_schedule()
    }
 }
 
-void database::update_son_schedule()
+void database::update_son_schedule(sidechain_type type)
 {
-   const son_schedule_object& sso = son_schedule_id_type()(*this);
    const global_property_object& gpo = get_global_properties();
 
-   if( head_block_num() % gpo.active_sons.size() == 0 )
+   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)
    {
-      modify( 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.size() );
+         _sso.current_shuffled_sons.reserve( gpo.active_sons.at(type).size() );
 
-         for( const son_info& w : gpo.active_sons )
+         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)
          {
             /// High performance random generator
@@ -304,13 +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();
-   const global_property_object& gpo = get_global_properties();
+#ifndef NDEBUG
    const son_schedule_object& sso = get(son_schedule_id_type());
-   uint32_t schedule_needs_filled = gpo.active_sons.size();
+#endif
-   uint32_t schedule_slot = get_slot_at_time(next_block.timestamp);
+   const global_property_object& gpo = get_global_properties();
+   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
@@ -319,22 +335,22 @@ void database::update_son_schedule(const signed_block& next_block)
 
    assert( schedule_slot > 0 );
 
-   son_id_type first_son;
-   bool slot_is_near = sso.scheduler.get_slot( schedule_slot-1, first_son );
-
-   son_id_type son;
-
    const dynamic_global_property_object& dpo = get_dynamic_global_properties();
 
    assert( dpo.random.data_size() == witness_scheduler_rng::seed_length );
    assert( witness_scheduler_rng::seed_length == sso.rng_seed.size() );
 
-   modify(sso, [&](son_schedule_object& _sso)
+   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)
    {
     _sso.slots_since_genesis += schedule_slot;
-      witness_scheduler_rng rng(sso.rng_seed.data, _sso.slots_since_genesis);
+    witness_scheduler_rng rng(_sso.rng_seed.data, _sso.slots_since_genesis);
 
-      _sso.scheduler._min_token_count = std::max(int(gpo.active_sons.size()) / 2, 1);
+    _sso.scheduler._min_token_count = std::max(int(gpo.active_sons.at(type).size()) / 2, 1);
 
     if( slot_is_near )
     {
@@ -351,7 +367,7 @@ void database::update_son_schedule(const signed_block& next_block)
     {
        _sso.scheduler.reset_schedule( first_son );
     }
-      while( !_sso.scheduler.get_slot(schedule_needs_filled, 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());
@@ -361,6 +377,7 @@ void database::update_son_schedule(const signed_block& next_block)
                                      (_sso.recent_slots_filled << 1)
                                      + 1) << (schedule_slot - 1);
    });
+
    auto end = fc::time_point::now();
    static uint64_t total_time = 0;
    static uint64_t calls = 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

@@ -0,0 +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("2023-07-17T12:00:00"))
+#else
+#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

@@ -66,6 +66,8 @@ namespace graphene { namespace chain {
          database();
          ~database();
 
+         std::vector<fc::time_point_sec> _hardfork_times;
+
          enum validation_steps
          {
             skip_nothing                = 0,
@@ -243,7 +245,16 @@ namespace graphene { namespace chain {
          witness_id_type get_scheduled_witness(uint32_t slot_num)const;
 
          /**
-          * @brief Get the son scheduled for block production in a slot.
+          * @brief Get son schedule id for the given sidechain_type.
+          *
+          * type sidechain_type we getting schedule.
+          *
+          * returns Id of the schedule object.
+          */
+         unsigned_int get_son_schedule_id(sidechain_type type)const;
+
+         /**
+          * @brief Get the bitcoin or hive son scheduled for block production in a slot.
           *
           * slot_num always corresponds to a time in the future.
           *
@@ -256,7 +267,7 @@ namespace graphene { namespace chain {
           *
           * Passing slot_num == 0 returns GRAPHENE_NULL_WITNESS
           */
-         son_id_type get_scheduled_son(uint32_t slot_num)const;
+         son_id_type get_scheduled_son(sidechain_type type, uint32_t slot_num)const;
 
          /**
           * Get the time at which the given slot occurs.
@@ -281,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(sidechain_type type);
-         void update_son_schedule(const signed_block& next_block);
+         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();
@@ -311,7 +322,7 @@ namespace graphene { namespace chain {
          fc::optional<operation>                create_son_deregister_proposal( son_id_type son_id, account_id_type paying_son );
          signed_transaction                     create_signed_transaction( const fc::ecc::private_key& signing_private_key, const operation& op );
          bool                                   is_son_dereg_valid( son_id_type son_id );
-         bool                                   is_son_active( son_id_type son_id );
+         bool                                   is_son_active( sidechain_type type, son_id_type son_id );
          bool                                   is_asset_creation_allowed(const string& symbol);
 
          time_point_sec   head_block_time()const;
@@ -332,6 +343,8 @@ namespace graphene { namespace chain {
          void initialize_evaluators();
          /// Reset the object graph in-memory
          void initialize_indexes();
+         void initialize_hardforks();
+
          void init_genesis(const genesis_state_type& genesis_state = genesis_state_type());
 
          template<typename EvaluatorType>
@@ -507,12 +520,16 @@ 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;
 
          template<class Index>
          vector<std::reference_wrapper<const typename Index::object_type>> sort_votable_objects(size_t count)const;
 
+         template<class Index>
+         vector<std::reference_wrapper<const typename Index::object_type>> sort_votable_objects(sidechain_type sidechain, size_t count)const;
+
          //////////////////// db_block.cpp ////////////////////
 
        public:
@@ -562,19 +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 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 vector<son_info>& cur_active_sons, const vector<son_info>& new_active_sons );
+         void update_son_statuses( const flat_map<sidechain_type, vector<son_sidechain_info> >& curr_active_sons,
-         void update_son_wallet( const vector<son_info>& new_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);
@@ -585,6 +605,7 @@ namespace graphene { namespace chain {
          ///@}
          ///@}
 
+         std::mutex                             _pending_tx_mutex;
          vector< processed_transaction >        _pending_tx;
          fork_database                          _fork_db;
 
@@ -615,7 +636,13 @@ namespace graphene { namespace chain {
          vector<uint64_t>                             _vote_tally_buffer;
          vector<uint64_t>                             _witness_count_histogram_buffer;
          vector<uint64_t>                             _committee_count_histogram_buffer;
-         vector<uint64_t>                  _son_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 : all_sidechain_types){
+               son_count_histogram_buffer[active_sidechain_type] = vector<uint64_t>{};
+            }
+            return son_count_histogram_buffer;
+         }();
          uint64_t                                     _total_voting_stake;
 
          flat_map<uint32_t,block_id_type>  _checkpoints;

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 {
@@ -52,7 +52,15 @@ namespace graphene { namespace chain {
          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
-         vector<son_info>                   active_sons; // 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_sidechain_info> > active_sons;
+            for(const auto& active_sidechain_type : all_sidechain_types)
+            {
+               active_sons[active_sidechain_type] = vector<son_sidechain_info>();
+            }
+            return active_sons;
+         }();
          // n.b. witness scheduling is done by witness_schedule object
    };
 

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

@@ -28,6 +28,7 @@
 #include <graphene/chain/protocol/special_authority.hpp>
 #include <graphene/chain/protocol/types.hpp>
 #include <graphene/chain/protocol/vote.hpp>
+#include <graphene/chain/sidechain_defs.hpp>
 
 namespace graphene { namespace chain {
 
@@ -37,6 +38,26 @@ namespace graphene { namespace chain {
    /// These are the fields which can be updated by the active authority.
    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;
+
+         /// 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 : 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.
@@ -52,13 +73,10 @@ namespace graphene { namespace chain {
       /// The number of active committee members this account votes the blockchain should appoint
       /// Must not exceed the actual number of committee members voted for in @ref votes
       uint16_t num_committee = 0;
-      /// 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
-      uint16_t num_son = 0;
       /// This is the list of vote IDs this account votes for. The weight of these votes is determined by this
       /// account's balance of core asset.
       flat_set<vote_id_type> votes;
-      extensions_type        extensions;
+      extension< ext > extensions;
 
       /// Whether this account is voting
       inline bool is_voting() const
@@ -289,6 +307,7 @@ namespace graphene { namespace chain {
 
 } } // graphene::chain
 
+FC_REFLECT(graphene::chain::account_options::ext, (num_son))
 FC_REFLECT(graphene::chain::account_options, (memo_key)(voting_account)(num_witness)(num_committee)(votes)(extensions))
 // FC_REFLECT_TYPENAME( graphene::chain::account_whitelist_operation::account_listing)
 FC_REFLECT_ENUM( graphene::chain::account_whitelist_operation::account_listing,

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

@@ -70,6 +70,7 @@ namespace graphene { namespace chain {
       optional < uint16_t >           maximum_son_count                 = GRAPHENE_DEFAULT_MAX_SONS; ///< maximum number of active SONS
       optional < asset_id_type >      hbd_asset                         = asset_id_type();
       optional < asset_id_type >      hive_asset                        = asset_id_type();
+      optional < asset_id_type >      eth_asset                         = asset_id_type();
    };
 
    struct chain_parameters
@@ -220,6 +221,9 @@ namespace graphene { namespace chain {
       inline asset_id_type hive_asset() const {
          return extensions.value.hive_asset.valid() ? *extensions.value.hive_asset : asset_id_type();
       }
+      inline asset_id_type eth_asset() const {
+         return extensions.value.eth_asset.valid() ? *extensions.value.eth_asset : asset_id_type();
+      }
       private:
       static void safe_copy(chain_parameters& to, const chain_parameters& from);
    };
@@ -257,6 +261,7 @@ FC_REFLECT( graphene::chain::parameter_extension,
    (maximum_son_count)
    (hbd_asset)
    (hive_asset)
+   (eth_asset)
 )
 
 FC_REFLECT( graphene::chain::chain_parameters,

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

@@ -111,12 +111,12 @@ struct stealth_confirmation
    /**
     *  Packs *this then encodes as base58 encoded string.
     */
-   operator string()const;
+   //operator string()const;
    /**
     * Unpacks from a base58 string
     */
-   stealth_confirmation( const std::string& base58 );
+   //stealth_confirmation( const std::string& base58 );
-   stealth_confirmation(){}
+   //stealth_confirmation(){}
 
    public_key_type           one_time_key;
    optional<public_key_type> to;
@@ -152,7 +152,6 @@ struct transfer_to_blind_operation : public base_operation
       uint32_t price_per_output = 5*GRAPHENE_BLOCKCHAIN_PRECISION;
    };
 
-
    asset                 fee;
    asset                 amount;
    account_id_type       from;
@@ -160,8 +159,8 @@ struct transfer_to_blind_operation : public base_operation
    vector<blind_output>  outputs;
 
    account_id_type fee_payer()const { return from; }
-   void            validate()const;
+   //void            validate()const;
-   share_type      calculate_fee(const fee_parameters_type& )const;
+   //share_type      calculate_fee(const fee_parameters_type& )const;
 };
 
 /**
@@ -181,13 +180,12 @@ struct transfer_from_blind_operation : public base_operation
    vector<blind_input>   inputs;
 
    account_id_type fee_payer()const { return GRAPHENE_TEMP_ACCOUNT; }
-   void            validate()const;
+   //void            validate()const;
-
+   //void            get_required_authorities( vector<authority>& a )const
-   void            get_required_authorities( vector<authority>& a )const
+   //{
-   {
+   //   for( const auto& in : inputs )
-      for( const auto& in : inputs )
+   //      a.push_back( in.owner );
-         a.push_back( in.owner ); 
+   //}
-   }
 };
 
 /**
@@ -245,15 +243,14 @@ struct blind_transfer_operation : public base_operation
    vector<blind_output>  outputs;
 
    /** graphene TEMP account */
-   account_id_type fee_payer()const;
+   account_id_type fee_payer()const { return GRAPHENE_TEMP_ACCOUNT; }
-   void            validate()const;
+   //void            validate()const;
-   share_type      calculate_fee( const fee_parameters_type& k )const;
+   //share_type      calculate_fee( const fee_parameters_type& k )const;
-
+   //void            get_required_authorities( vector<authority>& a )const
-   void            get_required_authorities( vector<authority>& a )const
+   //{
-   {
+   //   for( const auto& in : inputs )
-      for( const auto& in : inputs )
+   //      a.push_back( in.owner );
-         a.push_back( in.owner ); 
+   //}
-   }
 };
 
 ///@} endgroup stealth

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;
 

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

@@ -106,9 +106,9 @@ namespace graphene { namespace chain {
             assert_operation,
             balance_claim_operation,
             override_transfer_operation,
-            transfer_to_blind_operation,
+            transfer_to_blind_operation,     //! We don't use this operation
-            blind_transfer_operation,
+            blind_transfer_operation,        //! We don't use this operation
-            transfer_from_blind_operation,
+            transfer_from_blind_operation,   //! We don't use this operation
             asset_settle_cancel_operation,  // VIRTUAL
             asset_claim_fees_operation,
             fba_distribute_operation,        // VIRTUAL

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

@@ -1,17 +1,23 @@
 #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 ext
+     {
+        optional<flat_map<sidechain_type, vector<son_sidechain_info> > > sidechain_sons;
+     };
 
      asset fee;
      account_id_type payer;
 
      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; }
@@ -35,6 +41,7 @@ namespace graphene { namespace chain {
 } } // 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/protocol/vote.hpp

@@ -59,7 +59,9 @@ struct vote_id_type
       committee,
       witness,
       worker,
-      son,
+      son_bitcoin,
+      son_hive,
+      son_ethereum,
       VOTE_TYPE_COUNT
    };
 
@@ -144,7 +146,7 @@ void from_variant( const fc::variant& var, graphene::chain::vote_id_type& vo, ui
 
 FC_REFLECT_TYPENAME( fc::flat_set<graphene::chain::vote_id_type> )
 
-FC_REFLECT_ENUM( graphene::chain::vote_id_type::vote_type, (witness)(committee)(worker)(son)(VOTE_TYPE_COUNT) )
+FC_REFLECT_ENUM( graphene::chain::vote_id_type::vote_type, (witness)(committee)(worker)(son_bitcoin)(son_hive)(son_ethereum)(VOTE_TYPE_COUNT) )
 FC_REFLECT( graphene::chain::vote_id_type, (content) )
 
 GRAPHENE_EXTERNAL_SERIALIZATION( extern, graphene::chain::vote_id_type )

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

@@ -31,11 +31,20 @@ namespace graphene { namespace chain {
          time_point_sec expires;
 
          sidechain_address_object() :
-            sidechain(sidechain_type::bitcoin),
+            sidechain(sidechain_type::bitcoin), //! FIXME - bitcoin ???
             deposit_public_key(""),
             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,6 +1,11 @@
 #pragma once
 
+#include <set>
+
+#include <graphene/chain/hardfork.hpp>
+
 #include <fc/reflect/reflect.hpp>
+#include <fc/time.hpp>
 
 namespace graphene { namespace chain {
 
@@ -13,7 +18,23 @@ enum class 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,7 +3,6 @@
 #include <graphene/chain/sidechain_defs.hpp>
 
 namespace graphene { namespace chain {
-   using namespace graphene::db;
 
    /**
           * @class son_info
@@ -40,8 +39,4 @@ namespace graphene { namespace chain {
 
 } }
 
-FC_REFLECT( graphene::chain::son_info,
+FC_REFLECT( graphene::chain::son_info, (son_id) (weight) (signing_key) (sidechain_public_keys) )
-      (son_id)
-      (weight)
-      (signing_key)
-      (sidechain_public_keys) )

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

@@ -35,15 +35,15 @@ namespace graphene { namespace chain {
          // Transactions signed since the last son payouts
          flat_map<sidechain_type, uint64_t> txs_signed;
          // Total Voted Active time i.e. duration selected as part of voted active SONs
-         uint64_t total_voted_time = 0;
+         flat_map<sidechain_type, uint64_t> total_voted_time;
          // Total Downtime barring the current down time in seconds, used for stats to present to user
-         uint64_t total_downtime = 0;
+         flat_map<sidechain_type, uint64_t> total_downtime;
          // Current Interval Downtime since last maintenance
-         uint64_t current_interval_downtime = 0;
+         flat_map<sidechain_type, uint64_t> current_interval_downtime;
          // Down timestamp, if son status is in_maintenance use this
-         fc::time_point_sec last_down_timestamp;
+         flat_map<sidechain_type, fc::time_point_sec> last_down_timestamp;
          // Last Active heartbeat timestamp
-         fc::time_point_sec last_active_timestamp;
+         flat_map<sidechain_type, fc::time_point_sec> last_active_timestamp;
          // Deregistered Timestamp
          fc::time_point_sec deregistered_timestamp;
          // Total sidechain transactions reported by SON network while SON was active
@@ -64,23 +64,48 @@ namespace graphene { namespace chain {
          static const uint8_t type_id  = son_object_type;
 
          account_id_type son_account;
-         vote_id_type vote_id;
+         flat_map<sidechain_type, vote_id_type> sidechain_vote_ids;
-         uint64_t total_votes = 0;
+         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;
          vesting_balance_id_type pay_vb;
          son_statistics_id_type statistics;
-         son_status status = son_status::inactive;
+         flat_map<sidechain_type, son_status> statuses = []()
+         {
+            flat_map<sidechain_type, son_status> statuses;
+            for(const auto& active_sidechain_type : all_sidechain_types)
+            {
+               statuses[active_sidechain_type] = son_status::inactive;
+            }
+            return statuses;
+         }();
          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, sidechain_type sidechain) const;
-         bool has_valid_config(time_point_sec head_block_time)const;
+
+         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;
-   struct by_vote_id;
+   struct by_vote_id_bitcoin;
+   struct by_vote_id_hive;
+   struct by_vote_id_ethereum;
    using son_multi_index_type = multi_index_container<
       son_object,
       indexed_by<
@@ -90,8 +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>,
+         ordered_non_unique< tag<by_vote_id_bitcoin>,
-            member<son_object, vote_id_type, &son_object::vote_id>
+            const_mem_fun<son_object, optional<vote_id_type>, &son_object::get_bitcoin_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_non_unique< tag<by_vote_id_ethereum>,
+            const_mem_fun<son_object, optional<vote_id_type>, &son_object::get_ethereum_vote_id>
          >
       >
    >;
@@ -117,14 +148,14 @@ FC_REFLECT_ENUM(graphene::chain::son_status, (inactive)(active)(request_maintena
 
 FC_REFLECT_DERIVED( graphene::chain::son_object, (graphene::db::object),
                     (son_account)
-                    (vote_id)
+                    (sidechain_vote_ids)
                     (total_votes)
                     (url)
                     (deposit)
                     (signing_key)
                     (pay_vb)
                     (statistics)
-                    (status)
+                    (statuses)
                     (sidechain_public_keys)
                   )
 

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;
-         vector<son_info> sons;
+         flat_map<sidechain_type, vector<son_sidechain_info> > sons;
    };
 
    struct by_valid_from;

libraries/chain/include/graphene/chain/voters_info.hpp

@@ -23,7 +23,7 @@ namespace graphene { namespace chain {
       optional<voters_info_object>                             voters_for_witness;
       optional<vector<voters_info_object> >                    voters_for_workers;
       optional<vector<voters_info_object> >                    voters_against_workers;
-      optional<voters_info_object>           voters_for_son;
+      optional<flat_map<sidechain_type, voters_info_object> >  voters_for_son;
    };
 
 } } // graphene::chain

libraries/chain/include/graphene/chain/votes_info.hpp

@@ -23,7 +23,7 @@ namespace graphene { namespace chain {
       optional< vector< votes_info_object > >                              votes_for_witnesses;
       optional< vector< votes_info_object > >                              votes_for_workers;
       optional< vector< votes_info_object > >                              votes_against_workers;
-      optional< vector< votes_info_object > > votes_for_sons;
+      optional< flat_map<sidechain_type, vector< votes_info_object > > >   votes_for_sons;
    };
 
 } } // graphene::chain

libraries/chain/include/graphene/chain/witness_scheduler.hpp

@@ -162,8 +162,12 @@ class generic_witness_scheduler
          _schedule.pop_front();
 
          auto it = _lame_duck.find( result );
-         if( it != _lame_duck.end() )
+         if( it != _lame_duck.end() ) {
+            set< WitnessID > removal_set;
+            removal_set.insert(*it);
+            remove_all( removal_set );
             _lame_duck.erase(it);
+         }
          if( debug ) check_invariant();
          return result;
       }
@@ -389,7 +393,7 @@ class generic_witness_scheduler
       // scheduled
       std::deque < WitnessID > _schedule;
 
-      // in _schedule, but not to be replaced
+      // in _schedule, but must be removed
       set< WitnessID > _lame_duck;
 };
 

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))

libraries/chain/protocol/account.cpp

@@ -174,22 +174,37 @@ void account_options::validate() const
 {
    auto needed_witnesses = num_witness;
    auto needed_committee = num_committee;
-   auto needed_sons = 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 && needed_sons )
-         --needed_sons;
 
    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 == 0,
+
-              "May not specify fewer 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/protocol/confidential.cpp

@@ -22,12 +22,10 @@
  * THE SOFTWARE.
  */
 #include <graphene/chain/protocol/confidential.hpp>
-#include <graphene/chain/confidential_evaluator.hpp>
-#include <graphene/chain/database.hpp>
 
-#include <fc/crypto/base58.hpp>
 #include <fc/io/raw.hpp>
 
+/*
 namespace graphene { namespace chain {
 
 void transfer_to_blind_operation::validate()const
@@ -47,19 +45,6 @@ void transfer_to_blind_operation::validate()const
       FC_ASSERT( !outputs[i].owner.is_impossible() );
    }
    FC_ASSERT( out.size(), "there must be at least one output" );
-
-   auto public_c = fc::ecc::blind(blinding_factor,net_public);
-
-   FC_ASSERT( fc::ecc::verify_sum( {public_c}, out, 0 ), "", ("net_public",net_public) );
-
-   if( outputs.size() > 1 )
-   {
-      for( auto out : outputs )
-      {
-         auto info = fc::ecc::range_get_info( out.range_proof );
-         FC_ASSERT( info.max_value <= GRAPHENE_MAX_SHARE_SUPPLY );
-      }
-   }
 }
 
 share_type transfer_to_blind_operation::calculate_fee( const fee_parameters_type& k )const
@@ -79,31 +64,15 @@ void transfer_from_blind_operation::validate()const
    vector<commitment_type> in(inputs.size());
    vector<commitment_type> out;
    int64_t                 net_public = fee.amount.value + amount.amount.value;
-   out.push_back( fc::ecc::blind( blinding_factor, net_public ) );
-   for( uint32_t i = 0; i < in.size(); ++i )
-   {
-      in[i] = inputs[i].commitment;
-      /// by requiring all inputs to be sorted we also prevent duplicate commitments on the input
-      if( i > 0 ) FC_ASSERT( in[i-1] < in[i], "all inputs must be sorted by commitment id" );
-   }
-   FC_ASSERT( in.size(), "there must be at least one input" );
-   FC_ASSERT( fc::ecc::verify_sum( in, out, 0 ) );
 }
 
 
-/**
- *  If fee_payer = temp_account_id, then the fee is paid by the surplus balance of inputs-outputs and
- *  100% of the fee goes to the network.
- */
 account_id_type blind_transfer_operation::fee_payer()const
 {
    return GRAPHENE_TEMP_ACCOUNT;
 }
 
 
-/**
- *  This method can be computationally intensive because it verifies that input commitments - output commitments add up to 0
- */
 void blind_transfer_operation::validate()const
 { try {
    vector<commitment_type> in(inputs.size());
@@ -122,17 +91,6 @@ void blind_transfer_operation::validate()const
       FC_ASSERT( !outputs[i].owner.is_impossible() );
    }
    FC_ASSERT( in.size(), "there must be at least one input" );
-   FC_ASSERT( fc::ecc::verify_sum( in, out, net_public ), "", ("net_public", net_public) );
-
-   if( outputs.size() > 1 )
-   {
-      for( auto out : outputs )
-      {
-         auto info = fc::ecc::range_get_info( out.range_proof );
-         FC_ASSERT( info.max_value <= GRAPHENE_MAX_SHARE_SUPPLY );
-      }
-   }
-   FC_ASSERT( fc::ecc::verify_sum( in, out, net_public ), "", ("net_public", net_public) );
 } FC_CAPTURE_AND_RETHROW( (*this) ) }
 
 share_type blind_transfer_operation::calculate_fee( const fee_parameters_type& k )const
@@ -140,16 +98,12 @@ share_type blind_transfer_operation::calculate_fee( const fee_parameters_type& k
     return k.fee + outputs.size() * k.price_per_output;
 }
 
-/**
+
- *  Packs *this then encodes as base58 encoded string.
- */
 stealth_confirmation::operator string()const
 {
    return fc::to_base58( fc::raw::pack( *this ) );
 }
-/**
+
- * Unpacks from a base58 string
- */
 stealth_confirmation::stealth_confirmation( const std::string& base58 )
 {
    *this = fc::raw::unpack<stealth_confirmation>( fc::from_base58( base58 ) );
@@ -157,6 +111,8 @@ stealth_confirmation::stealth_confirmation( const std::string& base58 )
 
 } } // graphene::chain
 
+*/
+
 GRAPHENE_EXTERNAL_SERIALIZATION( /*not extern*/, graphene::chain::transfer_to_blind_operation::fee_parameters_type )
 GRAPHENE_EXTERNAL_SERIALIZATION( /*not extern*/, graphene::chain::transfer_from_blind_operation::fee_parameters_type )
 GRAPHENE_EXTERNAL_SERIALIZATION( /*not extern*/, graphene::chain::blind_transfer_operation::fee_parameters_type )

libraries/chain/sidechain_address_evaluator.cpp

@@ -22,12 +22,15 @@ 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())
+    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 ){
         obj.sidechain_address_account = op.sidechain_address_account;
@@ -47,7 +50,7 @@ void_result update_sidechain_address_evaluator::do_evaluate(const sidechain_addr
 { try {
     const auto& sidx = db().get_index_type<son_index>().indices().get<by_account>();
     const auto& son_obj = sidx.find(op.payer);
-    FC_ASSERT( son_obj != sidx.end() && db().is_son_active(son_obj->id), "Non active SON trying to update deposit address object" );
+    FC_ASSERT( son_obj != sidx.end() && db().is_son_active(op.sidechain, son_obj->id), "Non active SON trying to update deposit address object" );
     const auto& sdpke_idx = db().get_index_type<sidechain_address_index>().indices().get<by_sidechain_and_deposit_public_key_and_expires>();
     FC_ASSERT( op.deposit_address.valid() && op.deposit_public_key.valid() && op.deposit_address_data.valid(), "Update operation by SON is not valid");
     FC_ASSERT( (*op.deposit_address).length() > 0 && (*op.deposit_public_key).length() > 0 && (*op.deposit_address_data).length() > 0, "SON should create a valid deposit address with valid deposit public key");
@@ -106,10 +109,14 @@ void_result delete_sidechain_address_evaluator::do_apply(const sidechain_address
     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()) {
+       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

@@ -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::vector<son_sidechain_info> signers;
-      std::transform(op.signers.begin(), op.signers.end(), std::inserter(sto.signatures, sto.signatures.end()), [](const son_info &si) {
+      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

@@ -39,13 +39,28 @@ 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;
+    flat_map<sidechain_type, vote_id_type> vote_ids;
+
+    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);
+         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.vote_id = vote_id;
+        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;
@@ -94,7 +109,8 @@ object_id_type update_son_evaluator::do_apply(const son_update_operation& op)
            if(op.new_signing_key.valid()) so.signing_key = *op.new_signing_key;
            if(op.new_sidechain_public_keys.valid()) so.sidechain_public_keys = *op.new_sidechain_public_keys;
            if(op.new_pay_vb.valid()) so.pay_vb = *op.new_pay_vb;
-           if(so.status == son_status::deregistered) so.status = son_status::inactive;
+           for(auto& status : so.statuses)
+            if(status.second == son_status::deregistered) status.second = son_status::inactive;
        });
    }
    return op.son_id;
@@ -127,7 +143,8 @@ void_result deregister_son_evaluator::do_apply(const son_deregister_operation& o
        });
 
        db().modify(*son, [&op](son_object &so) {
-          so.status = son_status::deregistered;
+          for(auto& status : so.statuses)
+            status.second = son_status::deregistered;
        });
 
        auto stats_obj = ss_idx.find(son->statistics);
@@ -144,18 +161,28 @@ void_result son_heartbeat_evaluator::do_evaluate(const son_heartbeat_operation&
 { try {
     FC_ASSERT(db().head_block_time() >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK"); // can be removed after HF date pass
     const auto& idx = db().get_index_type<son_index>().indices().get<by_id>();
-    auto itr = idx.find(op.son_id);
+    const auto itr = idx.find(op.son_id);
     FC_ASSERT( itr != idx.end() );
     FC_ASSERT(itr->son_account == op.owner_account);
     auto stats = itr->statistics( db() );
     // Inactive SONs need not send heartbeats
-    FC_ASSERT((itr->status == son_status::active) || (itr->status == son_status::in_maintenance) || (itr->status == son_status::request_maintenance), "Inactive SONs need not send heartbeats");
+    bool status_need_to_send_heartbeats = false;
+    for(const auto& status : itr->statuses)
+    {
+       if( (status.second == son_status::active) || (status.second == son_status::in_maintenance) || (status.second == son_status::request_maintenance) )
+          status_need_to_send_heartbeats = true;
+    }
+    FC_ASSERT(status_need_to_send_heartbeats, "Inactive SONs need not send heartbeats");
     // Account for network delays
     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());
-    FC_ASSERT(op.ts > stats.last_active_timestamp, "Heartbeat sent without waiting minimum time");
+    for(const auto& active_sidechain_type : active_sidechain_types(db().head_block_time())) {
-    FC_ASSERT(op.ts > stats.last_down_timestamp, "Heartbeat sent is invalid can't be <= last down timestamp");
+      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))
+         FC_ASSERT(op.ts > stats.last_down_timestamp.at(active_sidechain_type), "Heartbeat sent for sidechain = ${sidechain} is invalid can't be <= last down timestamp", ("sidechain", active_sidechain_type));
+    }
     FC_ASSERT(op.ts >= min_ts, "Heartbeat ts is behind the min threshold");
     FC_ASSERT(op.ts <= max_ts, "Heartbeat ts is above the max threshold");
     return void_result();
@@ -164,46 +191,50 @@ void_result son_heartbeat_evaluator::do_evaluate(const son_heartbeat_operation&
 object_id_type son_heartbeat_evaluator::do_apply(const son_heartbeat_operation& op)
 { try {
     const auto& idx = db().get_index_type<son_index>().indices().get<by_id>();
-    auto itr = idx.find(op.son_id);
+    const auto itr = idx.find(op.son_id);
     if(itr != idx.end())
     {
         const global_property_object& gpo = db().get_global_properties();
+
+        for(const auto& active_sidechain_sons : gpo.active_sons) {
+           const auto& sidechain = active_sidechain_sons.first;
+           const auto& active_sons = active_sidechain_sons.second;
+
            vector<son_id_type> active_son_ids;
-        active_son_ids.reserve(gpo.active_sons.size());
+           active_son_ids.reserve(active_sons.size());
-        std::transform(gpo.active_sons.begin(), gpo.active_sons.end(),
+           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;
                           });
 
-        auto it_son = std::find(active_son_ids.begin(), active_son_ids.end(), op.son_id);
+           const auto it_son = std::find(active_son_ids.begin(), active_son_ids.end(), op.son_id);
            bool is_son_active = true;
 
            if (it_son == active_son_ids.end()) {
               is_son_active = false;
            }
 
-        if(itr->status == son_status::in_maintenance) {
+           if (itr->statuses.at(sidechain) == son_status::in_maintenance) {
-            db().modify( itr->statistics( db() ), [&]( son_statistics_object& sso )
+              db().modify(itr->statistics(db()), [&](son_statistics_object &sso) {
-            {
+                 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.current_interval_downtime += op.ts.sec_since_epoch() - sso.last_down_timestamp.sec_since_epoch();
+                 sso.last_active_timestamp[sidechain] = op.ts;
-                sso.last_active_timestamp = op.ts;
               });
 
-            db().modify(*itr, [&is_son_active](son_object &so) {
+              db().modify(*itr, [&is_son_active, &sidechain](son_object &so) {
                  if (is_son_active) {
-                    so.status = son_status::active;
+                    so.statuses[sidechain] = son_status::active;
                  } else {
-                    so.status = son_status::inactive;
+                    so.statuses[sidechain] = son_status::inactive;
                  }
               });
-        } else if ((itr->status == son_status::active) || (itr->status == son_status::request_maintenance)) {
+           } else if ((itr->statuses.at(sidechain) == son_status::active) || (itr->statuses.at(sidechain) == son_status::request_maintenance)) {
-            db().modify( itr->statistics( db() ), [&]( son_statistics_object& sso )
+              db().modify(itr->statistics(db()), [&](son_statistics_object &sso) {
-            {
+                 sso.last_active_timestamp[sidechain] = op.ts;
-                sso.last_active_timestamp = op.ts;
               });
            }
         }
+    }
     return op.son_id;
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 
@@ -213,30 +244,42 @@ void_result son_report_down_evaluator::do_evaluate(const son_report_down_operati
     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_index>().indices().get<by_id>();
     FC_ASSERT( idx.find(op.son_id) != idx.end() );
-    auto itr = idx.find(op.son_id);
+    const auto itr = idx.find(op.son_id);
-    auto stats = itr->statistics( db() );
+    const auto stats = itr->statistics( db() );
-    FC_ASSERT(itr->status == son_status::active || itr->status == son_status::request_maintenance, "Inactive/Deregistered/in_maintenance SONs cannot be reported on as down");
+    bool status_need_to_report_down = false;
-    FC_ASSERT(op.down_ts >= stats.last_active_timestamp, "down_ts should be greater than last_active_timestamp");
+    for(const auto& status : itr->statuses)
+    {
+       if( (status.second == son_status::active) || (status.second == son_status::request_maintenance) )
+          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(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) ) }
 
 object_id_type son_report_down_evaluator::do_apply(const son_report_down_operation& op)
 { try {
     const auto& idx = db().get_index_type<son_index>().indices().get<by_id>();
-    auto itr = idx.find(op.son_id);
+    const auto itr = idx.find(op.son_id);
     if(itr != idx.end())
     {
-        if ((itr->status == son_status::active) || (itr->status == son_status::request_maintenance)) {
+       for( const auto& status : itr->statuses ) {
-            db().modify( itr->statistics( db() ), [&]( son_statistics_object& sso )
+          const auto& sidechain = status.first;
-            {
+
-                sso.last_down_timestamp = op.down_ts;
+          if ((status.second == son_status::active) || (status.second == son_status::request_maintenance)) {
+             db().modify(*itr, [&sidechain](son_object &so) {
+                so.statuses[sidechain] = son_status::in_maintenance;
              });
 
-            db().modify(*itr, [&op](son_object &so) {
+             db().modify(itr->statistics(db()), [&](son_statistics_object &sso) {
-                so.status = son_status::in_maintenance;
+                sso.last_down_timestamp[sidechain] = op.down_ts;
              });
           }
        }
+    }
     return op.son_id;
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 
@@ -249,9 +292,19 @@ void_result son_maintenance_evaluator::do_evaluate(const son_maintenance_operati
     FC_ASSERT( itr != idx.end() );
     // Inactive SONs can't go to maintenance, toggle between active and request_maintenance states
     if(op.request_type == son_maintenance_request_type::request_maintenance) {
-        FC_ASSERT(itr->status == son_status::active, "Inactive SONs can't request for maintenance");
+       bool status_active = false;
+       for(const auto& status : itr->statuses) {
+          if( (status.second == son_status::active) )
+             status_active = true;
+       }
+       FC_ASSERT(status_active, "Inactive SONs can't request for maintenance");
     } else if(op.request_type == son_maintenance_request_type::cancel_request_maintenance) { 
-        FC_ASSERT(itr->status == son_status::request_maintenance, "Only maintenance requested SONs can cancel the request");
+          bool status_request_maintenance = false;
+          for(const auto& status : itr->statuses) {
+             if( (status.second == son_status::request_maintenance) )
+                status_request_maintenance = true;
+          }
+          FC_ASSERT(status_request_maintenance, "Only maintenance requested SONs can cancel the request");
     } else {
         FC_ASSERT(false, "Invalid maintenance operation");
     }
@@ -264,16 +317,34 @@ object_id_type son_maintenance_evaluator::do_apply(const son_maintenance_operati
     auto itr = idx.find(op.son_id);
     if(itr != idx.end())
     {
-        if(itr->status == son_status::active && op.request_type == son_maintenance_request_type::request_maintenance) {
+       bool status_active = false;
+       for(const auto& status : itr->statuses) {
+          if( (status.second == son_status::active) )
+             status_active = true;
+       }
+       if(status_active && op.request_type == son_maintenance_request_type::request_maintenance) {
           db().modify(*itr, [](son_object &so) {
-                so.status = son_status::request_maintenance;
+             for(auto& status : so.statuses) {
+                status.second = son_status::request_maintenance;
+             }
           });
-        } else if(itr->status == son_status::request_maintenance && op.request_type == son_maintenance_request_type::cancel_request_maintenance) {
+       }
+       else
+       {
+          bool status_request_maintenance = false;
+          for(const auto& status : itr->statuses) {
+             if( (status.second == son_status::request_maintenance) )
+                status_request_maintenance = true;
+          }
+          if(status_request_maintenance && op.request_type == son_maintenance_request_type::cancel_request_maintenance) {
              db().modify(*itr, [](son_object &so) {
-                so.status = son_status::active;
+               for(auto& status : so.statuses) {
+                  status.second = son_status::active;
+               }
              });
           }
        }
+    }
     return op.son_id;
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 

libraries/chain/son_object.cpp

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

@@ -23,9 +23,9 @@ void_result create_son_wallet_deposit_evaluator::do_evaluate(const son_wallet_de
    const auto &swdo_idx = db().get_index_type<son_wallet_deposit_index>().indices().get<by_sidechain_uid>();
    const auto swdo = swdo_idx.find(op.sidechain_uid);
    if (swdo == swdo_idx.end()) {
-      auto &gpo = db().get_global_properties();
+      const auto &gpo = db().get_global_properties();
       bool expected = false;
-      for (auto &si : gpo.active_sons) {
+      for (auto &si : gpo.active_sons.at(op.sidechain)) {
          if (op.son_id == si.son_id) {
             expected = true;
             break;
@@ -78,8 +78,8 @@ object_id_type create_son_wallet_deposit_evaluator::do_apply(const son_wallet_de
          swdo.peerplays_to = op.peerplays_to;
          swdo.peerplays_asset = op.peerplays_asset;
 
-         auto &gpo = db().get_global_properties();
+         const auto &gpo = db().get_global_properties();
-         for (auto &si : gpo.active_sons) {
+         for (auto &si : gpo.active_sons.at(op.sidechain)) {
             swdo.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);
@@ -142,11 +142,11 @@ void_result process_son_wallet_deposit_evaluator::do_evaluate(const son_wallet_d
 { 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(db().get_global_properties().active_sons.size() >= db().get_chain_properties().immutable_parameters.min_son_count, "Min required voted SONs not present");
 
    const auto& idx = db().get_index_type<son_wallet_deposit_index>().indices().get<by_id>();
    const auto& itr = idx.find(op.son_wallet_deposit_id);
    FC_ASSERT(itr != idx.end(), "Son wallet deposit 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->processed, "Son wallet deposit is already processed");
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }

libraries/chain/son_wallet_evaluator.cpp

@@ -7,7 +7,8 @@ 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");
+   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>();
@@ -16,12 +17,36 @@ 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) {
+         for( const auto& cur_wallet_sidechain_sons : cur_wallet_sons ) {
+            const auto& sidechain = cur_wallet_sidechain_sons.first;
+            const auto& _cur_wallet_sidechain_sons = cur_wallet_sidechain_sons.second;
+
+            son_sets_equal = son_sets_equal && (_cur_wallet_sidechain_sons.size() == new_wallet_sons.at(sidechain).size());
             if (son_sets_equal) {
                for (size_t i = 0; i < cur_wallet_sons.size(); i++) {
-            son_sets_equal = son_sets_equal && cur_wallet_sons.at(i) == new_wallet_sons.at(i);
+                  son_sets_equal = son_sets_equal && _cur_wallet_sidechain_sons.at(i) == new_wallet_sons.at(sidechain).at(i);
+               }
+            }
          }
       }
 
@@ -43,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) ) }
@@ -55,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");
@@ -65,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,15 +24,23 @@ 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()) {
-      auto &gpo = db().get_global_properties();
+      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) {
+      for (auto &si : gpo.active_sons.at(sidechain)) {
          if (op.son_id == si.son_id) {
             expected = true;
             break;
          }
       }
-      FC_ASSERT(expected, "Only active SON can create deposit");
+      FC_ASSERT(expected, "Only active SON can create withdraw");
    } else {
       bool exactly_the_same = true;
       exactly_the_same = exactly_the_same && (swwo->sidechain == op.sidechain);
@@ -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;
 
-         auto &gpo = db().get_global_properties();
+         const sidechain_type sidechain = [&op]{
-         for (auto &si : gpo.active_sons) {
+            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(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." );
-   FC_ASSERT(db().get_global_properties().active_sons.size() >= db().get_chain_properties().immutable_parameters.min_son_count, "Min required voted SONs not present");
 
    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(!(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/fc

@@ -1 +1 @@
-Subproject commit e7369949bea26f3201d8442ba78286a88df74762
+Subproject commit 156b0c4e41c9215eadb2af8009b05e0f38c16dda

libraries/net/core_messages.cpp

@@ -47,4 +47,3 @@ namespace graphene { namespace net {
   const core_message_type_enum get_current_connections_reply_message::type   = core_message_type_enum::get_current_connections_reply_message_type;
 
 } } // graphene::net
-

libraries/net/include/graphene/net/config.hpp

@@ -23,6 +23,8 @@
  */
 #pragma once
 
+#include <stddef.h>
+
 #define GRAPHENE_NET_PROTOCOL_VERSION                        106
 
 /**
@@ -110,3 +112,6 @@
 #define GRAPHENE_NET_MAX_NESTED_OBJECTS                      (250)
 
 #define MAXIMUM_PEERDB_SIZE 1000
+
+constexpr size_t MAX_BLOCKS_TO_HANDLE_AT_ONCE = 200;
+constexpr size_t MAX_SYNC_BLOCKS_TO_PREFETCH = 10 * MAX_BLOCKS_TO_HANDLE_AT_ONCE;

libraries/net/include/graphene/net/node.hpp

@@ -61,7 +61,7 @@ namespace graphene { namespace net {
    class node_delegate
    {
       public:
-         virtual ~node_delegate(){}
+         virtual ~node_delegate() = default;
 
          /**
           *  If delegate has the item, the network has no need to fetch it.
@@ -71,7 +71,9 @@ namespace graphene { namespace net {
          /**
           *  @brief Called when a new block comes in from the network
           *
+          *  @param blk_msg the message which contains the block
           *  @param sync_mode true if the message was fetched through the sync process, false during normal operation
+          *  @param contained_transaction_msg_ids container for the transactions to write back into
           *  @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
@@ -152,6 +154,8 @@ namespace graphene { namespace net {
 
          virtual uint32_t get_block_number(const item_hash_t& block_id) = 0;
 
+         virtual fc::time_point_sec get_last_known_hardfork_time() = 0;
+
          /**
           * 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()
@@ -193,7 +197,7 @@ namespace graphene { namespace net {
    {
       public:
         node(const std::string& user_agent);
-        ~node();
+        virtual ~node();
 
         void close();
 
@@ -211,11 +215,34 @@ namespace graphene { namespace net {
          */
         void      add_node( const fc::ip::endpoint& ep );
 
+        /*****
+         * @brief add a list of nodes to seed the p2p network
+         * @param seeds a vector of url strings
+         */
+        void add_seed_nodes( std::vector<std::string> seeds );
+
+        /****
+         * @brief add a node to seed the p2p network
+         * @param in the url as a string
+         */
+        void add_seed_node( const std::string& in);
+
         /**
          *  Attempt to connect to the specified endpoint immediately.
          */
         virtual void connect_to_endpoint( const fc::ip::endpoint& ep );
 
+        /**
+         * @brief Helper to convert a string to a collection of endpoints
+         *
+         * This converts a string (i.e. "bitshares.eu:665535" to a collection of endpoints.
+         * NOTE: Throws an exception if not in correct format or was unable to resolve URL.
+         *
+         * @param in the incoming string
+         * @returns a vector of endpoints
+         */
+        static std::vector<fc::ip::endpoint> resolve_string_to_ip_endpoints( const std::string& in );
+
         /**
          *  Specifies the network interface and port upon which incoming
          *  connections should be accepted.

libraries/net/include/graphene/net/peer_connection.hpp

@@ -62,6 +62,7 @@ namespace graphene { namespace net
     class peer_connection_delegate
     {
     public:
+      virtual ~peer_connection_delegate() = default;
       virtual void on_message(peer_connection* originating_peer,
                               const message& received_message) = 0;
       virtual void on_connection_closed(peer_connection* originating_peer) = 0;
@@ -125,7 +126,7 @@ namespace graphene { namespace net
          * it is sitting on the queue
          */
         virtual size_t get_size_in_queue() = 0;
-        virtual ~queued_message() {}
+        virtual ~queued_message() = default;
       };
 
       /* when you queue up a 'real_queued_message', a full copy of the message is
@@ -258,6 +259,8 @@ namespace graphene { namespace net
 
       uint32_t last_known_fork_block_number = 0;
 
+      fc::time_point_sec last_known_hardfork_time;
+
       fc::future<void> accept_or_connect_task_done;
 
       firewall_check_state_data *firewall_check_state = nullptr;

libraries/net/include/graphene/net/peer_database.hpp

@@ -97,7 +97,7 @@ namespace graphene { namespace net {
   {
   public:
     peer_database();
-    ~peer_database();
+    virtual ~peer_database();
 
     void open(const fc::path& databaseFilename);
     void close();

libraries/net/peer_database.cpp

@@ -50,7 +50,8 @@ namespace graphene { namespace net {
                                            indexed_by<ordered_non_unique<tag<last_seen_time_index>, 
                                                                          member<potential_peer_record, 
                                                                                 fc::time_point_sec, 
-                                                                                &potential_peer_record::last_seen_time> >,
+                                                                                &potential_peer_record::last_seen_time>,
+                                                                         std::greater<fc::time_point_sec> >,
                                                       hashed_unique<tag<endpoint_index>, 
                                                                     member<potential_peer_record, 
                                                                            fc::ip::endpoint, 

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;
+   void plugin_initialize( const boost::program_options::variables_map& options ) override;
-   virtual void plugin_startup() override;
+   void plugin_startup() override;
-   virtual void plugin_shutdown() 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/delayed_node/delayed_node_plugin.cpp

@@ -63,8 +63,24 @@ void delayed_node_plugin::plugin_set_program_options(bpo::options_description& c
 
 void delayed_node_plugin::connect()
 {
-   my->client_connection = std::make_shared<fc::rpc::websocket_api_connection>(my->client.connect(my->remote_endpoint), GRAPHENE_MAX_NESTED_OBJECTS);
+   fc::http::websocket_connection_ptr con;
+   try
+   {
+      con = my->client.connect(my->remote_endpoint);
+   }
+   catch( const fc::exception& e )
+   {
+      wlog("Error while connecting: ${e}", ("e", e.to_detail_string()));
+      connection_failed();
+      return;
+   }
+   my->client_connection = std::make_shared<fc::rpc::websocket_api_connection>(
+           con, GRAPHENE_NET_MAX_NESTED_OBJECTS );
    my->database_api = my->client_connection->get_remote_api<graphene::app::database_api>(0);
+   my->database_api->set_block_applied_callback([this]( const fc::variant& block_id )
+   {
+      fc::from_variant( block_id, my->last_received_remote_head, GRAPHENE_MAX_NESTED_OBJECTS );
+   } );
    my->client_connection_closed = my->client_connection->closed.connect([this] {
       connection_failed();
    });
@@ -73,7 +89,9 @@ void delayed_node_plugin::connect()
 void delayed_node_plugin::plugin_initialize(const boost::program_options::variables_map& options)
 {
    FC_ASSERT(options.count("trusted-node") > 0);
+   ilog("delayed_node_plugin:  plugin_initialize() begin");
    my->remote_endpoint = "ws://" + options.at("trusted-node").as<std::string>();
+   ilog("delayed_node_plugin:  plugin_initialize() end");
 }
 
 void delayed_node_plugin::sync_with_trusted_node()
@@ -100,8 +118,11 @@ void delayed_node_plugin::sync_with_trusted_node()
       while( remote_dpo.last_irreversible_block_num > db.head_block_num() )
       {
          fc::optional<graphene::chain::signed_block> block = my->database_api->get_block( db.head_block_num()+1 );
+         // TODO: during sync, decouple requesting blocks from preprocessing + applying them
          FC_ASSERT(block, "Trusted node claims it has blocks it doesn't actually have.");
          ilog("Pushing block #${n}", ("n", block->block_num()));
+         // timur: failed to merge from bitshares, API n/a in peerplays
+         // db.precompute_parallel( *block, graphene::chain::database::skip_nothing ).wait();
          db.push_block(*block);
          synced_blocks++;
       }
@@ -136,24 +157,12 @@ void delayed_node_plugin::plugin_startup()
       mainloop();
    });
 
-   try
-   {
    connect();
-      my->database_api->set_block_applied_callback([this]( const fc::variant& block_id )
-      {
-         fc::from_variant( block_id, my->last_received_remote_head, GRAPHENE_MAX_NESTED_OBJECTS );
-      } );
-      return;
-   }
-   catch (const fc::exception& e)
-   {
-      elog("Error during connection: ${e}", ("e", e.to_detail_string()));
-   }
-   fc::async([this]{connection_failed();});
 }
 
 void delayed_node_plugin::connection_failed()
 {
+   my->last_received_remote_head = my->last_processed_remote_head;
    elog("Connection to trusted node failed; retrying in 5 seconds...");
    fc::schedule([this]{connect();}, fc::time_point::now() + fc::seconds(5));
 }

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

@@ -3,9 +3,10 @@ file(GLOB_RECURSE HEADERS "include/graphene/peerplays_sidechain/*.hpp")
 add_library( peerplays_sidechain
              peerplays_sidechain_plugin.cpp
              sidechain_api.cpp
-             sidechain_net_manager.cpp
+             sidechain_net_handler_factory.cpp
              sidechain_net_handler.cpp
              sidechain_net_handler_bitcoin.cpp
+             sidechain_net_handler_ethereum.cpp
              sidechain_net_handler_hive.cpp
              sidechain_net_handler_peerplays.cpp
              bitcoin/bech32.cpp
@@ -15,8 +16,15 @@ 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
+             ethereum/decoders.cpp
+             ethereum/transaction.cpp
+             ethereum/types.cpp
+             ethereum/utils.cpp
              hive/asset.cpp
              hive/operations.cpp
              hive/transaction.cpp
@@ -36,7 +44,7 @@ endif()
 unset(ENABLE_PEERPLAYS_ASSET_DEPOSITS)
 unset(ENABLE_PEERPLAYS_ASSET_DEPOSITS CACHE)
 
-target_link_libraries( peerplays_sidechain PRIVATE curl graphene_plugin 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;
    }
+
+   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;
    }
+
+   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/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/bitcoin/sign_bitcoin_transaction.cpp

@@ -1,4 +1,5 @@
 #include <graphene/peerplays_sidechain/bitcoin/serialize.hpp>
+#include <secp256k1.h>
 
 #include <fc/io/raw.hpp>
 
@@ -6,8 +7,8 @@
 
 namespace graphene { namespace peerplays_sidechain { namespace bitcoin {
 
-const secp256k1_context_t *btc_context() {
+const secp256k1_context *btc_context() {
-   static secp256k1_context_t *ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN);
+   static secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN);
    return ctx;
 }
 
@@ -31,20 +32,14 @@ fc::sha256 get_signature_hash(const bitcoin_transaction &tx, const bytes &script
    return fc::sha256::hash(fc::sha256::hash(vec.data(), vec.size()));
 }
 
-std::vector<char> privkey_sign(const bytes &privkey, const fc::sha256 &hash, const secp256k1_context_t *context_sign) {
+std::vector<char> privkey_sign(const bytes &privkey, const fc::sha256 &hash, const secp256k1_context *context_sign) {
    bytes sig;
    sig.resize(72);
    int sig_len = sig.size();
 
-   FC_ASSERT(secp256k1_ecdsa_sign(
+   secp256k1_ecdsa_signature sign;
-         context_sign,
+   FC_ASSERT(secp256k1_ecdsa_sign(context_sign, &sign, (const unsigned char *)hash.data(), (const unsigned char *)privkey.data(), secp256k1_nonce_function_rfc6979, nullptr));
-         reinterpret_cast<unsigned char *>(hash.data()),
+   FC_ASSERT(secp256k1_ecdsa_signature_serialize_der(context_sign, (unsigned char *)sig.data(), (size_t *)&sig_len, &sign));
-         reinterpret_cast<unsigned char *>(sig.data()),
-         &sig_len,
-         reinterpret_cast<const unsigned char *>(privkey.data()),
-         secp256k1_nonce_function_rfc6979,
-         nullptr)); // TODO: replace assert with exception
-
    sig.resize(sig_len);
 
    return sig;
@@ -52,7 +47,7 @@ std::vector<char> privkey_sign(const bytes &privkey, const fc::sha256 &hash, con
 
 std::vector<bytes> sign_witness_transaction_part(const bitcoin_transaction &tx, const std::vector<bytes> &redeem_scripts,
                                                  const std::vector<uint64_t> &amounts, const bytes &privkey,
-                                                 const secp256k1_context_t *context_sign, int hash_type) {
+                                                 const secp256k1_context *context_sign, int hash_type) {
    FC_ASSERT(tx.vin.size() == redeem_scripts.size() && tx.vin.size() == amounts.size());
    FC_ASSERT(!privkey.empty());
 
@@ -77,17 +72,34 @@ void sign_witness_transaction_finalize(bitcoin_transaction &tx, const std::vecto
    }
 }
 
-bool verify_sig(const bytes &sig, const bytes &pubkey, const bytes &msg, const secp256k1_context_t *context) {
+bool verify_sig(const bytes &sig, const bytes &pubkey, const bytes &msg, const secp256k1_context *context) {
-   std::vector<unsigned char> sig_temp(sig.begin(), sig.end());
+   //! Get sig_temp
+   FC_ASSERT(sig.size() > 70);
+   FC_ASSERT(sig[0] == 0x30);
+   FC_ASSERT(sig[1] == static_cast<char>(sig.size() - 3));
+   FC_ASSERT(sig[2] == 0x02);
+   const uint r_size = sig[3];
+   std::vector<unsigned char> sig_temp(sig.begin() + 4 + (r_size - 32), sig.begin() + 4 + r_size);
+   FC_ASSERT(sig[4 + r_size] == 0x02);
+   const uint s_size = sig[5 + r_size];
+   FC_ASSERT(sig.size() == r_size + s_size + 7);
+   sig_temp.insert(sig_temp.end(), sig.begin() + 6 + r_size, sig.end());
+
    std::vector<unsigned char> pubkey_temp(pubkey.begin(), pubkey.end());
    std::vector<unsigned char> msg_temp(msg.begin(), msg.end());
 
-   int result = secp256k1_ecdsa_verify(context, msg_temp.data(), sig_temp.data(), sig_temp.size(), pubkey_temp.data(), pubkey_temp.size());
+   secp256k1_pubkey pub_key;
+   FC_ASSERT(secp256k1_ec_pubkey_parse(context, &pub_key, (const unsigned char *)pubkey_temp.data(), pubkey_temp.size()));
+
+   secp256k1_ecdsa_signature sign;
+   FC_ASSERT(secp256k1_ecdsa_signature_parse_compact(context, &sign, (const unsigned char *)sig_temp.data()));
+
+   int result = secp256k1_ecdsa_verify(context, &sign, (const unsigned char *)msg_temp.data(), &pub_key);
    return result == 1;
 }
 
 std::vector<std::vector<bytes>> sort_sigs(const bitcoin_transaction &tx, const std::vector<bytes> &redeem_scripts,
-                                          const std::vector<uint64_t> &amounts, const secp256k1_context_t *context) {
+                                          const std::vector<uint64_t> &amounts, const secp256k1_context *context) {
    FC_ASSERT(redeem_scripts.size() == amounts.size());
 
    using data = std::pair<size_t, bytes>;

libraries/plugins/peerplays_sidechain/common/utils.cpp

@@ -1,8 +1,64 @@
 #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>
+
+namespace graphene { namespace peerplays_sidechain {
+
+const std::string base64_padding[] = {"", "==", "="};
+
+std::string base64_encode(const std::string &s) {
+   using namespace boost::archive::iterators;
+
+   typedef base64_from_binary<transform_width<const char *, 6, 8>> base64_enc;
+
+   std::stringstream os;
+   std::copy(base64_enc(s.c_str()), base64_enc(s.c_str() + s.size()), std::ostream_iterator<char>(os));
+   os << base64_padding[s.size() % 3];
+
+   return os.str();
+}
+
+std::string base64_decode(const std::string &s) {
+   using namespace boost::archive::iterators;
+
+   typedef transform_width<binary_from_base64<const char *>, 8, 6> base64_dec;
+
+   std::stringstream os;
+   unsigned int size = s.size();
+   if (size && s[size - 1] == '=') {
+      --size;
+      if (size && s[size - 1] == '=')
+         --size;
+   }
+   if (size == 0)
+      return std::string();
+
+   std::copy(base64_dec(s.data()), base64_dec(s.data() + size), std::ostream_iterator<char>(os));
+
+   return os.str();
+}
+
 std::string object_id_to_string(graphene::chain::object_id_type id) {
    std::string object_id = fc::to_string(id.space()) + "." +
                            fc::to_string(id.type()) + "." +
                            fc::to_string(id.instance());
    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

@@ -0,0 +1,267 @@
+#include <graphene/peerplays_sidechain/ethereum/decoders.hpp>
+
+#include <fc/exception/exception.hpp>
+#include <graphene/peerplays_sidechain/ethereum/utils.hpp>
+
+namespace graphene { namespace peerplays_sidechain { namespace ethereum {
+
+//! 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,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
+       -1, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+}
+
+std::vector<std::string> rlp_decoder::decode(const std::string &str) {
+   size_t consumed = 0;
+   const auto raw_vec = parse_hex(str);
+   const std::vector<std::string> rlp_array = decode_rlp(raw_vec.data(), raw_vec.size(), consumed);
+   std::vector<std::string> result_array;
+   for (const auto &rlp : decode_rlp(raw_vec.data(), raw_vec.size(), consumed)) {
+      result_array.emplace_back(bytes2hex(rlp));
+   }
+   return result_array;
+}
+
+std::vector<std::string> rlp_decoder::decode_rlp(const unsigned char *raw, size_t len, size_t &consumed) {
+   std::vector<std::string> rlp_result;
+
+   consumed = 0;
+
+   const unsigned char *end = raw + len;
+   const size_t prefixlen = 1;
+   unsigned char ch = *raw;
+
+   if (len < 1) {
+      return rlp_result;
+   }
+
+   // Case 1: [prefix is 1-byte data buffer]
+   if (ch <= 0x7f) {
+      const unsigned char *tok_start = raw;
+      const unsigned char *tok_end = tok_start + prefixlen;
+      FC_ASSERT(tok_end <= end);
+
+      // parsing done; assign data buffer value.
+      const std::vector<unsigned char> buf{tok_start, tok_end};
+      rlp_result.emplace_back(buf.cbegin(), buf.cend());
+
+      consumed = buf.size();
+   }
+   // Case 2: [prefix, including buffer length][data]
+   else if ((ch >= 0x80) && (ch <= 0xb7)) {
+      const size_t blen = ch - 0x80;
+      const size_t expected = prefixlen + blen;
+
+      if (len < expected)
+         return std::vector<std::string>{};
+
+      const unsigned char *tok_start = raw + 1;
+      const unsigned char *tok_end = tok_start + blen;
+      FC_ASSERT(tok_end <= end);
+
+      // require minimal encoding
+      if ((blen == 1) && (tok_start[0] <= 0x7f))
+         return std::vector<std::string>{};
+
+      // parsing done; assign data buffer value.
+      const std::vector<unsigned char> buf{tok_start, tok_end};
+      rlp_result.emplace_back(buf.cbegin(), buf.cend());
+
+      consumed = expected;
+   }
+   // Case 3: [prefix][buffer length][data]
+   else if ((ch >= 0xb8) && (ch <= 0xbf)) {
+      const size_t uintlen = ch - 0xb7;
+      size_t expected = prefixlen + uintlen;
+
+      if (len < expected)
+         return std::vector<std::string>{};
+
+      FC_ASSERT(uintlen > 0 && uintlen <= RLP_maxUintLen);
+
+      const unsigned char *tok_start = raw + prefixlen;
+      if ((uintlen > 1) && (tok_start[0] == 0)) // no leading zeroes
+         return std::vector<std::string>{};
+
+      // read buffer length
+      const uint64_t slen = to_int(tok_start, uintlen);
+
+      // validate buffer length, including possible addition overflows.
+      expected = prefixlen + uintlen + slen;
+      if ((slen < (RLP_listStart - RLP_bufferLenStart - RLP_maxUintLen)) || (expected > len) || (slen > len))
+         return std::vector<std::string>{};
+
+      // parsing done; assign data buffer value.
+      tok_start = raw + prefixlen + uintlen;
+      const unsigned char *tok_end = tok_start + slen;
+      const std::vector<unsigned char> buf{tok_start, tok_end};
+      rlp_result.emplace_back(buf.cbegin(), buf.cend());
+
+      consumed = expected;
+   }
+   // Case 4: [prefix][list]
+   else if ((ch >= 0xc0) && (ch <= 0xf7)) {
+      const size_t payloadlen = ch - 0xc0;
+      const size_t expected = prefixlen + payloadlen;
+
+      // read list payload
+      const auto array = decode_array(raw, len, 0, payloadlen);
+      rlp_result.insert(rlp_result.end(), array.cbegin(), array.cend());
+
+      consumed = expected;
+   }
+   // Case 5: [prefix][list length][list]
+   else {
+      FC_ASSERT((ch >= 0xf8) && (ch <= 0xff));
+
+      const size_t uintlen = ch - 0xf7;
+      const size_t expected = prefixlen + uintlen;
+
+      if (len < expected)
+         return std::vector<std::string>{};
+
+      FC_ASSERT(uintlen > 0 && uintlen <= RLP_maxUintLen);
+
+      const unsigned char *tok_start = raw + prefixlen;
+      if ((uintlen > 1) && (tok_start[0] == 0)) // no leading zeroes
+         return std::vector<std::string>{};
+
+      // read list length
+      const size_t payloadlen = to_int(tok_start, uintlen);
+
+      // special requirement for non-immediate length
+      if (payloadlen < (0x100 - RLP_listStart - RLP_maxUintLen))
+         return std::vector<std::string>{};
+
+      // read list payload
+      const auto array = decode_array(raw, len, uintlen, payloadlen);
+      rlp_result.insert(rlp_result.end(), array.cbegin(), array.cend());
+
+      consumed = prefixlen + uintlen + payloadlen;
+   }
+
+   return rlp_result;
+}
+
+std::vector<std::string> rlp_decoder::decode_array(const unsigned char *raw, size_t len, size_t uintlen, size_t payloadlen) {
+   std::vector<std::string> rlp_result;
+   const size_t prefixlen = 1;
+
+   // validate list length, including possible addition overflows.
+   const size_t expected = prefixlen + uintlen + payloadlen;
+   if ((expected > len) || (payloadlen > len))
+      return std::vector<std::string>{};
+
+   size_t child_len = payloadlen;
+   const unsigned char *list_ent = raw + prefixlen + uintlen;
+
+   // recursively read until payloadlen bytes parsed, or error
+   while (child_len > 0) {
+      size_t child_consumed = 0;
+
+      const auto val = decode_rlp(list_ent, child_len, child_consumed);
+      rlp_result.insert(rlp_result.end(), val.cbegin(), val.cend());
+
+      list_ent += child_consumed;
+      child_len -= child_consumed;
+   }
+
+   return rlp_result;
+}
+
+uint64_t rlp_decoder::to_int(const unsigned char *raw, size_t len) {
+   if (len == 0)
+      return 0;
+   else if (len == 1)
+      return *raw;
+   else
+      return (raw[len - 1]) + (to_int(raw, len - 1) * 256);
+}
+
+std::vector<unsigned char> rlp_decoder::parse_hex(const std::string &str) {
+   return parse_hex(str.c_str());
+}
+
+std::vector<unsigned char> rlp_decoder::parse_hex(const char *psz) {
+   // convert hex dump to vector
+   std::vector<unsigned char> vch;
+   while (true) {
+      while (isspace(*psz))
+         psz++;
+      signed char c = hex_digit(*psz++);
+      if (c == (signed char)-1)
+         break;
+      unsigned char n = (c << 4);
+      c = hex_digit(*psz++);
+      if (c == (signed char)-1)
+         break;
+      n |= c;
+      vch.push_back(n);
+   }
+   return vch;
+}
+
+signed char rlp_decoder::hex_digit(char c) {
+   return p_util_hexdigit[(unsigned char)c];
+}
+
+}}} // namespace graphene::peerplays_sidechain::ethereum

libraries/plugins/peerplays_sidechain/ethereum/encoders.cpp

@@ -0,0 +1,171 @@
+#include <graphene/peerplays_sidechain/ethereum/encoders.hpp>
+
+#include <boost/algorithm/hex.hpp>
+#include <boost/format.hpp>
+
+#include <graphene/peerplays_sidechain/ethereum/utils.hpp>
+
+namespace graphene { namespace peerplays_sidechain { namespace ethereum {
+
+//! base_encoder
+std::string base_encoder::encode_uint256(boost::multiprecision::uint256_t value) {
+   return (boost::format("%x") % boost::io::group(std::setw(64), std::setfill('0'), value)).str();
+}
+
+std::string base_encoder::encode_address(const std::string &value) {
+   return (boost::format("%x") % boost::io::group(std::setw(64), std::setfill('0'), value)).str();
+}
+
+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);
+   if (value.size() % 32 != 0) {
+      data += std::string((64 - value.size() * 2 % 64), '0');
+   }
+   return data;
+}
+
+//! update_owners_encoder
+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());
+   for (const auto &owner : owners_weights) {
+      data += base_encoder::encode_address(owner.first);
+      data += base_encoder::encode_uint256(owner.second);
+   }
+   data += base_encoder::encode_string(object_id);
+
+   return data;
+}
+
+//! withdrawal_encoder
+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);
+   data += base_encoder::encode_string(object_id);
+
+   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));
+}
+
+std::string rlp_encoder::encode_length(int len, int offset) {
+   if (len < 56) {
+      std::string temp;
+      temp = (char)(len + offset);
+      return temp;
+   } else {
+      const std::string hexLength = to_hex(len);
+      const int lLength = hexLength.size() / 2;
+      const std::string fByte = to_hex(offset + 55 + lLength);
+      return hex2bytes(fByte + hexLength);
+   }
+}
+
+std::string rlp_encoder::hex2bytes(const std::string &s) {
+   std::string dest;
+   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;
+}
+
+std::string rlp_encoder::encode_rlp(const std::string &s) {
+   if (s.size() == 1 && (unsigned char)s[0] < 128)
+      return s;
+   else
+      return encode_length(s.size(), 128) + s;
+}
+
+int rlp_encoder::char2int(char input) {
+   if (input >= '0' && input <= '9')
+      return input - '0';
+   if (input >= 'A' && input <= 'F')
+      return input - 'A' + 10;
+   if (input >= 'a' && input <= 'f')
+      return input - 'a' + 10;
+
+   return -1;
+}
+
+void rlp_encoder::hex2bin(const char *src, char *target) {
+   while (*src && src[1]) {
+      *(target++) = char2int(*src) * 16 + char2int(src[1]);
+      src += 2;
+   }
+}
+
+}}} // namespace graphene::peerplays_sidechain::ethereum

libraries/plugins/peerplays_sidechain/ethereum/transaction.cpp

@@ -0,0 +1,243 @@
+#include <graphene/peerplays_sidechain/ethereum/transaction.hpp>
+
+#include <boost/algorithm/hex.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
+
+#include <secp256k1_recovery.h>
+#include <sha3/sha3.h>
+
+#include <fc/crypto/elliptic.hpp>
+#include <fc/crypto/hex.hpp>
+
+#include <graphene/peerplays_sidechain/ethereum/decoders.hpp>
+#include <graphene/peerplays_sidechain/ethereum/encoders.hpp>
+#include <graphene/peerplays_sidechain/ethereum/utils.hpp>
+
+namespace graphene { namespace peerplays_sidechain { namespace ethereum {
+
+const secp256k1_context *eth_context() {
+   static secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN);
+   return ctx;
+}
+
+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) {
+}
+
+//! transaction
+
+transaction::transaction(const std::string &raw_tx) :
+      base_transaction{raw_tx} {
+   deserialize(raw_tx);
+}
+
+const transaction &transaction::sign(const std::string &private_key) const {
+   return *this;
+}
+
+std::string transaction::serialize() const {
+   boost::property_tree::ptree pt;
+   pt.put("from", from);
+   pt.put("to", to);
+   pt.put("data", data);
+
+   std::stringstream ss;
+   boost::property_tree::json_parser::write_json(ss, pt);
+   return ss.str();
+}
+
+void transaction::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("from"))
+      from = tx_json.get<std::string>("from");
+   if (tx_json.count("to"))
+      to = tx_json.get<std::string>("to");
+   if (tx_json.count("data"))
+      data = tx_json.get<std::string>("data");
+}
+
+//! raw_transaction
+
+raw_transaction::raw_transaction(const std::string &raw_tx) :
+      base_transaction{raw_tx} {
+   deserialize(raw_tx);
+}
+
+bytes raw_transaction::hash() const {
+   return keccak_hash(serialize());
+}
+
+signed_transaction raw_transaction::sign(const std::string &private_key) const {
+   //! Prepare signed transaction
+   signed_transaction tr;
+   tr.nonce = nonce;
+   tr.gas_price = gas_price;
+   tr.gas_limit = gas_limit;
+   tr.to = to;
+   tr.value = value;
+   tr.data = data;
+
+   const auto sig = sign_hash(hash(), chain_id, private_key);
+   tr.v = sig.v;
+   tr.r = sig.r;
+   tr.s = sig.s;
+
+   return tr;
+}
+
+std::string raw_transaction::serialize() const {
+   const std::string serialized = rlp_encoder::encode(remove_0x(nonce)) +
+                                  rlp_encoder::encode(remove_0x(gas_price)) +
+                                  rlp_encoder::encode(remove_0x(gas_limit)) +
+                                  rlp_encoder::encode(remove_0x(to)) +
+                                  rlp_encoder::encode(remove_0x(value)) +
+                                  rlp_encoder::encode(remove_0x(data)) +
+                                  rlp_encoder::encode(remove_0x(chain_id)) +
+                                  rlp_encoder::encode("") +
+                                  rlp_encoder::encode("");
+
+   return add_0x(bytes2hex(rlp_encoder::encode_length(serialized.size(), 192) + serialized));
+}
+
+void raw_transaction::deserialize(const std::string &raw_tx) {
+   const auto rlp_array = rlp_decoder::decode(remove_0x(raw_tx));
+   FC_ASSERT(rlp_array.size() >= 7, "Wrong rlp format");
+
+   nonce = !rlp_array.at(0).empty() ? add_0x(rlp_array.at(0)) : add_0x("0");
+   boost::algorithm::to_lower(nonce);
+   gas_price = add_0x(rlp_array.at(1));
+   boost::algorithm::to_lower(gas_price);
+   gas_limit = add_0x(rlp_array.at(2));
+   boost::algorithm::to_lower(gas_limit);
+   to = add_0x(rlp_array.at(3));
+   boost::algorithm::to_lower(to);
+   value = !rlp_array.at(4).empty() ? add_0x(rlp_array.at(4)) : add_0x("0");
+   boost::algorithm::to_lower(value);
+   data = !rlp_array.at(5).empty() ? add_0x(rlp_array.at(5)) : "";
+   boost::algorithm::to_lower(data);
+   chain_id = add_0x(rlp_array.at(6));
+   boost::algorithm::to_lower(chain_id);
+}
+
+//! signed_transaction
+
+signed_transaction::signed_transaction(const std::string &raw_tx) :
+      base_transaction{raw_tx} {
+   deserialize(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);
+   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;
+   FC_ASSERT(secp256k1_ecdsa_recoverable_signature_parse_compact(eth_context(), &sig, (const unsigned char *)&input64.data[1], recid));
+
+   raw_transaction tr;
+   tr.nonce = nonce;
+   tr.gas_price = gas_price;
+   tr.gas_limit = gas_limit;
+   tr.to = to;
+   tr.value = value;
+   tr.data = data;
+   tr.chain_id = chain_id;
+
+   secp256k1_pubkey rawPubkey;
+   FC_ASSERT(secp256k1_ecdsa_recover(eth_context(), &rawPubkey, &sig, (const unsigned char *)tr.hash().data()));
+
+   std::array<uint8_t, 65> pubkey;
+   size_t biglen = 65;
+   FC_ASSERT(secp256k1_ec_pubkey_serialize(eth_context(), pubkey.data(), &biglen, &rawPubkey, SECP256K1_EC_UNCOMPRESSED));
+
+   const std::string out = std::string(pubkey.begin(), pubkey.end()).substr(1);
+   bytes hash;
+   hash.resize(32);
+   keccak_256((const unsigned char *)out.data(), out.size(), (unsigned char *)hash.data());
+
+   return add_0x(fc::to_hex((char *)&hash[0], hash.size()).substr(24));
+}
+
+std::string signed_transaction::serialize() const {
+   const std::string serialized = rlp_encoder::encode(remove_0x(nonce)) +
+                                  rlp_encoder::encode(remove_0x(gas_price)) +
+                                  rlp_encoder::encode(remove_0x(gas_limit)) +
+                                  rlp_encoder::encode(remove_0x(to)) +
+                                  rlp_encoder::encode(remove_0x(value)) +
+                                  rlp_encoder::encode(remove_0x(data)) +
+                                  rlp_encoder::encode(remove_0x(v)) +
+                                  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));
+}
+
+void signed_transaction::deserialize(const std::string &raw_tx) {
+   const auto rlp_array = rlp_decoder::decode(remove_0x(raw_tx));
+   FC_ASSERT(rlp_array.size() >= 9, "Wrong rlp format");
+
+   nonce = !rlp_array.at(0).empty() ? add_0x(rlp_array.at(0)) : add_0x("0");
+   boost::algorithm::to_lower(nonce);
+   gas_price = add_0x(rlp_array.at(1));
+   boost::algorithm::to_lower(gas_price);
+   gas_limit = add_0x(rlp_array.at(2));
+   boost::algorithm::to_lower(gas_limit);
+   to = add_0x(rlp_array.at(3));
+   boost::algorithm::to_lower(to);
+   value = !rlp_array.at(4).empty() ? add_0x(rlp_array.at(4)) : add_0x("0");
+   boost::algorithm::to_lower(value);
+   data = !rlp_array.at(5).empty() ? add_0x(rlp_array.at(5)) : "";
+   boost::algorithm::to_lower(data);
+   v = add_0x(rlp_array.at(6));
+   boost::algorithm::to_lower(v);
+   r = add_0x(add_leading_00(rlp_array.at(7)));
+   boost::algorithm::to_lower(r);
+   s = add_0x(add_leading_00(rlp_array.at(8)));
+   boost::algorithm::to_lower(s);
+}
+
+}}} // namespace graphene::peerplays_sidechain::ethereum

libraries/plugins/peerplays_sidechain/ethereum/types.cpp

@@ -0,0 +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

@@ -0,0 +1,72 @@
+#include <graphene/peerplays_sidechain/ethereum/utils.hpp>
+
+#include <fc/crypto/hex.hpp>
+
+namespace graphene { namespace peerplays_sidechain { namespace ethereum {
+
+bytes parse_hex(const std::string &str) {
+   bytes vec(str.size() / 2);
+   fc::from_hex(str, vec.data(), vec.size());
+   return vec;
+}
+
+std::string bytes2hex(const std::string &s) {
+   std::string dest;
+   for (const auto &i : s)
+      dest += uchar2Hex((unsigned char)i);
+
+   return dest;
+}
+
+std::string uchar2Hex(unsigned char n) {
+   std::string dest;
+   dest.resize(2);
+   sprintf(&dest[0], "%X", n);
+
+   if (n < (unsigned char)16) {
+      dest[1] = dest[0];
+      dest[0] = '0';
+   }
+
+   return dest;
+}
+
+std::string add_0x(const std::string &s) {
+   if (s.size() > 1) {
+      if (s.substr(0, 2) == "0x")
+         return s;
+   }
+
+   return "0x" + s;
+}
+
+std::string remove_0x(const std::string &s) {
+   if (s.size() > 1) {
+      if (s.substr(0, 2) == "0x")
+         return s.substr(2);
+   }
+
+   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/sign_bitcoin_transaction.hpp

@@ -8,23 +8,23 @@ namespace graphene { namespace peerplays_sidechain { namespace bitcoin {
 
 class bitcoin_transaction;
 
-const secp256k1_context_t *btc_context();
+const secp256k1_context *btc_context();
 
 fc::sha256 get_signature_hash(const bitcoin_transaction &tx, const bytes &scriptPubKey, int64_t amount,
                               size_t in_index, int hash_type, bool is_witness);
 
-std::vector<char> privkey_sign(const bytes &privkey, const fc::sha256 &hash, const secp256k1_context_t *context_sign = nullptr);
+std::vector<char> privkey_sign(const bytes &privkey, const fc::sha256 &hash, const secp256k1_context *context_sign = nullptr);
 
 std::vector<bytes> sign_witness_transaction_part(const bitcoin_transaction &tx, const std::vector<bytes> &redeem_scripts,
                                                  const std::vector<uint64_t> &amounts, const bytes &privkey,
-                                                 const secp256k1_context_t *context_sign = nullptr, int hash_type = 1);
+                                                 const secp256k1_context *context_sign = nullptr, int hash_type = 1);
 
 void sign_witness_transaction_finalize(bitcoin_transaction &tx, const std::vector<bytes> &redeem_scripts, bool use_mulisig_workaround = true);
 
-bool verify_sig(const bytes &sig, const bytes &pubkey, const bytes &msg, const secp256k1_context_t *context);
+bool verify_sig(const bytes &sig, const bytes &pubkey, const bytes &msg, const secp256k1_context *context);
 
 std::vector<std::vector<bytes>> sort_sigs(const bitcoin_transaction &tx, const std::vector<bytes> &redeem_scripts,
-                                          const std::vector<uint64_t> &amounts, const secp256k1_context_t *context);
+                                          const std::vector<uint64_t> &amounts, const secp256k1_context *context);
 
 void add_signatures_to_transaction_multisig(bitcoin_transaction &tx, std::vector<std::vector<bytes>> &signature_set);
 

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,134 +3,52 @@
 #include <cstdint>
 #include <string>
 
-#include <boost/asio.hpp>
+#include <fc/thread/future.hpp>
-#include <boost/asio/ssl.hpp>
+#include <fc/thread/thread.hpp>
 
-//#include <fc/network/http/connection.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/beast/core.hpp>
+
+#include <graphene/peerplays_sidechain/defs.hpp>
 
 namespace graphene { namespace peerplays_sidechain {
 
-enum class url_schema_type { unknown,
+class rpc_connection;
-                             http,
+
-                             https,
+struct rpc_credentials {
+   std::string url;
+   std::string user;
+   std::string password;
 };
 
-// utl
-
-url_schema_type identify_url_schema_type(const std::string &schema_name);
-
-struct url_data {
-
-   url_schema_type schema_type;
-   std::string schema;
-   std::string host;
-   uint16_t port;
-   std::string path;
-
-   url_data() :
-         schema_type(url_schema_type::unknown),
-         port(0) {
-   }
-
-   url_data(const std::string &url);
-
-   void clear();
-
-   bool parse(const std::string &url);
-};
-
-struct http_request {
-
-   std::string body;
-   std::string content_type;
-
-   http_request(const std::string &body_, const std::string &content_type_) :
-         body(body_),
-         content_type(content_type_) {
-   }
-};
-
-struct http_response {
-
-   uint16_t status_code;
-   std::string body;
-
-   void clear() {
-      status_code = 0;
-      body = decltype(body)();
-   }
-};
-
-namespace detail {
-template <class>
-class http_call_impl;
-class tcp_socket;
-class ssl_socket;
-} // namespace detail
-
-class http_call {
-public:
-   http_call(const url_data &url, const std::string &method = std::string(), const std::string &headers = std::string());
-   ~http_call();
-
-   bool is_ssl() const;
-
-   const std::string &path() const;
-   void set_path(const std::string &path);
-   void set_method(const std::string &method);
-   void set_headers(const std::string &headers);
-   const std::string &host() const;
-   void set_host(const std::string &host);
-
-   uint16_t port() const;
-   void set_port(uint16_t port);
-
-   bool exec(const http_request &request, http_response *response);
-
-   const std::string &error_what() const;
-
-private:
-   template <class>
-   friend class detail::http_call_impl;
-   friend detail::tcp_socket;
-   friend detail::ssl_socket;
-   static constexpr auto response_size_limit_bytes = 16 * 1024 * 1024;
-   static constexpr auto response_first_alloc_bytes = 32 * 1024;
-   static constexpr auto response_next_alloc_bytes = 256 * 1024;
-   std::string m_host;
-   uint16_t m_port_default;
-   uint16_t m_port;
-   std::string m_path;
-   std::string m_method;
-   std::string m_headers;
-   std::string m_error_what;
-
-   boost::asio::io_service m_service;
-   boost::asio::ssl::context *m_context;
-   boost::asio::ip::tcp::endpoint m_endpoint;
-
-   void ctor_priv();
-};
-
-}} // namespace graphene::peerplays_sidechain
-
-namespace graphene { namespace peerplays_sidechain {
-
 class rpc_client {
 public:
-   rpc_client(const std::string &url, const std::string &user_name, const std::string &password, bool debug);
+   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);
+   bool debug_rpc_calls;
-   std::string retrieve_value_from_reply(std::string reply_str, std::string value_path);
+   bool simulate_connection_reselection;
    std::string send_post_request(std::string method, std::string params, bool show_log);
 
-   bool debug_rpc_calls;
+   static std::string send_post_request(rpc_connection &conn, std::string method, std::string params, bool show_log);
-   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:
-   http_call client;
+   std::vector<rpc_connection *> connections;
-   http_response send_post_request(const std::string &body, bool show_log);
+   int n_active_conn;
+   fc::future<void> connection_selection_task;
+   std::mutex conn_mutex;
+
+   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

@@ -2,4 +2,12 @@
 
 #include <graphene/chain/protocol/asset.hpp>
 
+namespace graphene { namespace peerplays_sidechain {
+
+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

@@ -0,0 +1,49 @@
+#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 {
+      RLP_maxUintLen = 8,
+      RLP_bufferLenStart = 0x80,
+      RLP_listStart = 0xc0,
+   };
+
+public:
+   static std::vector<std::string> decode(const std::string &str);
+
+private:
+   static std::vector<std::string> decode_rlp(const unsigned char *raw, size_t len, size_t &consumed);
+   static std::vector<std::string> decode_array(const unsigned char *raw, size_t len, size_t uintlen, size_t payloadlen);
+   static uint64_t to_int(const unsigned char *raw, size_t len);
+   static std::vector<unsigned char> parse_hex(const std::string &str);
+   static std::vector<unsigned char> parse_hex(const char *psz);
+   static signed char hex_digit(char c);
+};
+
+}}} // namespace graphene::peerplays_sidechain::ethereum

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

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <boost/multiprecision/cpp_int.hpp>
+#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);
+   static std::string encode_address(const std::string &value);
+   static std::string encode_string(const std::string &value);
+};
+
+class update_owners_encoder {
+public:
+   static const std::string function_signature;
+
+   static std::string encode(const std::vector<std::pair<std::string, uint16_t>> &owners_weights, const std::string &object_id);
+};
+
+class withdrawal_encoder {
+public:
+   static const std::string function_signature;
+
+   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 {
+public:
+   static std::string encode(const std::string &s);
+   static std::string encode_length(int len, int offset);
+   static std::string hex2bytes(const std::string &s);
+
+private:
+   static std::string encode_rlp(const std::string &s);
+   static int char2int(char input);
+   static void hex2bin(const char *src, char *target);
+};
+
+}}} // namespace graphene::peerplays_sidechain::ethereum

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

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include <graphene/peerplays_sidechain/ethereum/types.hpp>
+
+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;
+   base_transaction(const std::string &raw_tx);
+
+   virtual std::string serialize() const = 0;
+   virtual void deserialize(const std::string &raw_tx) = 0;
+};
+
+class transaction : base_transaction {
+public:
+   std::string from;
+   std::string to;
+   std::string data;
+
+   transaction() = default;
+   transaction(const std::string &raw_tx);
+
+   const transaction &sign(const std::string &private_key) const;
+
+   virtual std::string serialize() const override;
+   virtual void deserialize(const std::string &raw_tx) override;
+};
+
+class signed_transaction;
+class raw_transaction : base_transaction {
+public:
+   std::string nonce;
+   std::string gas_price;
+   std::string gas_limit;
+   std::string to;
+   std::string value;
+   std::string data;
+   std::string chain_id;
+
+   raw_transaction() = default;
+   raw_transaction(const std::string &raw_tx);
+
+   bytes hash() const;
+   signed_transaction sign(const std::string &private_key) const;
+
+   virtual std::string serialize() const override;
+   virtual void deserialize(const std::string &raw_tx) override;
+};
+
+class signed_transaction : base_transaction {
+public:
+   std::string nonce;
+   std::string gas_price;
+   std::string gas_limit;
+   std::string to;
+   std::string value;
+   std::string data;
+   std::string v;
+   std::string r;
+   std::string s;
+
+   signed_transaction() = default;
+   signed_transaction(const std::string &raw_tx);
+
+   std::string recover(const std::string &chain_id) const;
+
+   virtual std::string serialize() const override;
+   virtual void deserialize(const std::string &raw_tx) override;
+};
+
+}}} // namespace graphene::peerplays_sidechain::ethereum

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <boost/multiprecision/cpp_int.hpp>
+
+namespace graphene { namespace peerplays_sidechain { namespace ethereum {
+
+typedef uint64_t chain_id_type;
+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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <graphene/peerplays_sidechain/ethereum/types.hpp>
+
+namespace graphene { namespace peerplays_sidechain { namespace ethereum {
+
+bytes parse_hex(const std::string &str);
+
+std::string bytes2hex(const std::string &s);
+
+std::string uchar2Hex(unsigned char n);
+
+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, bool add_front_zero = true) {
+   std::stringstream stream;
+   stream << std::hex << val;
+   std::string result(stream.str());
+   if (add_front_zero) {
+      if (result.size() % 2)
+         result = "0" + result;
+   }
+   return result;
+}
+
+template <typename T>
+T from_hex(const std::string &s) {
+   T val;
+   std::stringstream stream;
+   stream << std::hex << s;
+   stream >> val;
+
+   return val;
+}
+
+}}} // namespace graphene::peerplays_sidechain::ethereum

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

@@ -13,16 +13,18 @@ class peerplays_sidechain_plugin_impl;
 }
 
 struct son_proposal_type {
-   son_proposal_type(int op, son_id_type son, object_id_type object) :
+   son_proposal_type(int op, sidechain_type sid, son_id_type son, object_id_type object) :
          op_type(op),
+         sidechain(sid),
          son_id(son),
          object_id(object) {
    }
    int op_type;
+   sidechain_type sidechain;
    son_id_type son_id;
    object_id_type object_id;
    bool operator<(const son_proposal_type &other) const {
-      return std::tie(op_type, son_id, object_id) < std::tie(other.op_type, other.son_id, other.object_id);
+      return std::tie(op_type, sidechain, son_id, object_id) < std::tie(other.op_type, other.sidechain, other.son_id, other.object_id);
    }
 };
 
@@ -42,16 +44,17 @@ public:
    std::unique_ptr<detail::peerplays_sidechain_plugin_impl> my;
 
    std::set<chain::son_id_type> &get_sons();
-   const son_id_type get_current_son_id();
+   const son_id_type get_current_son_id(sidechain_type sidechain);
-   const son_object get_current_son_object();
+   const son_object get_current_son_object(sidechain_type sidechain);
    const son_object get_son_object(son_id_type son_id);
-   bool is_active_son(son_id_type son_id);
+   bool is_active_son(sidechain_type sidechain, son_id_type son_id);
    bool is_son_deregistered(son_id_type son_id);
    fc::ecc::private_key get_private_key(son_id_type son_id);
    fc::ecc::private_key get_private_key(chain::public_key_type public_key);
-   void log_son_proposal_retry(int op_type, object_id_type object_id);
+   void log_son_proposal_retry(sidechain_type sidechain, int op_type, object_id_type object_id);
-   bool can_son_participate(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();
+   sidechain_type get_sidechain() const;
-   std::vector<std::string> get_sidechain_deposit_addresses();
+   std::vector<std::string> get_sidechain_deposit_addresses() const;
-   std::vector<std::string> get_sidechain_withdraw_addresses();
+   std::vector<std::string> get_sidechain_withdraw_addresses() const;
-   std::string get_private_key(std::string public_key);
+   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;