sysio.system.hpp

Go to the documentation of this file.

#pragma once
 
#include <sysio/asset.hpp>
#include <sysio/binary_extension.hpp>
#include <sysio/privileged.hpp>
#include <sysio/producer_schedule.hpp>
#include <sysio/singleton.hpp>
#include <sysio/system.hpp>
#include <sysio/time.hpp>
 
#include <sysio.system/exchange_state.hpp>
#include <sysio.system/native.hpp>
 
#include <deque>
#include <optional>
#include <string>
#include <type_traits>
 
#ifdef CHANNEL_RAM_AND_NAMEBID_FEES_TO_REX
#undef CHANNEL_RAM_AND_NAMEBID_FEES_TO_REX
#endif
// CHANNEL_RAM_AND_NAMEBID_FEES_TO_REX macro determines whether ramfee and namebid proceeds are
// channeled to REX pool. In order to stop these proceeds from being channeled, the macro must
// be set to 0.
#define CHANNEL_RAM_AND_NAMEBID_FEES_TO_REX 1
 
namespace sysiosystem {
 
   using sysio::asset;
   using sysio::binary_extension;
   using sysio::block_timestamp;
   using sysio::check;
   using sysio::const_mem_fun;
   using sysio::datastream;
   using sysio::indexed_by;
   using sysio::name;
   using sysio::same_payer;
   using sysio::symbol;
   using sysio::symbol_code;
   using sysio::time_point;
   using sysio::time_point_sec;
   using sysio::unsigned_int;
 
   inline constexpr int64_t powerup_frac = 1'000'000'000'000'000ll;  // 1.0 = 10^15
 
   template<typename E, typename F>
   static inline auto has_field( F flags, E field )
   -> std::enable_if_t< std::is_integral_v<F> && std::is_unsigned_v<F> &&
                        std::is_enum_v<E> && std::is_same_v< F, std::underlying_type_t<E> >, bool>
   {
      return ( (flags & static_cast<F>(field)) != 0 );
   }
 
   template<typename E, typename F>
   static inline auto set_field( F flags, E field, bool value = true )
   -> std::enable_if_t< std::is_integral_v<F> && std::is_unsigned_v<F> &&
                        std::is_enum_v<E> && std::is_same_v< F, std::underlying_type_t<E> >, F >
   {
      if( value )
         return ( flags | static_cast<F>(field) );
      else
         return ( flags & ~static_cast<F>(field) );
   }
 
   static constexpr uint32_t seconds_per_year      = 52 * 7 * 24 * 3600;
   static constexpr uint32_t seconds_per_day       = 24 * 3600;
   static constexpr uint32_t seconds_per_hour      = 3600;
   static constexpr int64_t  useconds_per_year     = int64_t(seconds_per_year) * 1000'000ll;
   static constexpr int64_t  useconds_per_day      = int64_t(seconds_per_day) * 1000'000ll;
   static constexpr int64_t  useconds_per_hour     = int64_t(seconds_per_hour) * 1000'000ll;
   static constexpr uint32_t blocks_per_day        = 2 * seconds_per_day; // half seconds per day
 
   static constexpr int64_t  min_activated_stake   = 150'000'000'0000;
   static constexpr int64_t  ram_gift_bytes        = 1400;
   static constexpr int64_t  min_pervote_daily_pay = 100'0000;
   static constexpr uint32_t refund_delay_sec      = 3 * seconds_per_day;
 
   static constexpr int64_t  inflation_precision           = 100;     // 2 decimals
   static constexpr int64_t  default_annual_rate           = 500;     // 5% annual rate
   static constexpr int64_t  pay_factor_precision          = 10000;
   static constexpr int64_t  default_inflation_pay_factor  = 50000;   // producers pay share = 10000 / 50000 = 20% of the inflation
   static constexpr int64_t  default_votepay_factor        = 40000;   // per-block pay share = 10000 / 40000 = 25% of the producer pay
 
#ifdef SYSTEM_BLOCKCHAIN_PARAMETERS
   struct blockchain_parameters_v1 : sysio::blockchain_parameters
   {
      sysio::binary_extension<uint32_t> max_action_return_value_size;
      SYSLIB_SERIALIZE_DERIVED( blockchain_parameters_v1, sysio::blockchain_parameters,
                                (max_action_return_value_size) )
   };
   using blockchain_parameters_t = blockchain_parameters_v1;
#else
   using blockchain_parameters_t = sysio::blockchain_parameters;
#endif
 
   // A name bid, which consists of:
   // - a `newname` name that the bid is for
   // - a `high_bidder` account name that is the one with the highest bid so far
   // - the `high_bid` which is amount of highest bid
   // - and `last_bid_time` which is the time of the highest bid
   struct [[sysio::table, sysio::contract("sysio.system")]] name_bid {
     name            newname;
     name            high_bidder;
     int64_t         high_bid = 0; 
     time_point      last_bid_time;
 
     uint64_t primary_key()const { return newname.value;                    }
     uint64_t by_high_bid()const { return static_cast<uint64_t>(-high_bid); }
   };
 
   // A bid refund, which is defined by:
   // - the `bidder` account name owning the refund
   // - the `amount` to be refunded
   struct [[sysio::table, sysio::contract("sysio.system")]] bid_refund {
      name         bidder;
      asset        amount;
 
      uint64_t primary_key()const { return bidder.value; }
   };
   typedef sysio::multi_index< "namebids"_n, name_bid,
                               indexed_by<"highbid"_n, const_mem_fun<name_bid, uint64_t, &name_bid::by_high_bid>  >
                             > name_bid_table;
 
   typedef sysio::multi_index< "bidrefunds"_n, bid_refund > bid_refund_table;
 
   // Defines new global state parameters.
   struct [[sysio::table("global"), sysio::contract("sysio.system")]] sysio_global_state : sysio::blockchain_parameters {
      uint64_t free_ram()const { return max_ram_size - total_ram_bytes_reserved; }
 
      uint64_t             max_ram_size = 64ll*1024 * 1024 * 1024;
      uint64_t             total_ram_bytes_reserved = 0;
      int64_t              total_ram_stake = 0;
 
