hardfork.hpp

Go to the documentation of this file.

#pragma once
 
#include <libdevcore/CommonJS.h>
 
#include "common/encoding_rlp.hpp"
#include "common/types.hpp"
 
namespace taraxa {
struct Redelegation {
  taraxa::addr_t validator;
  taraxa::addr_t delegator;
  taraxa::uint256_t amount;
  HAS_RLP_FIELDS
};
Json::Value enc_json(const Redelegation& obj);
void dec_json(const Json::Value& json, Redelegation& obj);
 
struct MagnoliaHardfork {
  uint64_t block_num = -1;
  uint64_t jail_time = 0;  // number of blocks
 
  HAS_RLP_FIELDS
};
Json::Value enc_json(const MagnoliaHardfork& obj);
void dec_json(const Json::Value& json, MagnoliaHardfork& obj);
 
struct AspenHardfork {
  // Part 1 prepares db data that are required for part 2 to be functional
  uint64_t block_num_part_one{0};
  // Part 2 implements new yield curve
  uint64_t block_num_part_two{0};
 
  taraxa::uint256_t max_supply{"0x26C62AD77DC602DAE0000000"};  // 12 Billion
  // total generated rewards from block 1 to block_num
  // It is partially estimated for blocks between the aspen hf release block and actual aspen hf block_num
  taraxa::uint256_t generated_rewards{0};
 
  HAS_RLP_FIELDS
};
Json::Value enc_json(const AspenHardfork& obj);
void dec_json(const Json::Value& json, AspenHardfork& obj);
 
struct FicusHardforkConfig {
  uint64_t block_num{10};
  uint64_t pillar_blocks_interval{10};     // [periods] how often is the new pillar block created
  taraxa::addr_t bridge_contract_address;  // [address] of the bridge contract
 
  bool isFicusHardfork(taraxa::PbftPeriod period) const;
 
  bool isPillarBlockPeriod(taraxa::PbftPeriod period, bool skip_first_pillar_block = false) const;
 
  bool isPbftWithPillarBlockPeriod(taraxa::PbftPeriod period) const;
 
  taraxa::PbftPeriod firstPillarBlockPeriod() const;
 
  void validate(uint32_t delegation_delay) const;
 
  HAS_RLP_FIELDS
};
Json::Value enc_json(const FicusHardforkConfig& obj);
void dec_json(const Json::Value& json, FicusHardforkConfig& obj);
 
struct CornusHardforkConfig {
  uint64_t block_num = -1;
  uint32_t delegation_locking_period = 5;  // number of blocks
  uint64_t dag_gas_limit = 0;
  uint64_t pbft_gas_limit = 0;
 
  HAS_RLP_FIELDS
};
Json::Value enc_json(const CornusHardforkConfig& obj);
void dec_json(const Json::Value& json, CornusHardforkConfig& obj);
 
struct SoleiroliaHardforkConfig {
  uint64_t block_num = -1;
  uint64_t trx_min_gas_price = 1;  // [wei]
  uint64_t trx_max_gas_limit = 31500000;
 
  HAS_RLP_FIELDS
};
Json::Value enc_json(const SoleiroliaHardforkConfig& obj);
void dec_json(const Json::Value& json, SoleiroliaHardforkConfig& obj);
 
struct CactiHardforkConfig {
  uint64_t block_num = 0;
  uint32_t lambda_min = 500;             // [ms] - valid only for round 1
  uint32_t lambda_max = 1500;            // [ms] - valid only for round 1
  uint32_t lambda_default = 2000;        // [ms] - used in all rounds > 1
  uint32_t lambda_change_interval = 10;  // [number of blocks]
  uint32_t lambda_change = 10;           // [ms]
  uint32_t block_propagation_min =
      4000;  // [ms] - how long it takes to propagate block in good network conditions, used in round 1
  uint32_t block_propagation_max =
      17000;  // [ms] - how long it takes to propagate block in good network conditions, used in rounds > 1
 
  bool isDynamicLambdaChangeInterval(uint64_t block_number) const {
    return block_number > block_num && block_number % lambda_change_interval == 0;
  }
 
  HAS_RLP_FIELDS
};
Json::Value enc_json(const CactiHardforkConfig& obj);
void dec_json(const Json::Value& json, CactiHardforkConfig& obj);
 
// Keeping it for next HF
// struct BambooRedelegation {
//   taraxa::addr_t validator;
//   taraxa::uint256_t amount;
//   HAS_RLP_FIELDS
// };
// Json::Value enc_json(const BambooRedelegation& obj);
// void dec_json(const Json::Value& json, BambooRedelegation& obj);
 
// struct BambooHardfork {
//   uint64_t block_num{0};
//   std::vector<BambooRedelegation> redelegations;
 
//   HAS_RLP_FIELDS
// };
// Json::Value enc_json(const BambooHardfork& obj);
// void dec_json(const Json::Value& json, BambooHardfork& obj);
 
struct HardforksConfig {
  // disable it by default (set to max uint64)
  uint64_t fix_redelegate_block_num = -1;
  std::vector<Redelegation> redelegations;
  /*
   * @brief key is block number at which change is applied and value is new distribution interval.
   * Default distribution frequency is every block
   * To change rewards distribution frequency we should add a new element in map below.
   * For example {{101, 20}, {201, 10}} means:
   * 1. for blocks [1,100] we are distributing rewards every block
   * 2. for blocks [101, 200] rewards are distributed every 20 block. On blocks 120, 140, etc.
   * 3. for blocks after 201 rewards are distributed every 10 block. On blocks 210, 220, etc.
   */
  using RewardsDistributionMap = std::map<uint64_t, uint32_t>;
  RewardsDistributionMap rewards_distribution_frequency;
 
  // Magnolia hardfork:
  // 1.fixing premature deletion of validators in dpos contract -> validator is deleted only
  //  after last delegator confirms his undelegation and:
  //  total_stake == 0, rewards_pool == 0, undelegations_count == 0.
  // 2. changing fee rewards distribution.
  //  Rewards will be distributed to dag blocks creator commission pool, but not directly to the balance of pbft block
  //  creator.
  // 3. Introducing slashing/jailing contract - in case someone double votes - he is jailed for N blocks and unable to
  //    participate in consensus
  MagnoliaHardfork magnolia_hf;
 
  // disable it by default (set to max uint64)
  uint64_t phalaenopsis_hf_block_num = -1;
  // disable it by default (set to max uint64)
  uint64_t fix_claim_all_block_num = -1;
 
  // Aspen hardfork implements new yield curve
  AspenHardfork aspen_hf;
 
  bool isAspenHardforkPartOne(uint64_t block_number) const { return block_number >= aspen_hf.block_num_part_one; }
 
  // Ficus hardfork: implementation of pillar chain
  FicusHardforkConfig ficus_hf;
 
  // Cornus hf - support multiple undelegations from the same validator at the same time
  //           - change of delegation locking period
  //           - change gas limit
  CornusHardforkConfig cornus_hf;
  bool isOnCornusHardfork(uint64_t block_number) const { return block_number >= cornus_hf.block_num; }
 
  // Soleirolia hf - increase trx gas minimum price
  //               - limit max trx gas
  SoleiroliaHardforkConfig soleirolia_hf;
 
  // Cacti hardfork
  CactiHardforkConfig cacti_hf;
  bool isOnCactiHardfork(uint64_t block_number) const { return block_number >= cacti_hf.block_num; }
 
  HAS_RLP_FIELDS
};
 
Json::Value enc_json(const HardforksConfig& obj);
void dec_json(const Json::Value& json, HardforksConfig& obj);
}  // namespace taraxa