chore: increase gas limit

libraries/cli/include/cli/config_jsons/default/default_genesis.json

@@ -120,6 +120,10 @@
       "pillar_blocks_interval": 10,
       "bridge_contract_address": "0xcAF2b453FE8382a4B8110356DF0508f6d71F22BF"
     },
-    "cornus_hf_block_num": 100
+    "cornus_hf": {
+      "block_num": 100,
+      "dag_gas_limit": "0x1908B100",
+      "pbft_gas_limit": "0x7d2b7500"
+    }
   }
 }

libraries/cli/include/cli/config_jsons/devnet/devnet_genesis.json

@@ -285,6 +285,10 @@
       "pillar_blocks_interval": 10,
       "bridge_contract_address": "0xcAF2b453FE8382a4B8110356DF0508f6d71F22BF"
     },
-    "cornus_hf_block_num": 0
+    "cornus_hf": {
+      "block_num": 0,
+      "dag_gas_limit": "0x1908B100",
+      "pbft_gas_limit": "0x7d2b7500"
+    }
   }
 }

libraries/cli/include/cli/config_jsons/mainnet/mainnet_genesis.json

@@ -1654,6 +1654,10 @@
       "pillar_blocks_interval": 4000,
       "bridge_contract_address": "0xe126E0BaeAE904b8Cfd619Be1A8667A173b763a1"
     },
-    "cornus_hf_block_num": -1
+    "cornus_hf": {
+      "block_num": -1,
+      "dag_gas_limit": "0x1908B100",
+      "pbft_gas_limit": "0x7d2b7500"
+    }
   }
 }

libraries/cli/include/cli/config_jsons/testnet/testnet_genesis.json

@@ -105,13 +105,13 @@
     "dag_blocks_size": "0x32",
     "ghost_path_move_back": "0x0",
     "lambda_ms": "0x5DC",
-    "gas_limit": "0x7d2b7500"
+    "gas_limit": "0x12C684C0"
   },
   "dag": {
     "block_proposer": {
       "shard": 1
     },
-    "gas_limit": "0x1908B100"
+    "gas_limit": "0x1E0A6E0"
   },
   "sortition": {
     "changes_count_for_average": 10,
@@ -154,6 +154,10 @@
       "pillar_blocks_interval": 1000,
       "bridge_contract_address": "0xcAF2b453FE8382a4B8110356DF0508f6d71F22BF"
     },
-    "cornus_hf_block_num": 1668000
+    "cornus_hf": {
+      "block_num": 1668000,
+      "dag_gas_limit": "0x1908B100",
+      "pbft_gas_limit": "0x7d2b7500"
+    }
   }
 }

libraries/config/include/config/config.hpp

