fix circulating (#617)

turuslan · web-flow · commit 4887629da934 · 2022-03-02T19:58:28.000+03:00
Signed-off-by: turuslan &lt;turuslan.devbox@gmail.com&gt;
diff --git a/core/api/full_node/make.cpp b/core/api/full_node/make.cpp
@@ -588,7 +588,7 @@ namespace fc::api {
       if (!message.gas_limit) {
         message.gas_limit = kBlockGasLimit;
       }
-      auto env = std::make_shared<Env>(env_context, ts_branch, context.tipset);
+      OUTCOME_TRY(env, Env::make(env_context, ts_branch, context.tipset));
       InvocResult result;
       result.message = message;
       OUTCOME_TRYA(result.receipt, env->applyImplicitMessage(message));
diff --git a/core/api/wallet/local_wallet.cpp b/core/api/wallet/local_wallet.cpp
@@ -71,7 +71,7 @@ namespace fc::api {
       std::sort(addresses.begin(), addresses.end());
       auto last = std::unique(addresses.begin(), addresses.end());
       addresses.erase(last, addresses.end());
-      return addresses;
+      return std::move(addresses);
     };
     api->WalletSetDefault = [=](auto &address) -> outcome::result<void> {
       wallet_default_address->setCbor(address);
diff --git a/core/const.cpp b/core/const.cpp
@@ -51,8 +51,8 @@ namespace fc {
   DEFINE(kUpgradeHyperdriveHeight){892800};
   // 2021-10-26T13:30:00Z
   DEFINE(kUpgradeChocolateHeight){1231620};
-  // 2021-03-01T14:00:00Z
-  DEFINE(kUpgradeOhSnapHeight){1594560};
+  // 2022-03-01T15:00:00Z
+  DEFINE(kUpgradeOhSnapHeight){1594680};
 
   DEFINE(kBreezeGasTampingDuration){120};
 
diff --git a/core/node/blocksync_request.cpp b/core/node/blocksync_request.cpp
@@ -347,33 +347,10 @@ namespace fc::sync::blocksync {
         done();
 
         if (result_->error) {
-          int64_t dr = 0;
-          const auto &category =
-              std::error_code(BlocksyncRequest::Error::kTimeout).category();
-          if (result_->error.category() == category) {
-            switch (result_->error.value()) {
-              case int(BlocksyncRequest::Error::kStoreCidsMismatch):
-                dr = -700;
-                break;
-              case int(BlocksyncRequest::Error::kInconsistentResponse):
-                dr = -500;
-                break;
-              case int(BlocksyncRequest::Error::kTimeout):
-                dr = -200;
-                break;
-              default:
-                break;
-            }
-          } else {
-            // stream and other errors
-            dr -= 200;
-          }
-          log()->debug("peer {}, error {}, dr={}",
+          log()->debug("peer {}, error {}",
                        (result_->from.has_value() ? result_->from->toBase58()
                                                   : "unknown"),
-                       result_->error.message(),
-                       dr);
-          result_->delta_rating += dr;
+                       result_->error.message());
         }
 
         if (call_now) {
@@ -447,15 +424,9 @@ namespace fc::sync::blocksync {
                        statusToString(response.status),
                        response.message,
                        response.chain.size());
-
-          if (response.status == ResponseStatus::kResponseComplete) {
-            result_->delta_rating += 100;
-          }
           if (response.chain.size() > 0) {
-            result_->delta_rating += 50;
             storeChain(std::move(response.chain));
           } else {
-            result_->delta_rating -= 50;
             result_->error = BlocksyncRequest::Error::kIncompleteResponse;
           }
         }
@@ -554,11 +525,6 @@ namespace fc::sync::blocksync {
             break;
           }
         }
-
-        if (!result_->blocks_available.empty()) {
-          result_->delta_rating +=
-              (result_->blocks_available.size() + result_->parents.size()) * 5;
-        }
       }
 
       libp2p::Host &host_;
diff --git a/core/node/blocksync_request.hpp b/core/node/blocksync_request.hpp
@@ -34,9 +34,6 @@ namespace fc::sync::blocksync {
       /// Not 0 if error occured
       std::error_code error;
 
-      /// Change rating for this peer
-      int64_t delta_rating = 0;
-
       /// Blocks which were requested
       std::vector<CbCid> blocks_requested;
 
diff --git a/core/node/main/builder.cpp b/core/node/main/builder.cpp
@@ -364,7 +364,6 @@ namespace fc::node {
         storage::LevelDB::create(config.join("ipld_leveldb")).value();
     o.ipld_leveldb =
         std::make_shared<storage::ipfs::LeveldbDatastore>(o.ipld_leveldb_kv);
-    o.ipld = o.ipld_leveldb;
     o.ipld = *storage::cids_index::loadOrCreateWithProgress(
         config.genesisCar(), false, boost::none, o.ipld, log());
     auto snapshot_cids{loadSnapshot(config, o)};
diff --git a/core/node/sync_job.cpp b/core/node/sync_job.cpp
@@ -454,7 +454,6 @@ namespace fc::sync {
       ts = _ts.value();
     } else {
       peers_->onError(*r.from);
-      r.delta_rating -= 500;
     }
 
     if (ts) {
diff --git a/core/storage/mpool/mpool.cpp b/core/storage/mpool/mpool.cpp
@@ -628,7 +628,7 @@ namespace fc::storage::mpool {
       std::shared_lock head_lock(head_mutex_);
       const auto height = head_->height();
       OUTCOME_TRY(interpeted, env_context.interpreter_cache->get(head_->key));
-      auto env{std::make_shared<vm::runtime::Env>(env_context, ts_main, head_)};
+      OUTCOME_TRY(env, vm::runtime::Env::make(env_context, ts_main, head_));
       head_lock.unlock();
       env->state_tree = std::make_shared<vm::state::StateTreeImpl>(
           env->ipld, interpeted.state_root);
diff --git a/core/vm/interpreter/impl/interpreter_impl.cpp b/core/vm/interpreter/impl/interpreter_impl.cpp
@@ -146,7 +146,7 @@ namespace fc::vm::interpreter {
       return InterpreterError::kDuplicateMiner;
     }
 
-    auto env = std::make_shared<Env>(env_context_, ts_branch, tipset);
+    OUTCOME_TRY(env, Env::make(env_context_, ts_branch, tipset));
 
     auto cron{[&]() -> outcome::result<void> {
       OUTCOME_TRY(receipt,
@@ -171,10 +171,10 @@ namespace fc::vm::interpreter {
       OUTCOME_TRY(parent, env_context_.ts_load->load(tipset->getParents()));
       for (auto epoch{parent->height() + 1}; epoch < tipset->height();
            ++epoch) {
-        env->setHeight(epoch);
+        OUTCOME_TRY(env->setHeight(epoch));
         OUTCOME_TRY(cron());
       }
-      env->setHeight(tipset->height());
+      OUTCOME_TRY(env->setHeight(tipset->height()));
     }
 
     nextStep(&metricMessages);
diff --git a/core/vm/runtime/env.hpp b/core/vm/runtime/env.hpp
@@ -37,7 +37,8 @@ namespace fc::vm::runtime {
 
   /// Environment contains objects that are shared by runtime contexts
   struct Env : std::enable_shared_from_this<Env> {
-    Env(const EnvironmentContext &env_context,
+    static outcome::result<std::shared_ptr<Env>> make(
+        const EnvironmentContext &env_context,
         TsBranchPtr ts_branch,
         TipsetCPtr tipset);
 
@@ -47,7 +48,7 @@ namespace fc::vm::runtime {
       TokenAmount reward;
     };
 
-    void setHeight(ChainEpoch height);
+    outcome::result<void> setHeight(ChainEpoch height);
 
     outcome::result<Apply> applyMessage(const UnsignedMessage &message,
                                         size_t size);
@@ -61,7 +62,8 @@ namespace fc::vm::runtime {
     ChainEpoch epoch;  // mutable epoch for cron()
     TsBranchPtr ts_branch;
     TipsetCPtr tipset;
-    Pricelist pricelist;
+    Pricelist pricelist{0};
+    TokenAmount base_circulating;
   };
 
   struct Execution : std::enable_shared_from_this<Execution> {
diff --git a/core/vm/runtime/impl/env.cpp b/core/vm/runtime/impl/env.cpp
@@ -110,23 +110,31 @@ namespace fc::vm::runtime {
     return storage::ipfs::IpfsDatastoreError::kNotFound;
   }
 
-  Env::Env(const EnvironmentContext &env_context,
-           TsBranchPtr ts_branch,
-           TipsetCPtr tipset)
-      : ipld{std::make_shared<IpldBuffered>(env_context.ipld)},
-        state_tree{std::make_shared<StateTreeImpl>(
-            this->ipld, tipset->getParentStateRoot())},
-        env_context{env_context},
-        epoch{tipset->height()},
-        ts_branch{std::move(ts_branch)},
-        tipset{std::move(tipset)},
-        pricelist{epoch} {
-    setHeight(epoch);
+  outcome::result<std::shared_ptr<Env>> Env::make(
+      const EnvironmentContext &env_context,
+      TsBranchPtr ts_branch,
+      TipsetCPtr tipset) {
+    auto env{std::make_shared<Env>()};
+    env->ipld = std::make_shared<IpldBuffered>(env_context.ipld);
+    env->state_tree = std::make_shared<StateTreeImpl>(
+        env->ipld, tipset->getParentStateRoot());
+    env->env_context = env_context;
+    env->epoch = tipset->height();
+    env->ts_branch = std::move(ts_branch);
+    env->tipset = std::move(tipset);
+    env->pricelist = Pricelist{env->epoch};
+    OUTCOME_TRY(env->setHeight(env->epoch));
+    return env;
   }
 
-  void Env::setHeight(ChainEpoch height) {
+  outcome::result<void> Env::setHeight(ChainEpoch height) {
     epoch = height;
     ipld->actor_version = actorVersion(height);
+    if (env_context.circulating) {
+      OUTCOME_TRYA(base_circulating,
+                   env_context.circulating->circulating(state_tree, height));
+    }
+    return outcome::success();
   }
 
   // NOLINTNEXTLINE(readability-function-cognitive-complexity)
diff --git a/core/vm/runtime/impl/runtime_impl.cpp b/core/vm/runtime/impl/runtime_impl.cpp
@@ -181,11 +181,13 @@ namespace fc::vm::runtime {
 
   outcome::result<TokenAmount> RuntimeImpl::getTotalFilCirculationSupply()
       const {
-    if (auto circulating{execution_->env->env_context.circulating}) {
-      return circulating->circulating(execution_->state_tree,
-                                      getCurrentEpoch());
+    if (getNetworkVersion() <= NetworkVersion::kVersion14) {
+      if (const auto &circulating{execution_->env->env_context.circulating}) {
+        return circulating->circulating(execution_->state_tree,
+                                        getCurrentEpoch());
+      }
     }
-    return 0;
+    return execution_->env->base_circulating;
   }
 
   std::shared_ptr<IpfsDatastore> RuntimeImpl::getIpfsDatastore() const {
diff --git a/test/core/test_vectors/test.cpp b/test/core/test_vectors/test.cpp
@@ -363,7 +363,7 @@ void testMessages(const MessageVector &mv, IpldPtr ipld) {
     std::shared_ptr<RuntimeRandomness> randomness =
         std::make_shared<ReplayingRandomness>(mv.randomness);
     fc::vm::runtime::EnvironmentContext env_context{ipld, invoker, randomness};
-    auto env{std::make_shared<fc::vm::runtime::Env>(env_context, nullptr, ts)};
+    auto env{fc::vm::runtime::Env::make(env_context, nullptr, ts).value()};
     auto i{0};
     for (const auto &[epoch_offset, message] : mv.messages) {
       const auto &receipt{mv.receipts[i]};
diff --git a/test/core/vm/actor/invoker_test.cpp b/test/core/vm/actor/invoker_test.cpp
@@ -29,7 +29,7 @@ namespace fc::vm::actor {
     ts->blks.emplace_back();
     auto execution{std::make_shared<Execution>()};
     execution->env =
-        std::make_shared<Env>(runtime::EnvironmentContext{}, nullptr, ts);
+        Env::make(runtime::EnvironmentContext{}, nullptr, ts).value();
 
     InvokerImpl invoker;
 

Original file line number	Diff line number	Diff line change
`@@ -588,7 +588,7 @@ namespace fc::api {`
`588`	`588`	`if (!message.gas_limit) {`
`589`	`589`	`message.gas_limit = kBlockGasLimit;`
`590`	`590`	`}`
`591`		`- auto env = std::make_shared<Env>(env_context, ts_branch, context.tipset);`
	`591`	`+ OUTCOME_TRY(env, Env::make(env_context, ts_branch, context.tipset));`
`592`	`592`	`InvocResult result;`
`593`	`593`	`result.message = message;`
`594`	`594`	`OUTCOME_TRYA(result.receipt, env->applyImplicitMessage(message));`
Original file line number	Diff line number	Diff line change
`@@ -454,7 +454,6 @@ namespace fc::sync {`
`454`	`454`	`ts = _ts.value();`
`455`	`455`	`} else {`
`456`	`456`	`peers_->onError(*r.from);`
`457`		`- r.delta_rating -= 500;`
`458`	`457`	`}`
`459`	`458`
`460`	`459`	`if (ts) {`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ namespace fc::vm::interpreter {`
`146`	`146`	`return InterpreterError::kDuplicateMiner;`
`147`	`147`	`}`
`148`	`148`
`149`		`- auto env = std::make_shared<Env>(env_context_, ts_branch, tipset);`
	`149`	`+ OUTCOME_TRY(env, Env::make(env_context_, ts_branch, tipset));`
`150`	`150`
`151`	`151`	`auto cron{[&]() -> outcome::result<void> {`
`152`	`152`	`OUTCOME_TRY(receipt,`
`@@ -171,10 +171,10 @@ namespace fc::vm::interpreter {`
`171`	`171`	`OUTCOME_TRY(parent, env_context_.ts_load->load(tipset->getParents()));`
`172`	`172`	`for (auto epoch{parent->height() + 1}; epoch < tipset->height();`
`173`	`173`	`++epoch) {`
`174`		`- env->setHeight(epoch);`
	`174`	`+ OUTCOME_TRY(env->setHeight(epoch));`
`175`	`175`	`OUTCOME_TRY(cron());`
`176`	`176`	`}`
`177`		`- env->setHeight(tipset->height());`
	`177`	`+ OUTCOME_TRY(env->setHeight(tipset->height()));`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`nextStep(&metricMessages);`