Refactor power actor (#154)

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

Author: turuslan

core/adt/CMakeLists.txt

@@ -23,20 +23,10 @@ target_link_libraries(map INTERFACE
     hamt
     )
 
-add_library(balance_table_hamt
-    impl/balance_table_hamt.cpp
-    )
-target_link_libraries(balance_table_hamt
-    address_key
-    hamt
-    )
-
-add_library(multimap
-    impl/multimap.cpp
-    )
-target_link_libraries(multimap
-    amt
-    hamt
+add_library(multimap INTERFACE)
+target_link_libraries(multimap INTERFACE
+    array
+    map
     )
 
 add_library(uvarint_key

core/adt/balance_table_hamt.hpp

@@ -6,56 +6,40 @@
 #ifndef CPP_FILECOIN_MULTIMAP_HPP
 #define CPP_FILECOIN_MULTIMAP_HPP
 
-#include "storage/hamt/hamt.hpp"
+#include "adt/array.hpp"
+#include "adt/map.hpp"
 
 namespace fc::adt {
-
-  /**
-   * Container for storing multiple values per key.
-   * Implemented over a HAMT of AMTs.
-   * The order of values by the same key is preserved.
-   */
   struct Multimap {
-    using Value = storage::ipfs::IpfsDatastore::Value;
-    using Visitor = std::function<outcome::result<void>(const Value &)>;
-
-    explicit Multimap(
-        const std::shared_ptr<storage::ipfs::IpfsDatastore> &store);
-    Multimap(const std::shared_ptr<storage::ipfs::IpfsDatastore> &store,
-             const CID &root);
-
-    /**
-     * Apply changes to storage
-     * @return root CID
-     */
-    outcome::result<CID> flush();
-
-    /// Adds a value by key to the end of array. Does not change the store
-    outcome::result<void> add(const std::string &key,
-                              gsl::span<const uint8_t> value);
-
-    /**
-     * Adds a value which can be CBOR-encoded.
-     * Does not change the store immediately
-     * @tparam T value type that supports CBOR encoding
-     * @param value to be marshalled
-     * @return operation result
-     */
-    template <typename T>
-    outcome::result<void> addCbor(const std::string &key, const T &value) {
-      OUTCOME_TRY(bytes, codec::cbor::encode(value));
-      return add(key, bytes);
+    template <typename Value, typename Keyer, size_t bit_width>
+    static outcome::result<void> append(
+        Map<Array<Value>, Keyer, bit_width> &map,
+        const typename Keyer::Key &key,
+        const Value &value) {
+      OUTCOME_TRY(array, map.tryGet(key));
+      if (!array) {
+        array = Array<Value>{};
+      }
+      array->load(map.hamt.getIpld());
+      OUTCOME_TRY(count, array->amt.count());
+      OUTCOME_TRY(array->set(count, value));
+      OUTCOME_TRY(array->flush());
+      return map.set(key, *array);
     }
 
-    /// Removes array under the key
-    outcome::result<void> removeAll(const std::string &key);
-
-    /// Iterates over stored values by key
-    outcome::result<void> visit(const std::string &key, const Visitor &visitor);
-
-   private:
-    std::shared_ptr<storage::ipfs::IpfsDatastore> store_;
-    storage::hamt::Hamt hamt_;
+    template <typename Value, typename Keyer, size_t bit_width>
+    static outcome::result<void> visit(
+        Map<Array<Value>, Keyer, bit_width> &map,
+        const typename Keyer::Key &key,
+        const std::function<outcome::result<void>(const Value &)> &visitor) {
+      OUTCOME_TRY(array, map.tryGet(key));
+      if (array) {
+        array->load(map.hamt.getIpld());
+        OUTCOME_TRY(
+            array->visit([&](auto, auto &value) { return visitor(value); }));
+      }
+      return outcome::success();
+    }
   };
 }  // namespace fc::adt
 

core/adt/impl/balance_table_hamt.cpp

@@ -17,7 +17,6 @@ namespace fc::api {
   using vm::actor::kStorageMarketAddress;
   using vm::actor::kStoragePowerAddress;
   using vm::actor::builtin::miner::MinerActorState;
-  using vm::actor::builtin::storage_power::StoragePowerActor;
   using vm::actor::builtin::storage_power::StoragePowerActorState;
   using vm::interpreter::InterpreterImpl;
   using vm::state::StateTreeImpl;
@@ -55,7 +54,7 @@ namespace fc::api {
     }
 
     auto powerState() {
-      return actorState<StoragePowerActorState, false>(kStoragePowerAddress);
+      return actorState<StoragePowerActorState, true>(kStoragePowerAddress);
     }
   };
 
@@ -240,13 +239,9 @@ namespace fc::api {
 
           OUTCOME_TRY(power_state, context.powerState());
           StoragePower miner_power = 0;
-          auto maybe_claim =
-              StoragePowerActor{ipld, power_state}.getClaim(address);
-          if (maybe_claim) {
-            miner_power = maybe_claim.value().power;
-          } else if (maybe_claim.error()
-                     != VMExitCode::STORAGE_POWER_ILLEGAL_ARGUMENT) {
-            return maybe_claim.error();
+          OUTCOME_TRY(claim, power_state.claims.tryGet(address));
+          if (claim) {
+            miner_power = claim->power;
           }
 
           OUTCOME_TRY(miner_state, context.minerState(address));

core/adt/impl/multimap.cpp

@@ -11,5 +11,4 @@ add_subdirectory(miner)
 add_subdirectory(multisig)
 add_subdirectory(payment_channel)
 add_subdirectory(reward)
-add_subdirectory(shared)
 add_subdirectory(storage_power)