[FIL-97] Power table and part of Storage Power Actor (#73)

Signed-off-by: artyom-yurin <[email protected]>

Author: ortyomka

core/CMakeLists.txt

@@ -10,4 +10,5 @@ add_subdirectory(crypto)
 add_subdirectory(primitives)
 add_subdirectory(storage)
 add_subdirectory(fslock)
+add_subdirectory(power)
 add_subdirectory(vm)

core/crypto/randomness/impl/randomness_provider.cpp

@@ -35,4 +35,11 @@ namespace fc::crypto::randomness {
     return Randomness(hash);
   }
 
+  int RandomnessProviderImpl::randomInt(const Randomness &randomness,
+                                        size_t nonce,
+                                        size_t limit) {
+    // TODO(artyom-yurin): [FIL-141] Implement it
+    throw std::string("Not implemented");
+  }
+
 }  // namespace fc::crypto::randomness

core/crypto/randomness/impl/randomness_provider.hpp

@@ -21,6 +21,10 @@ namespace fc::crypto::randomness {
                                 Serialization s,
                                 ChainEpoch index) override;
 
+    int randomInt(const Randomness &randomness,
+                  size_t nonce,
+                  size_t limit) override;
+
    private:
     Randomness deriveRandomnessInternal(DomainSeparationTag tag,
                                         Serialization s,

core/crypto/randomness/randomness_provider.hpp

@@ -35,6 +35,13 @@ namespace fc::crypto::randomness {
     virtual Randomness deriveRandomness(DomainSeparationTag tag,
                                         Serialization s,
                                         ChainEpoch index) = 0;
+
+    /**
+     * @brief get random int value
+     */
+    virtual int randomInt(const Randomness &randomness,
+                          size_t nonce,
+                          size_t limit) = 0;
   };
 }  // namespace fc::crypto::randomness
 

core/power/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+add_library(power_table
+        impl/power_table_impl.cpp
+        impl/power_table_error.cpp
+        )
+target_link_libraries(power_table
+        outcome
+        address
+        )

core/power/impl/power_table_error.cpp

@@ -0,0 +1,19 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "power/power_table_error.hpp"
+
+OUTCOME_CPP_DEFINE_CATEGORY(fc::power, PowerTableError, e) {
+  using fc::power::PowerTableError;
+
+  switch (e) {
+    case PowerTableError::NO_SUCH_MINER:
+      return "PowerTableError: miner not found";
+    case PowerTableError::NEGATIVE_POWER:
+      return "PowerTableError: power cannot be negative";
+  }
+
+  return "unknown error";
+}

core/power/impl/power_table_impl.cpp

@@ -0,0 +1,65 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "power/impl/power_table_impl.hpp"
+
+#include "power/power_table_error.hpp"
+#include "primitives/address/address_codec.hpp"
+
+namespace fc::power {
+
+  outcome::result<Power> PowerTableImpl::getMinerPower(
+      const primitives::address::Address &address) const {
+    auto result =
+        power_table_.find(primitives::address::encodeToString(address));
+    if (result == power_table_.end()) {
+      return outcome::failure(PowerTableError::NO_SUCH_MINER);
+    }
+
+    return result->second;
+  }
+
+  outcome::result<void> PowerTableImpl::setMinerPower(
+      const primitives::address::Address &address, Power power_amount) {
+    if (power_amount < 0) return PowerTableError::NEGATIVE_POWER;
+    power_table_[primitives::address::encodeToString(address)] = power_amount;
+    return outcome::success();
+  }
+
+  outcome::result<void> PowerTableImpl::removeMiner(
+      const primitives::address::Address &address) {
+    if (power_table_.erase(primitives::address::encodeToString(address)) == 0)
+      return PowerTableError::NO_SUCH_MINER;
+
+    return outcome::success();
+  }
+
+  size_t PowerTableImpl::getSize() const {
+    return power_table_.size();
+  }
+
+  Power PowerTableImpl::getMaxPower() const {
+    if (power_table_.empty()) return 0;
+
+    auto res = std::max(power_table_.cbegin(),
+                        power_table_.cend(),
+                        [&](const auto &rhs, const auto &lhs) {
+                          return rhs->second < lhs->second;
+                        });
+
+    return res->second;
+  }
+
+  outcome::result<std::vector<primitives::address::Address>>
+  PowerTableImpl::getMiners() const {
+    std::vector<primitives::address::Address> result = {};
+    for (auto &elem : power_table_) {
+      OUTCOME_TRY(miner_addr,
+                  primitives::address::decodeFromString(elem.first));
+      result.push_back(miner_addr);
+    }
+    return result;
+  }
+}  // namespace fc::power

core/power/impl/power_table_impl.hpp

@@ -0,0 +1,36 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef FILECOIN_CORE_STORAGE_POWER_TABLE_IMPL_HPP
+#define FILECOIN_CORE_STORAGE_POWER_TABLE_IMPL_HPP
+
+#include <unordered_map>
+#include "power/power_table.hpp"
+
+namespace fc::power {
+  class PowerTableImpl : public PowerTable {
+   public:
+    outcome::result<Power> getMinerPower(
+        const primitives::address::Address &address) const override;
+
+    outcome::result<void> setMinerPower(
+        const primitives::address::Address &address,
+        Power power_amount) override;
+
+    outcome::result<void> removeMiner(
+        const primitives::address::Address &address) override;
+
+    size_t getSize() const override;
+
+    Power getMaxPower() const override;
+
+    outcome::result<std::vector<primitives::address::Address>> getMiners()
+        const override;
+
+   private:
+    std::unordered_map<std::string, Power> power_table_;
+  };
+}  // namespace fc::power
+#endif  // FILECOIN_CORE_STORAGE_POWER_TABLE_IMPL_HPP

core/power/power_table.hpp

@@ -0,0 +1,69 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef FILECOIN_CORE_POWER_TABLE_HPP
+#define FILECOIN_CORE_POWER_TABLE_HPP
+
+#include "common/outcome.hpp"
+#include "primitives/address/address.hpp"
+#include "primitives/big_int.hpp"
+
+namespace fc::power {
+
+  using Power = primitives::BigInt;
+
+  /**
+   * @interface Provides an interface to the power table
+   */
+  class PowerTable {
+   public:
+    virtual ~PowerTable() = default;
+
+    /**
+     * @brief Get the power of a particular miner
+     * @param address of the miner
+     * @return power of the miner or No such miner error
+     */
+    virtual outcome::result<Power> getMinerPower(
+        const primitives::address::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;
+
+    /**
+     * @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;
+
+    /**
+     * @brief Get size of table
+     * @return number of miners
+     */
+    virtual size_t getSize() const = 0;
+
+    /**
+     * @brief Get Max power from table
+     * @return max power from all miners
+     */
+    virtual 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;
+  };
+}  // namespace fc::power
+#endif  // FILECOIN_CORE_POWER_TABLE_HPP

core/power/power_table_error.hpp

@@ -0,0 +1,22 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef FILECOIN_CORE_POWER_POWER_TABLE_ERROR_HPP
+#define FILECOIN_CORE_POWER_POWER_TABLE_ERROR_HPP
+
+#include "common/outcome.hpp"
+
+namespace fc::power {
+
+  /**
+   * @brief Type of errors returned by Power Table
+   */
+  enum class PowerTableError { NO_SUCH_MINER = 1, NEGATIVE_POWER };
+
+}  // namespace fc::power
+
+OUTCOME_HPP_DECLARE_ERROR(fc::power, PowerTableError);
+
+#endif  // FILECOIN_CORE_POWER_POWER_TABLE_ERROR_HPP