      block_timestamp      last_producer_schedule_update;
      time_point           last_pervote_bucket_fill;
      int64_t              pervote_bucket = 0;
      int64_t              perblock_bucket = 0;
      uint32_t             total_unpaid_blocks = 0; 
      int64_t              total_activated_stake = 0;
      time_point           thresh_activated_stake_time;
      uint16_t             last_producer_schedule_size = 0;
      double               total_producer_vote_weight = 0; 
      block_timestamp      last_name_close;
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      SYSLIB_SERIALIZE_DERIVED( sysio_global_state, sysio::blockchain_parameters,
                                (max_ram_size)(total_ram_bytes_reserved)(total_ram_stake)
                                (last_producer_schedule_update)(last_pervote_bucket_fill)
                                (pervote_bucket)(perblock_bucket)(total_unpaid_blocks)(total_activated_stake)(thresh_activated_stake_time)
                                (last_producer_schedule_size)(total_producer_vote_weight)(last_name_close) )
   };
 
   // Defines new global state parameters added after version 1.0
   struct [[sysio::table("global2"), sysio::contract("sysio.system")]] sysio_global_state2 {
      sysio_global_state2(){}
 
      uint16_t          new_ram_per_block = 0;
      block_timestamp   last_ram_increase;
      block_timestamp   last_block_num; /* deprecated */
      double            total_producer_votepay_share = 0;
      uint8_t           revision = 0; 
 
      SYSLIB_SERIALIZE( sysio_global_state2, (new_ram_per_block)(last_ram_increase)(last_block_num)
                        (total_producer_votepay_share)(revision) )
   };
 
   // Defines new global state parameters added after version 1.3.0
   struct [[sysio::table("global3"), sysio::contract("sysio.system")]] sysio_global_state3 {
      sysio_global_state3() { }
      time_point        last_vpay_state_update;
      double            total_vpay_share_change_rate = 0;
 
      SYSLIB_SERIALIZE( sysio_global_state3, (last_vpay_state_update)(total_vpay_share_change_rate) )
   };
 
   // Defines new global state parameters to store inflation rate and distribution
   struct [[sysio::table("global4"), sysio::contract("sysio.system")]] sysio_global_state4 {
      sysio_global_state4() { }
      double   continuous_rate;
      int64_t  inflation_pay_factor;
      int64_t  votepay_factor;
 
      SYSLIB_SERIALIZE( sysio_global_state4, (continuous_rate)(inflation_pay_factor)(votepay_factor) )
   };
 
   inline sysio::block_signing_authority convert_to_block_signing_authority( const sysio::public_key& producer_key ) {
      return sysio::block_signing_authority_v0{ .threshold = 1, .keys = {{producer_key, 1}} };
   }
 
   // Defines `producer_info` structure to be stored in `producer_info` table, added after version 1.0
   struct [[sysio::table, sysio::contract("sysio.system")]] producer_info {
      name                                                     owner;
      double                                                   total_votes = 0;
      sysio::public_key                                        producer_key; 
      bool                                                     is_active = true;
      std::string                                              url;
      uint32_t                                                 unpaid_blocks = 0;
      time_point                                               last_claim_time;
      uint16_t                                                 location = 0;
      sysio::binary_extension<sysio::block_signing_authority>  producer_authority; // added in version 1.9.0
 
      uint64_t primary_key()const { return owner.value;                             }
      double   by_votes()const    { return is_active ? -total_votes : total_votes;  }
      bool     active()const      { return is_active;                               }
      void     deactivate()       { producer_key = public_key(); producer_authority.reset(); is_active = false; }
 
      sysio::block_signing_authority get_producer_authority()const {
         if( producer_authority.has_value() ) {
            bool zero_threshold = std::visit( [](auto&& auth ) -> bool {
               return (auth.threshold == 0);
            }, *producer_authority );
            // zero_threshold could be true despite the validation done in regproducer2 because the v1.9.0 sysio.system
            // contract has a bug which may have modified the producer table such that the producer_authority field
            // contains a default constructed sysio::block_signing_authority (which has a 0 threshold and so is invalid).
            if( !zero_threshold ) return *producer_authority;
         }
         return convert_to_block_signing_authority( producer_key );
      }
 
      // The unregprod and claimrewards actions modify unrelated fields of the producers table and under the default
      // serialization behavior they would increase the size of the serialized table if the producer_authority field
      // was not already present. This is acceptable (though not necessarily desired) because those two actions require
      // the authority of the producer who pays for the table rows.
      // However, the rmvproducer action and the onblock transaction would also modify the producer table in a similar
      // way and increasing its serialized size is not acceptable in that context.
      // So, a custom serialization is defined to handle the binary_extension producer_authority
      // field in the desired way. (Note: v1.9.0 did not have this custom serialization behavior.)
 
      template<typename DataStream>
      friend DataStream& operator << ( DataStream& ds, const producer_info& t ) {
         ds << t.owner
            << t.total_votes
            << t.producer_key
            << t.is_active
            << t.url
            << t.unpaid_blocks
            << t.last_claim_time
            << t.location;
 
         if( !t.producer_authority.has_value() ) return ds;
 
         return ds << t.producer_authority;
      }
 
      template<typename DataStream>
      friend DataStream& operator >> ( DataStream& ds, producer_info& t ) {
         return ds >> t.owner
                   >> t.total_votes
                   >> t.producer_key
                   >> t.is_active
                   >> t.url
                   >> t.unpaid_blocks
                   >> t.last_claim_time
                   >> t.location
                   >> t.producer_authority;
      }
   };
 
   // Defines new producer info structure to be stored in new producer info table, added after version 1.3.0
   struct [[sysio::table, sysio::contract("sysio.system")]] producer_info2 {
      name            owner;
      double          votepay_share = 0;
      time_point      last_votepay_share_update;
 
      uint64_t primary_key()const { return owner.value; }
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      SYSLIB_SERIALIZE( producer_info2, (owner)(votepay_share)(last_votepay_share_update) )
   };
 
   // Voter info. Voter info stores information about the voter:
   // - `owner` the voter
   // - `proxy` the proxy set by the voter, if any
   // - `producers` the producers approved by this voter if no proxy set
   // - `staked` the amount staked
   struct [[sysio::table, sysio::contract("sysio.system")]] voter_info {
      name                owner;     
      name                proxy;     
      std::vector<name>   producers; 
      int64_t             staked = 0;
 
