Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-07-22 22:51:02 -04:00
Code Issues Projects Releases Packages Wiki Activity

Unify OfferTradeTask and TakerTradeTask

Browse source
This commit is contained in:
Manfred Karrer 2015-04-02 14:02:34 +02:00
parent 091ab9f48f
commit a95936297a
65 changed files with 443 additions and 459 deletions
Download patch file Download diff file Expand all files Collapse all files

8
core/src/main/java/io/bitsquare/gui/main/portfolio/closed/ClosedTradesViewModel.java
View file

@ -20,9 +20,9 @@ package io.bitsquare.gui.main.portfolio.closed;
import io.bitsquare.common.viewfx.model.ActivatableWithDataModel; import io.bitsquare.common.viewfx.model.ActivatableWithDataModel;
import io.bitsquare.common.viewfx.model.ViewModel; import io.bitsquare.common.viewfx.model.ViewModel;
import io.bitsquare.gui.util.BSFormatter; import io.bitsquare.gui.util.BSFormatter;
import io.bitsquare.trade.OffererState; import io.bitsquare.trade.states.OffererState;
import io.bitsquare.trade.TakerState; import io.bitsquare.trade.states.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.states.TradeState;
import com.google.inject.Inject; import com.google.inject.Inject;
@ -70,7 +70,7 @@ class ClosedTradesViewModel extends ActivatableWithDataModel<ClosedTradesDataMod
String getState(ClosedTradesListItem item) { String getState(ClosedTradesListItem item) {
if (item != null && item.getTrade() != null) { if (item != null && item.getTrade() != null) {
Trade.LifeCycleState lifeCycleState = item.getTrade().lifeCycleStateProperty().get(); TradeState.LifeCycleState lifeCycleState = item.getTrade().lifeCycleStateProperty().get();
if (lifeCycleState instanceof TakerState.LifeCycleState) { if (lifeCycleState instanceof TakerState.LifeCycleState) {
switch ((TakerState.LifeCycleState) lifeCycleState) { switch ((TakerState.LifeCycleState) lifeCycleState) {
case COMPLETED: case COMPLETED:

43
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/PendingTradesDataModel.java
View file

@ -23,13 +23,14 @@ import io.bitsquare.common.viewfx.model.Activatable;
import io.bitsquare.common.viewfx.model.DataModel; import io.bitsquare.common.viewfx.model.DataModel;
import io.bitsquare.gui.components.Popups; import io.bitsquare.gui.components.Popups;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.Contract; import io.bitsquare.trade.Contract;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.TradeManager; import io.bitsquare.trade.TradeManager;
import io.bitsquare.trade.states.TradeState;
import io.bitsquare.user.User; import io.bitsquare.user.User;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
@ -68,10 +69,10 @@ class PendingTradesDataModel implements Activatable, DataModel {
final StringProperty txId = new SimpleStringProperty(); final StringProperty txId = new SimpleStringProperty();
final IntegerProperty selectedIndex = new SimpleIntegerProperty(-1); final IntegerProperty selectedIndex = new SimpleIntegerProperty(-1);
final ObjectProperty<Trade.ProcessState> takerAsSellerProcessState = new SimpleObjectProperty<>(); final ObjectProperty<TradeState.ProcessState> takerAsSellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<Trade.ProcessState> offererAsBuyerProcessState = new SimpleObjectProperty<>(); final ObjectProperty<TradeState.ProcessState> offererAsBuyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<Trade.ProcessState> takerAsBuyerProcessState = new SimpleObjectProperty<>(); final ObjectProperty<TradeState.ProcessState> takerAsBuyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<Trade.ProcessState> offererAsSellerProcessState = new SimpleObjectProperty<>(); final ObjectProperty<TradeState.ProcessState> offererAsSellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<Trade> currentTrade = new SimpleObjectProperty<>(); final ObjectProperty<Trade> currentTrade = new SimpleObjectProperty<>();
@ -135,13 +136,13 @@ class PendingTradesDataModel implements Activatable, DataModel {
Trade trade = item.getTrade(); Trade trade = item.getTrade();
isOfferer = trade.getOffer().getP2PSigPubKey().equals(user.getP2PSigPubKey()); isOfferer = trade.getOffer().getP2PSigPubKey().equals(user.getP2PSigPubKey());
if (trade instanceof TakerAsSellerTrade) if (trade instanceof SellerAsTakerTrade)
takerAsSellerProcessState.bind(trade.processStateProperty()); takerAsSellerProcessState.bind(trade.processStateProperty());
else if (trade instanceof OffererAsBuyerTrade) else if (trade instanceof BuyerAsOffererTrade)
offererAsBuyerProcessState.bind(trade.processStateProperty()); offererAsBuyerProcessState.bind(trade.processStateProperty());
else if (trade instanceof TakerAsBuyerTrade) else if (trade instanceof BuyerAsTakerTrade)
takerAsBuyerProcessState.bind(trade.processStateProperty()); takerAsBuyerProcessState.bind(trade.processStateProperty());
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
offererAsSellerProcessState.bind(trade.processStateProperty()); offererAsSellerProcessState.bind(trade.processStateProperty());
if (trade.getDepositTx() != null) if (trade.getDepositTx() != null)
@ -150,17 +151,17 @@ class PendingTradesDataModel implements Activatable, DataModel {
} }
void fiatPaymentStarted() { void fiatPaymentStarted() {
if (getTrade() instanceof OffererAsBuyerTrade) if (getTrade() instanceof BuyerAsOffererTrade)
((OffererAsBuyerTrade) getTrade()).onFiatPaymentStarted(); ((BuyerAsOffererTrade) getTrade()).onFiatPaymentStarted();
else if (getTrade() instanceof TakerAsBuyerTrade) else if (getTrade() instanceof BuyerAsTakerTrade)
((TakerAsBuyerTrade) getTrade()).onFiatPaymentStarted(); ((BuyerAsTakerTrade) getTrade()).onFiatPaymentStarted();
} }
void fiatPaymentReceived() { void fiatPaymentReceived() {
if (getTrade() instanceof TakerAsSellerTrade) if (getTrade() instanceof SellerAsTakerTrade)
((TakerAsSellerTrade) getTrade()).onFiatPaymentReceived(); ((SellerAsTakerTrade) getTrade()).onFiatPaymentReceived();
else if (getTrade() instanceof OffererAsSellerTrade) else if (getTrade() instanceof SellerAsOffererTrade)
((OffererAsSellerTrade) getTrade()).onFiatPaymentReceived(); ((SellerAsOffererTrade) getTrade()).onFiatPaymentReceived();
} }
void withdraw(String toAddress) { void withdraw(String toAddress) {
@ -262,7 +263,7 @@ class PendingTradesDataModel implements Activatable, DataModel {
Trade trade = selectedItem.getTrade(); Trade trade = selectedItem.getTrade();
Coin amountToWithdraw = trade.getSecurityDeposit(); Coin amountToWithdraw = trade.getSecurityDeposit();
assert trade.getTradeAmount() != null; assert trade.getTradeAmount() != null;
if (trade instanceof OffererAsBuyerTrade || trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade || trade instanceof BuyerAsTakerTrade)
amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount()); amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount());
return amountToWithdraw; return amountToWithdraw;
} }

4
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/PendingTradesViewModel.java
View file

@ -27,8 +27,8 @@ import io.bitsquare.gui.main.portfolio.closed.ClosedTradesView;
import io.bitsquare.gui.util.BSFormatter; import io.bitsquare.gui.util.BSFormatter;
import io.bitsquare.gui.util.validation.BtcAddressValidator; import io.bitsquare.gui.util.validation.BtcAddressValidator;
import io.bitsquare.locale.BSResources; import io.bitsquare.locale.BSResources;
import io.bitsquare.trade.OffererState; import io.bitsquare.trade.states.OffererState;
import io.bitsquare.trade.TakerState; import io.bitsquare.trade.states.TakerState;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.bitcoinj.utils.Fiat; import org.bitcoinj.utils.Fiat;

10
core/src/main/java/io/bitsquare/gui/main/trade/takeoffer/TakeOfferViewModel.java
View file

@ -26,9 +26,9 @@ import io.bitsquare.gui.util.validation.InputValidator;
import io.bitsquare.locale.BSResources; import io.bitsquare.locale.BSResources;
import io.bitsquare.locale.CurrencyUtil; import io.bitsquare.locale.CurrencyUtil;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState; import io.bitsquare.trade.states.TakerState;
import org.bitcoinj.core.Address; import org.bitcoinj.core.Address;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
@ -234,7 +234,7 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
if (trade.getErrorMessage() != null) if (trade.getErrorMessage() != null)
msg = "\nError message: " + trade.getErrorMessage(); msg = "\nError message: " + trade.getErrorMessage();
if (trade instanceof TakerAsBuyerTrade) { if (trade instanceof BuyerAsTakerTrade) {
switch ((TakerState.ProcessState) newValue) { switch ((TakerState.ProcessState) newValue) {
case TAKE_OFFER_FEE_TX_CREATED: case TAKE_OFFER_FEE_TX_CREATED:
break; break;
@ -266,7 +266,7 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
break; break;
} }
} }
else if (trade instanceof TakerAsSellerTrade) { else if (trade instanceof SellerAsTakerTrade) {
switch ((TakerState.ProcessState) newValue) { switch ((TakerState.ProcessState) newValue) {
case TAKE_OFFER_FEE_TX_CREATED: case TAKE_OFFER_FEE_TX_CREATED:
break; break;

23
core/src/main/java/io/bitsquare/trade/OffererAsBuyerTrade.java → core/src/main/java/io/bitsquare/trade/BuyerAsOffererTrade.java
View file

@ -20,6 +20,8 @@ package io.bitsquare.trade;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.trade.buyer.offerer.BuyerAsOffererProtocol; import io.bitsquare.trade.protocol.trade.buyer.offerer.BuyerAsOffererProtocol;
import io.bitsquare.trade.states.OffererState;
import io.bitsquare.trade.states.TradeState;
import java.io.IOException; import java.io.IOException;
import java.io.ObjectInputStream; import java.io.ObjectInputStream;
@ -28,23 +30,18 @@ import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererAsBuyerTrade extends Trade implements Serializable { public class BuyerAsOffererTrade extends Trade implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(OffererAsBuyerTrade.class); transient private static final Logger log = LoggerFactory.getLogger(BuyerAsOffererTrade.class);
///////////////////////////////////////////////////////////////////////////////////////////
// Enum
///////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Constructor, initialization // Constructor, initialization
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public OffererAsBuyerTrade(Offer offer, Storage<? extends TradeList> storage) { public BuyerAsOffererTrade(Offer offer, Storage<? extends TradeList> storage) {
super(offer, storage); super(offer, storage);
log.trace("Created by constructor"); log.trace("Created by constructor");
} }
@ -59,7 +56,7 @@ public class OffererAsBuyerTrade extends Trade implements Serializable {
@Override @Override
protected void createProtocol() { protected void createProtocol() {
protocol = new BuyerAsOffererProtocol(this); tradeProtocol = new BuyerAsOffererProtocol(this);
} }
@Override @Override
@ -75,8 +72,8 @@ public class OffererAsBuyerTrade extends Trade implements Serializable {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public void onFiatPaymentStarted() { public void onFiatPaymentStarted() {
assert protocol instanceof BuyerAsOffererProtocol; assert tradeProtocol instanceof BuyerAsOffererProtocol;
((BuyerAsOffererProtocol) protocol).onFiatPaymentStarted(); ((BuyerAsOffererProtocol) tradeProtocol).onFiatPaymentStarted();
} }
@ -85,7 +82,7 @@ public class OffererAsBuyerTrade extends Trade implements Serializable {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override @Override
public void setProcessState(Trade.ProcessState processState) { public void setProcessState(TradeState.ProcessState processState) {
super.setProcessState(processState); super.setProcessState(processState);
switch ((OffererState.ProcessState) processState) { switch ((OffererState.ProcessState) processState) {
@ -97,7 +94,7 @@ public class OffererAsBuyerTrade extends Trade implements Serializable {
} }
@Override @Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) { public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
super.setLifeCycleState(lifeCycleState); super.setLifeCycleState(lifeCycleState);
switch ((OffererState.LifeCycleState) lifeCycleState) { switch ((OffererState.LifeCycleState) lifeCycleState) {

22
core/src/main/java/io/bitsquare/trade/TakerAsBuyerTrade.java → core/src/main/java/io/bitsquare/trade/BuyerAsTakerTrade.java
View file

@ -21,6 +21,8 @@ import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.trade.buyer.taker.BuyerAsTakerProtocol; import io.bitsquare.trade.protocol.trade.buyer.taker.BuyerAsTakerProtocol;
import io.bitsquare.trade.states.TakerState;
import io.bitsquare.trade.states.TradeState;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
@ -30,18 +32,18 @@ import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerAsBuyerTrade extends Trade implements Serializable { public class BuyerAsTakerTrade extends Trade implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(TakerAsBuyerTrade.class); transient private static final Logger log = LoggerFactory.getLogger(BuyerAsTakerTrade.class);
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Constructor, initialization // Constructor, initialization
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public TakerAsBuyerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, public BuyerAsTakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer,
Storage<? extends TradeList> storage) { Storage<? extends TradeList> storage) {
super(offer, tradeAmount, tradingPeer, storage); super(offer, tradeAmount, tradingPeer, storage);
log.trace("Created by constructor"); log.trace("Created by constructor");
@ -64,7 +66,7 @@ public class TakerAsBuyerTrade extends Trade implements Serializable {
@Override @Override
public void createProtocol() { public void createProtocol() {
protocol = new BuyerAsTakerProtocol(this); tradeProtocol = new BuyerAsTakerProtocol(this);
} }
@ -74,13 +76,13 @@ public class TakerAsBuyerTrade extends Trade implements Serializable {
@Override @Override
public void takeAvailableOffer() { public void takeAvailableOffer() {
assert protocol instanceof BuyerAsTakerProtocol; assert tradeProtocol instanceof BuyerAsTakerProtocol;
((BuyerAsTakerProtocol) protocol).takeAvailableOffer(); ((BuyerAsTakerProtocol) tradeProtocol).takeAvailableOffer();
} }
public void onFiatPaymentStarted() { public void onFiatPaymentStarted() {
assert protocol instanceof BuyerAsTakerProtocol; assert tradeProtocol instanceof BuyerAsTakerProtocol;
((BuyerAsTakerProtocol) protocol).onFiatPaymentStarted(); ((BuyerAsTakerProtocol) tradeProtocol).onFiatPaymentStarted();
} }
@ -89,7 +91,7 @@ public class TakerAsBuyerTrade extends Trade implements Serializable {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override @Override
public void setProcessState(Trade.ProcessState processState) { public void setProcessState(TradeState.ProcessState processState) {
super.setProcessState(processState); super.setProcessState(processState);
switch ((TakerState.ProcessState) processState) { switch ((TakerState.ProcessState) processState) {
@ -101,7 +103,7 @@ public class TakerAsBuyerTrade extends Trade implements Serializable {
} }
@Override @Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) { public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
super.setLifeCycleState(lifeCycleState); super.setLifeCycleState(lifeCycleState);
switch ((TakerState.LifeCycleState) lifeCycleState) { switch ((TakerState.LifeCycleState) lifeCycleState) {

18
core/src/main/java/io/bitsquare/trade/OffererAsSellerTrade.java → core/src/main/java/io/bitsquare/trade/SellerAsOffererTrade.java
View file

@ -20,6 +20,8 @@ package io.bitsquare.trade;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.trade.seller.offerer.SellerAsOffererProtocol; import io.bitsquare.trade.protocol.trade.seller.offerer.SellerAsOffererProtocol;
import io.bitsquare.trade.states.OffererState;
import io.bitsquare.trade.states.TradeState;
import java.io.IOException; import java.io.IOException;
import java.io.ObjectInputStream; import java.io.ObjectInputStream;
@ -28,18 +30,18 @@ import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererAsSellerTrade extends Trade implements Serializable { public class SellerAsOffererTrade extends Trade implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(OffererAsSellerTrade.class); transient private static final Logger log = LoggerFactory.getLogger(SellerAsOffererTrade.class);
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Constructor, initialization // Constructor, initialization
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public OffererAsSellerTrade(Offer offer, Storage<? extends TradeList> storage) { public SellerAsOffererTrade(Offer offer, Storage<? extends TradeList> storage) {
super(offer, storage); super(offer, storage);
log.trace("Created by constructor"); log.trace("Created by constructor");
} }
@ -54,7 +56,7 @@ public class OffererAsSellerTrade extends Trade implements Serializable {
@Override @Override
protected void createProtocol() { protected void createProtocol() {
protocol = new SellerAsOffererProtocol(this); tradeProtocol = new SellerAsOffererProtocol(this);
} }
@Override @Override
@ -70,8 +72,8 @@ public class OffererAsSellerTrade extends Trade implements Serializable {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public void onFiatPaymentReceived() { public void onFiatPaymentReceived() {
assert protocol instanceof SellerAsOffererProtocol; assert tradeProtocol instanceof SellerAsOffererProtocol;
((SellerAsOffererProtocol) protocol).onFiatPaymentReceived(); ((SellerAsOffererProtocol) tradeProtocol).onFiatPaymentReceived();
} }
@ -80,7 +82,7 @@ public class OffererAsSellerTrade extends Trade implements Serializable {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override @Override
public void setProcessState(Trade.ProcessState processState) { public void setProcessState(TradeState.ProcessState processState) {
super.setProcessState(processState); super.setProcessState(processState);
switch ((OffererState.ProcessState) processState) { switch ((OffererState.ProcessState) processState) {
@ -92,7 +94,7 @@ public class OffererAsSellerTrade extends Trade implements Serializable {
} }
@Override @Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) { public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
super.setLifeCycleState(lifeCycleState); super.setLifeCycleState(lifeCycleState);
switch ((OffererState.LifeCycleState) lifeCycleState) { switch ((OffererState.LifeCycleState) lifeCycleState) {

20
core/src/main/java/io/bitsquare/trade/TakerAsSellerTrade.java → core/src/main/java/io/bitsquare/trade/SellerAsTakerTrade.java
View file

@ -21,6 +21,8 @@ import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.trade.seller.taker.SellerAsTakerProtocol; import io.bitsquare.trade.protocol.trade.seller.taker.SellerAsTakerProtocol;
import io.bitsquare.trade.states.TakerState;
import io.bitsquare.trade.states.TradeState;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
@ -30,7 +32,7 @@ import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerAsSellerTrade extends Trade implements Serializable { public class SellerAsTakerTrade extends Trade implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -41,7 +43,7 @@ public class TakerAsSellerTrade extends Trade implements Serializable {
// Constructor, initialization // Constructor, initialization
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public TakerAsSellerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, public SellerAsTakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer,
Storage<? extends TradeList> storage) { Storage<? extends TradeList> storage) {
super(offer, tradeAmount, tradingPeer, storage); super(offer, tradeAmount, tradingPeer, storage);
log.trace("Created by constructor"); log.trace("Created by constructor");
@ -64,7 +66,7 @@ public class TakerAsSellerTrade extends Trade implements Serializable {
@Override @Override
public void createProtocol() { public void createProtocol() {
protocol = new SellerAsTakerProtocol(this); tradeProtocol = new SellerAsTakerProtocol(this);
} }
@ -74,13 +76,13 @@ public class TakerAsSellerTrade extends Trade implements Serializable {
@Override @Override
public void takeAvailableOffer() { public void takeAvailableOffer() {
assert protocol instanceof SellerAsTakerProtocol; assert tradeProtocol instanceof SellerAsTakerProtocol;
((SellerAsTakerProtocol) protocol).takeAvailableOffer(); ((SellerAsTakerProtocol) tradeProtocol).takeAvailableOffer();
} }
public void onFiatPaymentReceived() { public void onFiatPaymentReceived() {
assert protocol instanceof SellerAsTakerProtocol; assert tradeProtocol instanceof SellerAsTakerProtocol;
((SellerAsTakerProtocol) protocol).onFiatPaymentReceived(); ((SellerAsTakerProtocol) tradeProtocol).onFiatPaymentReceived();
} }
@ -89,7 +91,7 @@ public class TakerAsSellerTrade extends Trade implements Serializable {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override @Override
public void setProcessState(Trade.ProcessState processState) { public void setProcessState(TradeState.ProcessState processState) {
TakerState.ProcessState state = (TakerState.ProcessState) processState; TakerState.ProcessState state = (TakerState.ProcessState) processState;
this.processState = processState; this.processState = processState;
processStateProperty.set(processState); processStateProperty.set(processState);
@ -103,7 +105,7 @@ public class TakerAsSellerTrade extends Trade implements Serializable {
} }
@Override @Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) { public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
TakerState.LifeCycleState state = (TakerState.LifeCycleState) lifeCycleState; TakerState.LifeCycleState state = (TakerState.LifeCycleState) lifeCycleState;
switch (state) { switch (state) {
case FAILED: case FAILED:

48
core/src/main/java/io/bitsquare/trade/Trade.java
View file

@ -28,8 +28,9 @@ import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.MessageService; import io.bitsquare.p2p.MessageService;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.Protocol; import io.bitsquare.trade.protocol.trade.TradeProtocol;
import io.bitsquare.trade.protocol.trade.shared.models.ProcessModel; import io.bitsquare.trade.protocol.trade.shared.models.ProcessModel;
import io.bitsquare.trade.states.TradeState;
import io.bitsquare.user.User; import io.bitsquare.user.User;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
@ -68,6 +69,7 @@ abstract public class Trade extends Model implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private transient static final Logger log = LoggerFactory.getLogger(Trade.class); private transient static final Logger log = LoggerFactory.getLogger(Trade.class);
// Mutable // Mutable
protected Coin tradeAmount; protected Coin tradeAmount;
protected Peer tradingPeer; protected Peer tradingPeer;
@ -75,27 +77,15 @@ abstract public class Trade extends Model implements Serializable {
transient protected ObjectProperty<Fiat> tradeVolumeProperty; transient protected ObjectProperty<Fiat> tradeVolumeProperty;
///////////////////////////////////////////////////////////////////////////////////////////
// Interfaces
///////////////////////////////////////////////////////////////////////////////////////////
public interface LifeCycleState {
}
public interface ProcessState {
}
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Fields // Fields
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Transient/Immutable // Transient/Immutable
transient protected ObjectProperty<ProcessState> processStateProperty; transient protected ObjectProperty<TradeState.ProcessState> processStateProperty;
transient protected ObjectProperty<LifeCycleState> lifeCycleStateProperty; transient protected ObjectProperty<TradeState.LifeCycleState> lifeCycleStateProperty;
transient private Storage<? extends TradeList> storage; transient private Storage<? extends TradeList> storage;
transient protected Protocol protocol; transient protected TradeProtocol tradeProtocol;
// Immutable // Immutable
protected final Offer offer; protected final Offer offer;
@ -103,8 +93,8 @@ abstract public class Trade extends Model implements Serializable {
protected final ProcessModel processModel; protected final ProcessModel processModel;
// Mutable // Mutable
protected ProcessState processState; protected TradeState.ProcessState processState;
protected LifeCycleState lifeCycleState; protected TradeState.LifeCycleState lifeCycleState;
private MailboxMessage mailboxMessage; private MailboxMessage mailboxMessage;
protected Transaction depositTx; protected Transaction depositTx;
private Contract contract; private Contract contract;
@ -173,7 +163,7 @@ abstract public class Trade extends Model implements Serializable {
createProtocol(); createProtocol();
if (mailboxMessage != null) if (mailboxMessage != null)
protocol.setMailboxMessage(mailboxMessage); tradeProtocol.setMailboxMessage(mailboxMessage);
} }
protected void initStateProperties() { protected void initStateProperties() {
@ -195,16 +185,16 @@ abstract public class Trade extends Model implements Serializable {
} }
public void disposeProtocol() { public void disposeProtocol() {
if (protocol != null) { if (tradeProtocol != null) {
protocol.cleanup(); tradeProtocol.cleanup();
protocol = null; tradeProtocol = null;
} }
} }
public void setMailboxMessage(MailboxMessage mailboxMessage) { public void setMailboxMessage(MailboxMessage mailboxMessage) {
this.mailboxMessage = mailboxMessage; this.mailboxMessage = mailboxMessage;
if (protocol != null) if (tradeProtocol != null)
protocol.setMailboxMessage(mailboxMessage); tradeProtocol.setMailboxMessage(mailboxMessage);
storage.queueUpForSave(); storage.queueUpForSave();
} }
@ -213,13 +203,13 @@ abstract public class Trade extends Model implements Serializable {
this.storage = storage; this.storage = storage;
} }
public void setProcessState(Trade.ProcessState processState) { public void setProcessState(TradeState.ProcessState processState) {
this.processState = processState; this.processState = processState;
processStateProperty.set(processState); processStateProperty.set(processState);
storage.queueUpForSave(); storage.queueUpForSave();
} }
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) { public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
this.lifeCycleState = lifeCycleState; this.lifeCycleState = lifeCycleState;
lifeCycleStateProperty.set(lifeCycleState); lifeCycleStateProperty.set(lifeCycleState);
storage.queueUpForSave(); storage.queueUpForSave();
@ -351,11 +341,11 @@ abstract public class Trade extends Model implements Serializable {
return null; return null;
} }
public ReadOnlyObjectProperty<? extends ProcessState> processStateProperty() { public ReadOnlyObjectProperty<? extends TradeState.ProcessState> processStateProperty() {
return processStateProperty; return processStateProperty;
} }
public ReadOnlyObjectProperty<? extends LifeCycleState> lifeCycleStateProperty() { public ReadOnlyObjectProperty<? extends TradeState.LifeCycleState> lifeCycleStateProperty() {
return lifeCycleStateProperty; return lifeCycleStateProperty;
} }
@ -430,7 +420,7 @@ abstract public class Trade extends Model implements Serializable {
@Override @Override
public String toString() { public String toString() {
return ", protocol=" + protocol + return ", protocol=" + tradeProtocol +
", offer=" + offer + ", offer=" + offer +
", date=" + date + ", date=" + date +
", processModel=" + processModel + ", processModel=" + processModel +

28
core/src/main/java/io/bitsquare/trade/TradeManager.java
View file

@ -43,6 +43,8 @@ import io.bitsquare.trade.protocol.availability.CheckOfferAvailabilityProtocol;
import io.bitsquare.trade.protocol.placeoffer.PlaceOfferModel; import io.bitsquare.trade.protocol.placeoffer.PlaceOfferModel;
import io.bitsquare.trade.protocol.placeoffer.PlaceOfferProtocol; import io.bitsquare.trade.protocol.placeoffer.PlaceOfferProtocol;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.states.OffererState;
import io.bitsquare.trade.states.TakerState;
import io.bitsquare.user.AccountSettings; import io.bitsquare.user.AccountSettings;
import io.bitsquare.user.User; import io.bitsquare.user.User;
@ -168,9 +170,9 @@ public class TradeManager {
// continue the trade, but that might fail. // continue the trade, but that might fail.
boolean failed = false; boolean failed = false;
if (trade instanceof TakerAsSellerTrade) if (trade instanceof SellerAsTakerTrade)
failed = trade.lifeCycleState == TakerState.LifeCycleState.FAILED; failed = trade.lifeCycleState == TakerState.LifeCycleState.FAILED;
else if (trade instanceof TakerAsBuyerTrade) else if (trade instanceof BuyerAsTakerTrade)
failed = trade.lifeCycleState == TakerState.LifeCycleState.FAILED; failed = trade.lifeCycleState == TakerState.LifeCycleState.FAILED;
if (failed) { if (failed) {
@ -278,9 +280,9 @@ public class TradeManager {
private void handlePlaceOfferResult(Transaction transaction, Offer offer, TransactionResultHandler resultHandler) { private void handlePlaceOfferResult(Transaction transaction, Offer offer, TransactionResultHandler resultHandler) {
Trade trade; Trade trade;
if (offer.getDirection() == Offer.Direction.BUY) if (offer.getDirection() == Offer.Direction.BUY)
trade = new OffererAsBuyerTrade(offer, openOfferTradesStorage); trade = new BuyerAsOffererTrade(offer, openOfferTradesStorage);
else else
trade = new OffererAsSellerTrade(offer, openOfferTradesStorage); trade = new SellerAsOffererTrade(offer, openOfferTradesStorage);
openOfferTrades.add(trade); openOfferTrades.add(trade);
initTrade(trade); initTrade(trade);
@ -319,9 +321,9 @@ public class TradeManager {
openOfferTrades.remove(trade); openOfferTrades.remove(trade);
if (isCancelRequest) { if (isCancelRequest) {
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_CANCELED); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_CANCELED);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_CANCELED); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_CANCELED);
closedTrades.add(trade); closedTrades.add(trade);
trade.disposeProtocol(); trade.disposeProtocol();
@ -379,9 +381,9 @@ public class TradeManager {
if (offer.getState() == Offer.State.AVAILABLE) { if (offer.getState() == Offer.State.AVAILABLE) {
Trade trade; Trade trade;
if (offer.getDirection() == Offer.Direction.BUY) if (offer.getDirection() == Offer.Direction.BUY)
trade = new TakerAsSellerTrade(offer, amount, model.getPeer(), pendingTradesStorage); trade = new SellerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
else else
trade = new TakerAsBuyerTrade(offer, amount, model.getPeer(), pendingTradesStorage); trade = new BuyerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
initTrade(trade); initTrade(trade);
pendingTrades.add(trade); pendingTrades.add(trade);
@ -402,7 +404,7 @@ public class TradeManager {
// TODO handle overpaid securityDeposit // TODO handle overpaid securityDeposit
Coin amountToWithdraw = trade.getSecurityDeposit(); Coin amountToWithdraw = trade.getSecurityDeposit();
assert trade.getTradeAmount() != null; assert trade.getTradeAmount() != null;
if (trade instanceof OffererAsBuyerTrade || trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade || trade instanceof BuyerAsTakerTrade)
amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount()); amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount());
FutureCallback<Transaction> callback = new FutureCallback<Transaction>() { FutureCallback<Transaction> callback = new FutureCallback<Transaction>() {
@ -410,13 +412,13 @@ public class TradeManager {
public void onSuccess(@javax.annotation.Nullable Transaction transaction) { public void onSuccess(@javax.annotation.Nullable Transaction transaction) {
if (transaction != null) { if (transaction != null) {
log.info("onWithdraw onSuccess tx ID:" + transaction.getHashAsString()); log.info("onWithdraw onSuccess tx ID:" + transaction.getHashAsString());
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.COMPLETED); trade.setLifeCycleState(OffererState.LifeCycleState.COMPLETED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setLifeCycleState(TakerState.LifeCycleState.COMPLETED); trade.setLifeCycleState(TakerState.LifeCycleState.COMPLETED);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.COMPLETED); trade.setLifeCycleState(OffererState.LifeCycleState.COMPLETED);
else if (trade instanceof TakerAsBuyerTrade) else if (trade instanceof BuyerAsTakerTrade)
trade.setLifeCycleState(TakerState.LifeCycleState.COMPLETED); trade.setLifeCycleState(TakerState.LifeCycleState.COMPLETED);
pendingTrades.remove(trade); pendingTrades.remove(trade);

4
core/src/main/java/io/bitsquare/trade/protocol/Protocol.java → core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProtocol.java
View file

@ -15,11 +15,11 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>. * along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/ */
package io.bitsquare.trade.protocol; package io.bitsquare.trade.protocol.trade;
import io.bitsquare.p2p.MailboxMessage; import io.bitsquare.p2p.MailboxMessage;
public interface Protocol { public interface TradeProtocol {
void cleanup(); void cleanup();
void setMailboxMessage(MailboxMessage mailboxMessage); void setMailboxMessage(MailboxMessage mailboxMessage);

8
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerTradeTask.java → core/src/main/java/io/bitsquare/trade/protocol/trade/TradeTask.java
View file

@ -15,7 +15,7 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>. * along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/ */
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade;
import io.bitsquare.common.taskrunner.Task; import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
@ -25,12 +25,12 @@ import io.bitsquare.trade.protocol.trade.shared.models.ProcessModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerTradeTask extends Task<Trade> { public class TradeTask extends Task<Trade> {
private static final Logger log = LoggerFactory.getLogger(TakerTradeTask.class); private static final Logger log = LoggerFactory.getLogger(TradeTask.class);
protected final ProcessModel processModel; protected final ProcessModel processModel;
protected final Trade trade; protected final Trade trade;
public TakerTradeTask(TaskRunner taskHandler, Trade trade) { public TradeTask(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade); super(taskHandler, trade);
this.trade = trade; this.trade = trade;

32
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/BuyerAsOffererProtocol.java
View file

@ -23,11 +23,10 @@ import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.MessageHandler; import io.bitsquare.p2p.MessageHandler;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.protocol.availability.messages.ReportOfferAvailabilityMessage; import io.bitsquare.trade.protocol.availability.messages.ReportOfferAvailabilityMessage;
import io.bitsquare.trade.protocol.availability.messages.RequestIsOfferAvailableMessage; import io.bitsquare.trade.protocol.availability.messages.RequestIsOfferAvailableMessage;
import io.bitsquare.trade.protocol.trade.TradeProtocol;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererCommitsPayoutTx; import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererCommitsPayoutTx;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererCreatesAndSignPayoutTx; import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererCreatesAndSignPayoutTx;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererCreatesDepositTxInputs; import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererCreatesDepositTxInputs;
@ -46,27 +45,28 @@ import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.shared.models.ProcessModel; import io.bitsquare.trade.protocol.trade.shared.models.ProcessModel;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakeOfferFeePayment; import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakeOfferFeePayment;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakerAccount; import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakerAccount;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class BuyerAsOffererProtocol implements Protocol { public class BuyerAsOffererProtocol implements TradeProtocol {
private static final Logger log = LoggerFactory.getLogger(BuyerAsOffererProtocol.class); private static final Logger log = LoggerFactory.getLogger(BuyerAsOffererProtocol.class);
private MessageHandler messageHandler; private MessageHandler messageHandler;
private final OffererAsBuyerTrade offererAsBuyerTrade; private final BuyerAsOffererTrade buyerAsOffererTrade;
private final ProcessModel processModel; private final ProcessModel processModel;
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public BuyerAsOffererProtocol(OffererAsBuyerTrade model) { public BuyerAsOffererProtocol(BuyerAsOffererTrade model) {
log.debug("New OffererProtocol " + this); log.debug("New OffererProtocol " + this);
this.offererAsBuyerTrade = model; this.buyerAsOffererTrade = model;
processModel = offererAsBuyerTrade.getProcessModel(); processModel = buyerAsOffererTrade.getProcessModel();
messageHandler = this::handleMessage; messageHandler = this::handleMessage;
processModel.getMessageService().addMessageHandler(messageHandler); processModel.getMessageService().addMessageHandler(messageHandler);
@ -110,7 +110,7 @@ public class BuyerAsOffererProtocol implements Protocol {
// to take the // to take the
// offer // offer
// at the same time // at the same time
boolean isOfferOpen = offererAsBuyerTrade.lifeCycleStateProperty().get() == OffererState.LifeCycleState.OFFER_OPEN; boolean isOfferOpen = buyerAsOffererTrade.lifeCycleStateProperty().get() == OffererState.LifeCycleState.OFFER_OPEN;
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(processModel.getId(), isOfferOpen); ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(processModel.getId(), isOfferOpen);
processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() { processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@Override @Override
@ -135,11 +135,11 @@ public class BuyerAsOffererProtocol implements Protocol {
private void handleRequestDepositTxInputsMessage(RequestDepositTxInputsMessage tradeMessage, Peer taker) { private void handleRequestDepositTxInputsMessage(RequestDepositTxInputsMessage tradeMessage, Peer taker) {
checkTradeId(processModel.getId(), tradeMessage); checkTradeId(processModel.getId(), tradeMessage);
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
offererAsBuyerTrade.setTradingPeer(taker); buyerAsOffererTrade.setTradingPeer(taker);
offererAsBuyerTrade.setLifeCycleState(OffererState.LifeCycleState.OFFER_RESERVED); buyerAsOffererTrade.setLifeCycleState(OffererState.LifeCycleState.OFFER_RESERVED);
TaskRunner<OffererAsBuyerTrade> taskRunner = new TaskRunner<>(offererAsBuyerTrade, TaskRunner<BuyerAsOffererTrade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> log.debug("taskRunner at handleRequestDepositTxInputsMessage completed"), () -> log.debug("taskRunner at handleRequestDepositTxInputsMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
@ -153,7 +153,7 @@ public class BuyerAsOffererProtocol implements Protocol {
private void handleRequestPublishDepositTxMessage(RequestPublishDepositTxMessage tradeMessage) { private void handleRequestPublishDepositTxMessage(RequestPublishDepositTxMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsBuyerTrade> taskRunner = new TaskRunner<>(offererAsBuyerTrade, TaskRunner<BuyerAsOffererTrade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"), () -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
@ -173,7 +173,7 @@ public class BuyerAsOffererProtocol implements Protocol {
// User clicked the "bank transfer started" button // User clicked the "bank transfer started" button
public void onFiatPaymentStarted() { public void onFiatPaymentStarted() {
TaskRunner<OffererAsBuyerTrade> taskRunner = new TaskRunner<>(offererAsBuyerTrade, TaskRunner<BuyerAsOffererTrade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"), () -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
@ -192,7 +192,7 @@ public class BuyerAsOffererProtocol implements Protocol {
private void handlePayoutTxPublishedMessage(PayoutTxPublishedMessage tradeMessage) { private void handlePayoutTxPublishedMessage(PayoutTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsBuyerTrade> taskRunner = new TaskRunner<>(offererAsBuyerTrade, TaskRunner<BuyerAsOffererTrade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> { () -> {
log.debug("taskRunner at handlePayoutTxPublishedMessage completed"); log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
// we are done! // we are done!
@ -216,7 +216,7 @@ public class BuyerAsOffererProtocol implements Protocol {
TradeMessage tradeMessage = (TradeMessage) message; TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId); nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(offererAsBuyerTrade.getId())) { if (tradeMessage.tradeId.equals(buyerAsOffererTrade.getId())) {
if (tradeMessage instanceof RequestIsOfferAvailableMessage) { if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
handleRequestIsOfferAvailableMessage((RequestIsOfferAvailableMessage) tradeMessage, sender); handleRequestIsOfferAvailableMessage((RequestIsOfferAvailableMessage) tradeMessage, sender);
} }

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererCommitsPayoutTx.java
View file

@ -19,14 +19,14 @@ package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererCommitsPayoutTx extends OffererTradeTask { public class OffererCommitsPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCommitsPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(OffererCommitsPayoutTx.class);
public OffererCommitsPayoutTx(TaskRunner taskHandler, Trade trade) { public OffererCommitsPayoutTx(TaskRunner taskHandler, Trade trade) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererCreatesAndSignPayoutTx.java
View file

@ -19,14 +19,14 @@ package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererCreatesAndSignPayoutTx extends OffererTradeTask { public class OffererCreatesAndSignPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignPayoutTx.class);
public OffererCreatesAndSignPayoutTx(TaskRunner taskHandler, Trade trade) { public OffererCreatesAndSignPayoutTx(TaskRunner taskHandler, Trade trade) {

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererCreatesDepositTxInputs.java
View file

@ -20,18 +20,18 @@ package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.btc.FeePolicy; import io.bitsquare.btc.FeePolicy;
import io.bitsquare.btc.TradeWalletService; import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.OffererState;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererCreatesDepositTxInputs extends OffererTradeTask { public class OffererCreatesDepositTxInputs extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesDepositTxInputs.class); private static final Logger log = LoggerFactory.getLogger(OffererCreatesDepositTxInputs.class);
public OffererCreatesDepositTxInputs(TaskRunner taskHandler, Trade trade) { public OffererCreatesDepositTxInputs(TaskRunner taskHandler, Trade trade) {
@ -54,10 +54,10 @@ public class OffererCreatesDepositTxInputs extends OffererTradeTask {
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade) { if (trade instanceof BuyerAsOffererTrade) {
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
} }
else if (trade instanceof OffererAsSellerTrade) { else if (trade instanceof SellerAsOffererTrade) {
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
} }

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererProcessPayoutTxPublishedMessage.java
View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks; package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.checkTradeId; import static io.bitsquare.util.Validator.checkTradeId;
public class OffererProcessPayoutTxPublishedMessage extends OffererTradeTask { public class OffererProcessPayoutTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessPayoutTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessPayoutTxPublishedMessage.class);
public OffererProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) { public OffererProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -47,9 +47,9 @@ public class OffererProcessPayoutTxPublishedMessage extends OffererTradeTask {
trade.setPayoutTx(checkNotNull(message.payoutTx)); trade.setPayoutTx(checkNotNull(message.payoutTx));
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED);
complete(); complete();

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererProcessRequestDepositTxInputsMessage.java
View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks; package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class OffererProcessRequestDepositTxInputsMessage extends OffererTradeTask { public class OffererProcessRequestDepositTxInputsMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestDepositTxInputsMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestDepositTxInputsMessage.class);
public OffererProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) { public OffererProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) {
@ -54,9 +54,9 @@ public class OffererProcessRequestDepositTxInputsMessage extends OffererTradeTas
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererProcessRequestPublishDepositTxMessage.java
View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks; package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*; import static com.google.common.base.Preconditions.*;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class OffererProcessRequestPublishDepositTxMessage extends OffererTradeTask { public class OffererProcessRequestPublishDepositTxMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestPublishDepositTxMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestPublishDepositTxMessage.class);
public OffererProcessRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) { public OffererProcessRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) {
@ -61,9 +61,9 @@ public class OffererProcessRequestPublishDepositTxMessage extends OffererTradeTa
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererSendsDepositTxPublishedMessage.java
View file

@ -19,17 +19,17 @@ package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererSendsDepositTxPublishedMessage extends OffererTradeTask { public class OffererSendsDepositTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsDepositTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererSendsDepositTxPublishedMessage.class);
public OffererSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) { public OffererSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -53,9 +53,9 @@ public class OffererSendsDepositTxPublishedMessage extends OffererTradeTask {
appendToErrorMessage("Sending DepositTxPublishedMessage failed"); appendToErrorMessage("Sending DepositTxPublishedMessage failed");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();

26
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererSendsFiatTransferStartedMessage.java
View file

@ -19,17 +19,17 @@ package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask { public class OffererSendsFiatTransferStartedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsFiatTransferStartedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererSendsFiatTransferStartedMessage.class);
public OffererSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) { public OffererSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
@ -53,11 +53,11 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
public void handleResult() { public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded."); log.trace("Sending FiatTransferStartedMessage succeeded.");
if (trade instanceof OffererAsBuyerTrade) { if (trade instanceof BuyerAsOffererTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED); ((BuyerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
} }
else if (trade instanceof OffererAsSellerTrade) { else if (trade instanceof SellerAsOffererTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED); ((SellerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
} }
complete(); complete();
@ -68,11 +68,11 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
appendToErrorMessage("Sending FiatTransferStartedMessage failed"); appendToErrorMessage("Sending FiatTransferStartedMessage failed");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade) { if (trade instanceof BuyerAsOffererTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); ((BuyerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
} }
else if (trade instanceof OffererAsSellerTrade) { else if (trade instanceof SellerAsOffererTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); ((SellerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
} }
failed(); failed();

34
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererSendsRequestSellerDepositPaymentMessage.java
View file

@ -19,17 +19,17 @@ package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTradeTask { public class OffererSendsRequestSellerDepositPaymentMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestSellerDepositPaymentMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestSellerDepositPaymentMessage.class);
public OffererSendsRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade trade) { public OffererSendsRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade trade) {
@ -60,13 +60,13 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed"); appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade) { if (trade instanceof BuyerAsOffererTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); ((BuyerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsBuyerTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); ((BuyerAsOffererTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
} }
else if (trade instanceof OffererAsSellerTrade) { else if (trade instanceof SellerAsOffererTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); ((SellerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); ((SellerAsOffererTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
} }
failed(); failed();
@ -76,13 +76,13 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade) { if (trade instanceof BuyerAsOffererTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); ((BuyerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); ((SellerAsOffererTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
} }
else if (trade instanceof OffererAsSellerTrade) { else if (trade instanceof SellerAsOffererTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); ((SellerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); ((SellerAsOffererTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
} }
failed(t); failed(t);

22
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererSignsAndPublishDepositTx.java
View file

@ -19,11 +19,11 @@ package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.btc.FeePolicy; import io.bitsquare.btc.FeePolicy;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.OffererState;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -35,7 +35,7 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererSignsAndPublishDepositTx extends OffererTradeTask { public class OffererSignsAndPublishDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishDepositTx.class); private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishDepositTx.class);
public OffererSignsAndPublishDepositTx(TaskRunner taskHandler, Trade trade) { public OffererSignsAndPublishDepositTx(TaskRunner taskHandler, Trade trade) {
@ -63,11 +63,11 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
trade.setDepositTx(transaction); trade.setDepositTx(transaction);
if (trade instanceof OffererAsBuyerTrade) { if (trade instanceof BuyerAsOffererTrade) {
trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(OffererState.LifeCycleState.PENDING); trade.setLifeCycleState(OffererState.LifeCycleState.PENDING);
} }
else if (trade instanceof OffererAsSellerTrade) { else if (trade instanceof SellerAsOffererTrade) {
trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(OffererState.LifeCycleState.PENDING); trade.setLifeCycleState(OffererState.LifeCycleState.PENDING);
} }
@ -80,9 +80,9 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);
@ -92,9 +92,9 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererVerifiesAndSignsContract.java
View file

@ -18,18 +18,18 @@
package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks; package io.bitsquare.trade.protocol.trade.buyer.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.Contract; import io.bitsquare.trade.Contract;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.OffererState;
import io.bitsquare.util.Utilities; import io.bitsquare.util.Utilities;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererVerifiesAndSignsContract extends OffererTradeTask { public class OffererVerifiesAndSignsContract extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererVerifiesAndSignsContract.class); private static final Logger log = LoggerFactory.getLogger(OffererVerifiesAndSignsContract.class);
public OffererVerifiesAndSignsContract(TaskRunner taskHandler, Trade trade) { public OffererVerifiesAndSignsContract(TaskRunner taskHandler, Trade trade) {
@ -63,9 +63,9 @@ public class OffererVerifiesAndSignsContract extends OffererTradeTask {
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);

20
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/BuyerAsTakerProtocol.java
View file

@ -22,8 +22,8 @@ import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.Message; import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.MessageHandler; import io.bitsquare.p2p.MessageHandler;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.protocol.Protocol; import io.bitsquare.trade.protocol.trade.TradeProtocol;
import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerCommitsPayoutTx; import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerCommitsPayoutTx;
import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerCreatesAndSignsPayoutTx; import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerCreatesAndSignsPayoutTx;
import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerCreatesDepositTxInputs; import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerCreatesDepositTxInputs;
@ -48,10 +48,10 @@ import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.nonEmptyStringOf; import static io.bitsquare.util.Validator.nonEmptyStringOf;
public class BuyerAsTakerProtocol implements Protocol { public class BuyerAsTakerProtocol implements TradeProtocol {
private static final Logger log = LoggerFactory.getLogger(BuyerAsTakerProtocol.class); private static final Logger log = LoggerFactory.getLogger(BuyerAsTakerProtocol.class);
private final TakerAsBuyerTrade takerAsBuyerTrade; private final BuyerAsTakerTrade buyerAsTakerTrade;
private final ProcessModel processModel; private final ProcessModel processModel;
private final MessageHandler messageHandler; private final MessageHandler messageHandler;
@ -60,9 +60,9 @@ public class BuyerAsTakerProtocol implements Protocol {
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public BuyerAsTakerProtocol(TakerAsBuyerTrade trade) { public BuyerAsTakerProtocol(BuyerAsTakerTrade trade) {
log.debug("New SellerAsTakerProtocol " + this); log.debug("New SellerAsTakerProtocol " + this);
this.takerAsBuyerTrade = trade; this.buyerAsTakerTrade = trade;
processModel = trade.getProcessModel(); processModel = trade.getProcessModel();
messageHandler = this::handleMessage; messageHandler = this::handleMessage;
@ -94,7 +94,7 @@ public class BuyerAsTakerProtocol implements Protocol {
} }
public void takeAvailableOffer() { public void takeAvailableOffer() {
TaskRunner<TakerAsBuyerTrade> taskRunner = new TaskRunner<>(takerAsBuyerTrade, TaskRunner<BuyerAsTakerTrade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> log.debug("taskRunner at takeAvailableOffer completed"), () -> log.debug("taskRunner at takeAvailableOffer completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
@ -115,7 +115,7 @@ public class BuyerAsTakerProtocol implements Protocol {
private void handle(RequestPublishDepositTxMessage tradeMessage) { private void handle(RequestPublishDepositTxMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsBuyerTrade> taskRunner = new TaskRunner<>(takerAsBuyerTrade, TaskRunner<BuyerAsTakerTrade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"), () -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
@ -135,7 +135,7 @@ public class BuyerAsTakerProtocol implements Protocol {
// User clicked the "bank transfer started" button // User clicked the "bank transfer started" button
public void onFiatPaymentStarted() { public void onFiatPaymentStarted() {
TaskRunner<TakerAsBuyerTrade> taskRunner = new TaskRunner<>(takerAsBuyerTrade, TaskRunner<BuyerAsTakerTrade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> log.debug("taskRunner at onFiatPaymentStarted completed"), () -> log.debug("taskRunner at onFiatPaymentStarted completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
@ -154,7 +154,7 @@ public class BuyerAsTakerProtocol implements Protocol {
private void handle(PayoutTxPublishedMessage tradeMessage) { private void handle(PayoutTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsBuyerTrade> taskRunner = new TaskRunner<>(takerAsBuyerTrade, TaskRunner<BuyerAsTakerTrade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> { () -> {
log.debug("taskRunner at handlePayoutTxPublishedMessage completed"); log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
// we are done! // we are done!

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerCommitsPayoutTx.java
View file

@ -19,14 +19,14 @@ package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerCommitsPayoutTx extends TakerTradeTask { public class TakerCommitsPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCommitsPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(TakerCommitsPayoutTx.class);
public TakerCommitsPayoutTx(TaskRunner taskHandler, Trade trade) { public TakerCommitsPayoutTx(TaskRunner taskHandler, Trade trade) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerCreatesAndSignsPayoutTx.java
View file

@ -19,14 +19,14 @@ package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignsPayoutTx extends TakerTradeTask { public class TakerCreatesAndSignsPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsPayoutTx.class);
public TakerCreatesAndSignsPayoutTx(TaskRunner taskHandler, Trade trade) { public TakerCreatesAndSignsPayoutTx(TaskRunner taskHandler, Trade trade) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerCreatesDepositTxInputs.java
View file

@ -21,14 +21,14 @@ import io.bitsquare.btc.FeePolicy;
import io.bitsquare.btc.TradeWalletService; import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerCreatesDepositTxInputs extends TakerTradeTask { public class TakerCreatesDepositTxInputs extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesDepositTxInputs.class); private static final Logger log = LoggerFactory.getLogger(TakerCreatesDepositTxInputs.class);
public TakerCreatesDepositTxInputs(TaskRunner taskHandler, Trade trade) { public TakerCreatesDepositTxInputs(TaskRunner taskHandler, Trade trade) {

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerProcessPayoutTxPublishedMessage.java
View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.trade.buyer.taker.tasks; package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.checkTradeId; import static io.bitsquare.util.Validator.checkTradeId;
public class TakerProcessPayoutTxPublishedMessage extends TakerTradeTask { public class TakerProcessPayoutTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerProcessPayoutTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerProcessPayoutTxPublishedMessage.class);
public TakerProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) { public TakerProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -47,9 +47,9 @@ public class TakerProcessPayoutTxPublishedMessage extends TakerTradeTask {
trade.setPayoutTx(checkNotNull(message.payoutTx)); trade.setPayoutTx(checkNotNull(message.payoutTx));
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED);
complete(); complete();

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerProcessRequestPublishDepositTxFromTakerMessage.java
View file

@ -19,8 +19,8 @@ package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxFromTakerMessage; import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxFromTakerMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -28,7 +28,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*; import static com.google.common.base.Preconditions.*;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class TakerProcessRequestPublishDepositTxFromTakerMessage extends TakerTradeTask { public class TakerProcessRequestPublishDepositTxFromTakerMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerProcessRequestPublishDepositTxFromTakerMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerProcessRequestPublishDepositTxFromTakerMessage.class);
public TakerProcessRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade trade) { public TakerProcessRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade trade) {

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsDepositTxPublishedMessage.java
View file

@ -19,17 +19,17 @@ package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerSendsDepositTxPublishedMessage extends TakerTradeTask { public class TakerSendsDepositTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsDepositTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsDepositTxPublishedMessage.class);
public TakerSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) { public TakerSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -53,9 +53,9 @@ public class TakerSendsDepositTxPublishedMessage extends TakerTradeTask {
appendToErrorMessage("Sending DepositTxPublishedMessage failed"); appendToErrorMessage("Sending DepositTxPublishedMessage failed");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();

20
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsFiatTransferStartedMessage.java
View file

@ -19,17 +19,17 @@ package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask { public class TakerSendsFiatTransferStartedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsFiatTransferStartedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsFiatTransferStartedMessage.class);
public TakerSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) { public TakerSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
@ -53,10 +53,10 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
public void handleResult() { public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded."); log.trace("Sending FiatTransferStartedMessage succeeded.");
if (trade instanceof TakerAsBuyerTrade) { if (trade instanceof BuyerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED);
} }
else if (trade instanceof TakerAsSellerTrade) { else if (trade instanceof SellerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED);
} }
@ -68,10 +68,10 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
appendToErrorMessage("Sending FiatTransferStartedMessage failed"); appendToErrorMessage("Sending FiatTransferStartedMessage failed");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade) { if (trade instanceof BuyerAsTakerTrade) {
((TakerAsBuyerTrade) trade).setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); ((BuyerAsTakerTrade) trade).setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
} }
else if (trade instanceof TakerAsSellerTrade) { else if (trade instanceof SellerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
} }

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsRequestDepositTxInputsMessage.java
View file

@ -19,19 +19,19 @@ package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.states.TakerState;
import javafx.application.Platform; import javafx.application.Platform;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask { public class TakerSendsRequestDepositTxInputsMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestDepositTxInputsMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestDepositTxInputsMessage.class);
public TakerSendsRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) { public TakerSendsRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) {
@ -73,9 +73,9 @@ public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask {
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);

18
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsRequestPayDepositMessage.java
View file

@ -19,17 +19,17 @@ package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositFromOffererMessage; import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositFromOffererMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerSendsRequestPayDepositMessage extends TakerTradeTask { public class TakerSendsRequestPayDepositMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPayDepositMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPayDepositMessage.class);
public TakerSendsRequestPayDepositMessage(TaskRunner taskHandler, Trade trade) { public TakerSendsRequestPayDepositMessage(TaskRunner taskHandler, Trade trade) {
@ -61,9 +61,9 @@ public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed"); appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
@ -73,10 +73,10 @@ public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
if (trade instanceof TakerAsBuyerTrade) { if (trade instanceof BuyerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
} }
else if (trade instanceof TakerAsSellerTrade) { else if (trade instanceof SellerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
} }

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsRequestPublishDepositTxMessage.java
View file

@ -19,17 +19,17 @@ package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask { public class TakerSendsRequestPublishDepositTxMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPublishDepositTxMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPublishDepositTxMessage.class);
public TakerSendsRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) { public TakerSendsRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) {
@ -63,9 +63,9 @@ public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask {
appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed"); appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();

14
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSignsAndPublishDepositTx.java
View file

@ -19,11 +19,11 @@ package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.btc.FeePolicy; import io.bitsquare.btc.FeePolicy;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.TakerState;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -35,7 +35,7 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerSignsAndPublishDepositTx extends TakerTradeTask { public class TakerSignsAndPublishDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishDepositTx.class); private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishDepositTx.class);
public TakerSignsAndPublishDepositTx(TaskRunner taskHandler, Trade trade) { public TakerSignsAndPublishDepositTx(TaskRunner taskHandler, Trade trade) {
@ -63,11 +63,11 @@ public class TakerSignsAndPublishDepositTx extends TakerTradeTask {
trade.setDepositTx(transaction); trade.setDepositTx(transaction);
if (trade instanceof TakerAsBuyerTrade) { if (trade instanceof BuyerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(TakerState.LifeCycleState.PENDING); trade.setLifeCycleState(TakerState.LifeCycleState.PENDING);
} }
else if (trade instanceof TakerAsSellerTrade) { else if (trade instanceof SellerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(TakerState.LifeCycleState.PENDING); trade.setLifeCycleState(TakerState.LifeCycleState.PENDING);
} }

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerVerifiesAndSignsContract.java
View file

@ -20,13 +20,13 @@ package io.bitsquare.trade.protocol.trade.buyer.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Contract; import io.bitsquare.trade.Contract;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.util.Utilities; import io.bitsquare.util.Utilities;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerVerifiesAndSignsContract extends TakerTradeTask { public class TakerVerifiesAndSignsContract extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerVerifiesAndSignsContract.class); private static final Logger log = LoggerFactory.getLogger(TakerVerifiesAndSignsContract.class);
public TakerVerifiesAndSignsContract(TaskRunner taskHandler, Trade trade) { public TakerVerifiesAndSignsContract(TaskRunner taskHandler, Trade trade) {

32
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/SellerAsOffererProtocol.java
View file

@ -23,11 +23,10 @@ import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.MessageHandler; import io.bitsquare.p2p.MessageHandler;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.protocol.availability.messages.ReportOfferAvailabilityMessage; import io.bitsquare.trade.protocol.availability.messages.ReportOfferAvailabilityMessage;
import io.bitsquare.trade.protocol.availability.messages.RequestIsOfferAvailableMessage; import io.bitsquare.trade.protocol.availability.messages.RequestIsOfferAvailableMessage;
import io.bitsquare.trade.protocol.trade.TradeProtocol;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage;
@ -44,27 +43,28 @@ import io.bitsquare.trade.protocol.trade.seller.offerer.tasks.OffererSignsAndPub
import io.bitsquare.trade.protocol.trade.shared.models.ProcessModel; import io.bitsquare.trade.protocol.trade.shared.models.ProcessModel;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakeOfferFeePayment; import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakeOfferFeePayment;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakerAccount; import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakerAccount;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class SellerAsOffererProtocol implements Protocol { public class SellerAsOffererProtocol implements TradeProtocol {
private static final Logger log = LoggerFactory.getLogger(SellerAsOffererProtocol.class); private static final Logger log = LoggerFactory.getLogger(SellerAsOffererProtocol.class);
private final MessageHandler messageHandler; private final MessageHandler messageHandler;
private final OffererAsSellerTrade offererAsSellerTrade; private final SellerAsOffererTrade sellerAsOffererTrade;
private final ProcessModel processModel; private final ProcessModel processModel;
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public SellerAsOffererProtocol(OffererAsSellerTrade model) { public SellerAsOffererProtocol(SellerAsOffererTrade model) {
log.debug("New OffererProtocol " + this); log.debug("New OffererProtocol " + this);
this.offererAsSellerTrade = model; this.sellerAsOffererTrade = model;
processModel = offererAsSellerTrade.getProcessModel(); processModel = sellerAsOffererTrade.getProcessModel();
messageHandler = this::handleMessage; messageHandler = this::handleMessage;
processModel.getMessageService().addMessageHandler(messageHandler); processModel.getMessageService().addMessageHandler(messageHandler);
@ -108,7 +108,7 @@ public class SellerAsOffererProtocol implements Protocol {
// to take the // to take the
// offer // offer
// at the same time // at the same time
boolean isOfferOpen = offererAsSellerTrade.lifeCycleStateProperty().get() == OffererState.LifeCycleState.OFFER_OPEN; boolean isOfferOpen = sellerAsOffererTrade.lifeCycleStateProperty().get() == OffererState.LifeCycleState.OFFER_OPEN;
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(processModel.getId(), isOfferOpen); ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(processModel.getId(), isOfferOpen);
processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() { processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@ -138,9 +138,9 @@ public class SellerAsOffererProtocol implements Protocol {
private void handle(RequestPayDepositMessage tradeMessage, Peer sender) { private void handle(RequestPayDepositMessage tradeMessage, Peer sender) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
offererAsSellerTrade.setTradingPeer(sender); sellerAsOffererTrade.setTradingPeer(sender);
TaskRunner<OffererAsSellerTrade> taskRunner = new TaskRunner<>(offererAsSellerTrade, TaskRunner<SellerAsOffererTrade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
() -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"), () -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
@ -157,7 +157,7 @@ public class SellerAsOffererProtocol implements Protocol {
private void handle(DepositTxPublishedMessage tradeMessage) { private void handle(DepositTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsSellerTrade> taskRunner = new TaskRunner<>(offererAsSellerTrade, TaskRunner<SellerAsOffererTrade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
() -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"), () -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
@ -171,7 +171,7 @@ public class SellerAsOffererProtocol implements Protocol {
private void handle(FiatTransferStartedMessage tradeMessage) { private void handle(FiatTransferStartedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsSellerTrade> taskRunner = new TaskRunner<>(offererAsSellerTrade, TaskRunner<SellerAsOffererTrade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
() -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"), () -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
@ -186,9 +186,9 @@ public class SellerAsOffererProtocol implements Protocol {
// User clicked the "bank transfer received" button, so we release the funds for pay out // User clicked the "bank transfer received" button, so we release the funds for pay out
public void onFiatPaymentReceived() { public void onFiatPaymentReceived() {
offererAsSellerTrade.setProcessState(OffererState.ProcessState.FIAT_PAYMENT_RECEIVED); sellerAsOffererTrade.setProcessState(OffererState.ProcessState.FIAT_PAYMENT_RECEIVED);
TaskRunner<OffererAsSellerTrade> taskRunner = new TaskRunner<>(offererAsSellerTrade, TaskRunner<SellerAsOffererTrade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
() -> { () -> {
log.debug("taskRunner at handleFiatReceivedUIEvent completed"); log.debug("taskRunner at handleFiatReceivedUIEvent completed");
@ -215,7 +215,7 @@ public class SellerAsOffererProtocol implements Protocol {
if (message instanceof TradeMessage) { if (message instanceof TradeMessage) {
TradeMessage tradeMessage = (TradeMessage) message; TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId); nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(offererAsSellerTrade.getId())) { if (tradeMessage.tradeId.equals(sellerAsOffererTrade.getId())) {
if (tradeMessage instanceof RequestIsOfferAvailableMessage) { if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
handle((RequestIsOfferAvailableMessage) tradeMessage, sender); handle((RequestIsOfferAvailableMessage) tradeMessage, sender);
} }

4
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererCommitDepositTx.java
View file

@ -19,14 +19,14 @@ package io.bitsquare.trade.protocol.trade.seller.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererCommitDepositTx extends OffererTradeTask { public class OffererCommitDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCommitDepositTx.class); private static final Logger log = LoggerFactory.getLogger(OffererCommitDepositTx.class);
public OffererCommitDepositTx(TaskRunner taskHandler, Trade trade) { public OffererCommitDepositTx(TaskRunner taskHandler, Trade trade) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererCreatesAndSignsContract.java
View file

@ -20,13 +20,13 @@ package io.bitsquare.trade.protocol.trade.seller.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Contract; import io.bitsquare.trade.Contract;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.util.Utilities; import io.bitsquare.util.Utilities;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererCreatesAndSignsContract extends OffererTradeTask { public class OffererCreatesAndSignsContract extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsContract.class); private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsContract.class);
public OffererCreatesAndSignsContract(TaskRunner taskHandler, Trade trade) { public OffererCreatesAndSignsContract(TaskRunner taskHandler, Trade trade) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererCreatesAndSignsDepositTx.java
View file

@ -21,14 +21,14 @@ import io.bitsquare.btc.FeePolicy;
import io.bitsquare.btc.TradeWalletService; import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererCreatesAndSignsDepositTx extends OffererTradeTask { public class OffererCreatesAndSignsDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsDepositTx.class); private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsDepositTx.class);
public OffererCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade trade) { public OffererCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade trade) {

14
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererProcessDepositTxPublishedMessage.java
View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.trade.seller.offerer.tasks; package io.bitsquare.trade.protocol.trade.seller.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.checkTradeId; import static io.bitsquare.util.Validator.checkTradeId;
public class OffererProcessDepositTxPublishedMessage extends OffererTradeTask { public class OffererProcessDepositTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessDepositTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessDepositTxPublishedMessage.class);
public OffererProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) { public OffererProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -47,9 +47,9 @@ public class OffererProcessDepositTxPublishedMessage extends OffererTradeTask {
trade.setDepositTx(checkNotNull(message.depositTx)); trade.setDepositTx(checkNotNull(message.depositTx));
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED);
complete(); complete();

14
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererProcessFiatTransferStartedMessage.java
View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.trade.seller.offerer.tasks; package io.bitsquare.trade.protocol.trade.seller.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class OffererProcessFiatTransferStartedMessage extends OffererTradeTask { public class OffererProcessFiatTransferStartedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessFiatTransferStartedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessFiatTransferStartedMessage.class);
public OffererProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) { public OffererProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
@ -50,9 +50,9 @@ public class OffererProcessFiatTransferStartedMessage extends OffererTradeTask {
processModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount))); processModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount)));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress)); processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
complete(); complete();

4
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererProcessRequestPayDepositFromOffererMessage.java
View file

@ -19,8 +19,8 @@ package io.bitsquare.trade.protocol.trade.seller.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositFromOffererMessage; import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositFromOffererMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -28,7 +28,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*; import static com.google.common.base.Preconditions.*;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class OffererProcessRequestPayDepositFromOffererMessage extends OffererTradeTask { public class OffererProcessRequestPayDepositFromOffererMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestPayDepositFromOffererMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestPayDepositFromOffererMessage.class);
public OffererProcessRequestPayDepositFromOffererMessage(TaskRunner taskHandler, Trade trade) { public OffererProcessRequestPayDepositFromOffererMessage(TaskRunner taskHandler, Trade trade) {

14
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererSendsPayoutTxPublishedMessage.java
View file

@ -19,17 +19,17 @@ package io.bitsquare.trade.protocol.trade.seller.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererSendsPayoutTxPublishedMessage extends OffererTradeTask { public class OffererSendsPayoutTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsPayoutTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererSendsPayoutTxPublishedMessage.class);
public OffererSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) { public OffererSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -56,9 +56,9 @@ public class OffererSendsPayoutTxPublishedMessage extends OffererTradeTask {
appendToErrorMessage("Sending PayoutTxPublishedMessage failed"); appendToErrorMessage("Sending PayoutTxPublishedMessage failed");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();

14
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererSendsRequestPublishDepositTxFromTakerMessage.java
View file

@ -19,17 +19,17 @@ package io.bitsquare.trade.protocol.trade.seller.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxFromTakerMessage; import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxFromTakerMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererSendsRequestPublishDepositTxFromTakerMessage extends OffererTradeTask { public class OffererSendsRequestPublishDepositTxFromTakerMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestPublishDepositTxFromTakerMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestPublishDepositTxFromTakerMessage.class);
public OffererSendsRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade trade) { public OffererSendsRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade trade) {
@ -64,9 +64,9 @@ public class OffererSendsRequestPublishDepositTxFromTakerMessage extends Offerer
appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed"); appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();

14
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererSignsAndPublishPayoutTx.java
View file

@ -18,11 +18,11 @@
package io.bitsquare.trade.protocol.trade.seller.offerer.tasks; package io.bitsquare.trade.protocol.trade.seller.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.OffererState;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -33,7 +33,7 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererSignsAndPublishPayoutTx extends OffererTradeTask { public class OffererSignsAndPublishPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishPayoutTx.class);
public OffererSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade trade) { public OffererSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade trade) {
@ -58,9 +58,9 @@ public class OffererSignsAndPublishPayoutTx extends OffererTradeTask {
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
processModel.setPayoutTx(transaction); processModel.setPayoutTx(transaction);
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED);
complete(); complete();

26
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/SellerAsTakerProtocol.java
View file

@ -22,10 +22,9 @@ import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.Message; import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.MessageHandler; import io.bitsquare.p2p.MessageHandler;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.Protocol; import io.bitsquare.trade.protocol.trade.TradeProtocol;
import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerSendsRequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerSendsRequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerSendsRequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerSendsRequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
@ -45,16 +44,17 @@ import io.bitsquare.trade.protocol.trade.shared.taker.tasks.BroadcastTakeOfferFe
import io.bitsquare.trade.protocol.trade.shared.taker.tasks.CreateTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.shared.taker.tasks.CreateTakeOfferFeeTx;
import io.bitsquare.trade.protocol.trade.shared.taker.tasks.VerifyOfferFeePayment; import io.bitsquare.trade.protocol.trade.shared.taker.tasks.VerifyOfferFeePayment;
import io.bitsquare.trade.protocol.trade.shared.taker.tasks.VerifyOffererAccount; import io.bitsquare.trade.protocol.trade.shared.taker.tasks.VerifyOffererAccount;
import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.nonEmptyStringOf; import static io.bitsquare.util.Validator.nonEmptyStringOf;
public class SellerAsTakerProtocol implements Protocol { public class SellerAsTakerProtocol implements TradeProtocol {
private static final Logger log = LoggerFactory.getLogger(SellerAsTakerProtocol.class); private static final Logger log = LoggerFactory.getLogger(SellerAsTakerProtocol.class);
private final TakerAsSellerTrade takerAsSellerTrade; private final SellerAsTakerTrade sellerAsTakerTrade;
private final ProcessModel processModel; private final ProcessModel processModel;
private final MessageHandler messageHandler; private final MessageHandler messageHandler;
@ -63,9 +63,9 @@ public class SellerAsTakerProtocol implements Protocol {
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public SellerAsTakerProtocol(TakerAsSellerTrade trade) { public SellerAsTakerProtocol(SellerAsTakerTrade trade) {
log.debug("New SellerAsTakerProtocol " + this); log.debug("New SellerAsTakerProtocol " + this);
this.takerAsSellerTrade = trade; this.sellerAsTakerTrade = trade;
processModel = trade.getProcessModel(); processModel = trade.getProcessModel();
messageHandler = this::handleMessage; messageHandler = this::handleMessage;
@ -97,7 +97,7 @@ public class SellerAsTakerProtocol implements Protocol {
} }
public void takeAvailableOffer() { public void takeAvailableOffer() {
TaskRunner<Trade> taskRunner = new TaskRunner<>(takerAsSellerTrade, TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at takeAvailableOffer completed"), () -> log.debug("taskRunner at takeAvailableOffer completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
@ -117,7 +117,7 @@ public class SellerAsTakerProtocol implements Protocol {
private void handleRequestTakerDepositPaymentMessage(RequestPayDepositMessage tradeMessage) { private void handleRequestTakerDepositPaymentMessage(RequestPayDepositMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(takerAsSellerTrade, TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"), () -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
@ -134,7 +134,7 @@ public class SellerAsTakerProtocol implements Protocol {
private void handleDepositTxPublishedMessage(DepositTxPublishedMessage tradeMessage) { private void handleDepositTxPublishedMessage(DepositTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsSellerTrade> taskRunner = new TaskRunner<>(takerAsSellerTrade, TaskRunner<SellerAsTakerTrade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"), () -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
@ -148,7 +148,7 @@ public class SellerAsTakerProtocol implements Protocol {
private void handleFiatTransferStartedMessage(FiatTransferStartedMessage tradeMessage) { private void handleFiatTransferStartedMessage(FiatTransferStartedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsSellerTrade> taskRunner = new TaskRunner<>(takerAsSellerTrade, TaskRunner<SellerAsTakerTrade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"), () -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
@ -163,9 +163,9 @@ public class SellerAsTakerProtocol implements Protocol {
// User clicked the "bank transfer received" button, so we release the funds for pay out // User clicked the "bank transfer received" button, so we release the funds for pay out
public void onFiatPaymentReceived() { public void onFiatPaymentReceived() {
takerAsSellerTrade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_RECEIVED); sellerAsTakerTrade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_RECEIVED);
TaskRunner<TakerAsSellerTrade> taskRunner = new TaskRunner<>(takerAsSellerTrade, TaskRunner<SellerAsTakerTrade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> { () -> {
log.debug("taskRunner at handleFiatReceivedUIEvent completed"); log.debug("taskRunner at handleFiatReceivedUIEvent completed");

4
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerCommitDepositTx.java
View file

@ -19,14 +19,14 @@ package io.bitsquare.trade.protocol.trade.seller.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerCommitDepositTx extends TakerTradeTask { public class TakerCommitDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCommitDepositTx.class); private static final Logger log = LoggerFactory.getLogger(TakerCommitDepositTx.class);
public TakerCommitDepositTx(TaskRunner taskHandler, Trade trade) { public TakerCommitDepositTx(TaskRunner taskHandler, Trade trade) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerCreatesAndSignContract.java
View file

@ -20,13 +20,13 @@ package io.bitsquare.trade.protocol.trade.seller.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Contract; import io.bitsquare.trade.Contract;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.util.Utilities; import io.bitsquare.util.Utilities;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignContract extends TakerTradeTask { public class TakerCreatesAndSignContract extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignContract.class); private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignContract.class);
public TakerCreatesAndSignContract(TaskRunner taskHandler, Trade trade) { public TakerCreatesAndSignContract(TaskRunner taskHandler, Trade trade) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerCreatesAndSignsDepositTx.java
View file

@ -21,14 +21,14 @@ import io.bitsquare.btc.FeePolicy;
import io.bitsquare.btc.TradeWalletService; import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignsDepositTx extends TakerTradeTask { public class TakerCreatesAndSignsDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsDepositTx.class); private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsDepositTx.class);
public TakerCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade trade) { public TakerCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade trade) {

14
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerProcessDepositTxPublishedMessage.java
View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.trade.seller.taker.tasks; package io.bitsquare.trade.protocol.trade.seller.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.checkTradeId; import static io.bitsquare.util.Validator.checkTradeId;
public class TakerProcessDepositTxPublishedMessage extends TakerTradeTask { public class TakerProcessDepositTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerProcessDepositTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerProcessDepositTxPublishedMessage.class);
public TakerProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) { public TakerProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -47,9 +47,9 @@ public class TakerProcessDepositTxPublishedMessage extends TakerTradeTask {
trade.setDepositTx(checkNotNull(message.depositTx)); trade.setDepositTx(checkNotNull(message.depositTx));
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED);
complete(); complete();

14
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerProcessFiatTransferStartedMessage.java
View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.trade.seller.taker.tasks; package io.bitsquare.trade.protocol.trade.seller.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class TakerProcessFiatTransferStartedMessage extends TakerTradeTask { public class TakerProcessFiatTransferStartedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerProcessFiatTransferStartedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerProcessFiatTransferStartedMessage.class);
public TakerProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) { public TakerProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
@ -50,9 +50,9 @@ public class TakerProcessFiatTransferStartedMessage extends TakerTradeTask {
processModel.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.sellerPayoutAmount))); processModel.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.sellerPayoutAmount)));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress)); processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED);
complete(); complete();

4
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerProcessRequestSellerDepositPaymentMessage.java
View file

@ -19,8 +19,8 @@ package io.bitsquare.trade.protocol.trade.seller.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -28,7 +28,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*; import static com.google.common.base.Preconditions.*;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class TakerProcessRequestSellerDepositPaymentMessage extends TakerTradeTask { public class TakerProcessRequestSellerDepositPaymentMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerProcessRequestSellerDepositPaymentMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerProcessRequestSellerDepositPaymentMessage.class);
public TakerProcessRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade trade) { public TakerProcessRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade trade) {

14
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerSendsPayoutTxPublishedMessage.java
View file

@ -19,17 +19,17 @@ package io.bitsquare.trade.protocol.trade.seller.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerSendsPayoutTxPublishedMessage extends TakerTradeTask { public class TakerSendsPayoutTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsPayoutTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsPayoutTxPublishedMessage.class);
public TakerSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) { public TakerSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -56,9 +56,9 @@ public class TakerSendsPayoutTxPublishedMessage extends TakerTradeTask {
appendToErrorMessage("Sending PayoutTxPublishedMessage failed"); appendToErrorMessage("Sending PayoutTxPublishedMessage failed");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();

14
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerSignsAndPublishPayoutTx.java
View file

@ -18,11 +18,11 @@
package io.bitsquare.trade.protocol.trade.seller.taker.tasks; package io.bitsquare.trade.protocol.trade.seller.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.TakerState;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -33,7 +33,7 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerSignsAndPublishPayoutTx extends TakerTradeTask { public class TakerSignsAndPublishPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishPayoutTx.class);
public TakerSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade trade) { public TakerSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade trade) {
@ -58,9 +58,9 @@ public class TakerSignsAndPublishPayoutTx extends TakerTradeTask {
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
processModel.setPayoutTx(transaction); processModel.setPayoutTx(transaction);
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED);
complete(); complete();

4
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/offerer/tasks/VerifyTakeOfferFeePayment.java
View file

@ -19,12 +19,12 @@ package io.bitsquare.trade.protocol.trade.shared.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class VerifyTakeOfferFeePayment extends OffererTradeTask { public class VerifyTakeOfferFeePayment extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyTakeOfferFeePayment.class); private static final Logger log = LoggerFactory.getLogger(VerifyTakeOfferFeePayment.class);
public VerifyTakeOfferFeePayment(TaskRunner taskHandler, Trade trade) { public VerifyTakeOfferFeePayment(TaskRunner taskHandler, Trade trade) {

18
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/offerer/tasks/VerifyTakerAccount.java
View file

@ -18,16 +18,16 @@
package io.bitsquare.trade.protocol.trade.shared.offerer.tasks; package io.bitsquare.trade.protocol.trade.shared.offerer.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.OffererAsSellerTrade; import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class VerifyTakerAccount extends OffererTradeTask { public class VerifyTakerAccount extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyTakerAccount.class); private static final Logger log = LoggerFactory.getLogger(VerifyTakerAccount.class);
public VerifyTakerAccount(TaskRunner taskHandler, Trade trade) { public VerifyTakerAccount(TaskRunner taskHandler, Trade trade) {
@ -53,18 +53,18 @@ public class VerifyTakerAccount extends OffererTradeTask {
else { else {
failed("Account registration validation for peer failed."); failed("Account registration validation for peer failed.");
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
} }
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade) if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade) else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);

18
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/taker/tasks/BroadcastTakeOfferFeeTx.java
View file

@ -18,11 +18,11 @@
package io.bitsquare.trade.protocol.trade.shared.taker.tasks; package io.bitsquare.trade.protocol.trade.shared.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.TakerState;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -33,7 +33,7 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class BroadcastTakeOfferFeeTx extends TakerTradeTask { public class BroadcastTakeOfferFeeTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(BroadcastTakeOfferFeeTx.class); private static final Logger log = LoggerFactory.getLogger(BroadcastTakeOfferFeeTx.class);
public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, Trade trade) { public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, Trade trade) {
@ -49,9 +49,9 @@ public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString()); log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString());
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISHED); trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISHED); trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
complete(); complete();
} }
@ -62,9 +62,9 @@ public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again."); appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again.");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED); trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED); trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
failed(t); failed(t);

14
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/taker/tasks/CreateTakeOfferFeeTx.java
View file

@ -18,18 +18,18 @@
package io.bitsquare.trade.protocol.trade.shared.taker.tasks; package io.bitsquare.trade.protocol.trade.shared.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.TakerAsSellerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.TakerState;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class CreateTakeOfferFeeTx extends TakerTradeTask { public class CreateTakeOfferFeeTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateTakeOfferFeeTx.class); private static final Logger log = LoggerFactory.getLogger(CreateTakeOfferFeeTx.class);
public CreateTakeOfferFeeTx(TaskRunner taskHandler, Trade trade) { public CreateTakeOfferFeeTx(TaskRunner taskHandler, Trade trade) {
@ -43,9 +43,9 @@ public class CreateTakeOfferFeeTx extends TakerTradeTask {
processModel.setTakeOfferFeeTx(createTakeOfferFeeTx); processModel.setTakeOfferFeeTx(createTakeOfferFeeTx);
if (trade instanceof TakerAsBuyerTrade) if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_TX_CREATED); trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
else if (trade instanceof TakerAsSellerTrade) else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_TX_CREATED); trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
complete(); complete();

4
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/taker/tasks/VerifyOfferFeePayment.java
View file

@ -19,12 +19,12 @@ package io.bitsquare.trade.protocol.trade.shared.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class VerifyOfferFeePayment extends TakerTradeTask { public class VerifyOfferFeePayment extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyOfferFeePayment.class); private static final Logger log = LoggerFactory.getLogger(VerifyOfferFeePayment.class);
public VerifyOfferFeePayment(TaskRunner taskHandler, Trade trade) { public VerifyOfferFeePayment(TaskRunner taskHandler, Trade trade) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/taker/tasks/VerifyOffererAccount.java
View file

@ -19,12 +19,12 @@ package io.bitsquare.trade.protocol.trade.shared.taker.tasks;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class VerifyOffererAccount extends TakerTradeTask { public class VerifyOffererAccount extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyOffererAccount.class); private static final Logger log = LoggerFactory.getLogger(VerifyOffererAccount.class);
public VerifyOffererAccount(TaskRunner taskHandler, Trade trade) { public VerifyOffererAccount(TaskRunner taskHandler, Trade trade) {

6
core/src/main/java/io/bitsquare/trade/OffererState.java → core/src/main/java/io/bitsquare/trade/states/OffererState.java
View file

@ -15,7 +15,7 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>. * along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/ */
package io.bitsquare.trade; package io.bitsquare.trade.states;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -23,7 +23,7 @@ import org.slf4j.LoggerFactory;
public class OffererState { public class OffererState {
private static final Logger log = LoggerFactory.getLogger(OffererState.class); private static final Logger log = LoggerFactory.getLogger(OffererState.class);
public enum LifeCycleState implements Trade.LifeCycleState { public enum LifeCycleState implements TradeState.LifeCycleState {
OFFER_OPEN, OFFER_OPEN,
OFFER_RESERVED, OFFER_RESERVED,
OFFER_CANCELED, OFFER_CANCELED,
@ -32,7 +32,7 @@ public class OffererState {
FAILED FAILED
} }
public enum ProcessState implements Trade.ProcessState { public enum ProcessState implements TradeState.ProcessState {
UNDEFINED, UNDEFINED,
DEPOSIT_PUBLISHED, DEPOSIT_PUBLISHED,
DEPOSIT_CONFIRMED, DEPOSIT_CONFIRMED,

6
core/src/main/java/io/bitsquare/trade/TakerState.java → core/src/main/java/io/bitsquare/trade/states/TakerState.java
View file

@ -15,7 +15,7 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>. * along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/ */
package io.bitsquare.trade; package io.bitsquare.trade.states;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -23,13 +23,13 @@ import org.slf4j.LoggerFactory;
public class TakerState { public class TakerState {
private static final Logger log = LoggerFactory.getLogger(TakerState.class); private static final Logger log = LoggerFactory.getLogger(TakerState.class);
public enum LifeCycleState implements Trade.LifeCycleState { public enum LifeCycleState implements TradeState.LifeCycleState {
PENDING, PENDING,
COMPLETED, COMPLETED,
FAILED FAILED
} }
public enum ProcessState implements Trade.ProcessState { public enum ProcessState implements TradeState.ProcessState {
UNDEFINED, UNDEFINED,
TAKE_OFFER_FEE_TX_CREATED, TAKE_OFFER_FEE_TX_CREATED,
TAKE_OFFER_FEE_PUBLISHED, TAKE_OFFER_FEE_PUBLISHED,

22
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/OffererTradeTask.java → core/src/main/java/io/bitsquare/trade/states/TradeState.java
View file

@ -15,29 +15,17 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>. * along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/ */
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.states;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.shared.models.ProcessModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererTradeTask extends Task<Trade> { public class TradeState {
private static final Logger log = LoggerFactory.getLogger(OffererTradeTask.class); private static final Logger log = LoggerFactory.getLogger(TradeState.class);
protected final ProcessModel processModel;
protected final Trade trade;
public OffererTradeTask(TaskRunner taskHandler, Trade trade) { public interface LifeCycleState {
super(taskHandler, trade);
this.trade = trade;
processModel = trade.getProcessModel();
} }
@Override public interface ProcessState {
protected void doRun() {
} }
} }