VM assert (#495)

Signed-off-by: Mikhail Tagirov <[email protected]>

Author: Mikhail Tagirov

core/vm/actor/builtin/states/market/market_actor_state.cpp

@@ -11,16 +11,14 @@
 
 namespace fc::vm::actor::builtin::states {
   using primitives::kChainEpochUndefined;
-  using runtime::Runtime;
   using toolchain::Toolchain;
   using namespace types::market;
 
   outcome::result<void> MarketActorState::unlockBalance(
-      const Runtime &runtime,
       const Address &address,
       const TokenAmount &amount,
       BalanceLockingReason lock_reason) {
-    VM_ASSERT(amount >= 0);
+    OUTCOME_TRY(check(amount >= 0));
 
     OUTCOME_TRY(locked_table.subtract(address, amount));
 
@@ -39,41 +37,34 @@ namespace fc::vm::actor::builtin::states {
   }
 
   outcome::result<void> MarketActorState::slashBalance(
-      const Runtime &runtime,
       const Address &address,
       const TokenAmount &amount,
       BalanceLockingReason reason) {
-    VM_ASSERT(amount >= 0);
+    OUTCOME_TRY(check(amount >= 0));
     OUTCOME_TRY(escrow_table.subtract(address, amount));
-    return unlockBalance(runtime, address, amount, reason);
+    return unlockBalance(address, amount, reason);
   }
 
   outcome::result<void> MarketActorState::transferBalance(
-      const Runtime &runtime,
-      const Address &from,
-      const Address &to,
-      const TokenAmount &amount) {
-    VM_ASSERT(amount >= 0);
+      const Address &from, const Address &to, const TokenAmount &amount) {
+    OUTCOME_TRY(check(amount >= 0));
     CHANGE_ERROR_ABORT(escrow_table.subtract(from, amount),
                        VMExitCode::kErrIllegalState);
     CHANGE_ERROR_ABORT(
-        unlockBalance(
-            runtime, from, amount, BalanceLockingReason::kClientStorageFee),
+        unlockBalance(from, amount, BalanceLockingReason::kClientStorageFee),
         VMExitCode::kErrIllegalState);
     CHANGE_ERROR_ABORT(escrow_table.add(to, amount),
                        VMExitCode::kErrIllegalState);
     return outcome::success();
   }
 
   outcome::result<TokenAmount> MarketActorState::processDealInitTimedOut(
-      const Runtime &runtime, const DealProposal &deal) {
-    CHANGE_ERROR_ABORT(unlockBalance(runtime,
-                                     deal.client,
+      const DealProposal &deal) {
+    CHANGE_ERROR_ABORT(unlockBalance(deal.client,
                                      deal.getTotalStorageFee(),
                                      BalanceLockingReason::kClientStorageFee),
                        VMExitCode::kErrIllegalState);
-    CHANGE_ERROR_ABORT(unlockBalance(runtime,
-                                     deal.client,
+    CHANGE_ERROR_ABORT(unlockBalance(deal.client,
                                      deal.client_collateral,
                                      BalanceLockingReason::kClientCollateral),
                        VMExitCode::kErrIllegalState);
@@ -82,13 +73,11 @@ namespace fc::vm::actor::builtin::states {
         collateralPenaltyForDealActivationMissed(deal.provider_collateral);
     const auto amount_remaining = deal.providerBalanceRequirement() - slashed;
 
-    CHANGE_ERROR_ABORT(slashBalance(runtime,
-                                    deal.provider,
-                                    slashed,
-                                    BalanceLockingReason::kProviderCollateral),
-                       VMExitCode::kErrIllegalState);
-    CHANGE_ERROR_ABORT(unlockBalance(runtime,
-                                     deal.provider,
+    CHANGE_ERROR_ABORT(
+        slashBalance(
+            deal.provider, slashed, BalanceLockingReason::kProviderCollateral),
+        VMExitCode::kErrIllegalState);
+    CHANGE_ERROR_ABORT(unlockBalance(deal.provider,
                                      amount_remaining,
                                      BalanceLockingReason::kProviderCollateral),
                        VMExitCode::kErrIllegalState);
@@ -97,18 +86,14 @@ namespace fc::vm::actor::builtin::states {
   }
 
   outcome::result<void> MarketActorState::processDealExpired(
-      const Runtime &runtime,
-      const DealProposal &deal,
-      const DealState &deal_state) {
-    VM_ASSERT(deal_state.sector_start_epoch != kChainEpochUndefined);
+      const DealProposal &deal, const DealState &deal_state) {
+    OUTCOME_TRY(check(deal_state.sector_start_epoch != kChainEpochUndefined));
 
-    CHANGE_ERROR_ABORT(unlockBalance(runtime,
-                                     deal.provider,
+    CHANGE_ERROR_ABORT(unlockBalance(deal.provider,
                                      deal.provider_collateral,
                                      BalanceLockingReason::kProviderCollateral),
                        VMExitCode::kErrIllegalState);
-    CHANGE_ERROR_ABORT(unlockBalance(runtime,
-                                     deal.client,
+    CHANGE_ERROR_ABORT(unlockBalance(deal.client,
                                      deal.client_collateral,
                                      BalanceLockingReason::kClientCollateral),
                        VMExitCode::kErrIllegalState);
@@ -127,16 +112,16 @@ namespace fc::vm::actor::builtin::states {
     const auto updated{deal_state.last_updated_epoch != kChainEpochUndefined};
     const auto slashed{deal_state.slash_epoch != kChainEpochUndefined};
 
-    VM_ASSERT(!updated || (deal_state.last_updated_epoch <= epoch));
+    OUTCOME_TRY(check(!updated || (deal_state.last_updated_epoch <= epoch)));
 
     if (deal.start_epoch > epoch) {
       return std::make_tuple(slashed_sum, kChainEpochUndefined, false);
     }
 
     auto payment_end_epoch = deal.end_epoch;
     if (slashed) {
-      VM_ASSERT(epoch >= deal_state.slash_epoch);
-      VM_ASSERT(deal_state.slash_epoch <= deal.end_epoch);
+      OUTCOME_TRY(check(epoch >= deal_state.slash_epoch));
+      OUTCOME_TRY(check(deal_state.slash_epoch <= deal.end_epoch));
       payment_end_epoch = deal_state.slash_epoch;
     } else if (epoch < payment_end_epoch) {
       payment_end_epoch = epoch;
@@ -152,8 +137,7 @@ namespace fc::vm::actor::builtin::states {
         epochs_elapsed * deal.storage_price_per_epoch;
 
     if (total_payment > 0) {
-      OUTCOME_TRY(
-          transferBalance(runtime, deal.client, deal.provider, total_payment));
+      OUTCOME_TRY(transferBalance(deal.client, deal.provider, total_payment));
     }
 
     const auto utils = Toolchain::createMarketUtils(runtime);
@@ -162,23 +146,20 @@ namespace fc::vm::actor::builtin::states {
       OUTCOME_TRY(remaining,
                   utils->dealGetPaymentRemaining(deal, deal_state.slash_epoch));
 
-      CHANGE_ERROR_ABORT(unlockBalance(runtime,
-                                       deal.client,
-                                       remaining,
-                                       BalanceLockingReason::kClientStorageFee),
-                         VMExitCode::kErrIllegalState);
+      CHANGE_ERROR_ABORT(
+          unlockBalance(
+              deal.client, remaining, BalanceLockingReason::kClientStorageFee),
+          VMExitCode::kErrIllegalState);
 
-      CHANGE_ERROR_ABORT(unlockBalance(runtime,
-                                       deal.client,
+      CHANGE_ERROR_ABORT(unlockBalance(deal.client,
                                        deal.client_collateral,
                                        BalanceLockingReason::kClientCollateral),
                          VMExitCode::kErrIllegalState);
 
       slashed_sum = deal.provider_collateral;
 
       CHANGE_ERROR_ABORT(
-          slashBalance(runtime,
-                       deal.provider,
+          slashBalance(deal.provider,
                        slashed_sum,
                        BalanceLockingReason::kProviderCollateral),
           VMExitCode::kErrIllegalState);
@@ -187,7 +168,7 @@ namespace fc::vm::actor::builtin::states {
     }
 
     if (epoch >= deal.end_epoch) {
-      OUTCOME_TRY(processDealExpired(runtime, deal, deal_state));
+      OUTCOME_TRY(processDealExpired(deal, deal_state));
       return std::make_tuple(slashed_sum, kChainEpochUndefined, true);
     }
 
@@ -197,10 +178,8 @@ namespace fc::vm::actor::builtin::states {
   }
 
   outcome::result<void> MarketActorState::maybeLockBalance(
-      const Runtime &runtime,
-      const Address &address,
-      const TokenAmount &amount) {
-    VM_ASSERT(amount >= 0);
+      const Address &address, const TokenAmount &amount) {
+    OUTCOME_TRY(check(amount >= 0));
 
     CHANGE_ERROR_A(
         locked, locked_table.get(address), VMExitCode::kErrIllegalState);
@@ -218,11 +197,10 @@ namespace fc::vm::actor::builtin::states {
   }
 
   outcome::result<void> MarketActorState::lockClientAndProviderBalances(
-      const Runtime &runtime, const DealProposal &deal) {
-    OUTCOME_TRY(maybeLockBalance(
-        runtime, deal.client, deal.clientBalanceRequirement()));
-    OUTCOME_TRY(maybeLockBalance(
-        runtime, deal.provider, deal.providerBalanceRequirement()));
+      const DealProposal &deal) {
+    OUTCOME_TRY(maybeLockBalance(deal.client, deal.clientBalanceRequirement()));
+    OUTCOME_TRY(
+        maybeLockBalance(deal.provider, deal.providerBalanceRequirement()));
     total_client_locked_collateral += deal.client_collateral;
     total_client_storage_fee += deal.getTotalStorageFee();
     total_provider_locked_collateral += deal.provider_collateral;

core/vm/actor/builtin/states/market/market_actor_state.hpp

@@ -27,11 +27,12 @@ namespace fc::vm::actor::builtin::states {
   using primitives::DealId;
   using primitives::TokenAmount;
   using primitives::address::Address;
+  using runtime::Runtime;
+  using types::Universal;
   using types::market::BalanceLockingReason;
   using types::market::DealProposal;
   using types::market::DealState;
   using types::market::PendingProposals;
-  using types::Universal;
 
   constexpr size_t kProposalsAmtBitwidth = 5;
   constexpr size_t kStatesAmtBitwidth = 6;
@@ -55,41 +56,39 @@ namespace fc::vm::actor::builtin::states {
     TokenAmount total_client_storage_fee{};
 
     // Methods
-    outcome::result<void> unlockBalance(const runtime::Runtime &runtime,
-                                        const Address &address,
+    outcome::result<void> unlockBalance(const Address &address,
                                         const TokenAmount &amount,
                                         BalanceLockingReason lock_reason);
 
-    outcome::result<void> slashBalance(const runtime::Runtime &runtime,
-                                       const Address &address,
+    outcome::result<void> slashBalance(const Address &address,
                                        const TokenAmount &amount,
                                        BalanceLockingReason reason);
 
-    outcome::result<void> transferBalance(const runtime::Runtime &runtime,
-                                          const Address &from,
+    outcome::result<void> transferBalance(const Address &from,
                                           const Address &to,
                                           const TokenAmount &amount);
 
     outcome::result<TokenAmount> processDealInitTimedOut(
-        const runtime::Runtime &runtime, const DealProposal &deal);
+        const DealProposal &deal);
 
-    virtual outcome::result<void> processDealExpired(const runtime::Runtime &runtime,
-                                             const DealProposal &deal,
-                                             const DealState &deal_state);
+    virtual outcome::result<void> processDealExpired(
+        const DealProposal &deal, const DealState &deal_state);
 
     virtual outcome::result<std::tuple<TokenAmount, ChainEpoch, bool>>
-    updatePendingDealState(runtime::Runtime &runtime,
+    updatePendingDealState(Runtime &runtime,
                            DealId deal_id,
                            const DealProposal &deal,
                            const DealState &deal_state,
                            ChainEpoch epoch);
 
-    outcome::result<void> maybeLockBalance(const runtime::Runtime &runtime,
-                                           const Address &address,
+    outcome::result<void> maybeLockBalance(const Address &address,
                                            const TokenAmount &amount);
 
     outcome::result<void> lockClientAndProviderBalances(
-        const runtime::Runtime &runtime, const DealProposal &deal);
+        const DealProposal &deal);
+
+   protected:
+    virtual outcome::result<void> check(bool condition) const = 0;
   };
 
   using MarketActorStatePtr = Universal<MarketActorState>;

core/vm/actor/builtin/states/market/v0/market_actor_state.hpp

@@ -8,10 +8,16 @@
 #include "vm/actor/builtin/states/market/market_actor_state.hpp"
 
 #include "codec/cbor/streams_annotation.hpp"
+#include "vm/exit_code/exit_code.hpp"
 
 namespace fc::vm::actor::builtin::v0::market {
 
-  struct MarketActorState : states::MarketActorState {};
+  struct MarketActorState : states::MarketActorState {
+   protected:
+    outcome::result<void> check(bool condition) const override {
+      return vm_assert(condition);
+    }
+  };
   CBOR_TUPLE(MarketActorState,
              proposals,
              states,