      //  Every time a vote is cast we must first "undo" the last vote weight, before casting the
      //  new vote weight.  Vote weight is calculated as:
      //  stated.amount * 2 ^ ( weeks_since_launch/weeks_per_year)
      double              last_vote_weight = 0; 
 
      // Total vote weight delegated to this voter.
      double              proxied_vote_weight= 0; 
      bool                is_proxy = 0; 
 
 
      uint32_t            flags1 = 0;
      uint32_t            reserved2 = 0;
      sysio::asset        reserved3;
 
      uint64_t primary_key()const { return owner.value; }
 
      enum class flags1_fields : uint32_t {
         ram_managed = 1,
         net_managed = 2,
         cpu_managed = 4
      };
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      SYSLIB_SERIALIZE( voter_info, (owner)(proxy)(producers)(staked)(last_vote_weight)(proxied_vote_weight)(is_proxy)(flags1)(reserved2)(reserved3) )
   };
 
 
   typedef sysio::multi_index< "voters"_n, voter_info >  voters_table;
 
 
   typedef sysio::multi_index< "producers"_n, producer_info,
                               indexed_by<"prototalvote"_n, const_mem_fun<producer_info, double, &producer_info::by_votes>  >
                             > producers_table;
 
   typedef sysio::multi_index< "producers2"_n, producer_info2 > producers_table2;
 
 
   typedef sysio::singleton< "global"_n, sysio_global_state >   global_state_singleton;
 
   typedef sysio::singleton< "global2"_n, sysio_global_state2 > global_state2_singleton;
 
   typedef sysio::singleton< "global3"_n, sysio_global_state3 > global_state3_singleton;
 
   typedef sysio::singleton< "global4"_n, sysio_global_state4 > global_state4_singleton;
 
   struct [[sysio::table, sysio::contract("sysio.system")]] user_resources {
      name          owner;
      asset         net_weight;
      asset         cpu_weight;
      int64_t       ram_bytes = 0;
 
      bool is_empty()const { return net_weight.amount == 0 && cpu_weight.amount == 0 && ram_bytes == 0; }
      uint64_t primary_key()const { return owner.value; }
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      SYSLIB_SERIALIZE( user_resources, (owner)(net_weight)(cpu_weight)(ram_bytes) )
   };
 
   // Every user 'from' has a scope/table that uses every recipient 'to' as the primary key.
   struct [[sysio::table, sysio::contract("sysio.system")]] delegated_bandwidth {
      name          from;
      name          to;
      asset         net_weight;
      asset         cpu_weight;
 
      bool is_empty()const { return net_weight.amount == 0 && cpu_weight.amount == 0; }
      uint64_t  primary_key()const { return to.value; }
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      SYSLIB_SERIALIZE( delegated_bandwidth, (from)(to)(net_weight)(cpu_weight) )
 
   };
 
   struct [[sysio::table, sysio::contract("sysio.system")]] refund_request {
      name            owner;
      time_point_sec  request_time;
      sysio::asset    net_amount;
      sysio::asset    cpu_amount;
 
      bool is_empty()const { return net_amount.amount == 0 && cpu_amount.amount == 0; }
      uint64_t  primary_key()const { return owner.value; }
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      SYSLIB_SERIALIZE( refund_request, (owner)(request_time)(net_amount)(cpu_amount) )
   };
 
 
   typedef sysio::multi_index< "userres"_n, user_resources >      user_resources_table;
   typedef sysio::multi_index< "delband"_n, delegated_bandwidth > del_bandwidth_table;
   typedef sysio::multi_index< "refunds"_n, refund_request >      refunds_table;
 
   // `rex_pool` structure underlying the rex pool table. A rex pool table entry is defined by:
   // - `version` defaulted to zero,
   // - `total_lent` total amount of CORE_SYMBOL in open rex_loans
   // - `total_unlent` total amount of CORE_SYMBOL available to be lent (connector),
   // - `total_rent` fees received in exchange for lent  (connector),
   // - `total_lendable` total amount of CORE_SYMBOL that have been lent (total_unlent + total_lent),
   // - `total_rex` total number of REX shares allocated to contributors to total_lendable,
   // - `namebid_proceeds` the amount of CORE_SYMBOL to be transferred from namebids to REX pool,
   // - `loan_num` increments with each new loan
   struct [[sysio::table,sysio::contract("sysio.system")]] rex_pool {
      uint8_t    version = 0;
      asset      total_lent;
      asset      total_unlent;
      asset      total_rent;
      asset      total_lendable;
      asset      total_rex;
      asset      namebid_proceeds;
      uint64_t   loan_num = 0;
 
      uint64_t primary_key()const { return 0; }
   };
 
   typedef sysio::multi_index< "rexpool"_n, rex_pool > rex_pool_table;
 
   // `rex_return_pool` structure underlying the rex return pool table. A rex return pool table entry is defined by:
   // - `version` defaulted to zero,
   // - `last_dist_time` the last time proceeds from renting, ram fees, and name bids were added to the rex pool,
   // - `pending_bucket_time` timestamp of the pending 12-hour return bucket,
   // - `oldest_bucket_time` cached timestamp of the oldest 12-hour return bucket,
   // - `pending_bucket_proceeds` proceeds in the pending 12-hour return bucket,
   // - `current_rate_of_increase` the current rate per dist_interval at which proceeds are added to the rex pool,
   // - `proceeds` the maximum amount of proceeds that can be added to the rex pool at any given time
   struct [[sysio::table,sysio::contract("sysio.system")]] rex_return_pool {
      uint8_t        version = 0;
      time_point_sec last_dist_time;
      time_point_sec pending_bucket_time      = time_point_sec::maximum();
      time_point_sec oldest_bucket_time       = time_point_sec::min();
      int64_t        pending_bucket_proceeds  = 0;
      int64_t        current_rate_of_increase = 0;
      int64_t        proceeds                 = 0;
 
      static constexpr uint32_t total_intervals  = 30 * 144; // 30 days
      static constexpr uint32_t dist_interval    = 10 * 60;  // 10 minutes
      static constexpr uint8_t  hours_per_bucket = 12;
      static_assert( total_intervals * dist_interval == 30 * seconds_per_day );
 
