Rename EpochIndex to ChainEpoch (#47)

Signed-off-by: Alexey-N-Chernyshov <[email protected]>

Author: Alexey-N-Chernyshov

core/crypto/randomness/impl/randomness_provider.cpp

@@ -17,15 +17,15 @@ namespace fc::crypto::randomness {
 
   Randomness RandomnessProviderImpl::deriveRandomness(DomainSeparationTag tag,
                                                       Serialization s,
-                                                      EpochIndex index) {
+                                                      ChainEpoch index) {
     return deriveRandomnessInternal(tag, std::move(s), static_cast<size_t>(-1));
   }
 
   Randomness RandomnessProviderImpl::deriveRandomnessInternal(
-      DomainSeparationTag tag, Serialization s, EpochIndex index) {
+      DomainSeparationTag tag, Serialization s, ChainEpoch index) {
     common::Buffer value{};
     const size_t bytes_required =
-        sizeof(DomainSeparationTag) + sizeof(EpochIndex) + s.size();
+        sizeof(DomainSeparationTag) + sizeof(ChainEpoch) + s.size();
     value.reserve(bytes_required);
     common::encodeInteger(static_cast<size_t>(tag), value);
     common::encodeInteger(static_cast<size_t>(index), value);

core/crypto/randomness/impl/randomness_provider.hpp

@@ -19,12 +19,12 @@ namespace fc::crypto::randomness {
 
     Randomness deriveRandomness(DomainSeparationTag tag,
                                 Serialization s,
-                                EpochIndex index) override;
+                                ChainEpoch index) override;
 
    private:
     Randomness deriveRandomnessInternal(DomainSeparationTag tag,
                                         Serialization s,
-                                        EpochIndex index);
+                                        ChainEpoch index);
   };
 
 }  // namespace fc::crypto::randomness

core/crypto/randomness/randomness_provider.hpp

@@ -34,7 +34,7 @@ namespace fc::crypto::randomness {
      */
     virtual Randomness deriveRandomness(DomainSeparationTag tag,
                                         Serialization s,
-                                        EpochIndex index) = 0;
+                                        ChainEpoch index) = 0;
   };
 }  // namespace fc::crypto::randomness
 

core/crypto/randomness/randomness_types.hpp

@@ -6,8 +6,8 @@
 #ifndef CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_RANDOMNESS_HPP
 #define CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_RANDOMNESS_HPP
 
-#include "common/buffer.hpp"
 #include "common/blob.hpp"
+#include "common/buffer.hpp"
 
 namespace fc::crypto::randomness {
   /// @brief randomness value type
@@ -17,14 +17,14 @@ namespace fc::crypto::randomness {
   using Serialization = common::Buffer;
 
   /// @brief domain separation tag enum
-  enum class DomainSeparationTag: size_t {
-      TicketDrawingDST = 1,
-      TicketProductionDST = 2,
-      PoStDST = 3
+  enum class DomainSeparationTag : size_t {
+    TicketDrawingDST = 1,
+    TicketProductionDST = 2,
+    PoStDST = 3
   };
 
-  /// @brief epoch index type
-  using EpochIndex = size_t;
-}
+  /// @brief epoch index type represents a round of a blockchain protocol
+  using ChainEpoch = size_t;
+}  // namespace fc::crypto::randomness
 
-#endif //CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_RANDOMNESS_HPP
+#endif  // CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_RANDOMNESS_HPP

test/core/crypto/randomness/randomness_provider_test.cpp

@@ -29,14 +29,14 @@ struct RandomnessProviderTest
     : public RandomnessProviderBaseTest,
       public ::testing::TestWithParam<std::tuple<DomainSeparationTag,
                                                  Serialization,
-                                                 EpochIndex,
+                                                 ChainEpoch,
                                                  Randomness>> {
   template <class T, class S, class I, class R>
-  static std::tuple<DomainSeparationTag, Serialization, EpochIndex, Randomness>
+  static std::tuple<DomainSeparationTag, Serialization, ChainEpoch, Randomness>
   makeParams(T tag, S s, I index, R res) {
     return std::make_tuple(static_cast<DomainSeparationTag>(std::move(tag)),
                            static_cast<Serialization>(std::move(s)),
-                           static_cast<EpochIndex>(std::move(index)),
+                           static_cast<ChainEpoch>(std::move(index)),
                            static_cast<Randomness>(std::move(res)));
   }
 };
@@ -103,7 +103,7 @@ struct RandomnessProviderValuesTest : public RandomnessProviderBaseTest,
   Randomness generateRandomnessValue() {
     auto tag = static_cast<DomainSeparationTag>(getRandomByte() % 3 + 1);
     Serialization s{random_generator->randomBytes(buffer_size)};
-    EpochIndex index = getRandomByte() % 100;
+    ChainEpoch index = getRandomByte() % 100;
 
     return randomness_provider->deriveRandomness(tag, s, index);
   }

test/core/vm/actor/actor_test.cpp

@@ -8,7 +8,6 @@
 #include "codec/cbor/cbor.hpp"
 #include <gtest/gtest.h>
 #include "testutil/literals.hpp"
-#include "testutil/outcome.hpp"
 
 using libp2p::multi::ContentIdentifier;