merge gpos to develop (#186)

* issue - 154: Don't allow to vote when vesting balance is 0

* changes to withdraw_vesting feature(for both cdd and GPOS)

* Comments update

* update to GPOS hardfork ref

* fix for get_vesting_balance API call

* braces update

* Create .gitlab-ci.yml

* fixing build errors (#150)

* fixing build errors

vest type correction

* fixing build errors

vest type correction

* fixes 

new Dockerfile

* vesting_balance_type correction

vesting_balance_type changed to normal

* gcc5 support to Dockerfile

gcc5 support to Dockerfile

* Changes to compiple with GCC 7(Ubuntu 18.04)

* changes to have separate methods and single withdrawl fee for multiple vest objects

* 163-fix, Return only non-zero vesting balances

* Revert "Revert "GPOS protocol""

This reverts commit 67616417b7.

* add new line needed to gpos hardfork file

* comment temporally cli_vote_for_2_witnesses until refactor or delete

* fix gpos tests

* fix gitlab-ci conflict

.gitlab-ci.yml

@@ -30,7 +30,7 @@ test:
     - ./tests/cli_test
   tags:
     - builder
-    
+
 code_quality:
   stage: test
   image: docker:stable

libraries/app/database_api.cpp

@@ -171,6 +171,8 @@ class database_api_impl : public std::enable_shared_from_this<database_api_impl>
       vector<tournament_object> get_tournaments_by_state(tournament_id_type stop, unsigned limit, tournament_id_type start, tournament_state state);
       vector<tournament_id_type> get_registered_tournaments(account_id_type account_filter, uint32_t limit) const;
 
+      // gpos
+      gpos_info get_gpos_info(const account_id_type account) const;
 
    //private:
       template<typename T>
@@ -934,7 +936,8 @@ vector<vesting_balance_object> database_api_impl::get_vesting_balances( account_
       auto vesting_range = _db.get_index_type<vesting_balance_index>().indices().get<by_account>().equal_range(account_id);
       std::for_each(vesting_range.first, vesting_range.second,
                     [&result](const vesting_balance_object& balance) {
-                       result.emplace_back(balance);
+                        if(balance.balance.amount > 0)
+                           result.emplace_back(balance);
                     });
       return result;
    }
@@ -2130,6 +2133,55 @@ vector<tournament_id_type> database_api_impl::get_registered_tournaments(account
    return tournament_ids;
 }
 
+//////////////////////////////////////////////////////////////////////
+//                                                                  //
+// GPOS methods                                                     //
+//                                                                  //
+//////////////////////////////////////////////////////////////////////
+
+graphene::app::gpos_info database_api::get_gpos_info(const account_id_type account) const
+{
+   return my->get_gpos_info(account);
+
+}
+graphene::app::gpos_info database_api_impl::get_gpos_info(const account_id_type account) const
+{
+   gpos_info result;
+   result.vesting_factor = _db.calculate_vesting_factor(account(_db));
+
+   const auto& dividend_data = asset_id_type()(_db).dividend_data(_db);
+   const account_object& dividend_distribution_account = dividend_data.dividend_distribution_account(_db);
+   result.award = _db.get_balance(dividend_distribution_account, asset_id_type()(_db));
+
+   share_type total_amount;
+   auto balance_type = vesting_balance_type::gpos;
+#ifdef USE_VESTING_OBJECT_BY_ASSET_BALANCE_INDEX
+   // get only once a collection of accounts that hold nonzero vesting balances of the dividend asset
+   auto vesting_balances_begin =
+      vesting_index.indices().get<by_asset_balance>().lower_bound(boost::make_tuple(asset_id_type(), balance_type));
+   auto vesting_balances_end =
+      vesting_index.indices().get<by_asset_balance>().upper_bound(boost::make_tuple(asset_id_type(), balance_type, share_type()));
+
+   for (const vesting_balance_object& vesting_balance_obj : boost::make_iterator_range(vesting_balances_begin, vesting_balances_end))
+   {
+        total_amount += vesting_balance_obj.balance.amount;
+   }
+#else
+   const vesting_balance_index& vesting_index = _db.get_index_type<vesting_balance_index>();
+   const auto& vesting_balances = vesting_index.indices().get<by_id>();
+   for (const vesting_balance_object& vesting_balance_obj : vesting_balances)
+   {
+      if (vesting_balance_obj.balance.asset_id == asset_id_type() && vesting_balance_obj.balance_type == balance_type)
+      {
+         total_amount += vesting_balance_obj.balance.amount;
+      }
+   }
+#endif
+
+   result.total_amount = total_amount;
+   return result;
+}
+
 //////////////////////////////////////////////////////////////////////
 //                                                                  //
 // Private methods                                                  //

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

@@ -114,6 +114,12 @@ struct market_trade
    double                     value;
 };
 
+struct gpos_info {
+   double vesting_factor;
+   asset award;
+   share_type total_amount;
+};
+
 /**
  * @brief The database_api class implements the RPC API for the chain database.
  *
@@ -673,7 +679,17 @@ class database_api
        */
       vector<tournament_id_type> get_registered_tournaments(account_id_type account_filter, uint32_t limit) const;
 
-   private:
+      //////////
+      // GPOS //
+      //////////
+      /**
+       * @return account and network GPOS information
+       */
+      gpos_info get_gpos_info(const account_id_type account) const;
+
+
+
+private:
       std::shared_ptr< database_api_impl > my;
 };
 
@@ -684,6 +700,8 @@ 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) );
 FC_REFLECT( graphene::app::market_volume, (base)(quote)(base_volume)(quote_volume) );
 FC_REFLECT( graphene::app::market_trade, (date)(price)(amount)(value) );
+FC_REFLECT( graphene::app::gpos_info, (vesting_factor)(award)(total_amount) );
+
 
 FC_API(graphene::app::database_api,
    // Objects
@@ -801,4 +819,7 @@ FC_API(graphene::app::database_api,
    (get_tournaments_by_state)
    (get_tournaments )
    (get_registered_tournaments)
+
+   // gpos
+   (get_gpos_info)
 )

libraries/chain/db_maint.cpp

@@ -749,6 +749,120 @@ void deprecate_annual_members( database& db )
    return;
 }
 
+double database::calculate_vesting_factor(const account_object& stake_account)
+{
+   // get last time voted form stats
+   const auto &stats = stake_account.statistics(*this);
+   fc::time_point_sec last_date_voted = stats.last_vote_time;
+
+   // get global data related to gpos
+   const auto &gpo = this->get_global_properties();
+   const auto vesting_period = gpo.parameters.gpos_period();
+   const auto vesting_subperiod = gpo.parameters.gpos_subperiod();
+   const auto period_start = fc::time_point_sec(gpo.parameters.gpos_period_start());
+
+   //  variables needed
+   const fc::time_point_sec period_end = period_start + vesting_period;
+   const auto number_of_subperiods = vesting_period / vesting_subperiod;
+   const auto now = this->head_block_time();
+   double vesting_factor;
+   auto seconds_since_period_start = now.sec_since_epoch() - period_start.sec_since_epoch();
+
+   FC_ASSERT(period_start <= now && now <= period_end);
+
+   // get in what sub period we are
+   uint32_t current_subperiod = 0;
+   std::list<uint32_t> period_list(number_of_subperiods);
+   std::iota(period_list.begin(), period_list.end(), 1);
+
+   std::for_each(period_list.begin(), period_list.end(),[&](uint32_t period) {
+      if(seconds_since_period_start >= vesting_subperiod * (period - 1) &&
+            seconds_since_period_start < vesting_subperiod * period)
+         current_subperiod = period;
+   });
+
+   if(current_subperiod == 0 || current_subperiod > number_of_subperiods) return 0;
+   if(last_date_voted < period_start) return 0;
+
+   double numerator = number_of_subperiods;
+
+   if(current_subperiod > 1) {
+      std::list<uint32_t> subperiod_list(current_subperiod - 1);
+      std::iota(subperiod_list.begin(), subperiod_list.end(), 2);
+      subperiod_list.reverse();
+
+      for(auto subperiod: subperiod_list)
+      {
+         numerator--;
+
+         auto last_period_start = period_start + fc::seconds(vesting_subperiod * (subperiod - 1));
+         auto last_period_end = period_start + fc::seconds(vesting_subperiod * (subperiod));
+
+         if (last_date_voted > last_period_start && last_date_voted <= last_period_end) {
+            numerator++;
+            break;
+         }
+      }
+   }
+   vesting_factor = numerator / number_of_subperiods;
+   return vesting_factor;
+}
+
+share_type credit_account(database& db, const account_id_type owner_id, const std::string owner_name,
+                          share_type remaining_amount_to_distribute,
+                          const share_type shares_to_credit, const asset_id_type payout_asset_type,
+                          const pending_dividend_payout_balance_for_holder_object_index& pending_payout_balance_index,
+                          const asset_id_type dividend_id) {
+
+   //wdump((delta_balance.value)(holder_balance)(total_balance_of_dividend_asset));
+   if (shares_to_credit.value) {
+
+      remaining_amount_to_distribute -= shares_to_credit;
+
+      dlog("Crediting account ${account} with ${amount}",
+           ("account", owner_name)
+                 ("amount", asset(shares_to_credit, payout_asset_type)));
+      auto pending_payout_iter =
+            pending_payout_balance_index.indices().get<by_dividend_payout_account>().find(
+                  boost::make_tuple(dividend_id, payout_asset_type,
+                                    owner_id));
+      if (pending_payout_iter ==
+          pending_payout_balance_index.indices().get<by_dividend_payout_account>().end())
+         db.create<pending_dividend_payout_balance_for_holder_object>(
+               [&](pending_dividend_payout_balance_for_holder_object &obj) {
+                  obj.owner = owner_id;
+                  obj.dividend_holder_asset_type = dividend_id;
+                  obj.dividend_payout_asset_type = payout_asset_type;
+                  obj.pending_balance = shares_to_credit;
+               });
+      else
+         db.modify(*pending_payout_iter,
+                   [&](pending_dividend_payout_balance_for_holder_object &pending_balance) {
+                      pending_balance.pending_balance += shares_to_credit;
+                   });
+   }
+   return remaining_amount_to_distribute;
+}
+
+void rolling_period_start(database& db)
+{
+   if(db.head_block_time() >= HARDFORK_GPOS_TIME)
+   {
+      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();
+
+      auto now = db.head_block_time();
+      if(now.sec_since_epoch() > (period_start + vesting_period))
+      {
+         // roll
+         db.modify(db.get_global_properties(), [now](global_property_object& p) {
+            p.parameters.extensions.value.gpos_period_start =  now.sec_since_epoch();
+         });
+      }
+   }
+}
+
 // Schedules payouts from a dividend distribution account to the current holders of the
 // dividend-paying asset.  This takes any deposits made to the dividend distribution account
 // since the last time it was called, and distributes them to the current owners of the
