Feature/refactor chainepoch (#90)

Alexey-N-Chernyshov · web-flow · commit 3730b429255c · 2020-02-07T15:52:30.000+03:00
Signed-off-by: Alexey-N-Chernyshov &lt;alexey.n.chernyshov@gmail.com&gt;
diff --git a/core/clock/impl/chain_epoch_clock_impl.cpp b/core/clock/impl/chain_epoch_clock_impl.cpp
@@ -16,7 +16,7 @@ namespace fc::clock {
   outcome::result<ChainEpoch> ChainEpochClockImpl::epochAtTime(
       const Time &time) const {
     if (time < genesis_time_) {
-      return EpochAtTimeError::BEFORE_GENESIS;
+      return outcome::failure(EpochAtTimeError::BEFORE_GENESIS);
     }
     auto difference = time.unixTimeNano() - genesis_time_.unixTimeNano();
     return ChainEpoch(difference / kEpochDuration);
diff --git a/core/common/le_encoder.hpp b/core/common/le_encoder.hpp
@@ -11,16 +11,17 @@
 
 namespace fc::common {
   /**
-   * @brief little-endian -encodes an integral value
+   * @brief little-endian-encodes an integral value
    * @tparam T integral value type
    * @param value integral value to encode
    * @param out output buffer
    */
   template <class T,
             typename I = std::decay_t<T>,
             typename = std::enable_if_t<std::is_integral<I>::value>>
-  void encodeInteger(T value,
-                     common::Buffer &out) {  // no need to take integers by &&
+  void encodeLebInteger(
+      T value,
+      common::Buffer &out) {  // no need to take integers by &&
     constexpr size_t size = sizeof(T);
     constexpr size_t bits = size * 8;
     boost::endian::endian_buffer<boost::endian::order::little, T, bits> buf{};
diff --git a/core/crypto/randomness/CMakeLists.txt b/core/crypto/randomness/CMakeLists.txt
@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 add_library(randomness_provider
-    impl/randomness_provider_imp.cpp
+    impl/randomness_provider_impl.cpp
     )
 target_link_libraries(randomness_provider
     Boost::boost
diff --git a/core/crypto/randomness/impl/randomness_provider_impl.cpp b/core/crypto/randomness/impl/randomness_provider_impl.cpp
@@ -3,32 +3,36 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include "crypto/randomness/impl/randomness_provider_imp.hpp"
+#include "crypto/randomness/impl/randomness_provider_impl.hpp"
 
 #include <libp2p/crypto/sha/sha256.hpp>
 #include "common/le_encoder.hpp"
 
 namespace fc::crypto::randomness {
 
+  int64_t kNoIndex = -1;
+
   Randomness RandomnessProviderImpl::deriveRandomness(DomainSeparationTag tag,
                                                       Serialization s) {
-    return deriveRandomness(tag, std::move(s), ChainEpoch(-1));
+    return deriveRandomness(tag, std::move(s), kNoIndex);
   }
 
   Randomness RandomnessProviderImpl::deriveRandomness(DomainSeparationTag tag,
                                                       Serialization s,
                                                       const ChainEpoch &index) {
-    return deriveRandomnessInternal(tag, std::move(s), index);
+    return deriveRandomnessInternal(
+        static_cast<uint64_t>(tag), std::move(s), index.convert_to<int64_t>());
   }
 
-  Randomness RandomnessProviderImpl::deriveRandomnessInternal(
-      DomainSeparationTag tag, Serialization s, const ChainEpoch &index) {
+  Randomness RandomnessProviderImpl::deriveRandomnessInternal(uint64_t tag,
+                                                              Serialization s,
+                                                              int64_t index) {
     common::Buffer value{};
     const size_t bytes_required =
         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.toUInt64()), value);
+    common::encodeLebInteger(tag, value);
+    common::encodeLebInteger(index, value);
     value.put(s);
     auto hash = libp2p::crypto::sha256(value);
 
diff --git a/core/crypto/randomness/impl/randomness_provider_impl.hpp b/core/crypto/randomness/impl/randomness_provider_impl.hpp
@@ -26,9 +26,16 @@ namespace fc::crypto::randomness {
                   size_t limit) override;
 
    private:
-    Randomness deriveRandomnessInternal(DomainSeparationTag tag,
+    /**
+     * Internal implementation of random function
+     * @param tag - as uint64 - used for seed
+     * @param s - used for seed
+     * @param index - chain epoch as int64 - used for seed
+     * @return Randomness
+     */
+    Randomness deriveRandomnessInternal(uint64_t tag,
                                         Serialization s,
-                                        const ChainEpoch &index);
+                                        int64_t index);
   };
 
 }  // namespace fc::crypto::randomness
diff --git a/core/crypto/vrf/vrf_hash_encoder.cpp b/core/crypto/vrf/vrf_hash_encoder.cpp
@@ -22,8 +22,8 @@ namespace fc::crypto::vrf {
     auto required_bytes = sizeof(uint64_t) + 2 * sizeof(uint8_t)
                           + params.message.size() + miner_bytes.size();
     out.reserve(required_bytes);
-    common::encodeInteger(static_cast<uint64_t>(params.personalization_tag),
-                          out);
+    common::encodeLebInteger(static_cast<uint64_t>(params.personalization_tag),
+                             out);
     out.putUint8(0u);
     out.putBuffer(params.message);
     out.putUint8(0u);
diff --git a/core/primitives/big_int.hpp b/core/primitives/big_int.hpp
@@ -13,85 +13,107 @@
 namespace fc::primitives {
   using boost::multiprecision::cpp_int;
 
-  struct BigInt : cpp_int {
+  struct UBigInt : cpp_int,
+                   boost::totally_ordered<UBigInt, int> {
     using cpp_int::cpp_int;
-  };
 
-  struct UBigInt : cpp_int {
-    using cpp_int::cpp_int;
-  };
+    inline bool operator==(int other) const {
+      return static_cast<cpp_int>(*this) == other;
+    }
 
-  static inline BigInt operator*(const BigInt &lhs, const BigInt &rhs) {
-    return static_cast<cpp_int>(lhs) * static_cast<cpp_int>(rhs);
-  }
+    inline bool operator==(const UBigInt &other) const {
+      return static_cast<cpp_int>(*this) == static_cast<cpp_int>(other);
+    }
 
-  static inline BigInt operator*(const unsigned long &lhs, const BigInt &rhs) {
-    return static_cast<cpp_int>(lhs) * static_cast<cpp_int>(rhs);
-  }
+    inline bool operator<(int other) const {
+      return static_cast<cpp_int>(*this) < other;
+    }
 
-  static inline BigInt operator*(const BigInt &rhs, unsigned long long lhs) {
-    return static_cast<cpp_int>(lhs) * static_cast<cpp_int>(rhs);
-  }
+    inline bool operator<(const UBigInt &other) const {
+      return static_cast<cpp_int>(*this) < static_cast<cpp_int>(other);
+    }
 
-  static inline BigInt operator/(const BigInt &lhs, const BigInt &rhs) {
-    return static_cast<cpp_int>(lhs) / static_cast<cpp_int>(rhs);
-  }
+    inline UBigInt operator*(const UBigInt &other) const {
+      return static_cast<cpp_int>(*this) * static_cast<cpp_int>(other);
+    }
 
-  static inline BigInt operator/(const BigInt &lhs, unsigned long long rhs) {
-    return static_cast<cpp_int>(lhs) / static_cast<cpp_int>(rhs);
-  }
+    inline UBigInt operator-(const UBigInt &other) const {
+      return static_cast<cpp_int>(*this) - static_cast<cpp_int>(other);
+    }
 
-  static inline BigInt operator+(const BigInt &lhs, const BigInt &rhs) {
-    return static_cast<cpp_int>(lhs) + static_cast<cpp_int>(rhs);
-  }
+    inline UBigInt operator-(int other) const {
+      return static_cast<cpp_int>(*this) - other;
+    }
+  };
 
-  static inline BigInt operator-(const BigInt &lhs, const BigInt &rhs) {
-    return static_cast<cpp_int>(lhs) - static_cast<cpp_int>(rhs);
-  }
+  struct BigInt : cpp_int,
+                  boost::totally_ordered<BigInt>,
+                  boost::totally_ordered<BigInt, int>,
+                  boost::arithmetic<BigInt>,
+                  boost::multiplicative<BigInt, unsigned long>,
+                  boost::less_than_comparable<BigInt, UBigInt>,
+                  boost::multipliable<BigInt, UBigInt> {
+    using cpp_int::cpp_int;
 
-  static inline bool operator>=(const BigInt &lhs, const BigInt &rhs) {
-    return static_cast<cpp_int>(lhs) >= static_cast<cpp_int>(rhs);
-  }
+    inline bool operator==(int other) const {
+      return static_cast<cpp_int>(*this) == other;
+    }
 
-  static inline bool operator>(const BigInt &lhs, const BigInt &rhs) {
-    return static_cast<cpp_int>(lhs) > static_cast<cpp_int>(rhs);
-  }
+    inline bool operator<(int other) const {
+      return static_cast<cpp_int>(*this) < other;
+    }
 
-  static inline bool operator<=(const BigInt &lhs, const BigInt &rhs) {
-    return static_cast<cpp_int>(lhs) <= static_cast<cpp_int>(rhs);
-  }
+    inline bool operator==(const BigInt &other) const {
+      return static_cast<cpp_int>(*this) == static_cast<cpp_int>(other);
+    }
 
-  static inline bool operator<=(const BigInt &lhs, int rhs) {
-    return static_cast<cpp_int>(lhs) <= rhs;
-  }
+    inline bool operator<(const BigInt &other) const {
+      return static_cast<cpp_int>(*this) < static_cast<cpp_int>(other);
+    }
 
-  static inline bool operator<(const BigInt &lhs, const BigInt &rhs) {
-    return static_cast<cpp_int>(lhs) < static_cast<cpp_int>(rhs);
-  }
+    inline BigInt operator+=(const BigInt &other) {
+      static_cast<cpp_int *>(this)->operator+=(static_cast<cpp_int>(other));
+      return *this;
+    }
 
-  static inline bool operator<(const BigInt &lhs, unsigned long long rhs) {
-    return static_cast<cpp_int>(lhs) < rhs;
-  }
+    inline BigInt operator-=(const BigInt &other) {
+      static_cast<cpp_int *>(this)->operator-=(static_cast<cpp_int>(other));
+      return *this;
+    }
 
-  static inline bool operator<(const BigInt &lhs, int rhs) {
-    return static_cast<cpp_int>(lhs) < rhs;
-  }
+    inline BigInt operator*=(const BigInt &other) {
+      static_cast<cpp_int *>(this)->operator*=(static_cast<cpp_int>(other));
+      return *this;
+    }
 
-  static inline bool operator==(const BigInt &lhs, const BigInt &rhs) {
-    return static_cast<cpp_int>(lhs) == static_cast<cpp_int>(rhs);
-  }
+    inline BigInt operator/=(const BigInt &other) {
+      static_cast<cpp_int *>(this)->operator/=(static_cast<cpp_int>(other));
+      return *this;
+    }
 
-  static inline bool operator==(const BigInt &lhs, int rhs) {
-    return static_cast<cpp_int>(lhs) == rhs;
-  }
+    inline BigInt operator*=(const unsigned long &other) {
+      static_cast<cpp_int *>(this)->operator*=(other);
+      return *this;
+    }
 
-  static inline bool operator==(const UBigInt &lhs, const UBigInt &rhs) {
-    return static_cast<cpp_int>(lhs) == static_cast<cpp_int>(rhs);
-  }
+    inline BigInt operator/=(const unsigned long &other) {
+      static_cast<cpp_int *>(this)->operator/=(other);
+      return *this;
+    }
 
-  static inline bool operator==(const UBigInt &lhs, int rhs) {
-    return static_cast<cpp_int>(lhs) == static_cast<cpp_int>(rhs);
-  }
+    inline bool operator<(const UBigInt &other) const {
+      return static_cast<cpp_int>(*this) < static_cast<cpp_int>(other);
+    }
+
+    inline bool operator>(const UBigInt &other) const {
+      return static_cast<cpp_int>(*this) > static_cast<cpp_int>(other);
+    }
+
+    inline BigInt operator*=(const UBigInt &other) {
+      static_cast<cpp_int *>(this)->operator*=(static_cast<cpp_int>(other));
+      return *this;
+    }
+  };
 
   template <class Stream,
             class T,
diff --git a/core/primitives/chain_epoch.hpp b/core/primitives/chain_epoch.hpp
@@ -6,7 +6,6 @@
 #ifndef CPP_FILECOIN_PRIMITIVES_CHAIN_EPOCH_HPP
 #define CPP_FILECOIN_PRIMITIVES_CHAIN_EPOCH_HPP
 
-#include "libp2p/multi/uvarint.hpp"
 #include "primitives/big_int.hpp"
 
 namespace fc::primitives {
@@ -15,7 +14,7 @@ namespace fc::primitives {
    * @brief epoch index type represents a round of a blockchain protocol, which
    * acts as a proxy for time within the VM
    */
-  using ChainEpoch = libp2p::multi::UVarint;
+  using ChainEpoch = UBigInt;
 
   using EpochDuration = BigInt;
 
diff --git a/core/primitives/ticket/epost_ticket_codec.hpp b/core/primitives/ticket/epost_ticket_codec.hpp
@@ -65,8 +65,7 @@ namespace fc::primitives::ticket {
             typename = std::enable_if_t<
                 std::remove_reference<Stream>::type::is_cbor_encoder_stream>>
   Stream &operator<<(Stream &&s, const EPostProof &epp) {
-    return s << (s.list() << epp.proof << epp.post_rand
-                          << epp.candidates);
+    return s << (s.list() << epp.proof << epp.post_rand << epp.candidates);
   }
 
   /**
@@ -80,7 +79,8 @@ namespace fc::primitives::ticket {
             typename = std::enable_if_t<
                 std::remove_reference<Stream>::type::is_cbor_decoder_stream>>
   Stream &operator>>(Stream &&s, EPostProof &epp) {
-    std::vector<uint8_t> proof, rand;
+    std::vector<uint8_t> proof;
+    std::vector<uint8_t> rand;
     s.list() >> proof >> rand >> epp.candidates;
     epp.proof = common::Buffer(std::move(proof));
     if (rand.size() != epp.post_rand.size()) {
diff --git a/core/primitives/ticket/ticket.cpp b/core/primitives/ticket/ticket.cpp
@@ -14,7 +14,7 @@ namespace fc::primitives::ticket {
                                                      int64_t round) {
     common::Buffer buffer{};
     buffer.put(ticket.bytes);
-    common::encodeInteger(round, buffer);
+    common::encodeLebInteger(round, buffer);
     auto &&hash = libp2p::crypto::sha256(buffer);
 
     return Randomness::fromSpan(hash);
diff --git a/core/vm/actor/builtin/multisig/multisig_actor.cpp b/core/vm/actor/builtin/multisig/multisig_actor.cpp
@@ -11,6 +11,7 @@
 
 using fc::common::Buffer;
 using fc::primitives::BigInt;
+using fc::primitives::ChainEpoch;
 using fc::vm::VMExitCode;
 using fc::vm::actor::ActorExports;
 using fc::vm::actor::ActorMethod;
@@ -109,12 +110,13 @@ fc::outcome::result<void> MultiSignatureActorState::approveTransaction(
     if (actor.balance < pending_tx.value)
       return VMExitCode::MULTISIG_ACTOR_INSUFFICIENT_FUNDS;
 
-    auto amount_locked = getAmountLocked(runtime.getCurrentEpoch().toUInt64());
+    auto amount_locked = getAmountLocked(runtime.getCurrentEpoch());
     if (actor.balance - pending_tx.value < amount_locked)
       return VMExitCode::MULTISIG_ACTOR_INSUFFICIENT_FUNDS;
 
     // send messsage ignoring value returned
     // https://github.com/filecoin-project/specs-actors/issues/113
+    // NOLINTNEXTLINE(clang-diagnostic-unused-result)
     runtime.send(
         pending_tx.to, pending_tx.method, pending_tx.params, pending_tx.value);
 
@@ -148,7 +150,7 @@ fc::outcome::result<InvocationOutput> MultiSigActor::construct(
                                  construct_params.threshold,
                                  TransactionNumber{0},
                                  BigInt{0},
-                                 runtime.getCurrentEpoch().toUInt64(),
+                                 runtime.getCurrentEpoch(),
                                  construct_params.unlock_duration,
                                  {}};
 
diff --git a/core/vm/actor/builtin/multisig/multisig_actor.hpp b/core/vm/actor/builtin/multisig/multisig_actor.hpp
@@ -17,13 +17,12 @@
 
 namespace fc::vm::actor::builtin::multisig {
 
+  using primitives::ChainEpoch;
   using primitives::EpochDuration;
-  using primitives::UBigInt;
   using primitives::address::Address;
   using runtime::InvocationOutput;
   using runtime::Runtime;
   using TransactionNumber = size_t;
-  using ChainEpoch = BigInt;
 
   constexpr MethodNumber kProposeMethodNumber{2};
   constexpr MethodNumber kApproveMethodNumber{3};
diff --git a/core/vm/state/impl/state_tree_impl.hpp b/core/vm/state/impl/state_tree_impl.hpp
@@ -23,7 +23,6 @@ namespace fc::vm::state {
    public:
     explicit StateTreeImpl(const std::shared_ptr<IpfsDatastore> &store);
     StateTreeImpl(const std::shared_ptr<IpfsDatastore> &store, const CID &root);
-    ~StateTreeImpl() = default;
     /// Set actor state, does not write to storage
     outcome::result<void> set(const Address &address,
                               const Actor &actor) override;
diff --git a/test/core/clock/chain_epoch_clock_test.cpp b/test/core/clock/chain_epoch_clock_test.cpp
@@ -18,7 +18,7 @@ using fc::clock::ChainEpochClockImpl;
 static Time kGenesisTime(UnixTimeNano(1));
 static std::chrono::nanoseconds kNano1(1);
 static ChainEpoch kEpoch(3);
-static std::chrono::nanoseconds kNanoEpoch(kEpoch.toUInt64() * kEpochDuration);
+static std::chrono::nanoseconds kNanoEpoch(kEpoch * kEpochDuration);
 
 class ChainEpochClockTest : public ::testing::Test {
  public:
@@ -72,7 +72,7 @@ TEST_F(ChainEpochClockTest, AtGenesis) {
 TEST_F(ChainEpochClockTest, BeforeEpoch) {
   auto epoch = epochAtTime(kGenesisTime.unixTimeNano() + kNanoEpoch - kNano1).value();
 
-  EXPECT_EQ(epoch, ChainEpoch(kEpoch.toUInt64() - 1));
+  EXPECT_EQ(epoch, ChainEpoch(kEpoch - 1));
 }
 
 /**
diff --git a/test/core/common/le_encoder_test.cpp b/test/core/common/le_encoder_test.cpp
diff --git a/test/core/crypto/randomness/randomness_provider_test.cpp b/test/core/crypto/randomness/randomness_provider_test.cpp
diff --git a/test/core/primitives/CMakeLists.txt b/test/core/primitives/CMakeLists.txt
diff --git a/test/core/primitives/big_int_test.cpp b/test/core/primitives/big_int_test.cpp
diff --git a/test/core/vm/actor/builtin/multisig_actor/multisig_actor_test.cpp b/test/core/vm/actor/builtin/multisig_actor/multisig_actor_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ namespace fc::clock {`
`16`	`16`	`outcome::result<ChainEpoch> ChainEpochClockImpl::epochAtTime(`
`17`	`17`	`const Time &time) const {`
`18`	`18`	`if (time < genesis_time_) {`
`19`		`- return EpochAtTimeError::BEFORE_GENESIS;`
	`19`	`+ return outcome::failure(EpochAtTimeError::BEFORE_GENESIS);`
`20`	`20`	`}`
`21`	`21`	`auto difference = time.unixTimeNano() - genesis_time_.unixTimeNano();`
`22`	`22`	`return ChainEpoch(difference / kEpochDuration);`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`# SPDX-License-Identifier: Apache-2.0`
`3`	`3`
`4`	`4`	`add_library(randomness_provider`
`5`		`- impl/randomness_provider_imp.cpp`
	`5`	`+ impl/randomness_provider_impl.cpp`
`6`	`6`	`)`
`7`	`7`	`target_link_libraries(randomness_provider`
`8`	`8`	`Boost::boost`