Feature/power actor methods (#123)

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

Co-authored-by: Ruslan Tushov <[email protected]>

Author: Alexey-N-Chernyshov

core/vm/actor/builtin/miner/miner_actor.cpp

@@ -30,17 +30,19 @@ namespace fc::vm::actor::builtin::miner {
   using runtime::DomainSeparationTag;
   using storage::amt::Amt;
   using storage::hamt::Hamt;
-  using storage_power::EnrollCronEventParams;
+  using storage_power::EnrollCronEventParameters;
   using storage_power::kEnrollCronEventMethodNumber;
-  using storage_power::kOnMinerSurprisePoStFailureMethodNumber;
-  using storage_power::kOnMinerSurprisePoStSuccessMethodNumber;
+  using storage_power::kOnMinerWindowedPoStFailureMethodNumber;
+  using storage_power::kOnMinerWindowedPoStSuccessMethodNumber;
   using storage_power::kOnSectorModifyWeightDescMethodNumber;
   using storage_power::kOnSectorProveCommitMethodNumber;
   using storage_power::kOnSectorTemporaryFaultEffectiveBeginMethodNumber;
   using storage_power::kOnSectorTemporaryFaultEffectiveEndMethodNumber;
   using storage_power::kOnSectorTerminateMethodNumber;
-  using storage_power::OnMinerWindowedPoStFailureParams;
-  using storage_power::OnSectorModifyWeightDescParams;
+  using storage_power::kWindowedPostChallengeDuration;
+  using storage_power::kWindowedPostFailureLimit;
+  using storage_power::OnMinerWindowedPoStFailureParameters;
+  using storage_power::OnSectorModifyWeightDescParameters;
   using storage_power::OnSectorProveCommitParameters;
   using storage_power::OnSectorTemporaryFaultEffectiveBeginParameters;
   using storage_power::OnSectorTemporaryFaultEffectiveEndParameters;
@@ -99,7 +101,7 @@ namespace fc::vm::actor::builtin::miner {
     OUTCOME_TRY(payload2, codec::cbor::encode(payload));
     OUTCOME_TRY(runtime.sendP(kStoragePowerAddress,
                               kEnrollCronEventMethodNumber,
-                              EnrollCronEventParams{
+                              EnrollCronEventParameters{
                                   .event_epoch = event_epoch,
                                   .payload = Buffer{payload2},
                               },
@@ -478,8 +480,8 @@ namespace fc::vm::actor::builtin::miner {
       OUTCOME_TRY(requestTerminateDeals(runtime, deals));
     }
     OUTCOME_TRY(runtime.sendP(kStoragePowerAddress,
-                              kOnMinerSurprisePoStFailureMethodNumber,
-                              OnMinerWindowedPoStFailureParams{
+                              kOnMinerWindowedPoStFailureMethodNumber,
+                              OnMinerWindowedPoStFailureParameters{
                                   .num_consecutive_failures =
                                       state.post_state.num_consecutive_failures,
                               },
@@ -589,7 +591,7 @@ namespace fc::vm::actor::builtin::miner {
     state.proving_set = state.sectors;
     OUTCOME_TRY(runtime.commitState(state));
     OUTCOME_TRY(runtime.send(
-        kStoragePowerAddress, kOnMinerSurprisePoStSuccessMethodNumber, {}, 0));
+        kStoragePowerAddress, kOnMinerWindowedPoStSuccessMethodNumber, {}, 0));
     return outcome::success();
   }
 
@@ -768,7 +770,7 @@ namespace fc::vm::actor::builtin::miner {
                 runtime.sendPR<TokenAmount>(
                     kStoragePowerAddress,
                     kOnSectorModifyWeightDescMethodNumber,
-                    OnSectorModifyWeightDescParams{
+                    OnSectorModifyWeightDescParameters{
                         .prev_weight = prev_weight,
                         .prev_pledge = sector.pledge_requirement,
                         .new_weight = new_weight,

core/vm/actor/builtin/miner/policy.hpp

@@ -15,12 +15,6 @@ namespace fc::vm::actor::builtin::miner {
   using primitives::SectorStorageWeightDesc;
   using primitives::TokenAmount;
 
-  // TODO(turuslan): FIL-128 move to storage power actor
-  constexpr EpochDuration kWindowedPostChallengeDuration{240};
-
-  // TODO(turuslan): FIL-128 move to storage power actor
-  constexpr size_t kWindowedPostFailureLimit{3};
-
   constexpr ChainEpoch kPoStLookback{1};
 
   constexpr auto kElectionLookback{kPoStLookback};

core/vm/actor/builtin/storage_power/CMakeLists.txt

@@ -10,6 +10,7 @@ add_library(storage_power_actor
     )
 target_link_libraries(storage_power_actor
     actor
+    block
     builtin_shared
     chain_epoch_codec
     balance_table_hamt

core/vm/actor/builtin/storage_power/policy.cpp

@@ -5,6 +5,8 @@
 
 #include "vm/actor/builtin/storage_power/policy.hpp"
 
+#include <boost/multiprecision/cpp_int.hpp>
+
 namespace fc::vm::actor::builtin::storage_power {
 
   TokenAmount pledgePenaltyForSectorTermination(
@@ -30,4 +32,35 @@ namespace fc::vm::actor::builtin::storage_power {
     return weight.sector_size * weight.duration * kEpochTotalExpectedReward
            * kPledgeFactor / network_power;
   }
+
+  TokenAmount pledgePenaltyForWindowedPoStFailure(TokenAmount pledge,
+                                                  int64_t failures) {
+    return TokenAmount{0};
+  }
+
+  outcome::result<TokenAmount> pledgePenaltyForConsensusFault(
+      TokenAmount pledge, ConsensusFaultType fault_type) {
+    switch (fault_type) {
+      case ConsensusFaultType::ConsensusFaultDoubleForkMining:
+      case ConsensusFaultType::ConsensusFaultParentGrinding:
+      case ConsensusFaultType::ConsensusFaultTimeOffsetMining:
+        return outcome::success(pledge);
+    }
+    return outcome::failure(VMExitCode::STORAGE_POWER_ILLEGAL_ARGUMENT);
+  }
+
+  TokenAmount rewardForConsensusSlashReport(ChainEpoch elapsed_epoch,
+                                            TokenAmount collateral) {
+    BigInt slasher_share_numerator = boost::multiprecision::pow(
+        ConsensusFaultReporterShareGrowthRate::numerator, elapsed_epoch);
+    BigInt slasher_share_denominator = boost::multiprecision::pow(
+        ConsensusFaultReporterShareGrowthRate::denominator, elapsed_epoch);
+
+    BigInt num = slasher_share_numerator
+                 * ConsensusFaultReporterInitialShare::numerator * collateral;
+    BigInt denom = slasher_share_denominator
+                   * ConsensusFaultReporterInitialShare::denominator;
+    return boost::multiprecision::min((num / denom), collateral);
+  }
+
 }  // namespace fc::vm::actor::builtin::storage_power

core/vm/actor/builtin/storage_power/policy.hpp

@@ -10,11 +10,23 @@
 
 namespace fc::vm::actor::builtin::storage_power {
 
+  using fc::primitives::ChainEpoch;
+  using fc::primitives::EpochDuration;
   using fc::primitives::SectorStorageWeightDesc;
   using fc::primitives::StoragePower;
   using fc::primitives::TokenAmount;
   using fc::vm::actor::builtin::reward::kBlockRewardTarget;
 
+  enum class ConsensusFaultType : int64_t {
+    ConsensusFaultDoubleForkMining = 1,
+    ConsensusFaultParentGrinding = 2,
+    ConsensusFaultTimeOffsetMining = 3
+  };
+
+  constexpr EpochDuration kWindowedPostChallengeDuration{240};
+
+  constexpr size_t kWindowedPostFailureLimit{3};
+
   /**
    * Total expected block reward per epoch (per-winner reward * expected
    * winners), as input to pledge requirement
@@ -27,6 +39,16 @@ namespace fc::vm::actor::builtin::storage_power {
    */
   inline static const BigInt kPledgeFactor{3};
 
+  struct ConsensusFaultReporterInitialShare {
+    inline static const BigInt numerator{1};
+    inline static const BigInt denominator{1000};
+  };
+
+  struct ConsensusFaultReporterShareGrowthRate {
+    inline static const BigInt numerator{102813};
+    inline static const BigInt denominator{100000};
+  };
+
   enum class SectorTerminationType : int {
     // Implicit termination after all deals expire
     SECTOR_TERMINATION_EXPIRED = 0,
@@ -49,6 +71,17 @@ namespace fc::vm::actor::builtin::storage_power {
   TokenAmount pledgeForWeight(const SectorStorageWeightDesc &weight,
                               StoragePower network_power);
 
+  /** Penalty to pledge collateral for repeated failure to prove storage */
+  TokenAmount pledgePenaltyForWindowedPoStFailure(TokenAmount pledge,
+                                                  int64_t failures);
+
+  /** Penalty to pledge collateral for a consensus fault */
+  outcome::result<TokenAmount> pledgePenaltyForConsensusFault(
+      TokenAmount pledge, ConsensusFaultType fault_type);
+
+  TokenAmount rewardForConsensusSlashReport(ChainEpoch elapsed_epoch,
+                                            TokenAmount collateral);
+
 }  // namespace fc::vm::actor::builtin::storage_power
 
 #endif  // CPP_FILECOIN_VM_ACTOR_BUILTIN_STORAGE_POWER_POLICY_HPP