@@ -780,34 +894,42 @@ void schedule_pending_dividend_balances(database& db,
       balance_index.indices().get<by_asset_balance>().lower_bound(boost::make_tuple(dividend_holder_asset_obj.id));
    auto holder_balances_end =
       balance_index.indices().get<by_asset_balance>().upper_bound(boost::make_tuple(dividend_holder_asset_obj.id, share_type()));
-   uint32_t holder_account_count = std::distance(holder_balances_begin, holder_balances_end);
    uint64_t distribution_base_fee = gpo.parameters.current_fees->get<asset_dividend_distribution_operation>().distribution_base_fee;
    uint32_t distribution_fee_per_holder = gpo.parameters.current_fees->get<asset_dividend_distribution_operation>().distribution_fee_per_holder;
-   // the fee, in BTS, for distributing each asset in the account
-   uint64_t total_fee_per_asset_in_core = distribution_base_fee + holder_account_count * (uint64_t)distribution_fee_per_holder;
 
    std::map<account_id_type, share_type> vesting_amounts;
+
+   auto balance_type = vesting_balance_type::normal;
+   if(db.head_block_time() >= HARDFORK_GPOS_TIME)
+      balance_type = vesting_balance_type::gpos;
+
+   uint32_t holder_account_count = 0;
+
 #ifdef USE_VESTING_OBJECT_BY_ASSET_BALANCE_INDEX
    // get only once a collection of accounts that hold nonzero vesting balances of the dividend asset
    auto vesting_balances_begin =
-      vesting_index.indices().get<by_asset_balance>().lower_bound(boost::make_tuple(dividend_holder_asset_obj.id));
+      vesting_index.indices().get<by_asset_balance>().lower_bound(boost::make_tuple(dividend_holder_asset_obj.id, balance_type));
    auto vesting_balances_end =
-      vesting_index.indices().get<by_asset_balance>().upper_bound(boost::make_tuple(dividend_holder_asset_obj.id, share_type()));
+      vesting_index.indices().get<by_asset_balance>().upper_bound(boost::make_tuple(dividend_holder_asset_obj.id, balance_type, share_type()));
+
    for (const vesting_balance_object& vesting_balance_obj : boost::make_iterator_range(vesting_balances_begin, vesting_balances_end))
    {
         vesting_amounts[vesting_balance_obj.owner] += vesting_balance_obj.balance.amount;
-        //dlog("Vesting balance for account: ${owner}, amount: ${amount}",
-        //     ("owner", vesting_balance_obj.owner(db).name)
-        //     ("amount", vesting_balance_obj.balance.amount));
+        ++holder_account_count;
+        dlog("Vesting balance for account: ${owner}, amount: ${amount}",
+             ("owner", vesting_balance_obj.owner(db).name)
+             ("amount", vesting_balance_obj.balance.amount));
    }
 #else
    // get only once a collection of accounts that hold nonzero vesting balances of the dividend asset
    const auto& vesting_balances = vesting_index.indices().get<by_id>();
    for (const vesting_balance_object& vesting_balance_obj : vesting_balances)
    {
-        if (vesting_balance_obj.balance.asset_id == dividend_holder_asset_obj.id && vesting_balance_obj.balance.amount)
+        if (vesting_balance_obj.balance.asset_id == dividend_holder_asset_obj.id && vesting_balance_obj.balance.amount &&
+        vesting_balance_object.balance_type == balance_type)
         {
             vesting_amounts[vesting_balance_obj.owner] += vesting_balance_obj.balance.amount;
+            ++gpos_holder_account_count;
             dlog("Vesting balance for account: ${owner}, amount: ${amount}",
                  ("owner", vesting_balance_obj.owner(db).name)
                  ("amount", vesting_balance_obj.balance.amount));
@@ -816,6 +938,12 @@ void schedule_pending_dividend_balances(database& db,
 #endif
 
    auto current_distribution_account_balance_iter = current_distribution_account_balance_range.begin();
+   if(db.head_block_time() < HARDFORK_GPOS_TIME)
+      holder_account_count = std::distance(holder_balances_begin, holder_balances_end);
+   // the fee, in BTS, for distributing each asset in the account
+   uint64_t total_fee_per_asset_in_core = distribution_base_fee + holder_account_count * (uint64_t)distribution_fee_per_holder;
+
+   //auto current_distribution_account_balance_iter = current_distribution_account_balance_range.first;
    auto previous_distribution_account_balance_iter = previous_distribution_account_balance_range.first;
    dlog("Current balances in distribution account: ${current}, Previous balances: ${previous}",
         ("current", (int64_t)std::distance(current_distribution_account_balance_range.begin(), current_distribution_account_balance_range.end()))
@@ -825,14 +953,23 @@ void schedule_pending_dividend_balances(database& db,
    // accounts other than the distribution account (it would be silly to distribute dividends back to 
    // the distribution account)
    share_type total_balance_of_dividend_asset;
-   for (const account_balance_object& holder_balance_object : boost::make_iterator_range(holder_balances_begin, holder_balances_end))
-      if (holder_balance_object.owner != dividend_data.dividend_distribution_account)
-      {
-         total_balance_of_dividend_asset += holder_balance_object.balance;
-         auto itr = vesting_amounts.find(holder_balance_object.owner);
-         if (itr != vesting_amounts.end())
-             total_balance_of_dividend_asset += itr->second;
-      }
+   if(db.head_block_time() >= HARDFORK_GPOS_TIME && dividend_holder_asset_obj.symbol == GRAPHENE_SYMBOL) { // only core
+      for (const vesting_balance_object &holder_balance_object : boost::make_iterator_range(vesting_balances_begin,
+                                                                                            vesting_balances_end))
+         if (holder_balance_object.owner != dividend_data.dividend_distribution_account) {
+            total_balance_of_dividend_asset += holder_balance_object.balance.amount;
+         }
+   }
+   else {
+      for (const account_balance_object &holder_balance_object : boost::make_iterator_range(holder_balances_begin,
+                                                                                            holder_balances_end))
+         if (holder_balance_object.owner != dividend_data.dividend_distribution_account) {
+            total_balance_of_dividend_asset += holder_balance_object.balance;
+            auto itr = vesting_amounts.find(holder_balance_object.owner);
+            if (itr != vesting_amounts.end())
+               total_balance_of_dividend_asset += itr->second;
+         }
+   }
    // loop through all of the assets currently or previously held in the distribution account
    while (current_distribution_account_balance_iter != current_distribution_account_balance_range.end() ||
           previous_distribution_account_balance_iter != previous_distribution_account_balance_range.second)
@@ -956,46 +1093,68 @@ void schedule_pending_dividend_balances(database& db,
                     ("total", total_balance_of_dividend_asset));
                share_type remaining_amount_to_distribute = delta_balance;
 
-               // credit each account with their portion, don't send any back to the dividend distribution account
-               for (const account_balance_object& holder_balance_object : boost::make_iterator_range(holder_balances_begin, holder_balances_end))
-               {
-                  if (holder_balance_object.owner == dividend_data.dividend_distribution_account) continue;
+               if(db.head_block_time() >= HARDFORK_GPOS_TIME && dividend_holder_asset_obj.symbol == GRAPHENE_SYMBOL) { // core only
+                  // credit each account with their portion, don't send any back to the dividend distribution account
+                  for (const vesting_balance_object &holder_balance_object : boost::make_iterator_range(
+                        vesting_balances_begin, vesting_balances_end)) {
+                     if (holder_balance_object.owner == dividend_data.dividend_distribution_account) continue;
 
-                  auto holder_balance = holder_balance_object.balance;
+                     auto vesting_factor = db.calculate_vesting_factor(holder_balance_object.owner(db));
 
-                  auto itr = vesting_amounts.find(holder_balance_object.owner);
-                  if (itr != vesting_amounts.end())
-                      holder_balance += itr->second;
+                     auto holder_balance = holder_balance_object.balance;
 
-                  fc::uint128_t amount_to_credit(delta_balance.value);
-                  amount_to_credit *= holder_balance.value;
-                  amount_to_credit /= total_balance_of_dividend_asset.value;
-                  share_type shares_to_credit((int64_t)amount_to_credit.to_uint64());
-                  if (shares_to_credit.value)
-                  {
-                     wdump((delta_balance.value)(holder_balance)(total_balance_of_dividend_asset));
+                     fc::uint128_t amount_to_credit(delta_balance.value);
+                     amount_to_credit *= holder_balance.amount.value;
+                     amount_to_credit /= total_balance_of_dividend_asset.value;
+                     share_type full_shares_to_credit((int64_t) amount_to_credit.to_uint64());
+                     share_type shares_to_credit = (uint64_t) floor(full_shares_to_credit.value * vesting_factor);
 
-                     remaining_amount_to_distribute -= shares_to_credit;
+                     if (shares_to_credit < full_shares_to_credit) {
+                        // Todo: sending results of decay to committee account, need to change to specified account
+                        dlog("Crediting committee_account with ${amount}",
+                             ("amount", asset(full_shares_to_credit - shares_to_credit, payout_asset_type)));
+                        db.adjust_balance(dividend_data.dividend_distribution_account,
+                                          -(full_shares_to_credit - shares_to_credit));
+                        db.adjust_balance(account_id_type(0), full_shares_to_credit - shares_to_credit);
+                     }
 
-                     dlog("Crediting account ${account} with ${amount}", 
-                          ("account", holder_balance_object.owner(db).name)
-                          ("amount", asset(shares_to_credit, payout_asset_type)));
-                     auto pending_payout_iter = 
-                        pending_payout_balance_index.indices().get<by_dividend_payout_account>().find(boost::make_tuple(dividend_holder_asset_obj.id, payout_asset_type, holder_balance_object.owner));
-                     if (pending_payout_iter == pending_payout_balance_index.indices().get<by_dividend_payout_account>().end())
-                        db.create<pending_dividend_payout_balance_for_holder_object>( [&]( pending_dividend_payout_balance_for_holder_object& obj ){
-                           obj.owner = holder_balance_object.owner;
-                           obj.dividend_holder_asset_type = dividend_holder_asset_obj.id;
-                           obj.dividend_payout_asset_type = payout_asset_type;
-                           obj.pending_balance = shares_to_credit;
-                        });
-                     else
-                        db.modify(*pending_payout_iter, [&]( pending_dividend_payout_balance_for_holder_object& pending_balance ){
-                           pending_balance.pending_balance += shares_to_credit;
-                        });
+                     remaining_amount_to_distribute = credit_account(db,
+                                                                     holder_balance_object.owner,
+                                                                     holder_balance_object.owner(db).name,
+                                                                     remaining_amount_to_distribute,
+                                                                     shares_to_credit,
+                                                                     payout_asset_type,
+                                                                     pending_payout_balance_index,
+                                                                     dividend_holder_asset_obj.id);
                   }
                }
+               else {
+                  // credit each account with their portion, don't send any back to the dividend distribution account
+                  for (const account_balance_object &holder_balance_object : boost::make_iterator_range(
+                        holder_balances_begin, holder_balances_end)) {
+                     if (holder_balance_object.owner == dividend_data.dividend_distribution_account) continue;
 
+                     auto holder_balance = holder_balance_object.balance;
+
+                     auto itr = vesting_amounts.find(holder_balance_object.owner);
+                     if (itr != vesting_amounts.end())
+                        holder_balance += itr->second;
+
+                     fc::uint128_t amount_to_credit(delta_balance.value);
+                     amount_to_credit *= holder_balance.value;
+                     amount_to_credit /= total_balance_of_dividend_asset.value;
+                     share_type shares_to_credit((int64_t) amount_to_credit.to_uint64());
+
+                     remaining_amount_to_distribute = credit_account(db,
+                                                                     holder_balance_object.owner,
+                                                                     holder_balance_object.owner(db).name,
+                                                                     remaining_amount_to_distribute,
+                                                                     shares_to_credit,
+                                                                     payout_asset_type,
+                                                                     pending_payout_balance_index,
+                                                                     dividend_holder_asset_obj.id);
+                  }
+               }
                for (const auto& pending_payout : pending_payout_balance_index.indices())
                   if (pending_payout.pending_balance.value)
                       dlog("Pending payout: ${account_name}   ->   ${amount}",
@@ -1256,6 +1415,8 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g
    distribute_fba_balances(*this);
    create_buyback_orders(*this);
 
+   rolling_period_start(*this);
+
    process_dividend_assets(*this);
 
    struct vote_tally_helper {
@@ -1271,24 +1432,28 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g
          d._committee_count_histogram_buffer.resize(props.parameters.maximum_committee_count / 2 + 1);
          d._total_voting_stake = 0;
 
+         auto balance_type = vesting_balance_type::normal;
+         if(d.head_block_time() >= HARDFORK_GPOS_TIME)
+            balance_type = vesting_balance_type::gpos;
+
          const vesting_balance_index& vesting_index = d.get_index_type<vesting_balance_index>();
 #ifdef USE_VESTING_OBJECT_BY_ASSET_BALANCE_INDEX
          auto vesting_balances_begin =
-              vesting_index.indices().get<by_asset_balance>().lower_bound(boost::make_tuple(asset_id_type()));
+              vesting_index.indices().get<by_asset_balance>().lower_bound(boost::make_tuple(asset_id_type(), balance_type));
          auto vesting_balances_end =
-              vesting_index.indices().get<by_asset_balance>().upper_bound(boost::make_tuple(asset_id_type(), share_type()));
+              vesting_index.indices().get<by_asset_balance>().upper_bound(boost::make_tuple(asset_id_type(), balance_type, share_type()));
          for (const vesting_balance_object& vesting_balance_obj : boost::make_iterator_range(vesting_balances_begin, vesting_balances_end))
          {
             vesting_amounts[vesting_balance_obj.owner] += vesting_balance_obj.balance.amount;
-            //dlog("Vesting balance for account: ${owner}, amount: ${amount}",
-            //     ("owner", vesting_balance_obj.owner(d).name)
-            //     ("amount", vesting_balance_obj.balance.amount));
+            dlog("Vesting balance for account: ${owner}, amount: ${amount}",
+                 ("owner", vesting_balance_obj.owner(d).name)
+                 ("amount", vesting_balance_obj.balance.amount));
          }
 #else
          const auto& vesting_balances = vesting_index.indices().get<by_id>();
          for (const vesting_balance_object& vesting_balance_obj : vesting_balances)
          {
-            if (vesting_balance_obj.balance.asset_id == asset_id_type() && vesting_balance_obj.balance.amount)
+            if (vesting_balance_obj.balance.asset_id == asset_id_type() && vesting_balance_obj.balance.amount && vesting_balance_obj.balance_type == balance_type)
             {
                 vesting_amounts[vesting_balance_obj.owner] += vesting_balance_obj.balance.amount;
                 dlog("Vesting balance for account: ${owner}, amount: ${amount}",
@@ -1316,13 +1481,27 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g
             const account_object& opinion_account = *opinion_account_ptr;
 
             const auto& stats = stake_account.statistics(d);
-            uint64_t voting_stake = stats.total_core_in_orders.value
-                  + (stake_account.cashback_vb.valid() ? (*stake_account.cashback_vb)(d).balance.amount.value: 0)
-                  + d.get_balance(stake_account.get_id(), asset_id_type()).amount.value;
+            uint64_t voting_stake = 0;
 
             auto itr = vesting_amounts.find(stake_account.id);
             if (itr != vesting_amounts.end())
                 voting_stake += itr->second.value;
+
+            if(d.head_block_time() >= HARDFORK_GPOS_TIME)
+            {
+               if (itr == vesting_amounts.end())
+                  return;
+
+               auto vesting_factor = d.calculate_vesting_factor(stake_account);
+               voting_stake = (uint64_t)floor(voting_stake * vesting_factor);
+            }
+            else
+            {
+               voting_stake += stats.total_core_in_orders.value
+                               + (stake_account.cashback_vb.valid() ? (*stake_account.cashback_vb)(d).balance.amount.value : 0)
+                               + d.get_balance(stake_account.get_id(), asset_id_type()).amount.value;
+            }
+
             for( vote_id_type id : opinion_account.options.votes )
             {
                uint32_t offset = id.instance();

libraries/chain/hardfork.d/GPOS.hf

@@ -0,0 +1,4 @@
+// GPOS HARDFORK Friday, March 15, 2019 11:57:28 PM
+#ifndef HARDFORK_GPOS_TIME
+#define HARDFORK_GPOS_TIME (fc::time_point_sec( 1552694248 ))
+#endif

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

@@ -227,8 +227,10 @@
 #define TOURNAMENT_MAX_WHITELIST_LENGTH                     1000
 #define TOURNAMENT_MAX_START_TIME_IN_FUTURE                 (60*60*24*7*4) // 1 month
 #define TOURNAMENT_MAX_START_DELAY                          (60*60*24*7) // 1 week
-
 #define SWEEPS_DEFAULT_DISTRIBUTION_PERCENTAGE              (2*GRAPHENE_1_PERCENT)
 #define SWEEPS_DEFAULT_DISTRIBUTION_ASSET                   (graphene::chain::asset_id_type(0))
 #define SWEEPS_VESTING_BALANCE_MULTIPLIER                   100000000
 #define SWEEPS_ACCUMULATOR_ACCOUNT                          (graphene::chain::account_id_type(0))
+#define GPOS_PERIOD                                         (60*60*24*30*6) // 6 months
+#define GPOS_SUBPERIOD                                      (60*60*24*30) // 1 month
+#define GPOS_VESTING_LOCKIN_PERIOD                          (60*60*24*30) // 1 month

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

@@ -522,7 +522,10 @@ namespace graphene { namespace chain {
          void update_active_witnesses();
          void update_active_committee_members();
          void update_worker_votes();
-      
+
+         public:
+            double calculate_vesting_factor(const account_object& stake_account);
+
          template<class... Types>
          void perform_account_maintenance(std::tuple<Types...> helpers);
          ///@}

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

@@ -27,6 +27,8 @@
 #include <graphene/chain/protocol/types.hpp>
 #include <fc/smart_ref_fwd.hpp>
 
+#include <../hardfork.d/GPOS.hf>
+
 namespace graphene { namespace chain { struct fee_schedule; } }
 
 namespace graphene { namespace chain {
@@ -40,6 +42,11 @@ namespace graphene { namespace chain {
       optional< uint16_t >            sweeps_distribution_percentage;
       optional< asset_id_type >       sweeps_distribution_asset;
       optional< account_id_type >     sweeps_vesting_accumulator_account;
+      /* gpos parameters */
+      optional < uint32_t >           gpos_period;
+      optional < uint32_t >           gpos_subperiod;
+      optional < uint32_t >           gpos_period_start;
+      optional < uint32_t >           gpos_vesting_lockin_period;
    };
 
    struct chain_parameters
@@ -119,6 +126,18 @@ namespace graphene { namespace chain {
       inline account_id_type sweeps_vesting_accumulator_account()const {
          return extensions.value.sweeps_vesting_accumulator_account.valid() ? *extensions.value.sweeps_vesting_accumulator_account : SWEEPS_ACCUMULATOR_ACCOUNT;
       }
+      inline uint32_t gpos_period()const {
+         return extensions.value.gpos_period.valid() ? *extensions.value.gpos_period : GPOS_PERIOD; /// total seconds of current gpos period
+      }
+      inline uint32_t gpos_subperiod()const {
+         return extensions.value.gpos_subperiod.valid() ? *extensions.value.gpos_subperiod : GPOS_SUBPERIOD; /// gpos_period % gpos_subperiod = 0
+      }
+      inline uint32_t gpos_period_start()const {
+         return extensions.value.gpos_period_start.valid() ? *extensions.value.gpos_period_start : HARDFORK_GPOS_TIME.sec_since_epoch(); /// current period start date
+      }
+      inline uint32_t gpos_vesting_lockin_period()const {
+         return extensions.value.gpos_vesting_lockin_period.valid() ? *extensions.value.gpos_vesting_lockin_period : GPOS_VESTING_LOCKIN_PERIOD; /// GPOS vesting lockin period
+      }      
    };
 
 } }  // graphene::chain
@@ -132,6 +151,10 @@ FC_REFLECT( graphene::chain::parameter_extension,
    (sweeps_distribution_percentage)
    (sweeps_distribution_asset)
    (sweeps_vesting_accumulator_account)
+   (gpos_period)
+   (gpos_subperiod)
+   (gpos_period_start)
+   (gpos_vesting_lockin_period)
 )
 
 FC_REFLECT( graphene::chain::chain_parameters,

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

@@ -24,7 +24,9 @@
 #pragma once
 #include <graphene/chain/protocol/base.hpp>
 
-namespace graphene { namespace chain { 
+namespace graphene { namespace chain {
+
+   enum class vesting_balance_type { normal, gpos };
 
    struct linear_vesting_policy_initializer
    {
@@ -72,6 +74,7 @@ namespace graphene { namespace chain {
       account_id_type             owner; ///< Who is able to withdraw the balance
       asset                       amount;
       vesting_policy_initializer  policy;
+      vesting_balance_type        balance_type;
 
       account_id_type   fee_payer()const { return creator; }
       void              validate()const
@@ -112,9 +115,12 @@ namespace graphene { namespace chain {
 FC_REFLECT( graphene::chain::vesting_balance_create_operation::fee_parameters_type, (fee) )
 FC_REFLECT( graphene::chain::vesting_balance_withdraw_operation::fee_parameters_type, (fee) )
 
-FC_REFLECT( graphene::chain::vesting_balance_create_operation, (fee)(creator)(owner)(amount)(policy) )
+FC_REFLECT( graphene::chain::vesting_balance_create_operation, (fee)(creator)(owner)(amount)(policy)(balance_type) )
 FC_REFLECT( graphene::chain::vesting_balance_withdraw_operation, (fee)(vesting_balance)(owner)(amount) )
 
 FC_REFLECT(graphene::chain::linear_vesting_policy_initializer, (begin_timestamp)(vesting_cliff_seconds)(vesting_duration_seconds) )
 FC_REFLECT(graphene::chain::cdd_vesting_policy_initializer, (start_claim)(vesting_seconds) )
 FC_REFLECT_TYPENAME( graphene::chain::vesting_policy_initializer )
+
+FC_REFLECT_ENUM( graphene::chain::vesting_balance_type, (normal)(gpos) )
+

libraries/chain/include/graphene/chain/vesting_balance_evaluator.hpp

@@ -46,6 +46,7 @@ class vesting_balance_withdraw_evaluator : public evaluator<vesting_balance_with
 
         void_result do_evaluate( const vesting_balance_withdraw_operation& op );
         void_result do_apply( const vesting_balance_withdraw_operation& op );
+        virtual operation_result start_evaluate(transaction_evaluation_state& eval_state, const operation& op, bool apply);
 };
 
 } } // graphene::chain

libraries/chain/include/graphene/chain/vesting_balance_object.hpp

@@ -24,6 +24,8 @@
 #pragma once
 
 #include <graphene/chain/protocol/asset.hpp>
+#include <graphene/chain/protocol/vesting.hpp>
+
 #include <graphene/db/object.hpp>
 #include <graphene/db/generic_index.hpp>
 
@@ -140,6 +142,9 @@ namespace graphene { namespace chain {
          /// The vesting policy stores details on when funds vest, and controls when they may be withdrawn
          vesting_policy policy;
 
+         /// We can have 2 types of vesting, gpos and all the rest
+         vesting_balance_type balance_type = vesting_balance_type::normal;
+
          vesting_balance_object() {}
          
          asset_id_type get_asset_id() const { return balance.asset_id; }
@@ -186,12 +191,14 @@ namespace graphene { namespace chain {
            composite_key<
               vesting_balance_object,
               member_offset<vesting_balance_object, asset_id_type, (size_t) (offsetof(vesting_balance_object,balance) + offsetof(asset,asset_id))>,
+              member<vesting_balance_object, vesting_balance_type, &vesting_balance_object::balance_type>,
               member_offset<vesting_balance_object, share_type, (size_t) (offsetof(vesting_balance_object,balance) + offsetof(asset,amount))>
               //member<vesting_balance_object, account_id_type, &vesting_balance_object::owner>
               //member_offset<vesting_balance_object, account_id_type, (size_t) (offsetof(vesting_balance_object,owner))>
            >,
            composite_key_compare<
               std::less< asset_id_type >,
+              std::less< vesting_balance_type >,
               std::greater< share_type >
               //std::less< account_id_type >
            >
@@ -225,4 +232,5 @@ FC_REFLECT_DERIVED(graphene::chain::vesting_balance_object, (graphene::db::objec
                    (owner)
                    (balance)
                    (policy)
+                   (balance_type)
                   )

libraries/chain/proposal_evaluator.cpp

@@ -135,6 +135,11 @@ struct proposal_operation_hardfork_visitor
        FC_ASSERT( block_time >= HARDFORK_1000_TIME, "event_update_status_operation not allowed yet!" );
    }
 
+   void operator()(const vesting_balance_create_operation &vbco) const {
+      if(block_time < HARDFORK_GPOS_TIME)
+      FC_ASSERT( vbco.balance_type == vesting_balance_type::normal, "balance_type in vesting create not allowed yet!" );
+   }
+
    // loop and self visit in proposals
    void operator()(const proposal_create_operation &v) const {
       for (const op_wrapper &op : v.proposed_ops)

libraries/chain/vesting_balance_evaluator.cpp

@@ -42,6 +42,10 @@ void_result vesting_balance_create_evaluator::do_evaluate( const vesting_balance
    FC_ASSERT( d.get_balance( creator_account.id, op.amount.asset_id ) >= op.amount );
    FC_ASSERT( !op.amount.asset_id(d).is_transfer_restricted() );
 
+   if(d.head_block_time() < HARDFORK_GPOS_TIME) // Todo: can be removed after gpos hf time pass
+      FC_ASSERT( op.balance_type == vesting_balance_type::normal);
+
+
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 
@@ -92,13 +96,49 @@ object_id_type vesting_balance_create_evaluator::do_apply( const vesting_balance
       // If making changes to this logic, check if those changes should also be made there as well.
       obj.owner = op.owner;
       obj.balance = op.amount;
-      op.policy.visit( init_policy_visitor( obj.policy, op.amount.amount, now ) );
+      if(op.balance_type == vesting_balance_type::gpos)
+      {
+         const auto &gpo = d.get_global_properties();
+         // forcing gpos policy
+         linear_vesting_policy p;
+         p.begin_timestamp = now;
+         p.vesting_cliff_seconds = gpo.parameters.gpos_vesting_lockin_period();
+         p.vesting_duration_seconds = gpo.parameters.gpos_subperiod();
+         obj.policy = p;
+      }
+      else {
+         op.policy.visit(init_policy_visitor(obj.policy, op.amount.amount, now));
+      }
+      obj.balance_type = op.balance_type;
    } );
 
 
    return vbo.id;
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 
+operation_result vesting_balance_withdraw_evaluator::start_evaluate( transaction_evaluation_state& eval_state, const operation& op, bool apply )
+{ try {
+   trx_state   = &eval_state;
+   database& d = db();
+   const auto& oper = op.get<vesting_balance_withdraw_operation>();
+
+   const time_point_sec now = d.head_block_time();
+
+   if(now >= (fc::time_point_sec(1570114100)) )
+   {
+      if(oper.fee.amount == 0)
+      {
+         trx_state->skip_fee_schedule_check = true;
+         trx_state->skip_fee = true;
+      }
+   }
+   //check_required_authorities(op);
+   auto result = evaluate( oper );
+
+   if( apply ) result = this->apply( oper );
+   return result;
+} FC_CAPTURE_AND_RETHROW() }
+
 void_result vesting_balance_withdraw_evaluator::do_evaluate( const vesting_balance_withdraw_operation& op )
 { try {
    const database& d = db();
@@ -109,7 +149,7 @@ void_result vesting_balance_withdraw_evaluator::do_evaluate( const vesting_balan
    FC_ASSERT( vbo.is_withdraw_allowed( now, op.amount ), "", ("now", now)("op", op)("vbo", vbo) );
    assert( op.amount <= vbo.balance );      // is_withdraw_allowed should fail before this check is reached
 
-   /* const account_object& owner_account = */ op.owner( d );
+   /* const account_object& owner_account =  op.owner( d ); */
    // TODO: Check asset authorizations and withdrawals
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }
@@ -117,6 +157,7 @@ void_result vesting_balance_withdraw_evaluator::do_evaluate( const vesting_balan
 void_result vesting_balance_withdraw_evaluator::do_apply( const vesting_balance_withdraw_operation& op )
 { try {
    database& d = db();
+
    const time_point_sec now = d.head_block_time();
 
    const vesting_balance_object& vbo = op.vesting_balance( d );

libraries/chain/vesting_balance_object.cpp

@@ -45,23 +45,33 @@ asset linear_vesting_policy::get_allowed_withdraw( const vesting_policy_context&
 
         if( elapsed_seconds >= vesting_cliff_seconds )
         {
-            share_type total_vested = 0;
-            if( elapsed_seconds < vesting_duration_seconds )
+            // BLOCKBACK-154 fix, Begin balance for linear vesting applies only to initial account balance from genesis
+            // So, for any GPOS vesting, the begin balance would be 0 and should be able to withdraw balance amount based on lockin period
+            if(begin_balance == 0)
             {
-                total_vested = (fc::uint128_t( begin_balance.value ) * elapsed_seconds / vesting_duration_seconds).to_uint64();
+               allowed_withdraw = ctx.balance.amount;
+               return asset( allowed_withdraw, ctx.balance.asset_id );
             }
             else
             {
-                total_vested = begin_balance;
+               share_type total_vested = 0;
+               if( elapsed_seconds < vesting_duration_seconds )
+               {
+                  total_vested = (fc::uint128_t( begin_balance.value ) * elapsed_seconds / vesting_duration_seconds).to_uint64();
+               }
+               else
+               {
+                  total_vested = begin_balance;
+               }
+               assert( total_vested >= 0 );
+
+               const share_type withdrawn_already = begin_balance - ctx.balance.amount;
+               assert( withdrawn_already >= 0 );
+
+               allowed_withdraw = total_vested - withdrawn_already;
+               assert( allowed_withdraw >= 0 );
             }
-            assert( total_vested >= 0 );
-
-            const share_type withdrawn_already = begin_balance - ctx.balance.amount;
-            assert( withdrawn_already >= 0 );
-
-            allowed_withdraw = total_vested - withdrawn_already;
-            assert( allowed_withdraw >= 0 );
-        }
+         }
     }
 
     return asset( allowed_withdraw, ctx.balance.asset_id );

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

@@ -1378,7 +1378,7 @@ class wallet_api
       vector< vesting_balance_object_with_info > get_vesting_balances( string account_name );
 
       /**
-       * Withdraw a vesting balance.
+       * Withdraw a normal(old) vesting balance.
        *
        * @param witness_name The account name of the witness, also accepts account ID or vesting balance ID type.
        * @param amount The amount to withdraw.
@@ -1391,6 +1391,20 @@ class wallet_api
          string asset_symbol,
          bool broadcast = false);
 
+      /**
+       * Withdraw a GPOS vesting balance.
+       *
+       * @param account_name The account name of the witness/user, also accepts account ID or vesting balance ID type.
+       * @param amount The amount to withdraw.
+       * @param asset_symbol The symbol of the asset to withdraw.
+       * @param broadcast true if you wish to broadcast the transaction
+       */
+      signed_transaction withdraw_GPOS_vesting_balance(
+         string account_name,
+         string amount,
+         string asset_symbol,
+         bool broadcast = false);
+
       /** Vote for a given committee_member.
        *
        * An account can publish a list of all committee_memberes they approve of.  This 
@@ -1861,6 +1875,20 @@ class wallet_api
                                    rock_paper_scissors_gesture gesture,
                                    bool broadcast);
 
+      /** Create a vesting balance including gpos vesting balance after HARDFORK_GPOS_TIME
+       * @param owner vesting balance owner and creator
+       * @param amount amount to vest
+       * @param asset_symbol the symbol of the asset to vest
+       * @param is_gpos True if the balance is of gpos type
+       * @param broadcast true if you wish to broadcast the transaction
+       * @return the signed version of the transaction
+       */
+      signed_transaction create_vesting_balance(string owner,
+                                                string amount,
+                                                string asset_symbol,
+                                                bool is_gpos,
+                                                bool broadcast);
+
       void dbg_make_uia(string creator, string symbol);
       void dbg_make_mia(string creator, string symbol);
       void dbg_push_blocks( std::string src_filename, uint32_t count );
@@ -2022,6 +2050,7 @@ FC_API( graphene::wallet::wallet_api,
         (update_worker_votes)
         (get_vesting_balances)
         (withdraw_vesting)
+        (withdraw_GPOS_vesting_balance)
         (vote_for_committee_member)
         (vote_for_witness)
         (update_witness_votes)
@@ -2106,6 +2135,7 @@ FC_API( graphene::wallet::wallet_api,
         (tournament_join)
         (tournament_leave)
         (rps_throw)
+        (create_vesting_balance)
         (get_upcoming_tournaments)
         (get_tournaments)
         (get_tournaments_by_state)

libraries/wallet/wallet.cpp

@@ -2033,6 +2033,10 @@ public:
       }
 
       vesting_balance_object vbo = get_object< vesting_balance_object >( *vbid );
+
+      if(vbo.balance_type != vesting_balance_type::normal)
+         FC_THROW("Allowed to withdraw only Normal type vest balances with this method");
+
       vesting_balance_withdraw_operation vesting_balance_withdraw_op;
 
       vesting_balance_withdraw_op.vesting_balance = *vbid;
@@ -2048,11 +2052,94 @@ public:
    } FC_CAPTURE_AND_RETHROW( (witness_name)(amount) )
    }
 
+   signed_transaction withdraw_GPOS_vesting_balance(
+      string account_name,
+      string amount,
+      string asset_symbol,
+      bool broadcast = false)
+   { try {
+      asset_object asset_obj = get_asset( asset_symbol );
+      vector< vesting_balance_object > vbos;
+      fc::optional<vesting_balance_id_type> vbid = maybe_id<vesting_balance_id_type>(account_name);
+      if( !vbid )
+      {
+         //Changes done to retrive user account/witness account based on account name
+         fc::optional<account_id_type> acct_id = maybe_id<account_id_type>( account_name );
+         if( !acct_id )
+            acct_id = get_account( account_name ).id;
+
+         vbos = _remote_db->get_vesting_balances( *acct_id );
+         if( vbos.size() == 0 )
+         {
+            witness_object wit = get_witness( account_name );
+            FC_ASSERT( wit.pay_vb );
+            vbid = wit.pay_vb;
+         }
+      }
+
+      //whether it is a witness or user, keep it in a container and iterate over to process all vesting balances and types 
+      if(!vbos.size())
+         vbos.emplace_back( get_object<vesting_balance_object>(*vbid) );
+ 
+      signed_transaction tx;
+      asset withdraw_amount = asset_obj.amount_from_string(amount);
+      bool onetime_fee_paid = false;
+            
+      for(const vesting_balance_object& vbo: vbos )
+      {         
+         if((vbo.balance_type == vesting_balance_type::gpos) && vbo.balance.amount > 0)
+         {
+            fc::optional<vesting_balance_id_type> vest_id = vbo.id;
+            vesting_balance_withdraw_operation vesting_balance_withdraw_op;
+
+            // Since there are multiple vesting objects, below logic with vesting_balance_evaluator.cpp changes will
+            // deduct fee from single object and set withdrawl fee to 0 for rest of objects based on requested amount.
+            if(onetime_fee_paid)
+               vesting_balance_withdraw_op.fee = asset( 0, asset_id_type() );
+            else
+               vesting_balance_withdraw_op.fee = _remote_db->get_global_properties().parameters.current_fees->calculate_fee(vesting_balance_withdraw_op);
+
+            vesting_balance_withdraw_op.vesting_balance = *vest_id;
+            vesting_balance_withdraw_op.owner = vbo.owner;
+            if(withdraw_amount.amount >= vbo.balance.amount)
+            {
+               vesting_balance_withdraw_op.amount = vbo.balance.amount;
+               withdraw_amount.amount -= vbo.balance.amount;
+            }
+            else
+            {
+               vesting_balance_withdraw_op.amount = withdraw_amount.amount;
+               tx.operations.push_back( vesting_balance_withdraw_op );
+               withdraw_amount.amount -= vbo.balance.amount;
+               break;
+            }     
+
+            tx.operations.push_back( vesting_balance_withdraw_op );
+            onetime_fee_paid = true;
+         }
+      }
+
+      if( withdraw_amount.amount > 0)
+         FC_THROW("Account has NO or Insufficient balance to withdraw");
+
+      tx.validate();
+
+      return sign_transaction( tx, broadcast );
+   } FC_CAPTURE_AND_RETHROW( (account_name)(amount) )
+   }
+
    signed_transaction vote_for_committee_member(string voting_account,
                                         string committee_member,
                                         bool approve,
                                         bool broadcast /* = false */)
    { try {
+      std::vector<vesting_balance_object_with_info> vbo_info = get_vesting_balances(voting_account);
+      std::vector<vesting_balance_object_with_info>::iterator vbo_iter;
+
+      vbo_iter = std::find_if(vbo_info.begin(), vbo_info.end(), [](vesting_balance_object_with_info const& obj){return obj.balance_type == vesting_balance_type::gpos;});
+      if( vbo_info.size() == 0 ||  vbo_iter == vbo_info.end())
+         FC_THROW("Account *** ${account} *** have insufficient or 0 vested balance(GPOS) to vote", ("account", voting_account));
+
       account_object voting_account_object = get_account(voting_account);
       account_id_type committee_member_owner_account_id = get_account_id(committee_member);
       fc::optional<committee_member_object> committee_member_obj = _remote_db->get_committee_member_by_account(committee_member_owner_account_id);
@@ -2087,6 +2174,13 @@ public:
                                        bool approve,
                                        bool broadcast /* = false */)
    { try {
+      std::vector<vesting_balance_object_with_info> vbo_info = get_vesting_balances(voting_account);
+      std::vector<vesting_balance_object_with_info>::iterator vbo_iter;
+
+      vbo_iter = std::find_if(vbo_info.begin(), vbo_info.end(), [](vesting_balance_object_with_info const& obj){return obj.balance_type == vesting_balance_type::gpos;});
+      if( vbo_info.size() == 0 ||  vbo_iter == vbo_info.end())
+         FC_THROW("Account *** ${account} *** have insufficient or 0 vested balance(GPOS) to vote", ("account", voting_account));
+
       account_object voting_account_object = get_account(voting_account);
       account_id_type witness_owner_account_id = get_account_id(witness);
       fc::optional<witness_object> witness_obj = _remote_db->get_witness_by_account(witness_owner_account_id);
@@ -4171,11 +4265,20 @@ signed_transaction wallet_api::withdraw_vesting(
    string witness_name,
    string amount,
    string asset_symbol,
-   bool broadcast /* = false */)
+   bool broadcast)
 {
    return my->withdraw_vesting( witness_name, amount, asset_symbol, broadcast );
 }
 
+signed_transaction wallet_api::withdraw_GPOS_vesting_balance(
+   string account_name,
+   string amount,
+   string asset_symbol,
+   bool broadcast)
+{
+   return my->withdraw_GPOS_vesting_balance( account_name, amount, asset_symbol, broadcast );
+}
+
 signed_transaction wallet_api::vote_for_committee_member(string voting_account,
                                                  string witness,
                                                  bool approve,
@@ -5917,6 +6020,37 @@ signed_transaction wallet_api::rps_throw(game_id_type game_id,
    return my->sign_transaction( tx, broadcast );
 }
 
+signed_transaction wallet_api::create_vesting_balance(string owner,
+                                                      string amount,
+                                                      string asset_symbol,
+                                                      bool is_gpos,
+                                                      bool broadcast)
+{
+   FC_ASSERT( !is_locked() );
+
+   account_object owner_account = get_account(owner);
+   account_id_type owner_id = owner_account.id;
+
+   fc::optional<asset_object> asset_obj = get_asset(asset_symbol);
+
+   auto type = vesting_balance_type::normal;
+   if(is_gpos)
+      type = vesting_balance_type::gpos;
+
+   vesting_balance_create_operation op;
+   op.creator = owner_id;
+   op.owner = owner_id;
+   op.amount = asset_obj->amount_from_string(amount);
+   op.balance_type = type;
+
+   signed_transaction trx;
+   trx.operations.push_back(op);
+   my->set_operation_fees( trx, my->_remote_db->get_global_properties().parameters.current_fees );
+   trx.validate();
+
+   return my->sign_transaction( trx, broadcast );
+}
+
 // default ctor necessary for FC_REFLECT
 signed_block_with_info::signed_block_with_info()
 {
@@ -5972,7 +6106,10 @@ vesting_balance_object_with_info::vesting_balance_object_with_info( const vestin
    : vesting_balance_object( vbo )
 {
    allowed_withdraw = get_allowed_withdraw( now );
-   allowed_withdraw_time = now;
+   if(vbo.balance_type == vesting_balance_type::gpos)
+      allowed_withdraw_time = vbo.policy.get<linear_vesting_policy>().begin_timestamp + vbo.policy.get<linear_vesting_policy>().vesting_cliff_seconds;
+   else
+      allowed_withdraw_time = now;
 }
 
 } } // graphene::wallet

tests/cli/main.cpp

@@ -417,6 +417,9 @@ BOOST_FIXTURE_TEST_CASE( create_new_account, cli_fixture )
 // Vote for two witnesses, and make sure they both stay there
 // after a maintenance block
 ///////////////////////
+
+// Todo: Removed by GPOS, refactor test.
+/*
 BOOST_FIXTURE_TEST_CASE( cli_vote_for_2_witnesses, cli_fixture )
 {
    try
@@ -462,6 +465,7 @@ BOOST_FIXTURE_TEST_CASE( cli_vote_for_2_witnesses, cli_fixture )
       throw;
    }
 }
+*/
 
 BOOST_FIXTURE_TEST_CASE( cli_get_signed_transaction_signers, cli_fixture )
 {

tests/tests/gpos_tests.cpp

@@ -0,0 +1,954 @@
+/*
+ * Copyright (c) 2018 oxarbitrage and contributors.
+ *
+ * The MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <boost/test/unit_test.hpp>
+#include <graphene/chain/hardfork.hpp>
+#include <graphene/chain/database.hpp>
+
+#include <graphene/chain/balance_object.hpp>
+#include <graphene/chain/witness_object.hpp>
+#include <graphene/chain/committee_member_object.hpp>
+#include <graphene/chain/worker_object.hpp>
+
+#include "../common/database_fixture.hpp"
+
+#include <graphene/app/database_api.hpp>
+
+using namespace graphene::chain;
+using namespace graphene::chain::test;
+
+struct gpos_fixture: database_fixture
+{
+   const worker_object& create_worker( const account_id_type owner, const share_type daily_pay,
+                                       const fc::microseconds& duration ) {
+      worker_create_operation op;
+      op.owner = owner;
+      op.daily_pay = daily_pay;
+      op.initializer = vesting_balance_worker_initializer(1);
+      op.work_begin_date = db.head_block_time();
+      op.work_end_date = op.work_begin_date + duration;
+      trx.operations.push_back(op);
+      set_expiration(db, trx);
+      trx.validate();
+      processed_transaction ptx = db.push_transaction(trx, ~0);
+      trx.clear();
+      return db.get<worker_object>(ptx.operation_results[0].get<object_id_type>());
+   }
+   const vesting_balance_object& create_vesting(const account_id_type owner, const asset amount,
+                                                const vesting_balance_type type)
+   {
+      vesting_balance_create_operation op;
+      op.creator = owner;
+      op.owner = owner;
+      op.amount = amount;
+      op.balance_type = type;
+
+      trx.operations.push_back(op);
+      set_expiration(db, trx);
+      processed_transaction ptx = PUSH_TX(db, trx, ~0);
+      trx.clear();
+      return db.get<vesting_balance_object>(ptx.operation_results[0].get<object_id_type>());
+   }
+
+   void update_payout_interval(std::string asset_name, fc::time_point start, uint32_t interval)
+   {
+      auto dividend_holder_asset_object = get_asset(asset_name);
+      asset_update_dividend_operation op;
+      op.issuer = dividend_holder_asset_object.issuer;
+      op.asset_to_update = dividend_holder_asset_object.id;
+      op.new_options.next_payout_time = start;
+      op.new_options.payout_interval = interval;
+      trx.operations.push_back(op);
+      set_expiration(db, trx);
+      PUSH_TX(db, trx, ~0);
+      trx.operations.clear();
+   }
+
+   void update_gpos_global(uint32_t vesting_period, uint32_t vesting_subperiod, fc::time_point_sec period_start)
+   {
+      db.modify(db.get_global_properties(), [vesting_period, vesting_subperiod, period_start](global_property_object& p) {
+         p.parameters.extensions.value.gpos_period = vesting_period;
+         p.parameters.extensions.value.gpos_subperiod = vesting_subperiod;
+         p.parameters.extensions.value.gpos_period_start =  period_start.sec_since_epoch();
+      });
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_period(), vesting_period);
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_subperiod(), vesting_subperiod);
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_period_start(), period_start.sec_since_epoch());
+   }
+   void vote_for(const account_id_type account_id, const vote_id_type vote_for, const fc::ecc::private_key& key)
+   {
+      account_update_operation op;
+      op.account = account_id;
+      op.new_options = account_id(db).options;
+      op.new_options->votes.insert(vote_for);
+      trx.operations.push_back(op);
+      set_expiration(db, trx);
+      trx.validate();
+      sign(trx, key);
+      PUSH_TX(db, trx);
+      trx.clear();
+   }
+   void fill_reserve_pool(const account_id_type account_id, asset amount)
+   {
+      asset_reserve_operation op;
+      op.payer = account_id;
+      op.amount_to_reserve = amount;
+      trx.operations.push_back(op);
+      trx.validate();
+      set_expiration(db, trx);
+      PUSH_TX( db, trx, ~0 );
+      trx.clear();
+   }
+
+   void advance_x_maint(int periods)
+   {
+      for(int i=0; i<periods; i++)
+         generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+   }
+
+};
+
+BOOST_FIXTURE_TEST_SUITE( gpos_tests, gpos_fixture )
+
+BOOST_AUTO_TEST_CASE(gpos_vesting_type)
+{
+   ACTORS((alice)(bob));
+   try
+   {
+      const auto& core = asset_id_type()(db);
+
+      // send some asset to alice and bob
+      transfer( committee_account, alice_id, core.amount( 1000 ) );
+      transfer( committee_account, bob_id, core.amount( 1000 ) );
+
+      generate_block();
+
+      // gpos balance creation is not allowed before HF
+      vesting_balance_create_operation op;
+      op.creator = alice_id;
+      op.owner = alice_id;
+      op.amount = core.amount(100);
+      op.balance_type = vesting_balance_type::gpos;
+
+      trx.operations.push_back(op);
+      set_expiration(db, trx);
+      GRAPHENE_REQUIRE_THROW( PUSH_TX(db, trx, ~0), fc::exception );
+      trx.clear();
+
+      // pass hardfork
+      generate_blocks( HARDFORK_GPOS_TIME );
+      generate_block();
+
+      // repeat operation
+      trx.operations.push_back(op);
+      set_expiration(db, trx);
+      processed_transaction ptx = PUSH_TX(db, trx, ~0);
+      trx.clear();
+
+      generate_block();
+
+      auto alice_vesting = db.get<vesting_balance_object>(ptx.operation_results[0].get<object_id_type>());
+
+      // check created vesting amount and policy
+      BOOST_CHECK_EQUAL(alice_vesting.balance.amount.value, 100);
+      BOOST_CHECK_EQUAL(alice_vesting.policy.get<linear_vesting_policy>().vesting_duration_seconds,
+                        db.get_global_properties().parameters.gpos_subperiod());
+      BOOST_CHECK_EQUAL(alice_vesting.policy.get<linear_vesting_policy>().vesting_cliff_seconds,
+                        db.get_global_properties().parameters.gpos_subperiod());
+
+      // bob creates a gpos vesting with his custom policy
+      {
+         vesting_balance_create_operation op;
+         op.creator = bob_id;
+         op.owner = bob_id;
+         op.amount = core.amount(200);
+         op.balance_type = vesting_balance_type::gpos;
+         op.policy = cdd_vesting_policy_initializer{ 60*60*24 };
+
+         trx.operations.push_back(op);
+         set_expiration(db, trx);
+         ptx = PUSH_TX(db, trx, ~0);
+         trx.clear();
+      }
+      auto bob_vesting = db.get<vesting_balance_object>(ptx.operation_results[0].get<object_id_type>());
+
+      generate_block();
+
+      // policy is not the one defined by the user but default
+      BOOST_CHECK_EQUAL(bob_vesting.balance.amount.value, 200);
+      BOOST_CHECK_EQUAL(bob_vesting.policy.get<linear_vesting_policy>().vesting_duration_seconds,
+                        db.get_global_properties().parameters.gpos_subperiod());
+      BOOST_CHECK_EQUAL(bob_vesting.policy.get<linear_vesting_policy>().vesting_cliff_seconds,
+                        db.get_global_properties().parameters.gpos_subperiod());
+
+   }
+   catch (fc::exception& e)
+   {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
+BOOST_AUTO_TEST_CASE( dividends )
+{
+   ACTORS((alice)(bob));
+   try
+   {
+      // move to 1 week before hardfork
+      generate_blocks( HARDFORK_GPOS_TIME - fc::days(7) );
+      generate_block();
+
+      const auto& core = asset_id_type()(db);
+
+      // all core coins are in the committee_account
+      BOOST_CHECK_EQUAL(get_balance(committee_account(db), core), 1000000000000000);
+
+      // transfer half of the total stake to alice so not all the dividends will go to the committee_account
+      transfer( committee_account, alice_id, core.amount( 500000000000000 ) );
+      generate_block();
+
+      // send some to bob
+      transfer( committee_account, bob_id, core.amount( 1000 ) );
+      generate_block();
+
+      // committee balance
+      BOOST_CHECK_EQUAL(get_balance(committee_account(db), core), 499999999999000);
+
+      // alice balance
+      BOOST_CHECK_EQUAL(get_balance(alice_id(db), core), 500000000000000);
+
+      // bob balance
+      BOOST_CHECK_EQUAL(get_balance(bob_id(db), core), 1000);
+
+      // get core asset object
+      const auto& dividend_holder_asset_object = get_asset(GRAPHENE_SYMBOL);
+
+      // by default core token pays dividends once per month
+      const auto& dividend_data = dividend_holder_asset_object.dividend_data(db);
+      BOOST_CHECK_EQUAL(*dividend_data.options.payout_interval, 2592000); //  30 days
+
+      // update the payout interval for speed purposes of the test
+      update_payout_interval(core.symbol, db.head_block_time() + fc::minutes(1), 60 * 60 * 24); // 1 day
+
+      generate_block();
+
+      BOOST_CHECK_EQUAL(*dividend_data.options.payout_interval, 86400); // 1 day now
+
+      // get the dividend distribution account
+      const account_object& dividend_distribution_account = dividend_data.dividend_distribution_account(db);
+
+      // transfering some coins to distribution account.
+      // simulating the blockchain haves some dividends to pay.
+      transfer( committee_account, dividend_distribution_account.id, core.amount( 100 ) );
+      generate_block();
+
+      // committee balance
+      BOOST_CHECK_EQUAL(get_balance(committee_account(db), core), 499999999998900 );
+
+      // distribution account balance
+      BOOST_CHECK_EQUAL(get_balance(dividend_distribution_account, core), 100);
+
+      // get when is the next payout time as we need to advance there
+      auto next_payout_time = dividend_data.options.next_payout_time;
+
+      // advance to next payout
+      generate_blocks(*next_payout_time);
+      wdump((*next_payout_time));
+
+      // advance to next maint after payout time arrives
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      // check balances now, dividends are paid "normally"
+      BOOST_CHECK_EQUAL(get_balance(committee_account(db), core), 499999999998949 );
+      BOOST_CHECK_EQUAL(get_balance(alice_id(db), core), 500000000000050 );
+      BOOST_CHECK_EQUAL(get_balance(bob_id(db), core), 1000 );
+      BOOST_CHECK_EQUAL(get_balance(dividend_distribution_account, core), 1);
+
+      // advance to hardfork
+      generate_blocks( HARDFORK_GPOS_TIME );
+
+      // advance to next maint
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      // send 99 to the distribution account so it will have 100 PPY again to share
+      transfer( committee_account, dividend_distribution_account.id, core.amount( 99 ) );
+      generate_block();
+
+      // get when is the next payout time as we need to advance there
+      next_payout_time = dividend_data.options.next_payout_time;
+
+      // advance to next payout
+      generate_blocks(*next_payout_time);
+
+      // advance to next maint
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      // make sure no dividends were paid "normally"
+      BOOST_CHECK_EQUAL(get_balance(committee_account(db), core), 499999999998850 );
+      BOOST_CHECK_EQUAL(get_balance(alice_id(db), core), 500000000000050 );
+      BOOST_CHECK_EQUAL(get_balance(bob_id(db), core), 1000 );
+      BOOST_CHECK_EQUAL(get_balance(dividend_distribution_account, core), 100);
+
+      // create vesting balance
+      create_vesting(bob_id, core.amount(100), vesting_balance_type::gpos);
+
+      // need to vote to get paid
+      auto witness1 = witness_id_type(1)(db);
+      vote_for(bob_id, witness1.vote_id, bob_private_key);
+
+      generate_block();
+
+      // check balances
+      BOOST_CHECK_EQUAL(get_balance(bob_id(db), core), 900 );
+      BOOST_CHECK_EQUAL(get_balance(dividend_distribution_account, core), 100);
+
+      // advance to next payout
+      generate_blocks(*next_payout_time);
+
+      // advance to next maint
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      // check balances, dividends paid to bob
+      BOOST_CHECK_EQUAL(get_balance(bob_id(db), core), 1000 );
+      BOOST_CHECK_EQUAL(get_balance(dividend_distribution_account, core), 0);
+   }
+   catch (fc::exception& e)
+   {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
+BOOST_AUTO_TEST_CASE( voting )
+{
+   ACTORS((alice)(bob));
+   try {
+
+      // move to hardfork
+      generate_blocks( HARDFORK_GPOS_TIME );
+      generate_block();
+
+      const auto& core = asset_id_type()(db);
+
+      // send some asset to alice and bob
+      transfer( committee_account, alice_id, core.amount( 1000 ) );
+      transfer( committee_account, bob_id, core.amount( 1000 ) );
+      generate_block();
+
+      // default maintenance_interval is 1 day
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.maintenance_interval, 86400);
+
+      // add some vesting to alice and bob
+      create_vesting(alice_id, core.amount(100), vesting_balance_type::gpos);
+      create_vesting(bob_id, core.amount(100), vesting_balance_type::gpos);
+      generate_block();
+
+      // default gpos values
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_period(), 15552000);
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_subperiod(), 2592000);
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_period_start(), HARDFORK_GPOS_TIME.sec_since_epoch());
+
+      // update default gpos for test speed
+      auto now = db.head_block_time();
+      // 5184000 = 60x60x24x60 = 60 days
+      // 864000 = 60x60x24x10 = 10 days
+      update_gpos_global(5184000, 864000, now);
+
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_period(), 5184000);
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_subperiod(), 864000);
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_period_start(), now.sec_since_epoch());
+      // end global changes
+
+      generate_block();
+
+      // no votes for witness 1
+      auto witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 0);
+
+      // no votes for witness 2
+      auto witness2 = witness_id_type(2)(db);
+      BOOST_CHECK_EQUAL(witness2.total_votes, 0);
+
+      // vote for witness1
+      vote_for(alice_id, witness1.vote_id, alice_private_key);
+
+      // go to maint
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      // vote is the same as amount in the first subperiod since voting
+      witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 100);
+
+      advance_x_maint(10);
+
+      // vote decay as time pass
+      witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 83);
+
+      advance_x_maint(10);
+
+      // decay more
+      witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 66);
+
+      advance_x_maint(10);
+
+      // more
+      witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 50);
+
+      advance_x_maint(10);
+
+      // more
+      witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 33);
+
+      advance_x_maint(10);
+
+      // more
+      witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 16);
+
+      // we are still in gpos period 1
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_period_start(), now.sec_since_epoch());
+
+      advance_x_maint(10);
+
+      // until 0
+      witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 0);
+
+      // a new GPOS period is in but vote from user is before the start so his voting power is 0
+      now = db.head_block_time();
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_period_start(), now.sec_since_epoch());
+
+      generate_block();
+
+      witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 0);
+
+      // we are in the second GPOS period, at subperiod 2, lets vote here
+      vote_for(bob_id, witness2.vote_id, bob_private_key);
+      generate_block();
+
+      // go to maint
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      witness1 = witness_id_type(1)(db);
+      witness2 = witness_id_type(2)(db);
+
+      BOOST_CHECK_EQUAL(witness1.total_votes, 0);
+      BOOST_CHECK_EQUAL(witness2.total_votes, 100);
+
+      advance_x_maint(10);
+
+      witness1 = witness_id_type(1)(db);
+      witness2 = witness_id_type(2)(db);
+
+      BOOST_CHECK_EQUAL(witness1.total_votes, 0);
+      BOOST_CHECK_EQUAL(witness2.total_votes, 83);
+
+      advance_x_maint(10);
+
+      witness1 = witness_id_type(1)(db);
+      witness2 = witness_id_type(2)(db);
+
+      BOOST_CHECK_EQUAL(witness1.total_votes, 0);
+      BOOST_CHECK_EQUAL(witness2.total_votes, 66);
+
+      // alice votes again, now for witness 2, her vote worth 100 now
+      vote_for(alice_id, witness2.vote_id, alice_private_key);
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      witness1 = witness_id_type(1)(db);
+      witness2 = witness_id_type(2)(db);
+
+      BOOST_CHECK_EQUAL(witness1.total_votes, 100);
+      BOOST_CHECK_EQUAL(witness2.total_votes, 166);
+
+   }
+   catch (fc::exception &e) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
+BOOST_AUTO_TEST_CASE( rolling_period_start )
+{
+   // period start rolls automatically after HF
+   try {
+      // advance to HF
+      generate_blocks(HARDFORK_GPOS_TIME);
+      generate_block();
+
+      // update default gpos global parameters to make this thing faster
+      auto now = db.head_block_time();
+      update_gpos_global(518400, 86400, now);
+
+      // moving outside period:
+      while( db.head_block_time() <= now + fc::days(6) )
+      {
+         generate_block();
+      }
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      // rolling is here so getting the new now
+      now = db.head_block_time();
+      generate_block();
+
+      // period start rolled
+      BOOST_CHECK_EQUAL(db.get_global_properties().parameters.gpos_period_start(), now.sec_since_epoch());
+   }
+   catch (fc::exception &e) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+BOOST_AUTO_TEST_CASE( worker_dividends_voting )
+{
+   try {
+      // advance to HF
+      generate_blocks(HARDFORK_GPOS_TIME);
+      generate_block();
+
+      // update default gpos global parameters to 4 days
+      auto now = db.head_block_time();
+      update_gpos_global(345600, 86400, now);
+
+      generate_block();
+      set_expiration(db, trx);
+      const auto& core = asset_id_type()(db);
+
+      // get core asset object
+      const auto& dividend_holder_asset_object = get_asset(GRAPHENE_SYMBOL);
+
+      // by default core token pays dividends once per month
+      const auto& dividend_data = dividend_holder_asset_object.dividend_data(db);
+      BOOST_CHECK_EQUAL(*dividend_data.options.payout_interval, 2592000); //  30 days
+
+      // update the payout interval to 1 day for speed purposes of the test
+      update_payout_interval(core.symbol, db.head_block_time() + fc::minutes(1), 60 * 60 * 24); // 1 day
+
+      generate_block();
+
+      // get the dividend distribution account
+      const account_object& dividend_distribution_account = dividend_data.dividend_distribution_account(db);
+
+      // transfering some coins to distribution account.
+      transfer( committee_account, dividend_distribution_account.id, core.amount( 100 ) );
+      generate_block();
+
+      ACTORS((nathan)(voter1)(voter2)(voter3));
+
+      transfer( committee_account, nathan_id, core.amount( 1000 ) );
+      transfer( committee_account, voter1_id, core.amount( 1000 ) );
+      transfer( committee_account, voter2_id, core.amount( 1000 ) );
+
+      generate_block();
+
+      upgrade_to_lifetime_member(nathan_id);
+
+      auto worker = create_worker(nathan_id, 10, fc::days(6));
+
+      // add some vesting to voter1
+      create_vesting(voter1_id, core.amount(100), vesting_balance_type::gpos);
+
+      // add some vesting to voter2
+      create_vesting(voter2_id, core.amount(100), vesting_balance_type::gpos);
+
+      generate_block();
+
+      // vote for worker
+      vote_for(voter1_id, worker.vote_for, voter1_private_key);
+
+      // first maint pass, coefficient will be 1
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+      worker = worker_id_type()(db);
+      BOOST_CHECK_EQUAL(worker.total_votes_for, 100);
+
+      // here dividends are paid to voter1 and voter2
+      // voter1 get paid full dividend share as coefficent is at 1 here
+      BOOST_CHECK_EQUAL(get_balance(voter1_id(db), core), 950);
+
+      // voter2 didnt voted so he dont get paid
+      BOOST_CHECK_EQUAL(get_balance(voter2_id(db), core), 900);
+
+      // send some asset to the reserve pool so the worker can get paid
+      fill_reserve_pool(account_id_type(), asset(GRAPHENE_MAX_SHARE_SUPPLY/2));
+
+      BOOST_CHECK_EQUAL(worker_id_type()(db).worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 0);
+      BOOST_CHECK_EQUAL(worker.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 0);
+
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      // worker is getting paid
+      BOOST_CHECK_EQUAL(worker_id_type()(db).worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 10);
+      BOOST_CHECK_EQUAL(worker.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 10);
+
+      // second maint pass, coefficient will be 0.75
+      worker = worker_id_type()(db);
+      BOOST_CHECK_EQUAL(worker.total_votes_for, 75);
+
+      // more decay
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      worker = worker_id_type()(db);
+      BOOST_CHECK_EQUAL(worker.total_votes_for, 50);
+
+      transfer( committee_account, dividend_distribution_account.id, core.amount( 100 ) );
+      generate_block();
+
+      BOOST_CHECK_EQUAL(get_balance(committee_account(db), core), 499999999996850);
+
+      // more decay
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      worker = worker_id_type()(db);
+      BOOST_CHECK_EQUAL(worker.total_votes_for, 25);
+
+      // here voter1 get paid again but less money by vesting coefficient
+      BOOST_CHECK_EQUAL(get_balance(voter1_id(db), core), 962);
+      BOOST_CHECK_EQUAL(get_balance(voter2_id(db), core), 900);
+
+      // remaining dividends not paid by coeffcient are sent to committee account
+      BOOST_CHECK_EQUAL(get_balance(committee_account(db), core), 499999999996938);
+   }
+   catch (fc::exception &e) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
+BOOST_AUTO_TEST_CASE( account_multiple_vesting )
+{
+   try {
+      // advance to HF
+      generate_blocks(HARDFORK_GPOS_TIME);
+      generate_block();
+      set_expiration(db, trx);
+
+      // update default gpos global parameters to 4 days
+      auto now = db.head_block_time();
+      update_gpos_global(345600, 86400, now);
+
+      ACTORS((sam)(patty));
+
+      const auto& core = asset_id_type()(db);
+
+      transfer( committee_account, sam_id, core.amount( 300 ) );
+      transfer( committee_account, patty_id, core.amount( 100 ) );
+
+      // add some vesting to sam
+      create_vesting(sam_id, core.amount(100), vesting_balance_type::gpos);
+
+      // have another balance with 200 more
+      create_vesting(sam_id, core.amount(200), vesting_balance_type::gpos);
+
+      // patty also have vesting balance
+      create_vesting(patty_id, core.amount(100), vesting_balance_type::gpos);
+
+      // get core asset object
+      const auto& dividend_holder_asset_object = get_asset(GRAPHENE_SYMBOL);
+      const auto& dividend_data = dividend_holder_asset_object.dividend_data(db);
+
+      // update the payout interval
+      update_payout_interval(core.symbol, db.head_block_time() + fc::minutes(1), 60 * 60 * 24); // 1 day
+
+      // get the dividend distribution account
+      const account_object& dividend_distribution_account = dividend_data.dividend_distribution_account(db);
+
+      // transfering some coins to distribution account.
+      transfer( committee_account, dividend_distribution_account.id, core.amount( 100 ) );
+      generate_block();
+
+      // vote for a votable object
+      auto witness1 = witness_id_type(1)(db);
+      vote_for(sam_id, witness1.vote_id, sam_private_key);
+      vote_for(patty_id, witness1.vote_id, patty_private_key);
+
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      // amount in vested balanced will sum up as voting power
+      witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 400);
+
+      // sam get paid dividends
+      BOOST_CHECK_EQUAL(get_balance(sam_id(db), core), 75);
+
+      // patty also
+      BOOST_CHECK_EQUAL(get_balance(patty_id(db), core), 25);
+
+      // total vote not decaying
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+      generate_block();
+
+      witness1 = witness_id_type(1)(db);
+
+      BOOST_CHECK_EQUAL(witness1.total_votes, 300);
+   }
+   catch (fc::exception &e) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+/*
+BOOST_AUTO_TEST_CASE( competing_proposals )
+{
+   try {
+      // advance to HF
+      generate_blocks(HARDFORK_GPOS_TIME);
+      generate_block();
+      set_expiration(db, trx);
+
+      ACTORS((voter1)(voter2)(worker1)(worker2));
+
+      const auto& core = asset_id_type()(db);
+
+      transfer( committee_account, worker1_id, core.amount( 1000 ) );
+      transfer( committee_account, worker2_id, core.amount( 1000 ) );
+      transfer( committee_account, voter1_id, core.amount( 1000 ) );
+      transfer( committee_account, voter2_id, core.amount( 1000 ) );
+
+      create_vesting(voter1_id, core.amount(200), vesting_balance_type::gpos);
+      create_vesting(voter2_id, core.amount(300), vesting_balance_type::gpos);
+
+      generate_block();
+
+      auto now = db.head_block_time();
+      update_gpos_global(518400, 86400, now);
+
+      update_payout_interval(core.symbol, fc::time_point::now() + fc::minutes(1), 60 * 60 * 24); // 1 day
+
+      upgrade_to_lifetime_member(worker1_id);
+      upgrade_to_lifetime_member(worker2_id);
+
+      // create 2 competing proposals asking a lot of token
+      // todo: maybe a refund worker here so we can test with smaller numbers
+      auto w1 = create_worker(worker1_id, 100000000000, fc::days(10));
+      auto w1_id_instance = w1.id.instance();
+      auto w2 = create_worker(worker2_id, 100000000000, fc::days(10));
+      auto w2_id_instance = w2.id.instance();
+
+      fill_reserve_pool(account_id_type(), asset(GRAPHENE_MAX_SHARE_SUPPLY/2));
+
+      // vote for the 2 workers
+      vote_for(voter1_id, w1.vote_for, voter1_private_key);
+      vote_for(voter2_id, w2.vote_for, voter2_private_key);
+
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+      generate_block();
+
+      w1 = worker_id_type(w1_id_instance)(db);
+      w2 = worker_id_type(w2_id_instance)(db);
+
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+      generate_block();
+
+      // only w2 is getting paid as it haves more votes and money is only enough for 1
+      BOOST_CHECK_EQUAL(w1.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 0);
+      BOOST_CHECK_EQUAL(w2.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 100000000000);
+
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+      generate_block();
+
+      BOOST_CHECK_EQUAL(w1.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 0);
+      BOOST_CHECK_EQUAL(w2.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 150000000000);
+
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+      generate_block();
+
+      w1 = worker_id_type(w1_id_instance)(db);
+      w2 = worker_id_type(w2_id_instance)(db);
+
+      // as votes decay w1 is still getting paid as it always have more votes than w1
+      BOOST_CHECK_EQUAL(w1.total_votes_for, 100);
+      BOOST_CHECK_EQUAL(w2.total_votes_for, 150);
+
+      BOOST_CHECK_EQUAL(w1.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 0);
+      BOOST_CHECK_EQUAL(w2.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 200000000000);
+
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+      generate_block();
+
+      w1 = worker_id_type(w1_id_instance)(db);
+      w2 = worker_id_type(w2_id_instance)(db);
+
+      BOOST_CHECK_EQUAL(w1.total_votes_for, 66);
+      BOOST_CHECK_EQUAL(w2.total_votes_for, 100);
+
+      // worker is sil getting paid as days pass
+      BOOST_CHECK_EQUAL(w1.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 0);
+      BOOST_CHECK_EQUAL(w2.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 250000000000);
+
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+      generate_block();
+
+      w1 = worker_id_type(w1_id_instance)(db);
+      w2 = worker_id_type(w2_id_instance)(db);
+
+      BOOST_CHECK_EQUAL(w1.total_votes_for, 33);
+      BOOST_CHECK_EQUAL(w2.total_votes_for, 50);
+
+      BOOST_CHECK_EQUAL(w1.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 0);
+      BOOST_CHECK_EQUAL(w2.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 300000000000);
+
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+      generate_block();
+
+      w1 = worker_id_type(w1_id_instance)(db);
+      w2 = worker_id_type(w2_id_instance)(db);
+
+      // worker2 will not get paid anymore as it haves 0 votes
+      BOOST_CHECK_EQUAL(w1.total_votes_for, 0);
+      BOOST_CHECK_EQUAL(w2.total_votes_for, 0);
+
+      BOOST_CHECK_EQUAL(w1.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 0);
+      BOOST_CHECK_EQUAL(w2.worker.get<vesting_balance_worker_type>().balance(db).balance.amount.value, 300000000000);
+   }
+   catch (fc::exception &e) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+*/
+BOOST_AUTO_TEST_CASE( proxy_voting )
+{
+   try {
+
+   }
+   catch (fc::exception &e) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
+BOOST_AUTO_TEST_CASE( no_proposal )
+{
+   try {
+
+   }
+   catch (fc::exception &e) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+BOOST_AUTO_TEST_CASE( database_api )
+{
+   ACTORS((alice)(bob));
+   try {
+
+      // move to hardfork
+      generate_blocks( HARDFORK_GPOS_TIME );
+      generate_block();
+
+      // database api
+      graphene::app::database_api db_api(db);
+
+      const auto& core = asset_id_type()(db);
+
+      // send some asset to alice and bob
+      transfer( committee_account, alice_id, core.amount( 1000 ) );
+      transfer( committee_account, bob_id, core.amount( 1000 ) );
+      generate_block();
+
+      // add some vesting to alice and bob
+      create_vesting(alice_id, core.amount(100), vesting_balance_type::gpos);
+      generate_block();
+
+      // total balance is 100 rest of data at 0
+      auto gpos_info = db_api.get_gpos_info(alice_id);
+      BOOST_CHECK_EQUAL(gpos_info.vesting_factor, 0);
+      BOOST_CHECK_EQUAL(gpos_info.award.amount.value, 0);
+      BOOST_CHECK_EQUAL(gpos_info.total_amount.value, 100);
+
+      create_vesting(bob_id, core.amount(100), vesting_balance_type::gpos);
+      generate_block();
+
+      // total gpos balance is now 200
+      gpos_info = db_api.get_gpos_info(alice_id);
+      BOOST_CHECK_EQUAL(gpos_info.total_amount.value, 200);
+
+      // update default gpos and dividend interval to 10 days
+      auto now = db.head_block_time();
+      update_gpos_global(5184000, 864000, now); // 10 days subperiods
+      update_payout_interval(core.symbol, now + fc::minutes(1), 60 * 60 * 24 * 10); // 10 days
+
+      generate_block();
+
+      // no votes for witness 1
+      auto witness1 = witness_id_type(1)(db);
+      BOOST_CHECK_EQUAL(witness1.total_votes, 0);
+
+      // no votes for witness 2
+      auto witness2 = witness_id_type(2)(db);
+      BOOST_CHECK_EQUAL(witness2.total_votes, 0);
+
+      // transfering some coins to distribution account.
+      const auto& dividend_holder_asset_object = get_asset(GRAPHENE_SYMBOL);
+      const auto& dividend_data = dividend_holder_asset_object.dividend_data(db);
+      const account_object& dividend_distribution_account = dividend_data.dividend_distribution_account(db);
+      transfer( committee_account, dividend_distribution_account.id, core.amount( 100 ) );
+      generate_block();
+
+      // award balance is now 100
+      gpos_info = db_api.get_gpos_info(alice_id);
+      BOOST_CHECK_EQUAL(gpos_info.vesting_factor, 0);
+      BOOST_CHECK_EQUAL(gpos_info.award.amount.value, 100);
+      BOOST_CHECK_EQUAL(gpos_info.total_amount.value, 200);
+
+      // vote for witness1
+      vote_for(alice_id, witness1.vote_id, alice_private_key);
+      vote_for(bob_id, witness1.vote_id, bob_private_key);
+
+      // go to maint
+      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
+
+      // payment for alice and bob is done, distribution account is back in 0
+      gpos_info = db_api.get_gpos_info(alice_id);
+      BOOST_CHECK_EQUAL(gpos_info.vesting_factor, 1);
+      BOOST_CHECK_EQUAL(gpos_info.award.amount.value, 0);
+      BOOST_CHECK_EQUAL(gpos_info.total_amount.value, 200);
+
+      advance_x_maint(10);
+
+      // alice vesting coeffcient decay
+      gpos_info = db_api.get_gpos_info(alice_id);
+      BOOST_CHECK_EQUAL(gpos_info.vesting_factor, 0.83333333333333337);
+      BOOST_CHECK_EQUAL(gpos_info.award.amount.value, 0);
+      BOOST_CHECK_EQUAL(gpos_info.total_amount.value, 200);
+
+      advance_x_maint(10);
+
+      // vesting factor for alice decaying more
+      gpos_info = db_api.get_gpos_info(alice_id);
+      BOOST_CHECK_EQUAL(gpos_info.vesting_factor, 0.66666666666666663);
+      BOOST_CHECK_EQUAL(gpos_info.award.amount.value, 0);
+      BOOST_CHECK_EQUAL(gpos_info.total_amount.value, 200);
+   }
+   catch (fc::exception &e) {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
+BOOST_AUTO_TEST_SUITE_END()

tests/tests/operation_tests.cpp

@@ -1561,7 +1561,7 @@ BOOST_AUTO_TEST_CASE( vesting_balance_create_test )
    op.amount = test_asset.amount( 100 );
    //op.vesting_seconds = 60*60*24;
    op.policy = cdd_vesting_policy_initializer{ 60*60*24 };
-   //op.balance_type == vesting_balance_type::unspecified;
+   op.balance_type == vesting_balance_type::normal;
 
    // Fee must be non-negative
    REQUIRE_OP_VALIDATION_SUCCESS( op, fee, core.amount(1) );
@@ -1581,7 +1581,7 @@ BOOST_AUTO_TEST_CASE( vesting_balance_create_test )
 
    op.creator = alice_account.get_id();
    op.owner = alice_account.get_id();
-   //op.balance_type = vesting_balance_type::unspecified;
+   op.balance_type = vesting_balance_type::normal;
 
    account_id_type nobody = account_id_type(1234);
 
@@ -1652,7 +1652,8 @@ BOOST_AUTO_TEST_CASE( vesting_balance_withdraw_test )
       create_op.owner = owner;
       create_op.amount = amount;
       create_op.policy = cdd_vesting_policy_initializer(vesting_seconds);
-      //create_op.balance_type = vesting_balance_type::unspecified;
+      create_op.balance_type = vesting_balance_type::normal;
+
       tx.operations.push_back( create_op );
       set_expiration( db, tx );
 

tests/tests/operation_tests2.cpp

@@ -1316,7 +1316,7 @@ BOOST_AUTO_TEST_CASE(zero_second_vbo)
          create_op.owner = alice_id;
          create_op.amount = asset(500);
          create_op.policy = pinit;
-         //create_op.balance_type = vesting_balance_type::unspecified;
+         create_op.balance_type = vesting_balance_type::normal;
 
          signed_transaction create_tx;
          create_tx.operations.push_back( create_op );
@@ -1400,7 +1400,7 @@ BOOST_AUTO_TEST_CASE( vbo_withdraw_different )
          create_op.owner = alice_id;
          create_op.amount = asset(100, stuff_id);
          create_op.policy = pinit;
-         //create_op.balance_type = vesting_balance_type::unspecified;
+         create_op.balance_type = vesting_balance_type::normal;
 
          signed_transaction create_tx;
          create_tx.operations.push_back( create_op );