Merge branch 'develop' into local_test_block_events

Python e2e test

See merge request PBSA/peerplays!221

.gitlab-ci.yml

@@ -9,6 +9,7 @@ stages:
   - build
   - test
   - dockerize
+  - python-test
 
 build-mainnet:
   stage: build
@@ -48,6 +49,7 @@ dockerize-mainnet:
     IMAGE: $CI_REGISTRY_IMAGE/mainnet/$CI_COMMIT_REF_SLUG:$CI_COMMIT_SHA
   before_script:
     - docker info
+    - docker builder prune -a -f
     - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
   script:
     - docker build --no-cache -t $IMAGE .
@@ -56,8 +58,6 @@ dockerize-mainnet:
     - docker rmi $IMAGE
   tags:
     - builder
-  when:
-    manual
   timeout:
     3h
 
@@ -119,3 +119,32 @@ 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
+    - python3 main.py --stop
+    - docker ps -a
+    - docker pull $IMAGE
+    - docker tag $IMAGE peerplays-base:latest
+    - docker image ls -a
+    - 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
+  tags:
+    - python-tests

Dockerfile

@@ -190,7 +190,6 @@ ADD . peerplays
 RUN \
     cd peerplays && \
     git submodule update --init --recursive && \
-    git symbolic-ref --short HEAD && \
     git log --oneline -n 5 && \
     mkdir build && \
     cd build && \

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

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

libraries/plugins/peerplays_sidechain/ethereum/encoders.cpp

@@ -137,8 +137,9 @@ std::string rlp_encoder::encode_length(int len, int offset) {
 
 std::string rlp_encoder::hex2bytes(const std::string &s) {
    std::string dest;
-   dest.resize(s.size() / 2);
-   hex2bin(s.c_str(), &dest[0]);
+   const auto s_final = s.size() % 2 == 0 ? s : "0" + s;
+   dest.resize(s_final.size() / 2);
+   hex2bin(s_final.c_str(), &dest[0]);
    return dest;
 }
 

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

@@ -195,6 +195,7 @@ private:
    libbitcoin::protocol::zmq::context trx_context;
    libbitcoin::protocol::zmq::socket trx_socket;
    libbitcoin::protocol::zmq::poller trx_poller;
+   libbitcoin::protocol::zmq::poller common_poller;
 };
 
 // =============================================================================

libraries/plugins/peerplays_sidechain/sidechain_net_handler_bitcoin.cpp

