{-
  A two-party exchange

  In this scenario there are ;Resource; types Dolphin, A and B.

  There are three participants, Alice, Bob and a Solver.

  Alice has:
  * 1 A and 2 B

  Bob has:
  * 1 Dolphin

  Alice is willing to exchange either 2 B or 1 A for 1 Dolphin.
  Bob is willing to exchange 1 A for 1 Dolphin.

  How to express this in Anoma using the Taiga execution model?

  Alice publishes a ;PartialTx; (1) to the gossip network that consumes two
  resources:

  1.1 An A ;Resource; with quantity 1

  1.2 A B ;Resource; with quantity 2

  and creates:

  1.3 A ;Resource; with quantity 1 containing a logic function which encodes
  her intent. i.e she wants to participate in a transaction that contains a
  partial transaction in which she receives either 1 Dolphin and 2 B or 1
  Dolphin and 1 A.

  Bob publishes a ;PartialTx; (2) to the gossip network that encodes his intent.
  It consumes:

  2.2 A Dolphin ;Resource; with quantity 1.

  and creates:

  2.1 An A ;Resource; with quantity 1


  The Solver finds both Alice's and Bob's partial transactions on the gossip
  network and publishes a new parital transaction (3) such that all the tial
  transactions logic are satisfied and the resources are balanced.

  The Solver's partial transaction consumes:

  3.1 Alice's logic ;Resource; created in 1.3.

  and creates:

  3.2 A Dolphin ;Resource; with quantity 1

  3.3 A B ;Resource; with quantity 2

  For a partial transaction to be valid, all of the logic functions associated
  with its resources must be valid. In our case, Alice's logic function is
  valid when applied to partial transaction 3.

  A transaction is formed from a collection of valid partial transaction that
  balance. i.e the quantities of created and consumed resources, for each
  resource type in the transaction must balance.

  This is true for the transaction containing the partial transactions 1,2,3 above.

  In particular:

  3.3 (create 2 B) balances with 1.2 (consume 2 B)
  3.2 (create 1 Dolphin) balances with 2.2 (consume 1 Dolphin)
  3.1 (consume Alice's intent) balances with 1.3 (create Alice's intent)
  2.1 (creates 1 A) balances with 1.1 (consume 1 A).
-}

module Apps.TwoPartyExchange;

import Simulator open;
import Simulator.Resource open using {mkResource as mkResource'};
import Apps.TwoPartyExchange.Asset open;

import Data.Map as Map;
open Map using {Map};

import Stdlib.Prelude open;
import Stdlib.Data.Int.Ord open;

--- Definitions related to Alice's intent
module AliceIntent;
  
  logicFunction : LogicFunction
    | kind tx :=
      let
        {- check if the resource associated to this logic function is among
                the created (output) resources. Then check if alice's intent is satisfied. -}
        createdRs : List Resource := createdResources tx;
        createdHashes : List LogicHash := map Resource.logicHash createdRs;
      in isCreated kind
        || (quantityOfDenom Dolphin.denomination createdRs == 1
          && quantityOfDenom A.denomination createdRs == 1)
        || quantityOfDenom Dolphin.denomination createdRs == 1
        && quantityOfDenom B.denomination createdRs == 2;

  --- This will be computed from the logic function
  logicHash : LogicHash := 1;
  
  staticData : ByteString := 3 :: nil;
  
  denomination : Denomination := 1 :: staticData;
  
  mkResource (n : Int) : Resource :=
    mkResource'
      (logicHash := logicHash;
      staticData := staticData;
      dynamicData := nil;
      quantity := n);
end;

--- Definitions related to Alice
module Alice;
  partialTransaction : PartialTx :=
    mkPartialTx
      (consumedPair := A.mkResource 1, B.mkResource 2;
      createdPair := AliceIntent.mkResource 1, dummyResource);
end;

--- Definitions related to Bob
module Bob;
  partialTransaction : PartialTx :=
    mkPartialTx
      (consumedPair := Dolphin.mkResource 1, dummyResource;
      createdPair := A.mkResource 1, dummyResource);
end;

--- Definitions related to the Solver
module Solver;
  partialTransaction : PartialTx :=
    mkPartialTx
      (consumedPair := AliceIntent.mkResource 1, dummyResource;
      createdPair := Dolphin.mkResource 1, B.mkResource 2);
end;

logicFunctions : Map LogicHash LogicFunction :=
  mkLogicFunctionMap
    ((AliceIntent.logicHash, AliceIntent.logicFunction) :: nil);