Payment channel actor methods (#150)

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

Author: turuslan

core/api/rpc/json.hpp

@@ -483,7 +483,8 @@ namespace fc::api {
 
     ENCODE(SignedVoucher) {
       Value j{rapidjson::kObjectType};
-      Set(j, "TimeLock", v.time_lock);
+      Set(j, "TimeLockMin", v.time_lock_min);
+      Set(j, "TimeLockMax", v.time_lock_max);
       Set(j, "SecretPreimage", gsl::make_span(v.secret_preimage));
       Set(j, "Extra", v.extra);
       Set(j, "Lane", v.lane);
@@ -496,7 +497,8 @@ namespace fc::api {
     }
 
     DECODE(SignedVoucher) {
-      decode(v.time_lock, Get(j, "TimeLock"));
+      decode(v.time_lock_min, Get(j, "TimeLockMin"));
+      decode(v.time_lock_max, Get(j, "TimeLockMax"));
       decode(v.secret_preimage, Get(j, "SecretPreimage"));
       decode(v.extra, Get(j, "Extra"));
       decode(v.lane, Get(j, "Lane"));

core/vm/actor/builtin/multisig/multisig_actor.cpp

@@ -109,7 +109,7 @@ namespace fc::vm::actor::builtin::multisig {
     pending_tx.approved.push_back(caller);
 
     // check threshold
-    OUTCOME_TRY(balance, runtime.getBalance(runtime.getCurrentReceiver()));
+    OUTCOME_TRY(balance, runtime.getCurrentBalance());
     if (pending_tx.approved.size() >= threshold) {
       if (balance < pending_tx.value)
         return VMExitCode::MULTISIG_ACTOR_INSUFFICIENT_FUNDS;

core/vm/actor/builtin/payment_channel/payment_channel_actor.cpp

@@ -5,56 +5,140 @@
 
 #include "vm/actor/builtin/payment_channel/payment_channel_actor.hpp"
 
-#include "vm/actor/actor_method.hpp"
-#include "vm/exit_code/exit_code.hpp"
-
-using fc::outcome::result;
-using fc::primitives::address::Protocol;
-using fc::vm::actor::decodeActorParams;
-using fc::vm::actor::kAccountCodeCid;
-using fc::vm::runtime::InvocationOutput;
-using fc::vm::runtime::Runtime;
-namespace outcome = fc::outcome;
-using namespace fc::vm::actor::builtin::payment_channel;
-
-ACTOR_METHOD_IMPL(Construct) {
-  OUTCOME_TRY(code, runtime.getActorCodeID(runtime.getImmediateCaller()));
-  if (code != kAccountCodeCid) return VMExitCode::PAYMENT_CHANNEL_WRONG_CALLER;
-
-  if (params.to.getProtocol() != Protocol::ID)
-    return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
-  OUTCOME_TRY(target_actor_code_id, runtime.getActorCodeID(params.to));
-  if (target_actor_code_id != kAccountCodeCid)
-    return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
-
-  PaymentChannelActorState state{
-      runtime.getImmediateCaller(), params.to, 0, 0, 0, {}};
-
-  OUTCOME_TRY(runtime.commitState(state));
-  return fc::outcome::success();
-}
-
-ACTOR_METHOD_IMPL(UpdateChannelState) {
-  OUTCOME_TRY(state,
-              runtime.getCurrentActorStateCbor<PaymentChannelActorState>());
-  Address signer = runtime.getImmediateCaller();
-  if (signer != state.from || signer != state.to) {
-    return VMExitCode::PAYMENT_CHANNEL_WRONG_CALLER;
+namespace fc::vm::actor::builtin::payment_channel {
+  using primitives::address::Protocol;
+
+  outcome::result<Address> resolveAccount(Runtime &runtime,
+                                          const Address &address) {
+    OUTCOME_TRY(resolved, runtime.resolveAddress(address));
+    OUTCOME_TRY(code, runtime.getActorCodeID(resolved));
+    if (code != kAccountCodeCid) {
+      return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
+    }
+    return std::move(resolved);
   }
 
-  // TODO (a.chernyshov) not implemented yet FIL-129
+  outcome::result<State> assertCallerInChannel(Runtime &runtime) {
+    OUTCOME_TRY(state, runtime.getCurrentActorStateCbor<State>());
+    if (runtime.getImmediateCaller() != state.from
+        && runtime.getImmediateCaller() != state.to) {
+      return VMExitCode::PAYMENT_CHANNEL_WRONG_CALLER;
+    }
+    return std::move(state);
+  }
 
-  return fc::outcome::success();
-}
+  ACTOR_METHOD_IMPL(Construct) {
+    if (runtime.getImmediateCaller() != kInitAddress) {
+      return VMExitCode::PAYMENT_CHANNEL_WRONG_CALLER;
+    }
+    OUTCOME_TRY(to, resolveAccount(runtime, params.to));
+    OUTCOME_TRY(from, resolveAccount(runtime, params.from));
+    OUTCOME_TRY(runtime.commitState(State{from, to, 0, 0, 0, {}}));
+    return fc::outcome::success();
+  }
 
-ACTOR_METHOD_IMPL(Settle) {
-  // TODO (a.chernyshov) not implemented yet FIL-129
+  ACTOR_METHOD_IMPL(UpdateChannelState) {
+    OUTCOME_TRY(state, assertCallerInChannel(runtime));
+    auto &voucher = params.signed_voucher;
+    if (!voucher.signature) {
+      return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
+    }
+    auto voucher_signable = voucher;
+    voucher_signable.signature = boost::none;
+    OUTCOME_TRY(voucher_signable_bytes, codec::cbor::encode(voucher_signable));
+    auto &signer =
+        runtime.getImmediateCaller() != state.to ? state.to : state.from;
+    OUTCOME_TRY(verified,
+                runtime.verifySignature(
+                    *voucher.signature, signer, voucher_signable_bytes));
+    if (!verified) {
+      return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
+    }
+    if (runtime.getCurrentEpoch() < voucher.time_lock_min) {
+      return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
+    }
+    if (voucher.time_lock_max != 0
+        && runtime.getCurrentEpoch() > voucher.time_lock_max) {
+      return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
+    }
+    if (!voucher.secret_preimage.empty()
+        && gsl::make_span(runtime.hashBlake2b(params.secret))
+               != gsl::make_span(voucher.secret_preimage)) {
+      return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
+    }
+    if (voucher.extra) {
+      OUTCOME_TRY(params2,
+                  encodeActorParams(
+                      PaymentVerifyParams{voucher.extra->data, params.proof}));
+      OUTCOME_TRY(runtime.send(
+          voucher.extra->actor, voucher.extra->method, params2, 0));
+    }
 
-  return fc::outcome::success();
-}
+    auto lane_it = state.findLane(voucher.lane);
+    if (lane_it == state.lanes.end() || lane_it->id != voucher.lane) {
+      if (state.lanes.size() >= kLaneLimit) {
+        return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
+      }
+      lane_it = state.lanes.insert(lane_it, LaneState{voucher.lane, 0, 0});
+    }
+    auto &lane = *lane_it;
+    if (lane.nonce > voucher.nonce) {
+      return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
+    }
+    auto redeem = lane.redeem;
+    for (auto &merge : voucher.merges) {
+      if (merge.lane == voucher.lane) {
+        return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
+      }
+      lane_it = state.findLane(merge.lane);
+      if (lane_it == state.lanes.end() || lane_it->nonce >= merge.nonce) {
+        return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_ARGUMENT;
+      }
+      redeem += lane_it->redeem;
+      lane_it->nonce = merge.nonce;
+    }
+    lane.nonce = voucher.nonce;
+    state.to_send += voucher.amount - redeem;
+    lane.redeem = voucher.amount;
+    OUTCOME_TRY(balance, runtime.getCurrentBalance());
+    if (state.to_send < 0 || state.to_send > balance) {
+      return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_STATE;
+    }
+    if (voucher.min_close_height != 0) {
+      if (state.settling_at != 0) {
+        state.settling_at =
+            std::max(state.settling_at, voucher.min_close_height);
+      }
+      state.min_settling_height =
+          std::max(state.min_settling_height, voucher.min_close_height);
+    }
 
-ACTOR_METHOD_IMPL(Collect) {
-  // TODO (a.chernyshov) not implemented yet FIL-129
+    OUTCOME_TRY(runtime.commitState(state));
+    return fc::outcome::success();
+  }
 
-  return fc::outcome::success();
-}
+  ACTOR_METHOD_IMPL(Settle) {
+    OUTCOME_TRY(state, assertCallerInChannel(runtime));
+    if (state.settling_at != 0) {
+      return VMExitCode::PAYMENT_CHANNEL_ILLEGAL_STATE;
+    }
+    state.settling_at = std::max(state.min_settling_height,
+                                 runtime.getCurrentEpoch() + kSettleDelay);
+    OUTCOME_TRY(runtime.commitState(state));
+    return fc::outcome::success();
+  }
+
+  ACTOR_METHOD_IMPL(Collect) {
+    OUTCOME_TRY(state, assertCallerInChannel(runtime));
+    if (state.settling_at == 0
+        || runtime.getCurrentEpoch() < state.settling_at) {
+      return VMExitCode::PAYMENT_CHANNEL_FORBIDDEN;
+    }
+    OUTCOME_TRY(balance, runtime.getCurrentBalance());
+    OUTCOME_TRY(runtime.sendFunds(state.from, balance - state.to_send));
+    OUTCOME_TRY(runtime.sendFunds(state.to, state.to_send));
+    state.to_send = 0;
+    OUTCOME_TRY(runtime.commitState(state));
+    return fc::outcome::success();
+  }
+}  // namespace fc::vm::actor::builtin::payment_channel

core/vm/actor/builtin/payment_channel/payment_channel_actor.hpp

@@ -6,27 +6,24 @@
 #ifndef CPP_FILECOIN_VM_ACTOR_BUILTIN_PAYMENT_CHANNEL_ACTOR_HPP
 #define CPP_FILECOIN_VM_ACTOR_BUILTIN_PAYMENT_CHANNEL_ACTOR_HPP
 
-#include "codec/cbor/streams_annotation.hpp"
-#include "common/outcome.hpp"
 #include "primitives/address/address_codec.hpp"
 #include "vm/actor/actor_method.hpp"
 #include "vm/actor/builtin/payment_channel/payment_channel_actor_state.hpp"
-#include "vm/runtime/runtime.hpp"
-#include "vm/runtime/runtime_types.hpp"
 
 namespace fc::vm::actor::builtin::payment_channel {
+  using primitives::EpochDuration;
 
-  using fc::vm::runtime::InvocationOutput;
-  using fc::vm::runtime::Runtime;
+  constexpr size_t kLaneLimit{256};
+  constexpr EpochDuration kSettleDelay{1};
 
   struct Construct : ActorMethodBase<1> {
     struct Params {
-      /** Voucher receiver */
+      Address from;
       Address to;
     };
     ACTOR_METHOD_DECL();
   };
-  CBOR_TUPLE(Construct::Params, to)
+  CBOR_TUPLE(Construct::Params, from, to)
 
   struct UpdateChannelState : ActorMethodBase<2> {
     struct Params {
@@ -45,7 +42,6 @@ namespace fc::vm::actor::builtin::payment_channel {
   struct Collect : ActorMethodBase<4> {
     ACTOR_METHOD_DECL();
   };
-
 }  // namespace fc::vm::actor::builtin::payment_channel
 
 #endif  // CPP_FILECOIN_VM_ACTOR_BUILTIN_PAYMENT_CHANNEL_ACTOR_HPP

core/vm/actor/builtin/payment_channel/payment_channel_actor_state.hpp

@@ -6,47 +6,52 @@
 #ifndef CPP_FILECOIN_VM_ACTOR_BUILTIN_PAYMENT_CHANNEL_ACTOR_STATE_HPP
 #define CPP_FILECOIN_VM_ACTOR_BUILTIN_PAYMENT_CHANNEL_ACTOR_STATE_HPP
 
-#include "codec/cbor/streams_annotation.hpp"
-#include "common/buffer.hpp"
 #include "crypto/signature/signature.hpp"
-#include "primitives/address/address.hpp"
-#include "primitives/big_int.hpp"
-#include "primitives/chain_epoch/chain_epoch.hpp"
+#include "primitives/types.hpp"
 #include "vm/actor/actor.hpp"
 
 namespace fc::vm::actor::builtin::payment_channel {
-
   using common::Buffer;
   using crypto::signature::Signature;
-  using fc::vm::actor::MethodNumber;
-  using primitives::BigInt;
   using primitives::ChainEpoch;
+  using primitives::TokenAmount;
   using primitives::address::Address;
 
+  using LaneId = uint64_t;
+
   struct LaneState {
-    int64_t state{};
-    BigInt redeem{};
-    int64_t nonce{};
+    LaneId id{};
+    TokenAmount redeem{};
+    uint64_t nonce{};
 
     inline bool operator==(const LaneState &other) const {
-      return state == other.state && redeem == other.redeem
-             && nonce == other.nonce;
+      return id == other.id && redeem == other.redeem && nonce == other.nonce;
     }
   };
+  CBOR_TUPLE(LaneState, id, redeem, nonce)
+
+  struct State {
+    inline auto findLane(LaneId lane_id) {
+      return std::lower_bound(
+          lanes.begin(), lanes.end(), lane_id, [](auto &lane, auto lane_id) {
+            return lane.id < lane_id;
+          });
+    }
 
-  struct PaymentChannelActorState {
     Address from;
     Address to;
-    BigInt to_send{};
+    TokenAmount to_send{};
     ChainEpoch settling_at;
     ChainEpoch min_settling_height;
     std::vector<LaneState> lanes{};
   };
+  CBOR_TUPLE(State, from, to, to_send, settling_at, min_settling_height, lanes)
 
   struct Merge {
-    uint64_t lane{};
+    LaneId lane{};
     uint64_t nonce{};
   };
+  CBOR_TUPLE(Merge, lane, nonce)
 
   /**
    * Modular Verification method
@@ -56,35 +61,23 @@ namespace fc::vm::actor::builtin::payment_channel {
     MethodNumber method;
     Buffer data;
   };
+  CBOR_TUPLE(ModularVerificationParameter, actor, method, data)
 
   struct SignedVoucher {
-    uint64_t time_lock{};
+    ChainEpoch time_lock_min{};
+    ChainEpoch time_lock_max{};
     Buffer secret_preimage;
-    ModularVerificationParameter extra;
-    uint64_t lane{};
+    boost::optional<ModularVerificationParameter> extra;
+    LaneId lane{};
     uint64_t nonce{};
-    BigInt amount;
-    uint64_t min_close_height{};
+    TokenAmount amount;
+    ChainEpoch min_close_height{};
     std::vector<Merge> merges{};
-    Signature signature;
+    boost::optional<Signature> signature;
   };
-
-  CBOR_TUPLE(LaneState, state, redeem, nonce)
-
-  CBOR_TUPLE(PaymentChannelActorState,
-             from,
-             to,
-             to_send,
-             settling_at,
-             min_settling_height,
-             lanes)
-
-  CBOR_TUPLE(ModularVerificationParameter, actor, method, data)
-
-  CBOR_TUPLE(Merge, lane, nonce)
-
   CBOR_TUPLE(SignedVoucher,
-             time_lock,
+             time_lock_min,
+             time_lock_max,
              secret_preimage,
              extra,
              lane,
@@ -94,5 +87,11 @@ namespace fc::vm::actor::builtin::payment_channel {
              merges,
              signature)
 
+  struct PaymentVerifyParams {
+    Buffer extra;
+    Buffer proof;
+  };
+  CBOR_TUPLE(PaymentVerifyParams, extra, proof);
 }  // namespace fc::vm::actor::builtin::payment_channel
+
 #endif  // CPP_FILECOIN_VM_ACTOR_BUILTIN_PAYMENT_CHANNEL_ACTOR_STATE_HPP

core/vm/actor/builtin/reward/reward_actor.cpp

@@ -118,8 +118,7 @@ namespace fc::vm::actor::builtin::reward {
       return VMExitCode::REWARD_ACTOR_WRONG_CALLER;
     }
     assert(params.gas_reward == runtime.getValueReceived());
-    OUTCOME_TRY(prior_balance,
-                runtime.getBalance(runtime.getMessage().get().to));
+    OUTCOME_TRY(prior_balance, runtime.getCurrentBalance());
     TokenAmount penalty{0};
     OUTCOME_TRY(state, runtime.getCurrentActorStateCbor<State>());