[GH-759] Channel Snapshot

apps/aecore/lib/aecore/channel/channel_state_on_chain.ex

@@ -47,7 +47,7 @@ defmodule Aecore.Channel.ChannelStateOnChain do
   # Parameters
   - initiator_pubkey
   - responder_pubkey
-  - delegates - list of delegates alowed to perform certain operations
+  - delegates - list of delegates allowed to perform certain operations
   - total_amount - the total amount of tokens in the channel
   - initiator_amount - amount deposited by initiator in create_tx or from poi
   - responder_amount - amount deposited by responder in create_tx or from poi
@@ -147,6 +147,31 @@ defmodule Aecore.Channel.ChannelStateOnChain do
     {initiator_pubkey, responder_pubkey}
   end
 
+  @spec is_peer?(ChannelStateOnChain.t(), Keys.pubkey()) :: boolean()
+  def is_peer?(
+        %ChannelStateOnChain{
+          initiator_pubkey: initiator_pubkey,
+          responder_pubkey: responder_pubkey
+        },
+        pubkey
+      )
+      when is_binary(pubkey) do
+    pubkey in [initiator_pubkey, responder_pubkey]
+  end
+
+  @spec is_peer_or_delegate?(ChannelStateOnChain.t(), Keys.pubkey()) :: boolean()
+  def is_peer_or_delegate?(
+        %ChannelStateOnChain{
+          initiator_pubkey: initiator_pubkey,
+          responder_pubkey: responder_pubkey,
+          delegates: delegates
+        },
+        pubkey
+      )
+      when is_binary(pubkey) do
+    pubkey in [initiator_pubkey, responder_pubkey | delegates]
+  end
+
   @doc """
   Returns true if the channel wasn't slashed. (Closed channels should be removed from the Channels state tree)
   """
@@ -248,7 +273,7 @@ defmodule Aecore.Channel.ChannelStateOnChain do
 
         channel.sequence >= offchain_tx.sequence ->
           {:error,
-           "#{__MODULE__}: OffChain state is too old, expected newer than #{channel.sequence}, got #{
+           "#{__MODULE__}: OffChainTx is too old, expected newer than #{channel.sequence}, got #{
              offchain_tx.sequence
            }"}
 
@@ -334,32 +359,22 @@ defmodule Aecore.Channel.ChannelStateOnChain do
 
   @spec validate_withdraw(
           ChannelStateOnChain.t(),
-          Keys.pubkey(),
           non_neg_integer(),
           non_neg_integer()
         ) :: :ok | error()
   def validate_withdraw(
         %ChannelStateOnChain{
-          initiator_pubkey: initiator_pubkey,
-          responder_pubkey: responder_pubkey,
           total_amount: total_amount,
           sequence: sequence,
           channel_reserve: channel_reserve
         },
-        tx_account,
         tx_amount,
         tx_sequence
       ) do
     cond do
       sequence >= tx_sequence ->
         {:error, "Too old state - latest known sequence is #{sequence} but we got #{tx_sequence}"}
 
-      tx_account != initiator_pubkey and tx_account != responder_pubkey ->
-        {:error,
-         "Withdraw destination must be a party of this channel. Tried to withdraw from #{
-           tx_account
-         } but the parties are #{initiator_pubkey} and #{responder_pubkey}"}
-
       tx_amount < 0 ->
         {:error, "Withdraw of negative amount(#{tx_amount}) is forbidden"}
 
@@ -397,34 +412,23 @@ defmodule Aecore.Channel.ChannelStateOnChain do
 
   @spec validate_deposit(
           ChannelStateOnChain.t(),
-          Keys.pubkey(),
           non_neg_integer(),
           non_neg_integer()
         ) :: :ok | error()
   def validate_deposit(
         %ChannelStateOnChain{
-          initiator_pubkey: initiator_pubkey,
-          responder_pubkey: responder_pubkey,
           sequence: sequence
         },
-        tx_account,
         tx_amount,
         tx_sequence
-      )
-      when is_binary(tx_account) do
+      ) do
     cond do
       sequence >= tx_sequence ->
         {:error, "Too old state - latest known sequence is #{sequence} but we got #{tx_sequence}"}
 
       tx_amount < 0 ->
         {:error, "Deposit of negative amount(#{tx_amount}) is forbidden"}
 
