fix randomness (#497)

Signed-off-by: turuslan <[email protected]>

Author: turuslan

core/api/full_node/make.cpp

@@ -335,6 +335,7 @@ namespace fc::api {
             auto &entropy) -> outcome::result<Randomness> {
       std::unique_lock ts_lock{*env_context.ts_branches_mutex};
       OUTCOME_TRY(ts_branch, TsBranch::make(ts_load, tipset_key, ts_main));
+      ts_lock.unlock();
       return env_context.randomness->getRandomnessFromBeacon(
           ts_branch, tag, epoch, entropy);
     };
@@ -345,6 +346,7 @@ namespace fc::api {
             auto &entropy) -> outcome::result<Randomness> {
       std::unique_lock ts_lock{*env_context.ts_branches_mutex};
       OUTCOME_TRY(ts_branch, TsBranch::make(ts_load, tipset_key, ts_main));
+      ts_lock.unlock();
       return env_context.randomness->getRandomnessFromTickets(
           ts_branch, tag, epoch, entropy);
     };

core/const.cpp

@@ -202,7 +202,7 @@ namespace fc {
     kUpgradeNorwegianHeight = -13;
     kUpgradeActorsV4Height = -14;
     kUpgradeHyperdriveHeight = -15;
-    kUpgradeChocolateHeight = -17;
+    kUpgradeChocolateHeight = INT64_MAX;
 
     kBreezeGasTampingDuration = 0;
 

core/node/main/builder.cpp

@@ -378,11 +378,29 @@ namespace fc::node {
     assert(genesis_cids.size() == 1);
     config.genesis_cid = genesis_cids[0];
 
+    const auto genesis{o.ts_load->load(*TipsetKey::make(genesis_cids)).value()};
+    const clock::UnixTime genesis_timestamp{genesis->blks[0].timestamp};
+
+    log()->info("Genesis: {}, timestamp {}",
+                config.genesis_cid.value().toString().value(),
+                clock::unixTimeToString(genesis_timestamp));
+
+    const drand::ChainInfo drand_chain_info{
+        .key = *config.drand_bls_pubkey,
+        .genesis = std::chrono::seconds(*config.drand_genesis),
+        .period = std::chrono::seconds(*config.drand_period),
+    };
+
+    const auto drand_schedule{std::make_shared<drand::DrandScheduleImpl>(
+        drand_chain_info,
+        genesis_timestamp,
+        std::chrono::seconds(kEpochDurationSeconds))};
+
     o.env_context.ts_branches_mutex = ts_mutex;
     o.env_context.ipld = o.ipld;
     o.env_context.invoker = std::make_shared<vm::actor::InvokerImpl>();
     o.env_context.randomness = std::make_shared<vm::runtime::TipsetRandomness>(
-        o.ts_load, o.env_context.ts_branches_mutex);
+        o.ts_load, o.env_context.ts_branches_mutex, drand_schedule);
     o.env_context.ts_load = o.ts_load;
     o.env_context.interpreter_cache =
         std::make_shared<vm::interpreter::InterpreterCache>(
@@ -410,16 +428,9 @@ namespace fc::node {
     o.compacter->ts_main = o.ts_main;
     o.compacter->open();
 
-    OUTCOME_EXCEPT(genesis, o.ts_load->load(*TipsetKey::make(genesis_cids)));
     OUTCOME_TRY(initNetworkName(*genesis, o.ipld, config));
     log()->info("Network name: {}", *config.network_name);
 
-    auto genesis_timestamp = clock::UnixTime(genesis->blks[0].timestamp);
-
-    log()->info("Genesis: {}, timestamp {}",
-                config.genesis_cid.value().toString().value(),
-                clock::unixTimeToString(genesis_timestamp));
-
     o.utc_clock = std::make_shared<clock::UTCClockImpl>();
 
     o.chain_epoch_clock =
@@ -585,12 +596,6 @@ namespace fc::node {
       }
     }
 
-    drand::ChainInfo drand_chain_info{
-        .key = *config.drand_bls_pubkey,
-        .genesis = std::chrono::seconds(*config.drand_genesis),
-        .period = std::chrono::seconds(*config.drand_period),
-    };
-
     if (config.drand_servers.empty()) {
       config.drand_servers.emplace_back("https://127.0.0.1:8080");
     }
@@ -603,11 +608,6 @@ namespace fc::node {
                                                 config.drand_servers,
                                                 config.beaconizer_cache_size);
 
-    auto drand_schedule = std::make_shared<drand::DrandScheduleImpl>(
-        drand_chain_info,
-        genesis_timestamp,
-        std::chrono::seconds(kEpochDurationSeconds));
-
     o.markets_ipld = o.ipld_leveldb;
     o.api = std::make_shared<api::FullNodeApi>();
     o.datatransfer = DataTransfer::make(o.host, o.graphsync);

core/vm/dvm/CMakeLists.txt

@@ -18,6 +18,7 @@ add_executable(dvm_main
 target_link_libraries(dvm_main
     car
     cids_index
+    drand_beacon
     in_memory_storage
     interpreter
     ipfs_datastore_in_memory

core/vm/dvm/main.cpp

@@ -4,6 +4,7 @@
  */
 
 #include "cbor_blake/ipld_any.hpp"
+#include "drand/impl/beaconizer.hpp"
 #include "primitives/tipset/chain.hpp"
 #include "storage/car/car.hpp"
 #include "storage/car/cids_index/util.hpp"
@@ -41,8 +42,21 @@ int main(int argc, char **argv) {
           std::make_shared<fc::primitives::tipset::TsLoadIpld>(envx.ipld)};
       envx.ts_load =
           std::make_shared<primitives::tipset::TsLoadCache>(ts_load_ipld, 1000);
+
+      const auto genesis_block{
+          getCbor<primitives::block::BlockHeader>(envx.ipld, genesis_cid)
+              .value()};
       envx.randomness = std::make_shared<vm::runtime::TipsetRandomness>(
-          envx.ts_load, envx.ts_branches_mutex);
+          envx.ts_load,
+          envx.ts_branches_mutex,
+          std::make_shared<drand::DrandScheduleImpl>(
+              drand::ChainInfo{
+                  {},
+                  std::chrono::seconds{1595431050},
+                  std::chrono::seconds{30},
+              },
+              std::chrono::seconds{genesis_block.timestamp},
+              std::chrono::seconds{kEpochDurationSeconds}));
       envx.interpreter_cache =
           std::make_shared<vm::interpreter::InterpreterCache>(
               std::make_shared<storage::InMemoryStorage>(),

core/vm/runtime/impl/tipset_randomness.cpp

@@ -5,42 +5,77 @@
 
 #include "vm/runtime/impl/tipset_randomness.hpp"
 
+#include "drand/beaconizer.hpp"
 #include "primitives/tipset/chain.hpp"
 
 namespace fc::vm::runtime {
-  TipsetRandomness::TipsetRandomness(TsLoadPtr ts_load,
-                                     SharedMutexPtr ts_branches_mutex)
+  using drand::BeaconEntry;
+
+  TipsetRandomness::TipsetRandomness(
+      TsLoadPtr ts_load,
+      SharedMutexPtr ts_branches_mutex,
+      std::shared_ptr<DrandSchedule> drand_schedule)
       : ts_load{std::move(ts_load)},
-        ts_branches_mutex{std::move(ts_branches_mutex)} {}
+        ts_branches_mutex{std::move(ts_branches_mutex)},
+        drand_schedule{std::move(drand_schedule)} {}
 
   outcome::result<Randomness> TipsetRandomness::getRandomnessFromTickets(
       const TsBranchPtr &ts_branch,
       DomainSeparationTag tag,
       ChainEpoch epoch,
       gsl::span<const uint8_t> seed) const {
     std::shared_lock ts_lock{*ts_branches_mutex};
+    const auto network{version::getNetworkVersion(epoch)};
     OUTCOME_TRY(it,
                 find(ts_branch,
                      std::max<ChainEpoch>(0, epoch),
-                     epoch <= kUpgradeHyperdriveHeight));
+                     network < NetworkVersion::kVersion13));
     OUTCOME_TRY(ts, ts_load->lazyLoad(it.second->second));
     ts_lock.unlock();
 
     return crypto::randomness::drawRandomness(
         ts->getMinTicketBlock().ticket->bytes, tag, epoch, seed);
   }
 
+  inline outcome::result<BeaconEntry> extractBeaconEntryForEpoch(
+      TsLoadPtr ts_load,
+      primitives::tipset::chain::TsBranchIter it,
+      drand::Round round) {
+    // magic number from lotus
+    for (auto i{0}; i < 20; ++i) {
+      OUTCOME_TRY(ts, ts_load->lazyLoad(it.second->second));
+      for (const auto &beacon : ts->blks[0].beacon_entries) {
+        if (beacon.round == round) {
+          return beacon;
+        }
+      }
+      if (it.second->first == 0) {
+        break;
+      }
+      OUTCOME_TRYA(it, stepParent(it));
+    }
+    return primitives::tipset::TipsetError::kNoBeacons;
+  }
+
   outcome::result<Randomness> TipsetRandomness::getRandomnessFromBeacon(
       const TsBranchPtr &ts_branch,
       DomainSeparationTag tag,
       ChainEpoch epoch,
       gsl::span<const uint8_t> seed) const {
     std::shared_lock ts_lock{*ts_branches_mutex};
+    const auto network{version::getNetworkVersion(epoch)};
     OUTCOME_TRY(it,
                 find(ts_branch,
                      std::max<ChainEpoch>(0, epoch),
-                     epoch <= kUpgradeHyperdriveHeight));
-    OUTCOME_TRY(beacon, latestBeacon(ts_load, it));
+                     network < NetworkVersion::kVersion13));
+    BeaconEntry beacon;
+    if (network <= NetworkVersion::kVersion13 || epoch < 0) {
+      OUTCOME_TRYA(beacon, latestBeacon(ts_load, it));
+    } else {
+      OUTCOME_TRYA(beacon,
+                   extractBeaconEntryForEpoch(
+                       ts_load, it, drand_schedule->maxRound(epoch)));
+    }
     ts_lock.unlock();
 
     return crypto::randomness::drawRandomness(beacon.data, tag, epoch, seed);

core/vm/runtime/impl/tipset_randomness.hpp

@@ -9,9 +9,13 @@
 #include "vm/runtime/runtime_randomness.hpp"
 
 namespace fc::vm::runtime {
+  using drand::DrandSchedule;
+
   class TipsetRandomness : public RuntimeRandomness {
    public:
-    TipsetRandomness(TsLoadPtr ts_load, SharedMutexPtr ts_branches_mutex);
+    TipsetRandomness(TsLoadPtr ts_load,
+                     SharedMutexPtr ts_branches_mutex,
+                     std::shared_ptr<DrandSchedule> drand_schedule);
 
     outcome::result<Randomness> getRandomnessFromTickets(
         const TsBranchPtr &ts_branch,
@@ -28,6 +32,7 @@ namespace fc::vm::runtime {
    private:
     TsLoadPtr ts_load;
     SharedMutexPtr ts_branches_mutex;
+    std::shared_ptr<DrandSchedule> drand_schedule;
   };
 
 }  // namespace fc::vm::runtime