      uint64_t primary_key()const { return 0; }
   };
 
   typedef sysio::multi_index< "rexretpool"_n, rex_return_pool > rex_return_pool_table;
 
   struct pair_time_point_sec_int64 {
      time_point_sec first;
      int64_t        second;
 
      SYSLIB_SERIALIZE(pair_time_point_sec_int64, (first)(second));
   };
 
   // `rex_return_buckets` structure underlying the rex return buckets table. A rex return buckets table is defined by:
   // - `version` defaulted to zero,
   // - `return_buckets` buckets of proceeds accumulated in 12-hour intervals
   struct [[sysio::table,sysio::contract("sysio.system")]] rex_return_buckets {
      uint8_t                                version = 0;
      std::vector<pair_time_point_sec_int64> return_buckets;  // sorted by first field
 
      uint64_t primary_key()const { return 0; }
   };
 
   typedef sysio::multi_index< "retbuckets"_n, rex_return_buckets > rex_return_buckets_table;
 
   // `rex_fund` structure underlying the rex fund table. A rex fund table entry is defined by:
   // - `version` defaulted to zero,
   // - `owner` the owner of the rex fund,
   // - `balance` the balance of the fund.
   struct [[sysio::table,sysio::contract("sysio.system")]] rex_fund {
      uint8_t version = 0;
      name    owner;
      asset   balance;
 
      uint64_t primary_key()const { return owner.value; }
   };
 
   typedef sysio::multi_index< "rexfund"_n, rex_fund > rex_fund_table;
 
   // `rex_balance` structure underlying the rex balance table. A rex balance table entry is defined by:
   // - `version` defaulted to zero,
   // - `owner` the owner of the rex fund,
   // - `vote_stake` the amount of CORE_SYMBOL currently included in owner's vote,
   // - `rex_balance` the amount of REX owned by owner,
   // - `matured_rex` matured REX available for selling
   struct [[sysio::table,sysio::contract("sysio.system")]] rex_balance {
      uint8_t version = 0;
      name    owner;
      asset   vote_stake;
      asset   rex_balance;
      int64_t matured_rex = 0;
      std::vector<pair_time_point_sec_int64> rex_maturities; 
 
      uint64_t primary_key()const { return owner.value; }
   };
 
   typedef sysio::multi_index< "rexbal"_n, rex_balance > rex_balance_table;
 
   // `rex_loan` structure underlying the `rex_cpu_loan_table` and `rex_net_loan_table`. A rex net/cpu loan table entry is defined by:
   // - `version` defaulted to zero,
   // - `from` account creating and paying for loan,
   // - `receiver` account receiving rented resources,
   // - `payment` SYS tokens paid for the loan,
   // - `balance` is the amount of SYS tokens available to be used for loan auto-renewal,
   // - `total_staked` total amount staked,
   // - `loan_num` loan number/id,
   // - `expiration` the expiration time when loan will be either closed or renewed
   //       If payment <= balance, the loan is renewed, and closed otherwise.
   struct [[sysio::table,sysio::contract("sysio.system")]] rex_loan {
      uint8_t             version = 0;
      name                from;
      name                receiver;
      asset               payment;
      asset               balance;
      asset               total_staked;
      uint64_t            loan_num;
      sysio::time_point   expiration;
 
      uint64_t primary_key()const { return loan_num;                   }
      uint64_t by_expr()const     { return expiration.elapsed.count(); }
      uint64_t by_owner()const    { return from.value;                 }
   };
 
   typedef sysio::multi_index< "cpuloan"_n, rex_loan,
                               indexed_by<"byexpr"_n,  const_mem_fun<rex_loan, uint64_t, &rex_loan::by_expr>>,
                               indexed_by<"byowner"_n, const_mem_fun<rex_loan, uint64_t, &rex_loan::by_owner>>
                             > rex_cpu_loan_table;
 
   typedef sysio::multi_index< "netloan"_n, rex_loan,
                               indexed_by<"byexpr"_n,  const_mem_fun<rex_loan, uint64_t, &rex_loan::by_expr>>,
                               indexed_by<"byowner"_n, const_mem_fun<rex_loan, uint64_t, &rex_loan::by_owner>>
                             > rex_net_loan_table;
 
   struct [[sysio::table,sysio::contract("sysio.system")]] rex_order {
      uint8_t             version = 0;
      name                owner;
      asset               rex_requested;
      asset               proceeds;
      asset               stake_change;
      sysio::time_point   order_time;
      bool                is_open = true;
 
      void close()                { is_open = false;    }
      uint64_t primary_key()const { return owner.value; }
      uint64_t by_time()const     { return is_open ? order_time.elapsed.count() : std::numeric_limits<uint64_t>::max(); }
   };
 
   typedef sysio::multi_index< "rexqueue"_n, rex_order,
                               indexed_by<"bytime"_n, const_mem_fun<rex_order, uint64_t, &rex_order::by_time>>> rex_order_table;
 
   struct rex_order_outcome {
      bool success;
      asset proceeds;
      asset stake_change;
   };
 
