void system_contract::onblock( block_timestamp timestamp, account_name producer ) {

      using namespace eosio;

      require_auth(N(eosio));

      /** until activated stake crosses this threshold no new rewards are paid */

      if( _gstate.total_activated_stake < min_activated_stake )

         return;

      if( _gstate.last_pervote_bucket_fill ==  )  /// start the presses

         _gstate.last_pervote_bucket_fill = current_time();

      /**

       * At startup the initial producer may not be one that is registered / elected

       * and therefore there may be no producer object for them.

       */

      auto prod = _producers.find(producer);

      if ( prod != _producers.end() ) {

         _gstate.total_unpaid_blocks++;

         _producers.modify( prod, , [&](auto& p ) {

               p.unpaid_blocks++;

         });

      }

      /// only update block producers once every minute, block_timestamp is in half seconds

      if( timestamp.slot - _gstate.last_producer_schedule_update.slot >  ) {

         update_elected_producers( timestamp );

         if( (timestamp.slot - _gstate.last_name_close.slot) > blocks_per_day ) {

            name_bid_table bids(_self,_self);

            auto idx = bids.get_index<N(highbid)>();

            auto highest = idx.begin();

            if( highest != idx.end() &&

                highest->high_bid >  &&

                highest->last_bid_time < (current_time() - useconds_per_day) &&

                _gstate.thresh_activated_stake_time >  &&

                (current_time() - _gstate.thresh_activated_stake_time) >  * useconds_per_day ) {

                   _gstate.last_name_close = timestamp;

                   idx.modify( highest, , [&]( auto& b ){

                         b.high_bid = -b.high_bid;

               });

            }

         }

      }

   }

void system_contract::claimrewards( const account_name& owner ) {

      require_auth(owner);

      const auto& prod = _producers.get( owner );

      eosio_assert( prod.active(), "producer does not have an active key" );

      eosio_assert( _gstate.total_activated_stake >= min_activated_stake,

                    "cannot claim rewards until the chain is activated (at least 15% of all tokens participate in voting)" );

      auto ct = current_time();

      eosio_assert( ct - prod.last_claim_time > useconds_per_day, "already claimed rewards within past day" );

      const asset token_supply   = token( N(eosio.token)).get_supply(symbol_type(system_token_symbol).name() );

      const auto usecs_since_last_fill = ct - _gstate.last_pervote_bucket_fill;

      if( usecs_since_last_fill > 0 && _gstate.last_pervote_bucket_fill > 0 ) {

         auto new_tokens = static_cast<int64_t>( (continuous_rate * double(token_supply.amount) * double(usecs_since_last_fill)) / double(useconds_per_year) );

         auto to_producers       = new_tokens / 5;

         auto to_savings         = new_tokens - to_producers;

         auto to_per_block_pay   = to_producers / 4;

         auto to_per_vote_pay    = to_producers - to_per_block_pay;

         INLINE_ACTION_SENDER(eosio::token, issue)( N(eosio.token), {{N(eosio),N(active)}},

                                                    {N(eosio), asset(new_tokens), std::string("issue tokens for producer pay and savings")} );

         INLINE_ACTION_SENDER(eosio::token, transfer)( N(eosio.token), {N(eosio),N(active)},

                                                       { N(eosio), N(eosio.saving), asset(to_savings), "unallocated inflation" } );

         INLINE_ACTION_SENDER(eosio::token, transfer)( N(eosio.token), {N(eosio),N(active)},

                                                       { N(eosio), N(eosio.bpay), asset(to_per_block_pay), "fund per-block bucket" } );

         INLINE_ACTION_SENDER(eosio::token, transfer)( N(eosio.token), {N(eosio),N(active)},

                                                       { N(eosio), N(eosio.vpay), asset(to_per_vote_pay), "fund per-vote bucket" } );

         _gstate.pervote_bucket  += to_per_vote_pay;

         _gstate.perblock_bucket += to_per_block_pay;

         _gstate.last_pervote_bucket_fill = ct;

      }

      int64_t producer_per_block_pay = 0;

      if( _gstate.total_unpaid_blocks > 0 ) {

         producer_per_block_pay = (_gstate.perblock_bucket * prod.unpaid_blocks) / _gstate.total_unpaid_blocks;

      }

      int64_t producer_per_vote_pay = 0;

      if( _gstate.total_producer_vote_weight > 0 ) {

         producer_per_vote_pay  = int64_t((_gstate.pervote_bucket * prod.total_votes ) / _gstate.total_producer_vote_weight);

      }

      if( producer_per_vote_pay < min_pervote_daily_pay ) {

         producer_per_vote_pay = 0;

      }

      _gstate.pervote_bucket      -= producer_per_vote_pay;

      _gstate.perblock_bucket     -= producer_per_block_pay;

      _gstate.total_unpaid_blocks -= prod.unpaid_blocks;

      _producers.modify( prod, 0, [&](auto& p) {

          p.last_claim_time = ct;

          p.unpaid_blocks = 0;

      });

      if( producer_per_block_pay > 0 ) {

         INLINE_ACTION_SENDER(eosio::token, transfer)( N(eosio.token), {N(eosio.bpay),N(active)},

                                                       { N(eosio.bpay), owner, asset(producer_per_block_pay), std::string("producer block pay") } );

      }

      if( producer_per_vote_pay > 0 ) {

         INLINE_ACTION_SENDER(eosio::token, transfer)( N(eosio.token), {N(eosio.vpay),N(active)},

                                                       { N(eosio.vpay), owner, asset(producer_per_vote_pay), std::string("producer vote pay") } );

      }

   }

} //namespace eosiosy