Feature/storage power actor cboring (#98)

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

Author: Alexey-N-Chernyshov

core/adt/CMakeLists.txt

@@ -16,6 +16,14 @@ target_link_libraries(array
     amt
     )
 
+add_library(balance_table_hamt
+    impl/balance_table_hamt.cpp
+    )
+target_link_libraries(balance_table_hamt
+    address
+    hamt
+    )
+
 add_library(multimap
     impl/multimap.cpp
     )

core/adt/balance_table_hamt.hpp

@@ -0,0 +1,97 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef CPP_FILECOIN_ADT_BALANCE_TABLE_HAMT_HPP
+#define CPP_FILECOIN_ADT_BALANCE_TABLE_HAMT_HPP
+
+#include "common/outcome.hpp"
+#include "primitives/address/address.hpp"
+#include "primitives/big_int.hpp"
+#include "primitives/cid/cid.hpp"
+#include "storage/hamt/hamt.hpp"
+#include "storage/ipfs/datastore.hpp"
+
+namespace fc::adt {
+
+  using primitives::BigInt;
+  using primitives::address::Address;
+  using storage::hamt::Hamt;
+  using storage::ipfs::IpfsDatastore;
+  using TokenAmount = BigInt;
+
+  /**
+   * Stores miner balances
+   */
+  class BalanceTableHamt {
+   public:
+    /**
+     * Constructor
+     * @param datastore - internal store
+     * @param new_root - HAMT root CID
+     */
+    explicit BalanceTableHamt(std::shared_ptr<IpfsDatastore> datastore,
+                              const CID &new_root);
+
+    /**
+     * Get balance
+     * @param key - address
+     * @return balance or error
+     */
+    outcome::result<TokenAmount> get(const Address &key) const;
+
+    /**
+     * Checks if address is present in table
+     * @param key address
+     * @return true or false
+     */
+    outcome::result<bool> has(const Address &key) const;
+
+    /**
+     * Store balance
+     * @param key address
+     * @param balance token amount
+     * @return error in case of failure
+     */
+    outcome::result<void> set(const Address &key, const TokenAmount &balance);
+
+    /**
+     * Add amount to balance
+     * @param key address
+     * @param amount to add
+     * @return error in case of failure
+     */
+    outcome::result<void> add(const Address &key, const TokenAmount &amount);
+
+    /**
+     * Subtracts up to the specified amount from a balance, without reducing the
+     * balance below some minimum
+     * @param key address
+     * @param amount to subtract
+     * @param floor - minimum
+     * @return the amount subtracted
+     */
+    outcome::result<TokenAmount> subtractWithMinimum(const Address &key,
+                                                     const TokenAmount &amount,
+                                                     const TokenAmount &floor);
+
+    /**
+     * Removes from table
+     * @param key addrss
+     * @return error in case of failure
+     */
+    outcome::result<void> remove(const Address &key);
+
+    /**
+     * HAMT CID of root
+     */
+    CID root;
+
+   private:
+    mutable Hamt hamt_;
+  };
+
+}  // namespace fc::adt
+
+#endif  // CPP_FILECOIN_ADT_BALANCE_TABLE_HAMT_HPP

core/adt/impl/balance_table_hamt.cpp

@@ -0,0 +1,59 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "adt/balance_table_hamt.hpp"
+#include "primitives/address/address_codec.hpp"
+
+using fc::adt::BalanceTableHamt;
+using fc::adt::TokenAmount;
+using fc::primitives::address::encodeToByteString;
+
+BalanceTableHamt::BalanceTableHamt(std::shared_ptr<IpfsDatastore> datastore,
+                                   const CID &new_root)
+    : root{new_root}, hamt_{datastore} {}
+
+fc::outcome::result<TokenAmount> BalanceTableHamt::get(
+    const Address &key) const {
+  return hamt_.getCbor<TokenAmount>(encodeToByteString(key));
+}
+
+fc::outcome::result<bool> BalanceTableHamt::has(const Address &key) const {
+  return hamt_.contains(encodeToByteString(key));
+}
+
+fc::outcome::result<void> BalanceTableHamt::set(const Address &key,
+                                                const TokenAmount &balance) {
+  OUTCOME_TRY(hamt_.setCbor(encodeToByteString(key), balance));
+  OUTCOME_TRY(new_root, hamt_.flush());
+  root = new_root;
+  return fc::outcome::success();
+}
+
+fc::outcome::result<void> BalanceTableHamt::add(const Address &key,
+                                                const TokenAmount &amount) {
+  OUTCOME_TRY(balance, hamt_.getCbor<TokenAmount>(encodeToByteString(key)));
+  OUTCOME_TRY(hamt_.setCbor(encodeToByteString(key), balance + amount));
+  OUTCOME_TRY(new_root, hamt_.flush());
+  root = new_root;
+  return fc::outcome::success();
+}
+
+fc::outcome::result<TokenAmount> BalanceTableHamt::subtractWithMinimum(
+    const Address &key, const TokenAmount &amount, const TokenAmount &floor) {
+  OUTCOME_TRY(balance, hamt_.getCbor<TokenAmount>(encodeToByteString(key)));
+  TokenAmount available = balance < floor ? TokenAmount{0} : balance - floor;
+  TokenAmount sub = std::min(available, amount);
+  OUTCOME_TRY(hamt_.setCbor(encodeToByteString(key), balance - sub));
+  OUTCOME_TRY(new_root, hamt_.flush());
+  root = new_root;
+  return sub;
+}
+
+fc::outcome::result<void> BalanceTableHamt::remove(const Address &key) {
+  OUTCOME_TRY(hamt_.remove(encodeToByteString(key)));
+  OUTCOME_TRY(new_root, hamt_.flush());
+  root = new_root;
+  return fc::outcome::success();
+}

core/clock/chain_epoch_clock.hpp

@@ -7,7 +7,7 @@
 #define CPP_FILECOIN_CORE_CLOCK_CHAIN_EPOCH_CLOCK_HPP
 
 #include "clock/time.hpp"
-#include "primitives/chain_epoch.hpp"
+#include "primitives/chain_epoch/chain_epoch.hpp"
 
 namespace fc::clock {
   enum class EpochAtTimeError { BEFORE_GENESIS = 1 };

core/crypto/randomness/randomness_provider.hpp

@@ -7,7 +7,7 @@
 #define CPP_FILECOIN_CORE_CRYPTO_RANDOMNESS_RANDOMNESS_PROVIDER_HPP
 
 #include "crypto/randomness/randomness_types.hpp"
-#include "primitives/chain_epoch.hpp"
+#include "primitives/chain_epoch/chain_epoch.hpp"
 
 namespace fc::crypto::randomness {
 

core/power/impl/power_table_impl.hpp

@@ -10,6 +10,7 @@
 #include "power/power_table.hpp"
 
 namespace fc::power {
+
   class PowerTableImpl : public PowerTable {
    public:
     outcome::result<Power> getMinerPower(
@@ -32,5 +33,6 @@ namespace fc::power {
    private:
     std::unordered_map<std::string, Power> power_table_;
   };
+
 }  // namespace fc::power
 #endif  // FILECOIN_CORE_STORAGE_POWER_TABLE_IMPL_HPP

core/primitives/CMakeLists.txt

@@ -5,6 +5,7 @@
 
 add_subdirectory(address)
 add_subdirectory(block)
+add_subdirectory(chain_epoch)
 add_subdirectory(cid)
 add_subdirectory(ticket)
 add_subdirectory(tipset)

core/primitives/chain_epoch/CMakeLists.txt

@@ -0,0 +1,9 @@
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+add_library(chain_epoch_codec
+    chain_epoch_codec.cpp
+    )
+target_link_libraries(chain_epoch_codec
+    p2p::p2p_uvarint
+    )

core/primitives/chain_epoch.hpp renamed to core/primitives/chain_epoch/chain_epoch.hpp

@@ -0,0 +1,21 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "primitives/chain_epoch/chain_epoch_codec.hpp"
+
+#include <libp2p/multi/uvarint.hpp>
+
+namespace fc::primitives::chain_epoch {
+
+  using libp2p::multi::UVarint;
+
+  std::string encodeToByteString(const ChainEpoch &epoch) {
+    // TODO (a.chernyshov) actor-specs uses Protobuf Varint encoding
+    UVarint number(epoch.convert_to<int64_t>());
+    auto encoded = number.toBytes();
+    return std::string(encoded.begin(), encoded.end());
+  }
+
+}  // namespace fc::primitives::chain_epoch