-      tx_account != initiator_pubkey and tx_account != responder_pubkey ->
-        {:error,
-         "Deposit destination must be a party of this channel. Tried to deposit tokens to #{
-           tx_account
-         } but the parties are #{initiator_pubkey} and #{responder_pubkey}"}
-
       true ->
         :ok
     end
@@ -451,6 +455,41 @@ defmodule Aecore.Channel.ChannelStateOnChain do
     }
   end
 
+  @doc """
+  Validates the payload of ChannelSnapshotSoloTx.
+  """
+  @spec validate_snapshot(ChannelStateOnChain.t(), ChannelOffChainTx.t()) ::
+          :ok | {:error, binary()}
+  def validate_snapshot(
+        %ChannelStateOnChain{} = channel,
+        %ChannelOffChainTx{} = offchain_tx
+      ) do
+    if channel.sequence < offchain_tx.sequence do
+      ChannelOffChainTx.verify_signatures(offchain_tx, pubkeys(channel))
+    else
+      {:error,
+       "#{__MODULE__}: OffChainTx is too old, expected newer than #{channel.sequence}, got #{
+         offchain_tx.sequence
+       }"}
+    end
+  end
+
+  @doc """
+  Applies the provided payload of ChannelSnapshotSoloTx to the state of the channel. The contents should be validated by &validate_snapshot/2
+  """
+  @spec apply_snapshot(ChannelStateOnChain.t(), ChannelOffChainTx.t()) :: ChannelStateOnChain.t()
+  def apply_snapshot(%ChannelStateOnChain{} = channel, %ChannelOffChainTx{
+        sequence: sequence,
+        state_hash: state_hash
+      }) do
+    %ChannelStateOnChain{
+      channel
+      | sequence: sequence,
+        state_hash: state_hash,
+        solo_sequence: 0
+    }
+  end
+
   @spec encode_to_list(ChannelStateOnChain.t()) :: list(binary())
   def encode_to_list(%ChannelStateOnChain{} = channel) do
     [

apps/aecore/lib/aecore/channel/channel_state_peer.ex

@@ -21,7 +21,8 @@ defmodule Aecore.Channel.ChannelStatePeer do
     ChannelSlashTx,
     ChannelSettleTx,
     ChannelWithdrawTx,
-    ChannelDepositTx
+    ChannelDepositTx,
+    ChannelSnapshotSoloTx
   }
 
   alias Aecore.Keys
@@ -44,7 +45,8 @@ defmodule Aecore.Channel.ChannelStatePeer do
           mutually_signed_tx: list(ChannelOffChainTx.t()),
           highest_half_signed_tx: ChannelOffChainTx.t() | nil,
           channel_reserve: non_neg_integer(),
-          offchain_chainstate: Chainstate.t() | nil
+          offchain_chainstate: Chainstate.t() | nil,
+          snapshot_sequence: non_neg_integer()
         }
 
   @typedoc "Type of the errors returned by functions in this module"
@@ -60,7 +62,8 @@ defmodule Aecore.Channel.ChannelStatePeer do
     :channel_reserve,
     mutually_signed_tx: [],
     highest_half_signed_tx: nil,
-    offchain_chainstate: nil
+    offchain_chainstate: nil,
+    snapshot_sequence: 0
   ]
 
   require Logger
@@ -992,21 +995,31 @@ defmodule Aecore.Channel.ChannelStatePeer do
           Keys.sign_priv_key()
         ) :: {:ok, ChannelStatePeer.t(), SignedTx.t()} | error()
   def solo_close(
-        %ChannelStatePeer{channel_id: channel_id, mutually_signed_tx: [most_recent_tx | _]} =
-          peer_state,
+        %ChannelStatePeer{
+          channel_id: channel_id,
+          mutually_signed_tx: [most_recent_tx | _],
+          snapshot_sequence: snapshot_sequence
+        } = peer_state,
         fee,
         nonce,
         priv_key
       ) do
     new_peer_state = %ChannelStatePeer{peer_state | fsm_state: :closing}