@@ -58,6 +58,8 @@ struct FullNodeConfig {
   bool enable_test_rpc = false;
   bool enable_debug = false;
   uint32_t final_chain_cache_in_blocks = 5;
+  uint64_t propose_dag_gas_limit = 0x1E0A6E0;
+  uint64_t propose_pbft_gas_limit = 0x12C684C0;
 
   // config values that limits transactions pool
   uint32_t transactions_pool_size = kDefaultTransactionPoolSize;

libraries/config/include/config/genesis.hpp

@@ -34,6 +34,7 @@ struct GenesisConfig {
   bytes rlp() const;
   blk_hash_t genesisHash() const;
   void updateBlocksPerYear();
+  std::pair<uint64_t, uint64_t> getGasLimits(uint64_t block_number) const;
 };
 
 Json::Value enc_json(GenesisConfig const& obj);

libraries/config/include/config/hardfork.hpp

@@ -72,6 +72,16 @@ struct FicusHardforkConfig {
 Json::Value enc_json(const FicusHardforkConfig& obj);
 void dec_json(const Json::Value& json, FicusHardforkConfig& obj);
 
+struct CornusHardforkConfig {
+  uint64_t block_num = -1;
+  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);
+
 // Keeping it for next HF
 // struct BambooRedelegation {
 //   taraxa::addr_t validator;
@@ -130,10 +140,10 @@ struct HardforksConfig {
   // Ficus hardfork: implementation of pillar chain
   FicusHardforkConfig ficus_hf;
 
-  // Cornus hf - support multiple undelegations from the same validator at the same time
-  uint64_t cornus_hf_block_num{0};
+  // Cornus hardfork
+  CornusHardforkConfig cornus_hf;
 
-  bool isCornusHardfork(uint64_t block_number) const { return block_number >= cornus_hf_block_num; }
+  bool isCornusHardfork(uint64_t block_number) const { return block_number >= cornus_hf.block_num; }
 
   HAS_RLP_FIELDS
 };

libraries/config/src/config.cpp

@@ -108,6 +108,9 @@ FullNodeConfig::FullNodeConfig(const Json::Value &string_or_object, const Json::
     genesis = GenesisConfig();
   }
 
+  propose_dag_gas_limit = getConfigDataAsUInt(root, {"propose_dag_gas_limit"}, true, propose_dag_gas_limit);
+  propose_pbft_gas_limit = getConfigDataAsUInt(root, {"propose_pbft_gas_limit"}, true, propose_pbft_gas_limit);
+
   is_light_node = getConfigDataAsBoolean(root, {"is_light_node"}, true, is_light_node);
   const auto min_light_node_history = (genesis.state.dpos.blocks_per_year * kDefaultLightNodeHistoryDays) / 365;
   light_node_history = getConfigDataAsUInt(root, {"light_node_history"}, true, min_light_node_history);

libraries/config/src/genesis.cpp

@@ -129,4 +129,11 @@ bytes GenesisConfig::rlp() const {
 
 blk_hash_t GenesisConfig::genesisHash() const { return dev::sha3(rlp()); }
 
+std::pair<uint64_t, uint64_t> GenesisConfig::getGasLimits(uint64_t block_number) const {
+  if (this->state.hardforks.isCornusHardfork(block_number)) {
+    return {this->state.hardforks.cornus_hf.dag_gas_limit, this->state.hardforks.cornus_hf.pbft_gas_limit};
+  }
+  return {dag.gas_limit, pbft.gas_limit};
+}
+
 }  // namespace taraxa

libraries/config/src/hardfork.cpp

@@ -104,6 +104,21 @@ void dec_json(const Json::Value& json, FicusHardforkConfig& obj) {
 
 RLP_FIELDS_DEFINE(FicusHardforkConfig, block_num, pillar_blocks_interval, bridge_contract_address)
 
+Json::Value enc_json(const CornusHardforkConfig& obj) {
+  Json::Value json(Json::objectValue);
+  json["block_num"] = dev::toJS(obj.block_num);
+  json["dag_gas_limit"] = dev::toJS(obj.dag_gas_limit);
+  json["pbft_gas_limit"] = dev::toJS(obj.pbft_gas_limit);
+  return json;
+}
+
+void dec_json(const Json::Value& json, CornusHardforkConfig& obj) {
+  obj.block_num = json["block_num"].isUInt64() ? dev::getUInt(json["block_num"]) : uint64_t(-1);
+  obj.dag_gas_limit = dev::getUInt(json["dag_gas_limit"]);
+  obj.pbft_gas_limit = dev::getUInt(json["pbft_gas_limit"]);
+}
+RLP_FIELDS_DEFINE(CornusHardforkConfig, block_num, dag_gas_limit, pbft_gas_limit)
+
 // Json::Value enc_json(const BambooRedelegation& obj) {
 //   Json::Value json(Json::objectValue);
 //   json["validator"] = dev::toJS(obj.validator);
@@ -158,7 +173,7 @@ Json::Value enc_json(const HardforksConfig& obj) {
   json["aspen_hf"] = enc_json(obj.aspen_hf);
   json["ficus_hf"] = enc_json(obj.ficus_hf);
   // json["bamboo_hf"] = enc_json(obj.bamboo_hf);
-  json["cornus_hf_block_num"] = dev::toJS(obj.cornus_hf_block_num);
+  json["cornus_hf"] = enc_json(obj.cornus_hf);
 
   return json;
 }
@@ -190,10 +205,9 @@ void dec_json(const Json::Value& json, HardforksConfig& obj) {
   dec_json(json["aspen_hf"], obj.aspen_hf);
   dec_json(json["ficus_hf"], obj.ficus_hf);
   // dec_json(json["bamboo_hf"], obj.bamboo_hf);
-  obj.cornus_hf_block_num =
-      json["cornus_hf_block_num"].isUInt64() ? dev::getUInt(json["cornus_hf_block_num"]) : uint64_t(-1);
+  dec_json(json["cornus_hf"], obj.cornus_hf);
 }
 
 RLP_FIELDS_DEFINE(HardforksConfig, fix_redelegate_block_num, redelegations, rewards_distribution_frequency, magnolia_hf,
-                  phalaenopsis_hf_block_num, fix_claim_all_block_num, aspen_hf, ficus_hf, cornus_hf_block_num)
+                  phalaenopsis_hf_block_num, fix_claim_all_block_num, aspen_hf, ficus_hf, cornus_hf)
 }  // namespace taraxa

libraries/core_libs/consensus/include/dag/dag_manager.hpp

@@ -279,8 +279,7 @@ class DagManager : public std::enable_shared_from_this<DagManager> {
   const uint32_t cache_delete_step_ = 100;
   ExpirationCacheMap<blk_hash_t, std::shared_ptr<DagBlock>> seen_blocks_;
   std::shared_ptr<final_chain::FinalChain> final_chain_;
-  const uint64_t kPbftGasLimit;
-  const HardforksConfig kHardforks;
+  const GenesisConfig kGenesis;
   const uint64_t kValidatorMaxVote;
 
   LOG_OBJECTS_DEFINE

libraries/core_libs/consensus/include/pbft/pbft_manager.hpp

@@ -224,9 +224,10 @@ class PbftManager {
   /**
    * @brief Check a block weight of gas estimation
    * @param dag_blocks dag blocks
+   * @param period period
    * @return true if total weight of gas estimation is less or equal to gas limit. Otherwise return false
    */
-  bool checkBlockWeight(const std::vector<std::shared_ptr<DagBlock>> &dag_blocks) const;
+  bool checkBlockWeight(const std::vector<std::shared_ptr<DagBlock>> &dag_blocks, PbftPeriod period) const;
 
   blk_hash_t getLastPbftBlockHash();
 

libraries/core_libs/consensus/src/dag/dag_block_proposer.cpp

@@ -26,8 +26,8 @@ DagBlockProposer::DagBlockProposer(const FullNodeConfig& config, std::shared_ptr
       node_sk_(config.node_secret),
       vrf_sk_(config.vrf_secret),
       vrf_pk_(vrf_wrapper::getVrfPublicKey(vrf_sk_)),
-      kPbftGasLimit(config.genesis.pbft.gas_limit),
-      kDagGasLimit(config.genesis.dag.gas_limit),
+      kPbftGasLimit(config.propose_pbft_gas_limit),
+      kDagGasLimit(config.propose_dag_gas_limit),
       kHardforks(config.genesis.state.hardforks),
       kValidatorMaxVote(config.genesis.state.dpos.validator_maximum_stake /
                         config.genesis.state.dpos.vote_eligibility_balance_step) {
@@ -41,6 +41,20 @@ DagBlockProposer::DagBlockProposer(const FullNodeConfig& config, std::shared_ptr
   auto addr = std::stoull(node_addr.toString().substr(0, 6).c_str(), NULL, 16);
   my_trx_shard_ = addr % bp_config_.shard;
 
+  const auto [dag_gas_limit, pbft_gas_limit] = config.genesis.getGasLimits(final_chain_->lastBlockNumber());
+
+  if (kPbftGasLimit > pbft_gas_limit) {
+    LOG(log_er_) << "Propose pbft gas limit:" << kPbftGasLimit << " greater than max allowed pbft gas limit";
+    assert(false);
+    return;
+  }
+
+  if (kDagGasLimit > dag_gas_limit) {
+    LOG(log_er_) << "Propose dag gas limit:" << kDagGasLimit << " greater than max allowed dag gas limit";
+    assert(false);
+    return;
+  }
+
   LOG(log_nf_) << "Dag block proposer in " << my_trx_shard_ << " shard ...";
 }
 
@@ -117,7 +131,7 @@ bool DagBlockProposer::proposeDagBlock() {
     }
   }
 
-  auto [transactions, estimations] = getShardedTrxs(*proposal_period, dag_mgr_->getDagConfig().gas_limit);
+  auto [transactions, estimations] = getShardedTrxs(*proposal_period, kDagGasLimit);
   if (transactions.empty()) {
     last_propose_level_ = propose_level;
     num_tries_ = 0;

libraries/core_libs/consensus/src/dag/dag_manager.cpp

@@ -35,8 +35,7 @@ DagManager::DagManager(const FullNodeConfig &config, addr_t node_addr, std::shar
       dag_expiry_limit_(config.dag_expiry_limit),
       seen_blocks_(cache_max_size_, cache_delete_step_),
       final_chain_(std::move(final_chain)),
-      kPbftGasLimit(config.genesis.pbft.gas_limit),
-      kHardforks(config.genesis.state.hardforks),
+      kGenesis(config.genesis),
       kValidatorMaxVote(config.genesis.state.dpos.validator_maximum_stake /
                         config.genesis.state.dpos.vote_eligibility_balance_step) {
   LOG_OBJECTS_CREATE("DAGMGR");
@@ -512,7 +511,7 @@ void DagManager::recoverDag() {
         try {
           uint64_t max_vote_count = 0;
           const auto vote_count = final_chain_->dposEligibleVoteCount(*propose_period, blk->getSender());
-          if (*propose_period < kHardforks.magnolia_hf.block_num) {
+          if (*propose_period < kGenesis.state.hardforks.magnolia_hf.block_num) {
             max_vote_count = final_chain_->dposEligibleTotalVoteCount(*propose_period);
           } else {
             max_vote_count = kValidatorMaxVote;
@@ -673,7 +672,7 @@ std::pair<DagManager::VerifyBlockReturnType, SharedTransactions> DagManager::ver
     const auto proposal_period_hash = db_->getPeriodBlockHash(*propose_period);
     uint64_t max_vote_count = 0;
     const auto vote_count = final_chain_->dposEligibleVoteCount(*propose_period, blk->getSender());
-    if (*propose_period < kHardforks.magnolia_hf.block_num) {
+    if (*propose_period < kGenesis.state.hardforks.magnolia_hf.block_num) {
       max_vote_count = final_chain_->dposEligibleTotalVoteCount(*propose_period);
     } else {
       max_vote_count = kValidatorMaxVote;
@@ -715,14 +714,16 @@ std::pair<DagManager::VerifyBlockReturnType, SharedTransactions> DagManager::ver
       return {VerifyBlockReturnType::IncorrectTransactionsEstimation, {}};
     }
 
-    if (total_block_weight > getDagConfig().gas_limit) {
-      LOG(log_er_) << "BlockTooBig. DAG block " << blk->getHash() << " gas_limit: " << getDagConfig().gas_limit
+    const auto [dag_gas_limit, pbft_gas_limit] = kGenesis.getGasLimits(*propose_period);
+
+    if (total_block_weight > dag_gas_limit) {
+      LOG(log_er_) << "BlockTooBig. DAG block " << blk->getHash() << " gas_limit: " << dag_gas_limit
                    << " total_block_weight " << total_block_weight << " current period "
                    << final_chain_->lastBlockNumber();
       return {VerifyBlockReturnType::BlockTooBig, {}};
     }
 
-    if ((blk->getTips().size() + 1) > kPbftGasLimit / getDagConfig().gas_limit) {
+    if ((blk->getTips().size() + 1) > pbft_gas_limit / dag_gas_limit) {
       for (const auto &t : blk->getTips()) {
         const auto tip_blk = getDagBlock(t);
         if (tip_blk == nullptr) {
@@ -731,8 +732,8 @@ std::pair<DagManager::VerifyBlockReturnType, SharedTransactions> DagManager::ver
         }
         block_gas_estimation += tip_blk->getGasEstimation();
       }
-      if (block_gas_estimation > kPbftGasLimit) {
-        LOG(log_er_) << "BlockTooBig. DAG block " << blk->getHash() << " with tips has limit: " << kPbftGasLimit
+      if (block_gas_estimation > pbft_gas_limit) {
+        LOG(log_er_) << "BlockTooBig. DAG block " << blk->getHash() << " with tips has limit: " << pbft_gas_limit
                      << " block_gas_estimation " << block_gas_estimation << " current period "
                      << final_chain_->lastBlockNumber();
         return {VerifyBlockReturnType::BlockTooBig, {}};

libraries/core_libs/consensus/src/pbft/pbft_manager.cpp

@@ -1287,7 +1287,8 @@ PbftManager::proposePbftBlock() {
     }
     const auto &dag_block_weight = dag_blk->getGasEstimation();
 
-    if (total_weight + dag_block_weight > kGenesisConfig.pbft.gas_limit) {
+    const auto [dag_gas_limit, pbft_gas_limit] = kGenesisConfig.getGasLimits(current_pbft_period);
+    if (total_weight + dag_block_weight > pbft_gas_limit) {
       break;
     }
     total_weight += dag_block_weight;
@@ -1553,7 +1554,7 @@ bool PbftManager::validatePbftBlock(const std::shared_ptr<PbftBlock> &pbft_block
     auto prev_pbft_block = pbft_chain_->getPbftBlockInChain(last_pbft_block_hash);
     auto ghost = dag_mgr_->getGhostPath(prev_pbft_block.getPivotDagBlockHash());
     if (ghost.size() > 1 && anchor_hash != ghost[1]) {
-      if (!checkBlockWeight(anchor_dag_block_order_cache_[anchor_hash])) {
+      if (!checkBlockWeight(anchor_dag_block_order_cache_[anchor_hash], block_period)) {
         LOG(log_er_) << "PBFT block " << pbft_block_hash << " weight exceeded max limit";
         anchor_dag_block_order_cache_.erase(anchor_hash);
         return false;
@@ -2155,11 +2156,14 @@ void PbftManager::periodDataQueuePush(PeriodData &&period_data, dev::p2p::NodeID
 
 size_t PbftManager::periodDataQueueSize() const { return sync_queue_.size(); }
 
-bool PbftManager::checkBlockWeight(const std::vector<std::shared_ptr<DagBlock>> &dag_blocks) const {
+bool PbftManager::checkBlockWeight(const std::vector<std::shared_ptr<DagBlock>> &dag_blocks, PbftPeriod period) const {
   const u256 total_weight =
       std::accumulate(dag_blocks.begin(), dag_blocks.end(), u256(0),
                       [](u256 value, const auto &dag_block) { return value + dag_block->getGasEstimation(); });
-  if (total_weight > kGenesisConfig.pbft.gas_limit) {
+  auto pbft_gas_limit = kGenesisConfig.state.hardforks.isCornusHardfork(period)
+                            ? kGenesisConfig.state.hardforks.cornus_hf.pbft_gas_limit
+                            : kGenesisConfig.pbft.gas_limit;
+  if (total_weight > pbft_gas_limit) {
     return false;
   }
   return true;

tests/pbft_manager_test.cpp

@@ -665,7 +665,7 @@ TEST_F(PbftManagerWithDagCreation, produce_overweighted_block) {
   const auto period = node->getFinalChain()->lastBlockNumber();
   auto period_data = node->getDB()->getPeriodData(period);
   ASSERT_TRUE(period_data.has_value());
-  EXPECT_FALSE(node->getPbftManager()->checkBlockWeight(period_data->dag_blocks));
+  EXPECT_FALSE(node->getPbftManager()->checkBlockWeight(period_data->dag_blocks, period));
 }
 
 TEST_F(PbftManagerWithDagCreation, proposed_blocks) {