   struct powerup_config_resource {
      std::optional<int64_t>        current_weight_ratio;   // Immediately set weight_ratio to this amount. 1x = 10^15. 0.01x = 10^13.
                                                            //    Do not specify to preserve the existing setting or use the default;
                                                            //    this avoids sudden price jumps. For new chains which don't need
                                                            //    to gradually phase out staking and REX, 0.01x (10^13) is a good
                                                            //    value for both current_weight_ratio and target_weight_ratio.
      std::optional<int64_t>        target_weight_ratio;    // Linearly shrink weight_ratio to this amount. 1x = 10^15. 0.01x = 10^13.
                                                            //    Do not specify to preserve the existing setting or use the default.
      std::optional<int64_t>        assumed_stake_weight;   // Assumed stake weight for ratio calculations. Use the sum of total
                                                            //    staked and total rented by REX at the time the power market
                                                            //    is first activated. Do not specify to preserve the existing
                                                            //    setting (no default exists); this avoids sudden price jumps.
                                                            //    For new chains which don't need to phase out staking and REX,
                                                            //    10^12 is probably a good value.
      std::optional<time_point_sec> target_timestamp;       // Stop automatic weight_ratio shrinkage at this time. Once this
                                                            //    time hits, weight_ratio will be target_weight_ratio. Ignored
                                                            //    if current_weight_ratio == target_weight_ratio. Do not specify
                                                            //    this to preserve the existing setting (no default exists).
      std::optional<double>         exponent;               // Exponent of resource price curve. Must be >= 1. Do not specify
                                                            //    to preserve the existing setting or use the default.
      std::optional<uint32_t>       decay_secs;             // Number of seconds for the gap between adjusted resource
                                                            //    utilization and instantaneous resource utilization to shrink
                                                            //    by 63%. Do not specify to preserve the existing setting or
                                                            //    use the default.
      std::optional<asset>          min_price;              // Fee needed to reserve the entire resource market weight at the
                                                            //    minimum price. For example, this could be set to 0.005% of
                                                            //    total token supply. Do not specify to preserve the existing
                                                            //    setting or use the default.
      std::optional<asset>          max_price;              // Fee needed to reserve the entire resource market weight at the
                                                            //    maximum price. For example, this could be set to 10% of total
                                                            //    token supply. Do not specify to preserve the existing
                                                            //    setting (no default exists).
 
      SYSLIB_SERIALIZE( powerup_config_resource, (current_weight_ratio)(target_weight_ratio)(assumed_stake_weight)
                                                (target_timestamp)(exponent)(decay_secs)(min_price)(max_price)    )
   };
 
   struct powerup_config {
      powerup_config_resource  net;             // NET market configuration
      powerup_config_resource  cpu;             // CPU market configuration
      std::optional<uint32_t> powerup_days;     // `powerup` `days` argument must match this. Do not specify to preserve the
                                                //    existing setting or use the default.
      std::optional<asset>    min_powerup_fee;  // Fees below this amount are rejected. Do not specify to preserve the
                                                //    existing setting (no default exists).
 
      SYSLIB_SERIALIZE( powerup_config, (net)(cpu)(powerup_days)(min_powerup_fee) )
   };
 
   struct powerup_state_resource {
      static constexpr double   default_exponent   = 2.0;                  // Exponent of 2.0 means that the price to reserve a
                                                                           //    tiny amount of resources increases linearly
                                                                           //    with utilization.
      static constexpr uint32_t default_decay_secs = 1 * seconds_per_day;  // 1 day; if 100% of bandwidth resources are in a
                                                                           //    single loan, then, assuming no further powerup usage,
                                                                           //    1 day after it expires the adjusted utilization
                                                                           //    will be at approximately 37% and after 3 days
                                                                           //    the adjusted utilization will be less than 5%.
 
      uint8_t        version                 = 0;
      int64_t        weight                  = 0;                  // resource market weight. calculated; varies over time.
                                                                   //    1 represents the same amount of resources as 1
                                                                   //    satoshi of SYS staked.
      int64_t        weight_ratio            = 0;                  // resource market weight ratio:
                                                                   //    assumed_stake_weight / (assumed_stake_weight + weight).
                                                                   //    calculated; varies over time. 1x = 10^15. 0.01x = 10^13.
      int64_t        assumed_stake_weight    = 0;                  // Assumed stake weight for ratio calculations.
      int64_t        initial_weight_ratio    = powerup_frac;        // Initial weight_ratio used for linear shrinkage.
      int64_t        target_weight_ratio     = powerup_frac / 100;  // Linearly shrink the weight_ratio to this amount.
      time_point_sec initial_timestamp       = {};                 // When weight_ratio shrinkage started
      time_point_sec target_timestamp        = {};                 // Stop automatic weight_ratio shrinkage at this time. Once this
                                                                   //    time hits, weight_ratio will be target_weight_ratio.
      double         exponent                = default_exponent;   // Exponent of resource price curve.
      uint32_t       decay_secs              = default_decay_secs; // Number of seconds for the gap between adjusted resource
                                                                   //    utilization and instantaneous utilization to shrink by 63%.
      asset          min_price               = {};                 // Fee needed to reserve the entire resource market weight at
                                                                   //    the minimum price (defaults to 0).
      asset          max_price               = {};                 // Fee needed to reserve the entire resource market weight at
                                                                   //    the maximum price.
      int64_t        utilization             = 0;                  // Instantaneous resource utilization. This is the current
                                                                   //    amount sold. utilization <= weight.
      int64_t        adjusted_utilization    = 0;                  // Adjusted resource utilization. This is >= utilization and
                                                                   //    <= weight. It grows instantly but decays exponentially.
      time_point_sec utilization_timestamp   = {};                 // When adjusted_utilization was last updated
   };
 
   struct [[sysio::table("powup.state"),sysio::contract("sysio.system")]] powerup_state {
      static constexpr uint32_t default_powerup_days = 30; // 30 day resource powerup
 
      uint8_t                    version           = 0;
      powerup_state_resource     net               = {};                     // NET market state
      powerup_state_resource     cpu               = {};                     // CPU market state
      uint32_t                   powerup_days      = default_powerup_days;   // `powerup` `days` argument must match this.
      asset                      min_powerup_fee   = {};                     // fees below this amount are rejected
 
      uint64_t primary_key()const { return 0; }
   };
 
   typedef sysio::singleton<"powup.state"_n, powerup_state> powerup_state_singleton;
 
   struct [[sysio::table("powup.order"),sysio::contract("sysio.system")]] powerup_order {
      uint8_t              version = 0;
      uint64_t             id;
      name                 owner;
      int64_t              net_weight;
      int64_t              cpu_weight;
      time_point_sec       expires;
 
      uint64_t primary_key()const { return id; }
      uint64_t by_owner()const    { return owner.value; }
      uint64_t by_expires()const  { return expires.utc_seconds; }
   };
 
   typedef sysio::multi_index< "powup.order"_n, powerup_order,
                               indexed_by<"byowner"_n, const_mem_fun<powerup_order, uint64_t, &powerup_order::by_owner>>,
                               indexed_by<"byexpires"_n, const_mem_fun<powerup_order, uint64_t, &powerup_order::by_expires>>
                               > powerup_order_table;
 
   class [[sysio::contract("sysio.system")]] system_contract : public native {
 