+    # If we are closing with a recently snapshoted state we MUST use the state saved on chain
+    offchain_tx =
+      if snapshot_sequence == ChannelStatePeer.sequence(peer_state) do
+        :empty
+      else
+        ChannelTransaction.dispute_payload(most_recent_tx)
+      end
 
     data =
       DataTx.init(
         ChannelCloseSoloTx,
         %{
           channel_id: channel_id,
           poi: dispute_poi_for_latest_state(peer_state),
-          offchain_tx: ChannelTransaction.dispute_payload(most_recent_tx)
+          offchain_tx: offchain_tx
         },
         our_pubkey(peer_state),
         fee,
@@ -1049,7 +1062,7 @@ defmodule Aecore.Channel.ChannelStatePeer do
   end
 
   @doc """
-  Handles mined ChnanelSlashTx and ChannelCloseSoloTx. Provided fee and nonce are for potentially created SlashTx. Pubkey and Privkey don't have to match any of channel parties. Returns altered ChannelPeerState and ChannelSlashTx if we have higher signed state.
+  Handles mined ChannelSlashTx and ChannelCloseSoloTx. Provided fee and nonce are for potentially created SlashTx. Pubkey and Privkey don't have to match any of channel parties. Returns altered ChannelPeerState and ChannelSlashTx if we have higher signed state.
   """
   @spec slashed(
           ChannelStatePeer.t(),
@@ -1091,6 +1104,69 @@ defmodule Aecore.Channel.ChannelStatePeer do
     end
   end
 
+  @doc """
+  Creates a snapshot transaction from the most recent mutually signed transaction. This transaction must be a ChannelOffChainTx, otherwise the onchain state contains the most recent offchain state hash and a snapshot is unnecessary.
+  Can be called anytime after the channel was opened and before the channel is closed.
+  """
+  @spec snapshot(ChannelStatePeer.t(), non_neg_integer(), non_neg_integer(), Keys.sign_priv_key()) ::
+          {:ok, SignedTx.t()} | error()
+  def snapshot(
+        %ChannelStatePeer{
+          fsm_state: state,
+          channel_id: channel_id,
+          mutually_signed_tx: [%ChannelOffChainTx{} = offchain_tx | _],
+          snapshot_sequence: snapshot_sequence
+        } = peer_state,
+        fee,
+        nonce,
+        priv_key
+      )
+      when state in [:awaiting_full_tx, :awaiting_tx_confirmed, :open] do
+    if snapshot_sequence < ChannelStatePeer.sequence(peer_state) do
+      data =
+        DataTx.init(
+          ChannelSnapshotSoloTx,
+          %{channel_id: channel_id, offchain_tx: offchain_tx},
+          our_pubkey(peer_state),
+          fee,
+          nonce
+        )
+
+      SignedTx.sign_tx(data, priv_key)
+    else
+      {:error, "#{__MODULE__}: We cannot snapshot an already snapshoted state."}
+    end
+  end
+
+  def snapshot(
+        %ChannelStatePeer{
+          fsm_state: state
+        },
+        _,
+        _,
+        _
+      )
+      when state in [:awaiting_full_tx, :awaiting_tx_confirmed, :open] do
+    {:error, "#{__MODULE__}: We can only snapshot with ChannelOffChainTx."}
+  end
+
+  def snapshot(%ChannelStatePeer{fsm_state: state}, _, _, _) do
+    {:error, "#{__MODULE__}: Invalid peer state: #{state}"}
+  end
+
+  @doc """
+    Notifies the channel that a snapshot tx was mined. MUST only be called when ChannelSnapshotSoloTx was mined.
+  """
+  @spec snapshot_mined(ChannelStatePeer.t(), SignedTx.t()) :: ChannelStatePeer.t()
+  def snapshot_mined(%ChannelStatePeer{} = peer_state, %SignedTx{
+        data: %DataTx{
+          type: ChannelSnapshotSoloTx,
+          payload: %ChannelSnapshotSoloTx{offchain_tx: %ChannelOffChainTx{sequence: sequence}}
+        }
+      }) do
+    %ChannelStatePeer{peer_state | snapshot_sequence: sequence}
+  end
+
   @doc """
   Creates channel settle tx.
   """

apps/aecore/lib/aecore/channel/tx/channel_deposit_tx.ex

@@ -221,8 +221,14 @@ defmodule Aecore.Channel.Tx.ChannelDepositTx do
       !ChannelStateOnChain.active?(channel) ->
         {:error, "#{__MODULE__}: Can't deposit from inactive channel."}
 
+      !ChannelStateOnChain.is_peer?(channel, depositing_account) ->
+        {:error,
+         "Deposit destination must be a party of this channel. Tried to deposit tokens to #{
+           depositing_account
+         } but the parties are #{channel.initiator_pubkey} and #{channel.responder_pubkey}"}
+
       true ->
-        ChannelStateOnChain.validate_deposit(channel, depositing_account, amount, sequence)
+        ChannelStateOnChain.validate_deposit(channel, amount, sequence)
     end
   end