Feature/storage power actor (#95)

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

Author: Alexey-N-Chernyshov

core/power/CMakeLists.txt

@@ -2,10 +2,20 @@
 # SPDX-License-Identifier: Apache-2.0
 
 add_library(power_table
-        impl/power_table_impl.cpp
-        impl/power_table_error.cpp
-        )
+    impl/power_table_impl.cpp
+    impl/power_table_error.cpp
+    )
 target_link_libraries(power_table
-        outcome
-        address
-        )
+    address
+    outcome
+    )
+
+add_library(power_table_hamt
+    impl/power_table_hamt.cpp
+    impl/power_table_error.cpp
+    )
+target_link_libraries(power_table_hamt
+    address
+    outcome
+    hamt
+    )

core/power/impl/power_table_hamt.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "power/impl/power_table_hamt.hpp"
+
+#include "power/power_table_error.hpp"
+#include "primitives/address/address_codec.hpp"
+
+using fc::power::Power;
+using fc::power::PowerTableError;
+using fc::power::PowerTableHamt;
+using fc::primitives::address::Address;
+using fc::primitives::address::decodeFromByteString;
+using fc::primitives::address::encodeToByteString;
+using fc::storage::hamt::HamtError;
+using fc::storage::hamt::Value;
+
+PowerTableHamt::PowerTableHamt(Hamt hamt) : power_table_{std::move(hamt)} {}
+
+fc::outcome::result<Power> PowerTableHamt::getMinerPower(
+    const Address &address) const {
+  auto result = power_table_.getCbor<Power>(encodeToByteString(address));
+  if (!result && result.error() == HamtError::NOT_FOUND) {
+    return outcome::failure(PowerTableError::NO_SUCH_MINER);
+  }
+  return result;
+}
+
+fc::outcome::result<void> PowerTableHamt::setMinerPower(const Address &address,
+                                                        Power power_amount) {
+  if (power_amount < 0) return PowerTableError::NEGATIVE_POWER;
+  return power_table_.setCbor(encodeToByteString(address), power_amount);
+}
+
+fc::outcome::result<void> PowerTableHamt::removeMiner(const Address &address) {
+  auto result = power_table_.remove(encodeToByteString(address));
+  if (!result && result.error() == HamtError::NOT_FOUND) {
+    return outcome::failure(PowerTableError::NO_SUCH_MINER);
+  }
+  return result;
+}
+
+fc::outcome::result<size_t> PowerTableHamt::getSize() const {
+  size_t n = 0;
+  Hamt::Visitor counter{[&n](auto k, auto v) {
+    ++n;
+    return fc::outcome::success();
+  }};
+  OUTCOME_TRY(power_table_.visit(counter));
+  return n;
+}
+
+fc::outcome::result<Power> PowerTableHamt::getMaxPower() const {
+  Power max = 0;
+  Hamt::Visitor max_visitor{
+      [&max](auto k, auto v) -> fc::outcome::result<void> {
+        OUTCOME_TRY(power, codec::cbor::decode<Power>(v));
+        if (max < power) max = power;
+        return fc::outcome::success();
+      }};
+  OUTCOME_TRY(power_table_.visit(max_visitor));
+  return max;
+}
+
+fc::outcome::result<std::vector<Address>> PowerTableHamt::getMiners() const {
+  std::vector<Address> miners;
+  Hamt::Visitor max_visitor{
+      [&miners](auto k, auto v) -> fc::outcome::result<void> {
+        OUTCOME_TRY(address, decodeFromByteString(k));
+        miners.push_back(address);
+        return fc::outcome::success();
+      }};
+  OUTCOME_TRY(power_table_.visit(max_visitor));
+  return miners;
+}

core/power/impl/power_table_hamt.hpp

@@ -0,0 +1,61 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_POWER_POWER_TABLE_HAMT_HPP
+#define CPP_FILECOIN_POWER_POWER_TABLE_HAMT_HPP
+
+#include "power/power_table.hpp"
+#include "storage/hamt/hamt.hpp"
+
+namespace fc::power {
+
+  using storage::hamt::Hamt;
+
+  /**
+   * @class PowerTableHamt - HAMT-based implementation of PowerTable
+   */
+  class PowerTableHamt : public PowerTable {
+   public:
+    /**
+     * Construct HAMT-based power table
+     * @param store - ipfs datastore
+     * @param root - hamt root cid
+     */
+    explicit PowerTableHamt(Hamt hamt);
+
+    /** @copydoc PowerTable::getMinerPower() */
+    outcome::result<Power> getMinerPower(const Address &address) const override;
+
+    /** @copydoc PowerTable::setMinerPower() */
+    outcome::result<void> setMinerPower(const Address &address,
+                                        Power power_amount) override;
+
+    /** @copydoc PowerTable::removeMiner() */
+    outcome::result<void> removeMiner(const Address &address) override;
+
+    /** @copydoc PowerTable::getSize() */
+    fc::outcome::result<size_t> getSize() const override;
+
+    /** @copydoc PowerTable::getMaxPower() */
+    fc::outcome::result<Power> getMaxPower() const override;
+
+    /** @copydoc PowerTable::getMiners() */
+    outcome::result<std::vector<Address>> getMiners() const override;
+
+   private:
+    /**
+     * TODO (a.chernyshov) HAMT getter is not constant due to it uses cache.
+     * It is a common example to use mutable field in HAMT.
+     * In order to save semantic constant regarless of syntax constant
+     * correctness the power_table_ field is marked as mutable.
+     *
+     * Remove mutable keyword after HAMT getter has const qualifier.
+     */
+    mutable Hamt power_table_;
+  };
+
+}  // namespace fc::power
+
+#endif  // CPP_FILECOIN_POWER_POWER_TABLE_HAMT_HPP