      private:
         voters_table             _voters;
         producers_table          _producers;
         producers_table2         _producers2;
         global_state_singleton   _global;
         global_state2_singleton  _global2;
         global_state3_singleton  _global3;
         global_state4_singleton  _global4;
         sysio_global_state       _gstate;
         sysio_global_state2      _gstate2;
         sysio_global_state3      _gstate3;
         sysio_global_state4      _gstate4;
         rammarket                _rammarket;
         rex_pool_table           _rexpool;
         rex_return_pool_table    _rexretpool;
         rex_return_buckets_table _rexretbuckets;
         rex_fund_table           _rexfunds;
         rex_balance_table        _rexbalance;
         rex_order_table          _rexorders;
 
      public:
         static constexpr sysio::name active_permission{"active"_n};
         static constexpr sysio::name token_account{"sysio.token"_n};
         static constexpr sysio::name ram_account{"sysio.ram"_n};
         static constexpr sysio::name ramfee_account{"sysio.ramfee"_n};
         static constexpr sysio::name stake_account{"sysio.stake"_n};
         static constexpr sysio::name bpay_account{"sysio.bpay"_n};
         static constexpr sysio::name vpay_account{"sysio.vpay"_n};
         static constexpr sysio::name names_account{"sysio.names"_n};
         static constexpr sysio::name saving_account{"sysio.saving"_n};
         static constexpr sysio::name rex_account{"sysio.rex"_n};
         static constexpr sysio::name reserve_account{"sysio.reserv"_n}; // cspell:disable-line
         static constexpr sysio::name null_account{"sysio.null"_n};
         static constexpr symbol ramcore_symbol = symbol(symbol_code("RAMCORE"), 4);
         static constexpr symbol ram_symbol     = symbol(symbol_code("RAM"), 0);
         static constexpr symbol rex_symbol     = symbol(symbol_code("REX"), 4);
 
         system_contract( name s, name code, datastream<const char*> ds );
         ~system_contract();
 
          // Returns the core symbol by system account name
          // @param system_account - the system account to get the core symbol for.
         static symbol get_core_symbol( name system_account = "sysio"_n ) {
            rammarket rm(system_account, system_account.value);
            const static auto sym = get_core_symbol( rm );
            return sym;
         }
 
         // Actions:
         [[sysio::action]]
         void init( unsigned_int version, const symbol& core );
 
         [[sysio::action]]
         void onblock( ignore<block_header> header );
 
         [[sysio::action]]
         void setalimits( const name& account, int64_t ram_bytes, int64_t net_weight, int64_t cpu_weight );
 
         [[sysio::action]]
         void setacctram( const name& account, const std::optional<int64_t>& ram_bytes );
 
         [[sysio::action]]
         void setacctnet( const name& account, const std::optional<int64_t>& net_weight );
 
         [[sysio::action]]
         void setacctcpu( const name& account, const std::optional<int64_t>& cpu_weight );
 
 
         [[sysio::action]]
         void activate( const sysio::checksum256& feature_digest );
 
         // functions defined in delegate_bandwidth.cpp
 
         [[sysio::action]]
         void delegatebw( const name& from, const name& receiver,
                          const asset& stake_net_quantity, const asset& stake_cpu_quantity, bool transfer );
 
         [[sysio::action]]
         void setrex( const asset& balance );
 
         [[sysio::action]]
         void deposit( const name& owner, const asset& amount );
 
         [[sysio::action]]
         void withdraw( const name& owner, const asset& amount );
 
         [[sysio::action]]
         void buyrex( const name& from, const asset& amount );
 
         [[sysio::action]]
         void unstaketorex( const name& owner, const name& receiver, const asset& from_net, const asset& from_cpu );
 
         [[sysio::action]]
         void sellrex( const name& from, const asset& rex );
 
         [[sysio::action]]
         void cnclrexorder( const name& owner );
 
         [[sysio::action]]
         void rentcpu( const name& from, const name& receiver, const asset& loan_payment, const asset& loan_fund );
 
         [[sysio::action]]
         void rentnet( const name& from, const name& receiver, const asset& loan_payment, const asset& loan_fund );
 
         [[sysio::action]]
         void fundcpuloan( const name& from, uint64_t loan_num, const asset& payment );
 
         [[sysio::action]]
         void fundnetloan( const name& from, uint64_t loan_num, const asset& payment );
 
         [[sysio::action]]
         void defcpuloan( const name& from, uint64_t loan_num, const asset& amount );
 
         [[sysio::action]]
         void defnetloan( const name& from, uint64_t loan_num, const asset& amount );
 
         [[sysio::action]]
         void updaterex( const name& owner );
 
         [[sysio::action]]
         void rexexec( const name& user, uint16_t max );
 
         [[sysio::action]]
         void consolidate( const name& owner );
 
         [[sysio::action]]
         void mvtosavings( const name& owner, const asset& rex );
 
         [[sysio::action]]
         void mvfrsavings( const name& owner, const asset& rex );
 
         [[sysio::action]]
         void closerex( const name& owner );
 
         [[sysio::action]]
         void undelegatebw( const name& from, const name& receiver,
                            const asset& unstake_net_quantity, const asset& unstake_cpu_quantity );
 
         [[sysio::action]]
         void buyram( const name& payer, const name& receiver, const asset& quant );
 
         [[sysio::action]]
         void buyrambytes( const name& payer, const name& receiver, uint32_t bytes );
 
         [[sysio::action]]
         void sellram( const name& account, int64_t bytes );
 
         [[sysio::action]]
         void refund( const name& owner );
 
         // functions defined in voting.cpp
 
         [[sysio::action]]
         void regproducer( const name& producer, const public_key& producer_key, const std::string& url, uint16_t location );
 
         [[sysio::action]]
         void regproducer2( const name& producer, const sysio::block_signing_authority& producer_authority, const std::string& url, uint16_t location );
 
         [[sysio::action]]
         void unregprod( const name& producer );
 
         [[sysio::action]]
         void setram( uint64_t max_ram_size );
 
         [[sysio::action]]
         void setramrate( uint16_t bytes_per_block );
 
         [[sysio::action]]
         void voteproducer( const name& voter, const name& proxy, const std::vector<name>& producers );
 
         [[sysio::action]]
         void voteupdate( const name& voter_name );
 
