public class TwoPartyTradeFlow
This asset trading flow implements a "delivery vs payment" type swap. It has two parties (B and S for buyer and seller) and the following steps:
S sends the class StateAndRef
pointing to what they want to sell to B, along with info about the price they require
B to pay. For example this has probably been agreed on an exchange.
B sends to S a class SignedTransaction
that includes the state as input, B's cash as input, the state with the new
owner key as output, and any change cash as output. It contains a single signature from B but isn't valid because
it lacks a signature from S authorising movement of the asset.
S signs it and hands the now finalised SignedWireTransaction back to B.
Assuming no malicious termination, they both end the flow being in posession of a valid, signed transaction that represents an atomic asset swap.
Note that it's the seller who initiates contact with the buyer, not vice-versa as you might imagine.
To initiate the flow, use either the runBuyer or runSeller methods, depending on which side of the trade your node is taking. These methods return a future which will complete once the trade is over and a fully signed transaction is available: you can either block your thread waiting for the flow to complete by using ListenableFuture.get or more usefully, register a callback that will be invoked when the time comes.
To see an example of how to use this class, look at the unit tests.
Modifier and Type | Class and Description |
---|---|
static class |
TwoPartyTradeFlow.Buyer |
static class |
TwoPartyTradeFlow.Seller |
static class |
TwoPartyTradeFlow.SellerTradeInfo |
static class |
TwoPartyTradeFlow.SignaturesFromSeller |
Modifier and Type | Field and Description |
---|---|
static TwoPartyTradeFlow |
INSTANCE
This asset trading flow implements a "delivery vs payment" type swap. It has two parties (B and S for buyer
and seller) and the following steps:
|
public static TwoPartyTradeFlow INSTANCE
This asset trading flow implements a "delivery vs payment" type swap. It has two parties (B and S for buyer and seller) and the following steps:
S sends the class StateAndRef
pointing to what they want to sell to B, along with info about the price they require
B to pay. For example this has probably been agreed on an exchange.
B sends to S a class SignedTransaction
that includes the state as input, B's cash as input, the state with the new
owner key as output, and any change cash as output. It contains a single signature from B but isn't valid because
it lacks a signature from S authorising movement of the asset.
S signs it and hands the now finalised SignedWireTransaction back to B.
Assuming no malicious termination, they both end the flow being in posession of a valid, signed transaction that represents an atomic asset swap.
Note that it's the seller who initiates contact with the buyer, not vice-versa as you might imagine.
To initiate the flow, use either the runBuyer or runSeller methods, depending on which side of the trade your node is taking. These methods return a future which will complete once the trade is over and a fully signed transaction is available: you can either block your thread waiting for the flow to complete by using ListenableFuture.get or more usefully, register a callback that will be invoked when the time comes.
To see an example of how to use this class, look at the unit tests.