core/power/impl/power_table_impl.cpp

@@ -36,11 +36,11 @@ namespace fc::power {
     return outcome::success();
   }
 
-  size_t PowerTableImpl::getSize() const {
+  fc::outcome::result<size_t> PowerTableImpl::getSize() const {
     return power_table_.size();
   }
 
-  Power PowerTableImpl::getMaxPower() const {
+  fc::outcome::result<Power> PowerTableImpl::getMaxPower() const {
     if (power_table_.empty()) return 0;
 
     auto res = std::max(power_table_.cbegin(),
@@ -54,7 +54,8 @@ namespace fc::power {
 
   outcome::result<std::vector<primitives::address::Address>>
   PowerTableImpl::getMiners() const {
-    std::vector<primitives::address::Address> result = {};
+    std::vector<primitives::address::Address> result;
+    result.reserve(power_table_.size());
     for (auto &elem : power_table_) {
       OUTCOME_TRY(miner_addr,
                   primitives::address::decodeFromString(elem.first));

core/power/impl/power_table_impl.hpp

@@ -22,9 +22,9 @@ namespace fc::power {
     outcome::result<void> removeMiner(
         const primitives::address::Address &address) override;
 
-    size_t getSize() const override;
+    fc::outcome::result<size_t> getSize() const override;
 
-    Power getMaxPower() const override;
+    fc::outcome::result<Power> getMaxPower() const override;
 
     outcome::result<std::vector<primitives::address::Address>> getMiners()
         const override;

core/power/power_table.hpp

@@ -12,7 +12,8 @@
 
 namespace fc::power {
 
-  using Power = primitives::BigInt;
+  using primitives::address::Address;
+  using Power = primitives::UBigInt;
 
   /**
    * @interface Provides an interface to the power table
@@ -27,43 +28,41 @@ namespace fc::power {
      * @return power of the miner or No such miner error
      */
     virtual outcome::result<Power> getMinerPower(
-        const primitives::address::Address &address) const = 0;
+        const Address &address) const = 0;
 
     /**
      * @brief Set the power of a particular miner
      * @param address of the miner
      * @param power_amount - amount of power
      * @return success or Negative power error if amount less than 0
      */
-    virtual outcome::result<void> setMinerPower(
-        const primitives::address::Address &address, Power power_amount) = 0;
+    virtual outcome::result<void> setMinerPower(const Address &address,
+                                                Power power_amount) = 0;
 
     /**
      * @brief Remove a miner from power table
      * @param address of the miner
      * @return success or No such miner error
      */
-    virtual outcome::result<void> removeMiner(
-        const primitives::address::Address &address) = 0;
+    virtual outcome::result<void> removeMiner(const Address &address) = 0;
 
     /**
      * @brief Get size of table
      * @return number of miners
      */
-    virtual size_t getSize() const = 0;
+    virtual fc::outcome::result<size_t> getSize() const = 0;
 
     /**
      * @brief Get Max power from table
      * @return max power from all miners
      */
-    virtual Power getMaxPower() const = 0;
+    virtual fc::outcome::result<Power> getMaxPower() const = 0;
 
     /**
      * @brief Get list of all miners from table
      * @return list of miners
      */
-    virtual outcome::result<std::vector<primitives::address::Address>>
-    getMiners() const = 0;
+    virtual outcome::result<std::vector<Address>> getMiners() const = 0;
   };
 }  // namespace fc::power
 #endif  // FILECOIN_CORE_POWER_TABLE_HPP

core/primitives/address/address_codec.cpp

@@ -184,6 +184,17 @@ namespace fc::primitives::address {
     return std::move(address);
   }
 
+  std::string encodeToByteString(const Address &address) {
+    auto encoded = fc::primitives::address::encode(address);
+    return std::string(encoded.begin(), encoded.end());
+  }
+
+  fc::outcome::result<Address> decodeFromByteString(
+      const std::string &encoded) {
+    return fc::primitives::address::decode(
+        std::vector<uint8_t>(encoded.begin(), encoded.end()));
+  }
+
   std::vector<uint8_t> checksum(const Address &address) {
     std::vector<uint8_t> res{};
 
@@ -199,12 +210,13 @@ namespace fc::primitives::address {
 
     ingest.push_back(p);
 
-    ingest = visit_in_place(address.data,
-                            [&ingest](uint64_t v) { return ingest; },
-                            [&ingest](const auto &v) {
-                              ingest.insert(ingest.end(), v.begin(), v.end());
-                              return ingest;
-                            });
+    ingest = visit_in_place(
+        address.data,
+        [&ingest](uint64_t v) { return ingest; },
+        [&ingest](const auto &v) {
+          ingest.insert(ingest.end(), v.begin(), v.end());
+          return ingest;
+        });
 
     size_t outlen = 4;
     blake2b(res.data(), outlen, nullptr, 0, ingest.data(), ingest.size());

core/primitives/address/address_codec.hpp

@@ -36,6 +36,16 @@ namespace fc::primitives::address {
    */
   outcome::result<Address> decodeFromString(const std::string &s);
 
+  /**
+   * @brief Encodes an Address to an array of bytes with string representation
+   */
+
+  std::string encodeToByteString(const Address &address);
+  /**
+   * @brief Decodes Address from an array of bytes with string representation
+   */
+  outcome::result<Address> decodeFromByteString(const std::string &s);
+
   template <class Stream,
             typename = std::enable_if_t<
                 std::remove_reference<Stream>::type::is_cbor_encoder_stream>>