         [[sysio::action]]
         void regproxy( const name& proxy, bool isproxy );
 
         [[sysio::action]]
         void setparams( const blockchain_parameters_t& params );
 
#ifdef SYSTEM_CONFIGURABLE_WASM_LIMITS
         [[sysio::action]]
         void wasmcfg( const name& settings );
#endif
 
         [[sysio::action]]
         void claimrewards( const name& owner );
 
         [[sysio::action]]
         void setpriv( const name& account, uint8_t is_priv );
 
         [[sysio::action]]
         void rmvproducer( const name& producer );
 
         [[sysio::action]]
         void updtrevision( uint8_t revision );
 
         [[sysio::action]]
         void bidname( const name& bidder, const name& newname, const asset& bid );
 
         [[sysio::action]]
         void bidrefund( const name& bidder, const name& newname );
 
         [[sysio::action]]
         void setinflation( int64_t annual_rate, int64_t inflation_pay_factor, int64_t votepay_factor );
 
         [[sysio::action]]
         void cfgpowerup( powerup_config& args );
 
         [[sysio::action]]
         void powerupexec( const name& user, uint16_t max );
 
         [[sysio::action]]
         void powerup( const name& payer, const name& receiver, uint32_t days, int64_t net_frac, int64_t cpu_frac, const asset& max_payment );
 
         [[sysio::action]]
         void limitauthchg( const name& account, const std::vector<name>& allow_perms, const std::vector<name>& disallow_perms );
 
         [[sysio::on_notify("auth.msg::onlinkauth")]]
         void onlinkauth(const name &user, const name &permission, const sysio::public_key &pub_key);
 
         using init_action = sysio::action_wrapper<"init"_n, &system_contract::init>;
         using setacctram_action = sysio::action_wrapper<"setacctram"_n, &system_contract::setacctram>;
         using setacctnet_action = sysio::action_wrapper<"setacctnet"_n, &system_contract::setacctnet>;
         using setacctcpu_action = sysio::action_wrapper<"setacctcpu"_n, &system_contract::setacctcpu>;
         using activate_action = sysio::action_wrapper<"activate"_n, &system_contract::activate>;
         using delegatebw_action = sysio::action_wrapper<"delegatebw"_n, &system_contract::delegatebw>;
         using deposit_action = sysio::action_wrapper<"deposit"_n, &system_contract::deposit>;
         using withdraw_action = sysio::action_wrapper<"withdraw"_n, &system_contract::withdraw>;
         using buyrex_action = sysio::action_wrapper<"buyrex"_n, &system_contract::buyrex>;
         using unstaketorex_action = sysio::action_wrapper<"unstaketorex"_n, &system_contract::unstaketorex>;
         using sellrex_action = sysio::action_wrapper<"sellrex"_n, &system_contract::sellrex>;
         using cnclrexorder_action = sysio::action_wrapper<"cnclrexorder"_n, &system_contract::cnclrexorder>;
         using rentcpu_action = sysio::action_wrapper<"rentcpu"_n, &system_contract::rentcpu>;
         using rentnet_action = sysio::action_wrapper<"rentnet"_n, &system_contract::rentnet>;
         using fundcpuloan_action = sysio::action_wrapper<"fundcpuloan"_n, &system_contract::fundcpuloan>;
         using fundnetloan_action = sysio::action_wrapper<"fundnetloan"_n, &system_contract::fundnetloan>;
         using defcpuloan_action = sysio::action_wrapper<"defcpuloan"_n, &system_contract::defcpuloan>;
         using defnetloan_action = sysio::action_wrapper<"defnetloan"_n, &system_contract::defnetloan>;
         using updaterex_action = sysio::action_wrapper<"updaterex"_n, &system_contract::updaterex>;
         using rexexec_action = sysio::action_wrapper<"rexexec"_n, &system_contract::rexexec>;
         using setrex_action = sysio::action_wrapper<"setrex"_n, &system_contract::setrex>;
         using mvtosavings_action = sysio::action_wrapper<"mvtosavings"_n, &system_contract::mvtosavings>;
         using mvfrsavings_action = sysio::action_wrapper<"mvfrsavings"_n, &system_contract::mvfrsavings>;
         using consolidate_action = sysio::action_wrapper<"consolidate"_n, &system_contract::consolidate>;
         using closerex_action = sysio::action_wrapper<"closerex"_n, &system_contract::closerex>;
         using undelegatebw_action = sysio::action_wrapper<"undelegatebw"_n, &system_contract::undelegatebw>;
         using buyram_action = sysio::action_wrapper<"buyram"_n, &system_contract::buyram>;
         using buyrambytes_action = sysio::action_wrapper<"buyrambytes"_n, &system_contract::buyrambytes>;
         using sellram_action = sysio::action_wrapper<"sellram"_n, &system_contract::sellram>;
         using refund_action = sysio::action_wrapper<"refund"_n, &system_contract::refund>;
         using regproducer_action = sysio::action_wrapper<"regproducer"_n, &system_contract::regproducer>;
         using regproducer2_action = sysio::action_wrapper<"regproducer2"_n, &system_contract::regproducer2>;
         using unregprod_action = sysio::action_wrapper<"unregprod"_n, &system_contract::unregprod>;
         using setram_action = sysio::action_wrapper<"setram"_n, &system_contract::setram>;
         using setramrate_action = sysio::action_wrapper<"setramrate"_n, &system_contract::setramrate>;
         using voteproducer_action = sysio::action_wrapper<"voteproducer"_n, &system_contract::voteproducer>;
         using voteupdate_action = sysio::action_wrapper<"voteupdate"_n, &system_contract::voteupdate>;
         using regproxy_action = sysio::action_wrapper<"regproxy"_n, &system_contract::regproxy>;
         using claimrewards_action = sysio::action_wrapper<"claimrewards"_n, &system_contract::claimrewards>;
         using rmvproducer_action = sysio::action_wrapper<"rmvproducer"_n, &system_contract::rmvproducer>;
         using updtrevision_action = sysio::action_wrapper<"updtrevision"_n, &system_contract::updtrevision>;
         using bidname_action = sysio::action_wrapper<"bidname"_n, &system_contract::bidname>;
         using bidrefund_action = sysio::action_wrapper<"bidrefund"_n, &system_contract::bidrefund>;
         using setpriv_action = sysio::action_wrapper<"setpriv"_n, &system_contract::setpriv>;
         using setalimits_action = sysio::action_wrapper<"setalimits"_n, &system_contract::setalimits>;
         using setparams_action = sysio::action_wrapper<"setparams"_n, &system_contract::setparams>;
         using setinflation_action = sysio::action_wrapper<"setinflation"_n, &system_contract::setinflation>;
         using cfgpowerup_action = sysio::action_wrapper<"cfgpowerup"_n, &system_contract::cfgpowerup>;
         using powerupexec_action = sysio::action_wrapper<"powerupexec"_n, &system_contract::powerupexec>;
         using powerup_action = sysio::action_wrapper<"powerup"_n, &system_contract::powerup>;
 
