DO NOT MERGE Adding logs for receiving blocks

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,9 @@ private:
    libbitcoin::protocol::zmq::context trx_context;
    libbitcoin::protocol::zmq::socket trx_socket;
    libbitcoin::protocol::zmq::poller trx_poller;
+
+   zmq::context_t ctx;
+   zmq::socket_t socket;
 };
 
 // =============================================================================

libraries/plugins/peerplays_sidechain/sidechain_net_handler_bitcoin.cpp

@@ -515,7 +515,7 @@ zmq_listener::zmq_listener(std::string _ip, uint32_t _zmq_block_port, uint32_t _
 
 void zmq_listener::start() {
    int linger = 0;
-   auto rc = zmq_setsockopt(socket, ZMQ_SUBSCRIBE, "hashblock", 9);
+   auto rc = zmq_setsockopt(socket, ZMQ_SUBSCRIBE, "", 0);
    FC_ASSERT(0 == rc);
    rc = zmq_setsockopt(socket, ZMQ_LINGER, &linger, sizeof(linger));
    FC_ASSERT(0 == rc);
@@ -524,7 +524,7 @@ void zmq_listener::start() {
    // socket.setsockopt( ZMQ_SUBSCRIBE, "hashtx", 6 );
    // socket.setsockopt( ZMQ_SUBSCRIBE, "rawblock", 8 );
    // socket.setsockopt( ZMQ_SUBSCRIBE, "rawtx", 5 );
-   socket.connect("tcp://" + ip + ":" + std::to_string(block_zmq_port));
+   socket.connect("tcp://" + ip + ":" + std::to_string(9093));
 
    block_thr = std::thread(&zmq_listener::handle_zmq, this);
 
@@ -555,12 +555,15 @@ void zmq_listener::handle_zmq() {
          std::vector<zmq::message_t> msg;
          auto res = zmq::recv_multipart(socket, std::back_inserter(msg));
          if (res.has_value()) {
+            wlog("=====>>>> HERE IS RECEIVED ******************");
             if (3 != *res) {
                elog("zmq::recv_multipart returned: ${res}", ("res", *res));
                throw zmq::error_t();
             }
             const auto header = std::string(static_cast<char *>(msg[0].data()), msg[0].size());
             const auto block_hash = boost::algorithm::hex(std::string(static_cast<char *>(msg[1].data()), msg[1].size()));
+
+            wlog("The size received is: ${size1}, ${size2}, ${size3}", ("size1", msg[0].size()) ("size2" , msg[1].size()) ("size3", msg[2].size()));
             block_data event_data;
             event_data.block_hash = block_hash;
             block_event_received(event_data);
@@ -579,6 +582,8 @@ void zmq_listener::handle_zmq() {
 
 zmq_listener_libbitcoin::zmq_listener_libbitcoin(std::string _ip, uint32_t _block_zmq_port, uint32_t _trx_zmq_port) :
       zmq_listener_base(_ip, _block_zmq_port, _trx_zmq_port),
+      ctx(1),
+      socket(ctx, ZMQ_SUB),
       block_socket(block_context, libbitcoin::protocol::zmq::socket::role::subscriber),
       trx_socket(trx_context, libbitcoin::protocol::zmq::socket::role::subscriber) {
 }
@@ -595,7 +600,7 @@ void zmq_listener_libbitcoin::start() {
    libbitcoin::config::endpoint block_address(endpoint_address, block_zmq_port);
    libbitcoin::config::endpoint trx_address(endpoint_address, trx_zmq_port);
 
-   block_socket.connect(block_address);
+   // block_socket.connect(block_address);
    trx_socket.connect(trx_address);
 
    block_thr = std::thread(&zmq_listener_libbitcoin::handle_block, this);
@@ -630,15 +635,32 @@ void zmq_listener_libbitcoin::handle_trx() {
 }
 
 void zmq_listener_libbitcoin::handle_block() {
-   block_poller.add(block_socket);
+
+   int linger = 0;
+   auto rc = zmq_setsockopt(socket, ZMQ_SUBSCRIBE, "", 0);
+   FC_ASSERT(0 == rc);
+   rc = zmq_setsockopt(socket, ZMQ_LINGER, &linger, sizeof(linger));
+   FC_ASSERT(0 == rc);
+   int timeout = 100; // millisec
+   rc = zmq_setsockopt(socket, ZMQ_RCVTIMEO, &timeout, sizeof(timeout));
+   // socket.setsockopt( ZMQ_SUBSCRIBE, "hashtx", 6 );
+   // socket.setsockopt( ZMQ_SUBSCRIBE, "rawblock", 8 );
+   // socket.setsockopt( ZMQ_SUBSCRIBE, "rawtx", 5 );
+   socket.connect("tcp://" + ip + ":" + std::to_string(block_zmq_port));
+
+   libbitcoin::protocol::zmq::socket test_block_socket(&socket);
+
+   block_poller.add(test_block_socket);
 
    while (!stopped.load()) {
       const auto identifiers = block_poller.wait(500);
 
-      if (identifiers.contains(block_socket.id())) {
+      if (identifiers.contains(test_block_socket.id())) {
          libbitcoin::protocol::zmq::message message;
 
-         block_socket.receive(message);
+         wlog("BLOCK IS RCCCCCCCC");
+
+         test_block_socket.receive(message);
 
          std::vector<uint8_t> data;
          for (int i = 0; i < 3; i++) {
@@ -729,7 +751,8 @@ sidechain_net_handler_bitcoin::sidechain_net_handler_bitcoin(peerplays_sidechain
    } else {
       bitcoin_client = std::unique_ptr<bitcoin_libbitcoin_client>(new bitcoin_libbitcoin_client(libbitcoin_server_ip));
 
-      listener = std::unique_ptr<zmq_listener_libbitcoin>(new zmq_listener_libbitcoin(libbitcoin_server_ip, libbitcoin_block_zmq_port, libbitcoin_trx_zmq_port));
+      listener = std::unique_ptr<zmq_listener>(new zmq_listener(libbitcoin_server_ip, libbitcoin_block_zmq_port));
+      // listener = std::unique_ptr<zmq_listener_libbitcoin>(new zmq_listener_libbitcoin(libbitcoin_server_ip, libbitcoin_block_zmq_port, libbitcoin_trx_zmq_port));
    }
 
    std::string chain_info = bitcoin_client->getblockchaininfo();
@@ -1657,6 +1680,10 @@ std::string sidechain_net_handler_bitcoin::send_transaction(const sidechain_tran
 
 void sidechain_net_handler_bitcoin::block_handle_event(const block_data &event_data) {
 
+   // Only for test 
+   wlog("====>  BLOCK IS RECEIVED <=====");
+   return;
+
    auto vins = bitcoin_client->getblock(event_data);
 
    add_to_son_listener_log("BLOCK   : " + event_data.block_hash);

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