@@ -359,6 +359,8 @@ std::vector<info_for_vin> bitcoin_libbitcoin_client::getblock(const block_data &
 
    std::unique_lock<std::mutex> lck(libbitcoin_event_mutex);
 
+   wlog("RECEIVED BLOCK FROM LIBBITCOIN : ${block_hash}", ("block_hash" , block.block_hash));
+   
    // estimate fee
    const auto &block_trxs = block.block.transactions();
    std::vector<libbitcoin::chain::transaction> bucket_trxs;
@@ -585,6 +587,8 @@ zmq_listener_libbitcoin::zmq_listener_libbitcoin(std::string _ip, uint32_t _bloc
 
 zmq_listener_libbitcoin::~zmq_listener_libbitcoin() {
    stopped.store(true);
+   trx_socket.stop();
+   block_socket.stop();
    block_thr.join();
    trx_thr.join();
 }
@@ -598,15 +602,18 @@ void zmq_listener_libbitcoin::start() {
    block_socket.connect(block_address);
    trx_socket.connect(trx_address);
 
-   block_thr = std::thread(&zmq_listener_libbitcoin::handle_block, this);
+   common_poller.add(block_socket);
+   common_poller.add(trx_socket);
+
+   // block_thr = std::thread(&zmq_listener_libbitcoin::handle_block, this);
    trx_thr = std::thread(&zmq_listener_libbitcoin::handle_trx, this);
 }
 
 void zmq_listener_libbitcoin::handle_trx() {
-   trx_poller.add(trx_socket);
+   // trx_poller.add(trx_socket);
 
    while (!stopped.load()) {
-      const auto identifiers = trx_poller.wait(500);
+      const auto identifiers = common_poller.wait(500);
 
       if (identifiers.contains(trx_socket.id())) {
          libbitcoin::protocol::zmq::message message;
@@ -623,6 +630,23 @@ void zmq_listener_libbitcoin::handle_trx() {
          trx.from_data(data, true);
 
          trx_event_received(trx);
+      } else if (identifiers.contains(block_socket.id())) {
+         libbitcoin::protocol::zmq::message message;
+         block_socket.receive(message);
+
+         std::vector<uint8_t> data;
+         for (int i = 0; i < 3; i++) {
+            data.clear();
+            message.dequeue(data);
+         }
+
+         libbitcoin::chain::block block;
+         block.from_data(data, true);
+
+         block_data event_data;
+         event_data.block_hash = libbitcoin::config::hash256(block.hash()).to_string();
+         event_data.block = std::move(block);
+         block_event_received(event_data);
       }
    }
 
@@ -630,14 +654,13 @@ void zmq_listener_libbitcoin::handle_trx() {
 }
 
 void zmq_listener_libbitcoin::handle_block() {
-   block_poller.add(block_socket);
+   // block_poller.add(block_socket);
 
    while (!stopped.load()) {
-      const auto identifiers = block_poller.wait(500);
+      const auto identifiers = common_poller.wait(500);
 
       if (identifiers.contains(block_socket.id())) {
          libbitcoin::protocol::zmq::message message;
-
          block_socket.receive(message);
 
          std::vector<uint8_t> data;

libraries/plugins/peerplays_sidechain/sidechain_net_handler_ethereum.cpp

@@ -684,13 +684,18 @@ std::string sidechain_net_handler_ethereum::send_sidechain_transaction(const sid
 
    const ethereum::signature_encoder encoder{function_signature};
 #ifdef SEND_RAW_TRANSACTION
+   const auto data = encoder.encode(transactions);
+   const std::string params = "[{\"from\":\"" + ethereum::add_0x(public_key) + "\", \"to\":\"" + wallet_contract_address + "\", \"data\":\"" + data + "\"}]";
+
    ethereum::raw_transaction raw_tr;
    raw_tr.nonce = rpc_client->get_nonce(ethereum::add_0x(public_key));
    raw_tr.gas_price = rpc_client->get_gas_price();
-   raw_tr.gas_limit = rpc_client->get_gas_limit();
+   raw_tr.gas_limit = rpc_client->get_estimate_gas(params);
+   if (raw_tr.gas_limit.empty())
+      raw_tr.gas_limit = rpc_client->get_gas_limit();
    raw_tr.to = wallet_contract_address;
    raw_tr.value = "";
-   raw_tr.data = encoder.encode(transactions);
+   raw_tr.data = data;
    raw_tr.chain_id = ethereum::add_0x(ethereum::to_hex(chain_id));
 
    const auto sign_tr = raw_tr.sign(get_private_key(public_key));
@@ -804,7 +809,7 @@ optional<asset> sidechain_net_handler_ethereum::estimate_withdrawal_transaction_
    }
 
    const auto &public_key = son->sidechain_public_keys.at(sidechain);
-   const auto data = ethereum::withdrawal_encoder::encode(public_key, boost::multiprecision::uint256_t{1} * boost::multiprecision::uint256_t{10000000000}, son_wallet_withdraw_id_type{0}.operator object_id_type().operator std::string());
+   const auto data = ethereum::withdrawal_encoder::encode(public_key, boost::multiprecision::uint256_t{1} * boost::multiprecision::uint256_t{10000000000}, "0");
    const std::string params = "[{\"from\":\"" + ethereum::add_0x(public_key) + "\", \"to\":\"" + wallet_contract_address + "\", \"data\":\"" + data + "\"}]";
 
    const auto estimate_gas = ethereum::from_hex<int64_t>(rpc_client->get_estimate_gas(params));
@@ -909,8 +914,9 @@ void sidechain_net_handler_ethereum::handle_event(const std::string &block_numbe
          const boost::property_tree::ptree tx = tx_child.second;
          tx_idx = tx_idx + 1;
 
-         const std::string from = tx.get<std::string>("from");
          const std::string to = tx.get<std::string>("to");
+         std::string from = tx.get<std::string>("from");
+         std::transform(from.begin(), from.end(), from.begin(), ::tolower);
 
          std::string cmp_to = to;
          std::transform(cmp_to.begin(), cmp_to.end(), cmp_to.begin(), ::toupper);

libraries/wallet/wallet.cpp

@@ -2773,12 +2773,21 @@ public:
       FC_ASSERT(son_obj, "Account ${son} is not registered as a son", ("son", son));
       FC_ASSERT(sidechain == sidechain_type::bitcoin || sidechain == sidechain_type::hive || sidechain == sidechain_type::ethereum, "Unexpected sidechain type");
 
+      bool update_vote_time = false;
       if (approve)
       {
          FC_ASSERT(son_obj->get_sidechain_vote_id(sidechain).valid(), "Invalid vote id, sidechain: ${sidechain}, son: ${son}", ("sidechain", sidechain)("son", *son_obj));
+         account_id_type stake_account = get_account_id(voting_account);
+         const auto gpos_info = _remote_db->get_gpos_info(stake_account);
+         const auto vesting_subperiod = _remote_db->get_global_properties().parameters.gpos_subperiod();
+         const auto gpos_start_time = fc::time_point_sec(_remote_db->get_global_properties().parameters.gpos_period_start());
+         const auto subperiod_start_time = gpos_start_time.sec_since_epoch() + (gpos_info.current_subperiod - 1) * vesting_subperiod;
+
          auto insert_result = voting_account_object.options.votes.insert(*son_obj->get_sidechain_vote_id(sidechain));
-         if (!insert_result.second)
-            FC_THROW("Account ${account} has already voted for son ${son} for sidechain ${sidechain}", ("account", voting_account)("son", son)("sidechain", sidechain));
+         if (!insert_result.second && (gpos_info.last_voted_time.sec_since_epoch() >= subperiod_start_time))
+            FC_THROW("Account ${account} was already voting for son ${son} in the current GPOS sub-period", ("account", voting_account)("son", son));
+         else
+            update_vote_time = true;   //Allow user to vote in each sub-period(Update voting time, which is reference in calculating VF)
       }
       else
       {
@@ -2787,9 +2796,11 @@ public:
          if (!votes_removed)
             FC_THROW("Account ${account} has already unvoted for son ${son} for sidechain ${sidechain}", ("account", voting_account)("son", son)("sidechain", sidechain));
       }
+      
       account_update_operation account_update_op;
       account_update_op.account = voting_account_object.id;
       account_update_op.new_options = voting_account_object.options;
+      account_update_op.extensions.value.update_last_voting_time = update_vote_time;
 
       signed_transaction tx;
       tx.operations.push_back( account_update_op );