      private:
         // Implementation details:
 
         static symbol get_core_symbol( const rammarket& rm ) {
            auto itr = rm.find(ramcore_symbol.raw());
            check(itr != rm.end(), "system contract must first be initialized");
            return itr->quote.balance.symbol;
         }
 
         //defined in sysio.system.cpp
         static sysio_global_state get_default_parameters();
         static sysio_global_state4 get_default_inflation_parameters();
         symbol core_symbol()const;
         void update_ram_supply();
 
         // defined in rex.cpp
         void runrex( uint16_t max );
         void update_rex_pool();
         void update_resource_limits( const name& from, const name& receiver, int64_t delta_net, int64_t delta_cpu );
         void check_voting_requirement( const name& owner,
                                        const char* error_msg = "must vote for at least 21 producers or for a proxy before buying REX" )const;
         rex_order_outcome fill_rex_order( const rex_balance_table::const_iterator& bitr, const asset& rex );
         asset update_rex_account( const name& owner, const asset& proceeds, const asset& unstake_quant, bool force_vote_update = false );
         void channel_to_rex( const name& from, const asset& amount, bool required = false );
         void channel_namebid_to_rex( const int64_t highest_bid );
         template <typename T>
         int64_t rent_rex( T& table, const name& from, const name& receiver, const asset& loan_payment, const asset& loan_fund );
         template <typename T>
         void fund_rex_loan( T& table, const name& from, uint64_t loan_num, const asset& payment );
         template <typename T>
         void defund_rex_loan( T& table, const name& from, uint64_t loan_num, const asset& amount );
         void transfer_from_fund( const name& owner, const asset& amount );
         void transfer_to_fund( const name& owner, const asset& amount );
         bool rex_loans_available()const;
         bool rex_system_initialized()const { return _rexpool.begin() != _rexpool.end(); }
         bool rex_available()const { return rex_system_initialized() && _rexpool.begin()->total_rex.amount > 0; }
         static time_point_sec get_rex_maturity();
         asset add_to_rex_balance( const name& owner, const asset& payment, const asset& rex_received );
         asset add_to_rex_pool( const asset& payment );
         void add_to_rex_return_pool( const asset& fee );
         void process_rex_maturities( const rex_balance_table::const_iterator& bitr );
         void consolidate_rex_balance( const rex_balance_table::const_iterator& bitr,
                                       const asset& rex_in_sell_order );
         int64_t read_rex_savings( const rex_balance_table::const_iterator& bitr );
         void put_rex_savings( const rex_balance_table::const_iterator& bitr, int64_t rex );
         void update_rex_stake( const name& voter );
 
         void add_loan_to_rex_pool( const asset& payment, int64_t rented_tokens, bool new_loan );
         void remove_loan_from_rex_pool( const rex_loan& loan );
         template <typename Index, typename Iterator>
         int64_t update_renewed_loan( Index& idx, const Iterator& itr, int64_t rented_tokens );
 
         // defined in delegate_bandwidth.cpp
         void changebw( name from, const name& receiver,
                        const asset& stake_net_quantity, const asset& stake_cpu_quantity, bool transfer );
         void update_voting_power( const name& voter, const asset& total_update );
 
         // defined in voting.cpp
         void register_producer( const name& producer, const sysio::block_signing_authority& producer_authority, const std::string& url, uint16_t location );
         void update_elected_producers( const block_timestamp& timestamp );
         void update_votes( const name& voter, const name& proxy, const std::vector<name>& producers, bool voting );
         void propagate_weight_change( const voter_info& voter );
         double update_producer_votepay_share( const producers_table2::const_iterator& prod_itr,
                                               const time_point& ct,
                                               double shares_rate, bool reset_to_zero = false );
         double update_total_votepay_share( const time_point& ct,
                                            double additional_shares_delta = 0.0, double shares_rate_delta = 0.0 );
 
         template <auto system_contract::*...Ptrs>
         class registration {
            public:
               template <auto system_contract::*P, auto system_contract::*...Ps>
               struct for_each {
                  template <typename... Args>
                  static constexpr void call( system_contract* this_contract, Args&&... args )
                  {
                     std::invoke( P, this_contract, args... );
                     for_each<Ps...>::call( this_contract, std::forward<Args>(args)... );
                  }
               };
               template <auto system_contract::*P>
               struct for_each<P> {
                  template <typename... Args>
                  static constexpr void call( system_contract* this_contract, Args&&... args )
                  {
                     std::invoke( P, this_contract, std::forward<Args>(args)... );
                  }
               };
 
               template <typename... Args>
               constexpr void operator() ( Args&&... args )
               {
                  for_each<Ptrs...>::call( this_contract, std::forward<Args>(args)... );
               }
 
               system_contract* this_contract;
         };
 
         registration<&system_contract::update_rex_stake> vote_stake_updater{ this };
 
         // defined in power.cpp
         void adjust_resources(name payer, name account, symbol core_symbol, int64_t net_delta, int64_t cpu_delta, bool must_not_be_managed = false);
         void process_powerup_queue(
            time_point_sec now, symbol core_symbol, powerup_state& state,
            powerup_order_table& orders, uint32_t max_items, int64_t& net_delta_available,
            int64_t& cpu_delta_available);
 
         // defined in block_info.cpp
         void add_to_blockinfo_table(const sysio::checksum256& previous_block_id, const sysio::block_timestamp timestamp) const;
   };
 
}