Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-04-20 23:56:30 -04:00
Code Issues Packages Projects Releases 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
Show Stats 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.ViewModel;
import io.bitsquare.gui.util.BSFormatter;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.states.OffererState;
import io.bitsquare.trade.states.TakerState;
import io.bitsquare.trade.states.TradeState;
import com.google.inject.Inject;
@ -70,7 +70,7 @@ class ClosedTradesViewModel extends ActivatableWithDataModel<ClosedTradesDataMod
String getState(ClosedTradesListItem item) {
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) {
switch ((TakerState.LifeCycleState) lifeCycleState) {
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.gui.components.Popups;
import io.bitsquare.offer.Offer;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.Contract;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.TradeManager;
import io.bitsquare.trade.states.TradeState;
import io.bitsquare.user.User;
import org.bitcoinj.core.Coin;
@ -68,10 +69,10 @@ class PendingTradesDataModel implements Activatable, DataModel {
final StringProperty txId = new SimpleStringProperty();
final IntegerProperty selectedIndex = new SimpleIntegerProperty(-1);
final ObjectProperty<Trade.ProcessState> takerAsSellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<Trade.ProcessState> offererAsBuyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<Trade.ProcessState> takerAsBuyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<Trade.ProcessState> offererAsSellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> takerAsSellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> offererAsBuyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> takerAsBuyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> offererAsSellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<Trade> currentTrade = new SimpleObjectProperty<>();
@ -135,13 +136,13 @@ class PendingTradesDataModel implements Activatable, DataModel {
Trade trade = item.getTrade();
isOfferer = trade.getOffer().getP2PSigPubKey().equals(user.getP2PSigPubKey());
if (trade instanceof TakerAsSellerTrade)
if (trade instanceof SellerAsTakerTrade)
takerAsSellerProcessState.bind(trade.processStateProperty());
else if (trade instanceof OffererAsBuyerTrade)
else if (trade instanceof BuyerAsOffererTrade)
offererAsBuyerProcessState.bind(trade.processStateProperty());
else if (trade instanceof TakerAsBuyerTrade)
else if (trade instanceof BuyerAsTakerTrade)
takerAsBuyerProcessState.bind(trade.processStateProperty());
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
offererAsSellerProcessState.bind(trade.processStateProperty());
if (trade.getDepositTx() != null)
@ -150,17 +151,17 @@ class PendingTradesDataModel implements Activatable, DataModel {
}
void fiatPaymentStarted() {
if (getTrade() instanceof OffererAsBuyerTrade)
((OffererAsBuyerTrade) getTrade()).onFiatPaymentStarted();
else if (getTrade() instanceof TakerAsBuyerTrade)
((TakerAsBuyerTrade) getTrade()).onFiatPaymentStarted();
if (getTrade() instanceof BuyerAsOffererTrade)
((BuyerAsOffererTrade) getTrade()).onFiatPaymentStarted();
else if (getTrade() instanceof BuyerAsTakerTrade)
((BuyerAsTakerTrade) getTrade()).onFiatPaymentStarted();
}
void fiatPaymentReceived() {
if (getTrade() instanceof TakerAsSellerTrade)
((TakerAsSellerTrade) getTrade()).onFiatPaymentReceived();
else if (getTrade() instanceof OffererAsSellerTrade)
((OffererAsSellerTrade) getTrade()).onFiatPaymentReceived();
if (getTrade() instanceof SellerAsTakerTrade)
((SellerAsTakerTrade) getTrade()).onFiatPaymentReceived();
else if (getTrade() instanceof SellerAsOffererTrade)
((SellerAsOffererTrade) getTrade()).onFiatPaymentReceived();
}
void withdraw(String toAddress) {
@ -262,7 +263,7 @@ class PendingTradesDataModel implements Activatable, DataModel {
Trade trade = selectedItem.getTrade();
Coin amountToWithdraw = trade.getSecurityDeposit();
assert trade.getTradeAmount() != null;
if (trade instanceof OffererAsBuyerTrade || trade instanceof TakerAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade || trade instanceof BuyerAsTakerTrade)
amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount());
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.validation.BtcAddressValidator;
import io.bitsquare.locale.BSResources;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.states.OffererState;
import io.bitsquare.trade.states.TakerState;
import org.bitcoinj.core.Coin;
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.CurrencyUtil;
import io.bitsquare.offer.Offer;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.states.TakerState;
import org.bitcoinj.core.Address;
import org.bitcoinj.core.Coin;
@ -234,7 +234,7 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
if (trade.getErrorMessage() != null)
msg = "\nError message: " + trade.getErrorMessage();
if (trade instanceof TakerAsBuyerTrade) {
if (trade instanceof BuyerAsTakerTrade) {
switch ((TakerState.ProcessState) newValue) {
case TAKE_OFFER_FEE_TX_CREATED:
break;
@ -266,7 +266,7 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
break;
}
}
else if (trade instanceof TakerAsSellerTrade) {
else if (trade instanceof SellerAsTakerTrade) {
switch ((TakerState.ProcessState) newValue) {
case TAKE_OFFER_FEE_TX_CREATED:
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.storage.Storage;
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.ObjectInputStream;
@ -28,23 +30,18 @@ import java.io.Serializable;
import org.slf4j.Logger;
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.
private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(OffererAsBuyerTrade.class);
///////////////////////////////////////////////////////////////////////////////////////////
// Enum
///////////////////////////////////////////////////////////////////////////////////////////
transient private static final Logger log = LoggerFactory.getLogger(BuyerAsOffererTrade.class);
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor, initialization
///////////////////////////////////////////////////////////////////////////////////////////
public OffererAsBuyerTrade(Offer offer, Storage<? extends TradeList> storage) {
public BuyerAsOffererTrade(Offer offer, Storage<? extends TradeList> storage) {
super(offer, storage);
log.trace("Created by constructor");
}
@ -59,7 +56,7 @@ public class OffererAsBuyerTrade extends Trade implements Serializable {
@Override
protected void createProtocol() {
protocol = new BuyerAsOffererProtocol(this);
tradeProtocol = new BuyerAsOffererProtocol(this);
}
@Override
@ -75,8 +72,8 @@ public class OffererAsBuyerTrade extends Trade implements Serializable {
///////////////////////////////////////////////////////////////////////////////////////////
public void onFiatPaymentStarted() {
assert protocol instanceof BuyerAsOffererProtocol;
((BuyerAsOffererProtocol) protocol).onFiatPaymentStarted();
assert tradeProtocol instanceof BuyerAsOffererProtocol;
((BuyerAsOffererProtocol) tradeProtocol).onFiatPaymentStarted();
}
@ -85,7 +82,7 @@ public class OffererAsBuyerTrade extends Trade implements Serializable {
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setProcessState(Trade.ProcessState processState) {
public void setProcessState(TradeState.ProcessState processState) {
super.setProcessState(processState);
switch ((OffererState.ProcessState) processState) {
@ -97,7 +94,7 @@ public class OffererAsBuyerTrade extends Trade implements Serializable {
}
@Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) {
public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
super.setLifeCycleState(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.storage.Storage;
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;
@ -30,18 +32,18 @@ import java.io.Serializable;
import org.slf4j.Logger;
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.
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
///////////////////////////////////////////////////////////////////////////////////////////
public TakerAsBuyerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer,
public BuyerAsTakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer,
Storage<? extends TradeList> storage) {
super(offer, tradeAmount, tradingPeer, storage);
log.trace("Created by constructor");
@ -64,7 +66,7 @@ public class TakerAsBuyerTrade extends Trade implements Serializable {
@Override
public void createProtocol() {
protocol = new BuyerAsTakerProtocol(this);
tradeProtocol = new BuyerAsTakerProtocol(this);
}
@ -74,13 +76,13 @@ public class TakerAsBuyerTrade extends Trade implements Serializable {
@Override
public void takeAvailableOffer() {
assert protocol instanceof BuyerAsTakerProtocol;
((BuyerAsTakerProtocol) protocol).takeAvailableOffer();
assert tradeProtocol instanceof BuyerAsTakerProtocol;
((BuyerAsTakerProtocol) tradeProtocol).takeAvailableOffer();
}
public void onFiatPaymentStarted() {
assert protocol instanceof BuyerAsTakerProtocol;
((BuyerAsTakerProtocol) protocol).onFiatPaymentStarted();
assert tradeProtocol instanceof BuyerAsTakerProtocol;
((BuyerAsTakerProtocol) tradeProtocol).onFiatPaymentStarted();
}
@ -89,7 +91,7 @@ public class TakerAsBuyerTrade extends Trade implements Serializable {
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setProcessState(Trade.ProcessState processState) {
public void setProcessState(TradeState.ProcessState processState) {
super.setProcessState(processState);
switch ((TakerState.ProcessState) processState) {
@ -101,7 +103,7 @@ public class TakerAsBuyerTrade extends Trade implements Serializable {
}
@Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) {
public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
super.setLifeCycleState(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.storage.Storage;
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.ObjectInputStream;
@ -28,18 +30,18 @@ import java.io.Serializable;
import org.slf4j.Logger;
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.
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
///////////////////////////////////////////////////////////////////////////////////////////
public OffererAsSellerTrade(Offer offer, Storage<? extends TradeList> storage) {
public SellerAsOffererTrade(Offer offer, Storage<? extends TradeList> storage) {
super(offer, storage);
log.trace("Created by constructor");
}
@ -54,7 +56,7 @@ public class OffererAsSellerTrade extends Trade implements Serializable {
@Override
protected void createProtocol() {
protocol = new SellerAsOffererProtocol(this);
tradeProtocol = new SellerAsOffererProtocol(this);
}
@Override
@ -70,8 +72,8 @@ public class OffererAsSellerTrade extends Trade implements Serializable {
///////////////////////////////////////////////////////////////////////////////////////////
public void onFiatPaymentReceived() {
assert protocol instanceof SellerAsOffererProtocol;
((SellerAsOffererProtocol) protocol).onFiatPaymentReceived();
assert tradeProtocol instanceof SellerAsOffererProtocol;
((SellerAsOffererProtocol) tradeProtocol).onFiatPaymentReceived();
}
@ -80,7 +82,7 @@ public class OffererAsSellerTrade extends Trade implements Serializable {
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setProcessState(Trade.ProcessState processState) {
public void setProcessState(TradeState.ProcessState processState) {
super.setProcessState(processState);
switch ((OffererState.ProcessState) processState) {
@ -92,7 +94,7 @@ public class OffererAsSellerTrade extends Trade implements Serializable {
}
@Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) {
public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
super.setLifeCycleState(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.storage.Storage;
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;
@ -30,7 +32,7 @@ import java.io.Serializable;
import org.slf4j.Logger;
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.
private static final long serialVersionUID = 1L;
@ -41,7 +43,7 @@ public class TakerAsSellerTrade extends Trade implements Serializable {
// Constructor, initialization
///////////////////////////////////////////////////////////////////////////////////////////
public TakerAsSellerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer,
public SellerAsTakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer,
Storage<? extends TradeList> storage) {
super(offer, tradeAmount, tradingPeer, storage);
log.trace("Created by constructor");
@ -64,7 +66,7 @@ public class TakerAsSellerTrade extends Trade implements Serializable {
@Override
public void createProtocol() {
protocol = new SellerAsTakerProtocol(this);
tradeProtocol = new SellerAsTakerProtocol(this);
}
@ -74,13 +76,13 @@ public class TakerAsSellerTrade extends Trade implements Serializable {
@Override
public void takeAvailableOffer() {
assert protocol instanceof SellerAsTakerProtocol;
((SellerAsTakerProtocol) protocol).takeAvailableOffer();
assert tradeProtocol instanceof SellerAsTakerProtocol;
((SellerAsTakerProtocol) tradeProtocol).takeAvailableOffer();
}
public void onFiatPaymentReceived() {
assert protocol instanceof SellerAsTakerProtocol;
((SellerAsTakerProtocol) protocol).onFiatPaymentReceived();
assert tradeProtocol instanceof SellerAsTakerProtocol;
((SellerAsTakerProtocol) tradeProtocol).onFiatPaymentReceived();
}
@ -89,7 +91,7 @@ public class TakerAsSellerTrade extends Trade implements Serializable {
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setProcessState(Trade.ProcessState processState) {
public void setProcessState(TradeState.ProcessState processState) {
TakerState.ProcessState state = (TakerState.ProcessState) processState;
this.processState = processState;
processStateProperty.set(processState);
@ -103,7 +105,7 @@ public class TakerAsSellerTrade extends Trade implements Serializable {
}
@Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) {
public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
TakerState.LifeCycleState state = (TakerState.LifeCycleState) lifeCycleState;
switch (state) {
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.Peer;
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.states.TradeState;
import io.bitsquare.user.User;
import org.bitcoinj.core.Coin;
@ -68,6 +69,7 @@ abstract public class Trade extends Model implements Serializable {
private static final long serialVersionUID = 1L;
private transient static final Logger log = LoggerFactory.getLogger(Trade.class);
// Mutable
protected Coin tradeAmount;
protected Peer tradingPeer;
@ -75,27 +77,15 @@ abstract public class Trade extends Model implements Serializable {
transient protected ObjectProperty<Fiat> tradeVolumeProperty;
///////////////////////////////////////////////////////////////////////////////////////////
// Interfaces
///////////////////////////////////////////////////////////////////////////////////////////
public interface LifeCycleState {
}
public interface ProcessState {
}
///////////////////////////////////////////////////////////////////////////////////////////
// Fields
///////////////////////////////////////////////////////////////////////////////////////////
// Transient/Immutable
transient protected ObjectProperty<ProcessState> processStateProperty;
transient protected ObjectProperty<LifeCycleState> lifeCycleStateProperty;
transient protected ObjectProperty<TradeState.ProcessState> processStateProperty;
transient protected ObjectProperty<TradeState.LifeCycleState> lifeCycleStateProperty;
transient private Storage<? extends TradeList> storage;
transient protected Protocol protocol;
transient protected TradeProtocol tradeProtocol;
// Immutable
protected final Offer offer;
@ -103,8 +93,8 @@ abstract public class Trade extends Model implements Serializable {
protected final ProcessModel processModel;
// Mutable
protected ProcessState processState;
protected LifeCycleState lifeCycleState;
protected TradeState.ProcessState processState;
protected TradeState.LifeCycleState lifeCycleState;
private MailboxMessage mailboxMessage;
protected Transaction depositTx;
private Contract contract;
@ -173,7 +163,7 @@ abstract public class Trade extends Model implements Serializable {
createProtocol();
if (mailboxMessage != null)
protocol.setMailboxMessage(mailboxMessage);
tradeProtocol.setMailboxMessage(mailboxMessage);
}
protected void initStateProperties() {
@ -195,16 +185,16 @@ abstract public class Trade extends Model implements Serializable {
}
public void disposeProtocol() {
if (protocol != null) {
protocol.cleanup();
protocol = null;
if (tradeProtocol != null) {
tradeProtocol.cleanup();
tradeProtocol = null;
}
}
public void setMailboxMessage(MailboxMessage mailboxMessage) {
this.mailboxMessage = mailboxMessage;
if (protocol != null)
protocol.setMailboxMessage(mailboxMessage);
if (tradeProtocol != null)
tradeProtocol.setMailboxMessage(mailboxMessage);
storage.queueUpForSave();
}
@ -213,13 +203,13 @@ abstract public class Trade extends Model implements Serializable {
this.storage = storage;
}
public void setProcessState(Trade.ProcessState processState) {
public void setProcessState(TradeState.ProcessState processState) {
this.processState = processState;
processStateProperty.set(processState);
storage.queueUpForSave();
}
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) {
public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
this.lifeCycleState = lifeCycleState;
lifeCycleStateProperty.set(lifeCycleState);
storage.queueUpForSave();
@ -351,11 +341,11 @@ abstract public class Trade extends Model implements Serializable {
return null;
}
public ReadOnlyObjectProperty<? extends ProcessState> processStateProperty() {
public ReadOnlyObjectProperty<? extends TradeState.ProcessState> processStateProperty() {
return processStateProperty;
}
public ReadOnlyObjectProperty<? extends LifeCycleState> lifeCycleStateProperty() {
public ReadOnlyObjectProperty<? extends TradeState.LifeCycleState> lifeCycleStateProperty() {
return lifeCycleStateProperty;
}
@ -430,7 +420,7 @@ abstract public class Trade extends Model implements Serializable {
@Override
public String toString() {
return ", protocol=" + protocol +
return ", protocol=" + tradeProtocol +
", offer=" + offer +
", date=" + date +
", 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.PlaceOfferProtocol;
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.User;
@ -168,9 +170,9 @@ public class TradeManager {
// continue the trade, but that might fail.
boolean failed = false;
if (trade instanceof TakerAsSellerTrade)
if (trade instanceof SellerAsTakerTrade)
failed = trade.lifeCycleState == TakerState.LifeCycleState.FAILED;
else if (trade instanceof TakerAsBuyerTrade)
else if (trade instanceof BuyerAsTakerTrade)
failed = trade.lifeCycleState == TakerState.LifeCycleState.FAILED;
if (failed) {
@ -278,9 +280,9 @@ public class TradeManager {
private void handlePlaceOfferResult(Transaction transaction, Offer offer, TransactionResultHandler resultHandler) {
Trade trade;
if (offer.getDirection() == Offer.Direction.BUY)
trade = new OffererAsBuyerTrade(offer, openOfferTradesStorage);
trade = new BuyerAsOffererTrade(offer, openOfferTradesStorage);
else
trade = new OffererAsSellerTrade(offer, openOfferTradesStorage);
trade = new SellerAsOffererTrade(offer, openOfferTradesStorage);
openOfferTrades.add(trade);
initTrade(trade);
@ -319,9 +321,9 @@ public class TradeManager {
openOfferTrades.remove(trade);
if (isCancelRequest) {
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_CANCELED);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_CANCELED);
closedTrades.add(trade);
trade.disposeProtocol();
@ -379,9 +381,9 @@ public class TradeManager {
if (offer.getState() == Offer.State.AVAILABLE) {
Trade trade;
if (offer.getDirection() == Offer.Direction.BUY)
trade = new TakerAsSellerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
trade = new SellerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
else
trade = new TakerAsBuyerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
trade = new BuyerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
initTrade(trade);
pendingTrades.add(trade);
@ -402,7 +404,7 @@ public class TradeManager {
// TODO handle overpaid securityDeposit
Coin amountToWithdraw = trade.getSecurityDeposit();
assert trade.getTradeAmount() != null;
if (trade instanceof OffererAsBuyerTrade || trade instanceof TakerAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade || trade instanceof BuyerAsTakerTrade)
amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount());
FutureCallback<Transaction> callback = new FutureCallback<Transaction>() {
@ -410,13 +412,13 @@ public class TradeManager {
public void onSuccess(@javax.annotation.Nullable Transaction transaction) {
if (transaction != null) {
log.info("onWithdraw onSuccess tx ID:" + transaction.getHashAsString());
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.COMPLETED);
else if (trade instanceof TakerAsSellerTrade)
else if (trade instanceof SellerAsTakerTrade)
trade.setLifeCycleState(TakerState.LifeCycleState.COMPLETED);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.COMPLETED);
else if (trade instanceof TakerAsBuyerTrade)
else if (trade instanceof BuyerAsTakerTrade)
trade.setLifeCycleState(TakerState.LifeCycleState.COMPLETED);
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/>.
*/
package io.bitsquare.trade.protocol;
package io.bitsquare.trade.protocol.trade;
import io.bitsquare.p2p.MailboxMessage;
public interface Protocol {
public interface TradeProtocol {
void cleanup();
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/>.
*/
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.TaskRunner;
@ -25,12 +25,12 @@ import io.bitsquare.trade.protocol.trade.shared.models.ProcessModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerTradeTask extends Task<Trade> {
private static final Logger log = LoggerFactory.getLogger(TakerTradeTask.class);
public class TradeTask extends Task<Trade> {
private static final Logger log = LoggerFactory.getLogger(TradeTask.class);
protected final ProcessModel processModel;
protected final Trade trade;
public TakerTradeTask(TaskRunner taskHandler, Trade trade) {
public TradeTask(TaskRunner taskHandler, Trade trade) {
super(taskHandler, 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.Peer;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.protocol.availability.messages.ReportOfferAvailabilityMessage;
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.OffererCreatesAndSignPayoutTx;
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.offerer.tasks.VerifyTakeOfferFeePayment;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakerAccount;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 MessageHandler messageHandler;
private final OffererAsBuyerTrade offererAsBuyerTrade;
private final BuyerAsOffererTrade buyerAsOffererTrade;
private final ProcessModel processModel;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public BuyerAsOffererProtocol(OffererAsBuyerTrade model) {
public BuyerAsOffererProtocol(BuyerAsOffererTrade model) {
log.debug("New OffererProtocol " + this);
this.offererAsBuyerTrade = model;
processModel = offererAsBuyerTrade.getProcessModel();
this.buyerAsOffererTrade = model;
processModel = buyerAsOffererTrade.getProcessModel();
messageHandler = this::handleMessage;
processModel.getMessageService().addMessageHandler(messageHandler);
@ -110,7 +110,7 @@ public class BuyerAsOffererProtocol implements Protocol {
// to take the
// offer
// 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);
processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@Override
@ -135,11 +135,11 @@ public class BuyerAsOffererProtocol implements Protocol {
private void handleRequestDepositTxInputsMessage(RequestDepositTxInputsMessage tradeMessage, Peer taker) {
checkTradeId(processModel.getId(), 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"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -153,7 +153,7 @@ public class BuyerAsOffererProtocol implements Protocol {
private void handleRequestPublishDepositTxMessage(RequestPublishDepositTxMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsBuyerTrade> taskRunner = new TaskRunner<>(offererAsBuyerTrade,
TaskRunner<BuyerAsOffererTrade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -173,7 +173,7 @@ public class BuyerAsOffererProtocol implements Protocol {
// User clicked the "bank transfer started" button
public void onFiatPaymentStarted() {
TaskRunner<OffererAsBuyerTrade> taskRunner = new TaskRunner<>(offererAsBuyerTrade,
TaskRunner<BuyerAsOffererTrade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -192,7 +192,7 @@ public class BuyerAsOffererProtocol implements Protocol {
private void handlePayoutTxPublishedMessage(PayoutTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsBuyerTrade> taskRunner = new TaskRunner<>(offererAsBuyerTrade,
TaskRunner<BuyerAsOffererTrade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
() -> {
log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
// we are done!
@ -216,7 +216,7 @@ public class BuyerAsOffererProtocol implements Protocol {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(offererAsBuyerTrade.getId())) {
if (tradeMessage.tradeId.equals(buyerAsOffererTrade.getId())) {
if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
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.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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererCommitsPayoutTx extends OffererTradeTask {
public class OffererCommitsPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCommitsPayoutTx.class);
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.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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererCreatesAndSignPayoutTx extends OffererTradeTask {
public class OffererCreatesAndSignPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignPayoutTx.class);
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.TradeWalletService;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererCreatesDepositTxInputs extends OffererTradeTask {
public class OffererCreatesDepositTxInputs extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesDepositTxInputs.class);
public OffererCreatesDepositTxInputs(TaskRunner taskHandler, Trade trade) {
@ -54,10 +54,10 @@ public class OffererCreatesDepositTxInputs extends OffererTradeTask {
t.printStackTrace();
trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade) {
if (trade instanceof BuyerAsOffererTrade) {
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
}
else if (trade instanceof OffererAsSellerTrade) {
else if (trade instanceof SellerAsOffererTrade) {
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.offerer.tasks.OffererTradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public OffererProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -47,9 +47,9 @@ public class OffererProcessPayoutTxPublishedMessage extends OffererTradeTask {
trade.setPayoutTx(checkNotNull(message.payoutTx));
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.offerer.tasks.OffererTradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public OffererProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) {
@ -54,9 +54,9 @@ public class OffererProcessRequestDepositTxInputsMessage extends OffererTradeTas
t.printStackTrace();
trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.offerer.tasks.OffererTradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*;
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);
public OffererProcessRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) {
@ -61,9 +61,9 @@ public class OffererProcessRequestPublishDepositTxMessage extends OffererTradeTa
t.printStackTrace();
trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.offerer.tasks.OffererTradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererSendsDepositTxPublishedMessage extends OffererTradeTask {
public class OffererSendsDepositTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsDepositTxPublishedMessage.class);
public OffererSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -53,9 +53,9 @@ public class OffererSendsDepositTxPublishedMessage extends OffererTradeTask {
appendToErrorMessage("Sending DepositTxPublishedMessage failed");
trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.offerer.tasks.OffererTradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
public class OffererSendsFiatTransferStartedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsFiatTransferStartedMessage.class);
public OffererSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
@ -53,11 +53,11 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded.");
if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
if (trade instanceof BuyerAsOffererTrade) {
((BuyerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
}
else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
else if (trade instanceof SellerAsOffererTrade) {
((SellerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
}
complete();
@ -68,11 +68,11 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
appendToErrorMessage("Sending FiatTransferStartedMessage failed");
trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof BuyerAsOffererTrade) {
((BuyerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
}
else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof SellerAsOffererTrade) {
((SellerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.offerer.tasks.OffererTradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTradeTask {
public class OffererSendsRequestSellerDepositPaymentMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestSellerDepositPaymentMessage.class);
public OffererSendsRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade trade) {
@ -60,13 +60,13 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
public void handleFault() {
appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed");
trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsBuyerTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
if (trade instanceof BuyerAsOffererTrade) {
((BuyerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((BuyerAsOffererTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
}
else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof SellerAsOffererTrade) {
((SellerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((SellerAsOffererTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
}
failed();
@ -76,13 +76,13 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
t.printStackTrace();
trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
if (trade instanceof BuyerAsOffererTrade) {
((BuyerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((SellerAsOffererTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
}
else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof SellerAsOffererTrade) {
((SellerAsOffererTrade) trade).setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
((SellerAsOffererTrade) trade).setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
}
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.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.Transaction;
@ -35,7 +35,7 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
public class OffererSignsAndPublishDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishDepositTx.class);
public OffererSignsAndPublishDepositTx(TaskRunner taskHandler, Trade trade) {
@ -63,11 +63,11 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
trade.setDepositTx(transaction);
if (trade instanceof OffererAsBuyerTrade) {
if (trade instanceof BuyerAsOffererTrade) {
trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(OffererState.LifeCycleState.PENDING);
}
else if (trade instanceof OffererAsSellerTrade) {
else if (trade instanceof SellerAsOffererTrade) {
trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(OffererState.LifeCycleState.PENDING);
}
@ -80,9 +80,9 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
t.printStackTrace();
trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
failed(t);
@ -92,9 +92,9 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
t.printStackTrace();
trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.Contract;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.SellerAsOffererTrade;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererVerifiesAndSignsContract extends OffererTradeTask {
public class OffererVerifiesAndSignsContract extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererVerifiesAndSignsContract.class);
public OffererVerifiesAndSignsContract(TaskRunner taskHandler, Trade trade) {
@ -63,9 +63,9 @@ public class OffererVerifiesAndSignsContract extends OffererTradeTask {
t.printStackTrace();
trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
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.MessageHandler;
import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.BuyerAsTakerTrade;
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.TakerCreatesAndSignsPayoutTx;
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;
public class BuyerAsTakerProtocol implements Protocol {
public class BuyerAsTakerProtocol implements TradeProtocol {
private static final Logger log = LoggerFactory.getLogger(BuyerAsTakerProtocol.class);
private final TakerAsBuyerTrade takerAsBuyerTrade;
private final BuyerAsTakerTrade buyerAsTakerTrade;
private final ProcessModel processModel;
private final MessageHandler messageHandler;
@ -60,9 +60,9 @@ public class BuyerAsTakerProtocol implements Protocol {
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public BuyerAsTakerProtocol(TakerAsBuyerTrade trade) {
public BuyerAsTakerProtocol(BuyerAsTakerTrade trade) {
log.debug("New SellerAsTakerProtocol " + this);
this.takerAsBuyerTrade = trade;
this.buyerAsTakerTrade = trade;
processModel = trade.getProcessModel();
messageHandler = this::handleMessage;
@ -94,7 +94,7 @@ public class BuyerAsTakerProtocol implements Protocol {
}
public void takeAvailableOffer() {
TaskRunner<TakerAsBuyerTrade> taskRunner = new TaskRunner<>(takerAsBuyerTrade,
TaskRunner<BuyerAsTakerTrade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> log.debug("taskRunner at takeAvailableOffer completed"),
this::handleTaskRunnerFault);
@ -115,7 +115,7 @@ public class BuyerAsTakerProtocol implements Protocol {
private void handle(RequestPublishDepositTxMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsBuyerTrade> taskRunner = new TaskRunner<>(takerAsBuyerTrade,
TaskRunner<BuyerAsTakerTrade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -135,7 +135,7 @@ public class BuyerAsTakerProtocol implements Protocol {
// User clicked the "bank transfer started" button
public void onFiatPaymentStarted() {
TaskRunner<TakerAsBuyerTrade> taskRunner = new TaskRunner<>(takerAsBuyerTrade,
TaskRunner<BuyerAsTakerTrade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> log.debug("taskRunner at onFiatPaymentStarted completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
@ -154,7 +154,7 @@ public class BuyerAsTakerProtocol implements Protocol {
private void handle(PayoutTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsBuyerTrade> taskRunner = new TaskRunner<>(takerAsBuyerTrade,
TaskRunner<BuyerAsTakerTrade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
() -> {
log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
// 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.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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerCommitsPayoutTx extends TakerTradeTask {
public class TakerCommitsPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCommitsPayoutTx.class);
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.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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignsPayoutTx extends TakerTradeTask {
public class TakerCreatesAndSignsPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsPayoutTx.class);
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.common.taskrunner.TaskRunner;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerCreatesDepositTxInputs extends TakerTradeTask {
public class TakerCreatesDepositTxInputs extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesDepositTxInputs.class);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.taker.tasks.TakerTradeTask;
import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public TakerProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -47,9 +47,9 @@ public class TakerProcessPayoutTxPublishedMessage extends TakerTradeTask {
trade.setPayoutTx(checkNotNull(message.payoutTx));
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade)
else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED);
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.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxFromTakerMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -28,7 +28,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*;
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);
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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.taker.tasks.TakerTradeTask;
import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerSendsDepositTxPublishedMessage extends TakerTradeTask {
public class TakerSendsDepositTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsDepositTxPublishedMessage.class);
public TakerSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -53,9 +53,9 @@ public class TakerSendsDepositTxPublishedMessage extends TakerTradeTask {
appendToErrorMessage("Sending DepositTxPublishedMessage failed");
trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof 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);
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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.taker.tasks.TakerTradeTask;
import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
public class TakerSendsFiatTransferStartedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsFiatTransferStartedMessage.class);
public TakerSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
@ -53,10 +53,10 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded.");
if (trade instanceof TakerAsBuyerTrade) {
if (trade instanceof BuyerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED);
}
else if (trade instanceof TakerAsSellerTrade) {
else if (trade instanceof SellerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED);
}
@ -68,10 +68,10 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
appendToErrorMessage("Sending FiatTransferStartedMessage failed");
trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade) {
((TakerAsBuyerTrade) trade).setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof BuyerAsTakerTrade) {
((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);
}

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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.taker.tasks.TakerTradeTask;
import io.bitsquare.trade.states.TakerState;
import javafx.application.Platform;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask {
public class TakerSendsRequestDepositTxInputsMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestDepositTxInputsMessage.class);
public TakerSendsRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) {
@ -73,9 +73,9 @@ public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask {
trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof 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);

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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.taker.tasks.TakerTradeTask;
import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
public class TakerSendsRequestPayDepositMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPayDepositMessage.class);
public TakerSendsRequestPayDepositMessage(TaskRunner taskHandler, Trade trade) {
@ -61,9 +61,9 @@ public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
public void handleFault() {
appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed");
trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof 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);
failed();
@ -73,10 +73,10 @@ public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
t.printStackTrace();
trade.setThrowable(t);
if (trade instanceof TakerAsBuyerTrade) {
if (trade instanceof 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);
}

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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.taker.tasks.TakerTradeTask;
import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask {
public class TakerSendsRequestPublishDepositTxMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPublishDepositTxMessage.class);
public TakerSendsRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) {
@ -63,9 +63,9 @@ public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask {
appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed");
trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof 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);
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.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.Transaction;
@ -35,7 +35,7 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerSignsAndPublishDepositTx extends TakerTradeTask {
public class TakerSignsAndPublishDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishDepositTx.class);
public TakerSignsAndPublishDepositTx(TaskRunner taskHandler, Trade trade) {
@ -63,11 +63,11 @@ public class TakerSignsAndPublishDepositTx extends TakerTradeTask {
trade.setDepositTx(transaction);
if (trade instanceof TakerAsBuyerTrade) {
if (trade instanceof BuyerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(TakerState.LifeCycleState.PENDING);
}
else if (trade instanceof TakerAsSellerTrade) {
else if (trade instanceof SellerAsTakerTrade) {
trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED);
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.trade.Contract;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerVerifiesAndSignsContract extends TakerTradeTask {
public class TakerVerifiesAndSignsContract extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerVerifiesAndSignsContract.class);
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.Peer;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.protocol.availability.messages.ReportOfferAvailabilityMessage;
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.FiatTransferStartedMessage;
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.offerer.tasks.VerifyTakeOfferFeePayment;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakerAccount;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 final MessageHandler messageHandler;
private final OffererAsSellerTrade offererAsSellerTrade;
private final SellerAsOffererTrade sellerAsOffererTrade;
private final ProcessModel processModel;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public SellerAsOffererProtocol(OffererAsSellerTrade model) {
public SellerAsOffererProtocol(SellerAsOffererTrade model) {
log.debug("New OffererProtocol " + this);
this.offererAsSellerTrade = model;
processModel = offererAsSellerTrade.getProcessModel();
this.sellerAsOffererTrade = model;
processModel = sellerAsOffererTrade.getProcessModel();
messageHandler = this::handleMessage;
processModel.getMessageService().addMessageHandler(messageHandler);
@ -108,7 +108,7 @@ public class SellerAsOffererProtocol implements Protocol {
// to take the
// offer
// 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);
processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@ -138,9 +138,9 @@ public class SellerAsOffererProtocol implements Protocol {
private void handle(RequestPayDepositMessage tradeMessage, Peer sender) {
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"),
this::handleTaskRunnerFault);
@ -157,7 +157,7 @@ public class SellerAsOffererProtocol implements Protocol {
private void handle(DepositTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsSellerTrade> taskRunner = new TaskRunner<>(offererAsSellerTrade,
TaskRunner<SellerAsOffererTrade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
() -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"),
this::handleTaskRunnerFault);
@ -171,7 +171,7 @@ public class SellerAsOffererProtocol implements Protocol {
private void handle(FiatTransferStartedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsSellerTrade> taskRunner = new TaskRunner<>(offererAsSellerTrade,
TaskRunner<SellerAsOffererTrade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
() -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"),
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
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");
@ -215,7 +215,7 @@ public class SellerAsOffererProtocol implements Protocol {
if (message instanceof TradeMessage) {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(offererAsSellerTrade.getId())) {
if (tradeMessage.tradeId.equals(sellerAsOffererTrade.getId())) {
if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
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.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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererCommitDepositTx extends OffererTradeTask {
public class OffererCommitDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCommitDepositTx.class);
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.trade.Contract;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererCreatesAndSignsContract extends OffererTradeTask {
public class OffererCreatesAndSignsContract extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsContract.class);
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.common.taskrunner.TaskRunner;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererCreatesAndSignsDepositTx extends OffererTradeTask {
public class OffererCreatesAndSignsDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsDepositTx.class);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.offerer.tasks.OffererTradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public OffererProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -47,9 +47,9 @@ public class OffererProcessDepositTxPublishedMessage extends OffererTradeTask {
trade.setDepositTx(checkNotNull(message.depositTx));
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.offerer.tasks.OffererTradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public OffererProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
@ -50,9 +50,9 @@ public class OffererProcessFiatTransferStartedMessage extends OffererTradeTask {
processModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount)));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
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.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositFromOffererMessage;
import io.bitsquare.trade.protocol.trade.offerer.tasks.OffererTradeTask;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -28,7 +28,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*;
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);
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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.offerer.tasks.OffererTradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererSendsPayoutTxPublishedMessage extends OffererTradeTask {
public class OffererSendsPayoutTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsPayoutTxPublishedMessage.class);
public OffererSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -56,9 +56,9 @@ public class OffererSendsPayoutTxPublishedMessage extends OffererTradeTask {
appendToErrorMessage("Sending PayoutTxPublishedMessage failed");
trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.offerer.tasks.OffererTradeTask;
import io.bitsquare.trade.states.OffererState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererSendsRequestPublishDepositTxFromTakerMessage extends OffererTradeTask {
public class OffererSendsRequestPublishDepositTxFromTakerMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestPublishDepositTxFromTakerMessage.class);
public OffererSendsRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade trade) {
@ -64,9 +64,9 @@ public class OffererSendsRequestPublishDepositTxFromTakerMessage extends Offerer
appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed");
trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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;
@ -33,7 +33,7 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererSignsAndPublishPayoutTx extends OffererTradeTask {
public class OffererSignsAndPublishPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishPayoutTx.class);
public OffererSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade trade) {
@ -58,9 +58,9 @@ public class OffererSignsAndPublishPayoutTx extends OffererTradeTask {
public void onSuccess(Transaction transaction) {
processModel.setPayoutTx(transaction);
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED);
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.MessageHandler;
import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.SellerAsTakerTrade;
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.TakerSendsRequestPublishDepositTxMessage;
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.VerifyOfferFeePayment;
import io.bitsquare.trade.protocol.trade.shared.taker.tasks.VerifyOffererAccount;
import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 final TakerAsSellerTrade takerAsSellerTrade;
private final SellerAsTakerTrade sellerAsTakerTrade;
private final ProcessModel processModel;
private final MessageHandler messageHandler;
@ -63,9 +63,9 @@ public class SellerAsTakerProtocol implements Protocol {
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public SellerAsTakerProtocol(TakerAsSellerTrade trade) {
public SellerAsTakerProtocol(SellerAsTakerTrade trade) {
log.debug("New SellerAsTakerProtocol " + this);
this.takerAsSellerTrade = trade;
this.sellerAsTakerTrade = trade;
processModel = trade.getProcessModel();
messageHandler = this::handleMessage;
@ -97,7 +97,7 @@ public class SellerAsTakerProtocol implements Protocol {
}
public void takeAvailableOffer() {
TaskRunner<Trade> taskRunner = new TaskRunner<>(takerAsSellerTrade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at takeAvailableOffer completed"),
this::handleTaskRunnerFault);
@ -117,7 +117,7 @@ public class SellerAsTakerProtocol implements Protocol {
private void handleRequestTakerDepositPaymentMessage(RequestPayDepositMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(takerAsSellerTrade,
TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"),
this::handleTaskRunnerFault);
@ -134,7 +134,7 @@ public class SellerAsTakerProtocol implements Protocol {
private void handleDepositTxPublishedMessage(DepositTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsSellerTrade> taskRunner = new TaskRunner<>(takerAsSellerTrade,
TaskRunner<SellerAsTakerTrade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"),
this::handleTaskRunnerFault);
@ -148,7 +148,7 @@ public class SellerAsTakerProtocol implements Protocol {
private void handleFiatTransferStartedMessage(FiatTransferStartedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsSellerTrade> taskRunner = new TaskRunner<>(takerAsSellerTrade,
TaskRunner<SellerAsTakerTrade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
() -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"),
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
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");

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.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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerCommitDepositTx extends TakerTradeTask {
public class TakerCommitDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCommitDepositTx.class);
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.trade.Contract;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignContract extends TakerTradeTask {
public class TakerCreatesAndSignContract extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignContract.class);
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.common.taskrunner.TaskRunner;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignsDepositTx extends TakerTradeTask {
public class TakerCreatesAndSignsDepositTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsDepositTx.class);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.taker.tasks.TakerTradeTask;
import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public TakerProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -47,9 +47,9 @@ public class TakerProcessDepositTxPublishedMessage extends TakerTradeTask {
trade.setDepositTx(checkNotNull(message.depositTx));
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade)
else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.taker.tasks.TakerTradeTask;
import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public TakerProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
@ -50,9 +50,9 @@ public class TakerProcessFiatTransferStartedMessage extends TakerTradeTask {
processModel.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.sellerPayoutAmount)));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED);
else if (trade instanceof TakerAsSellerTrade)
else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED);
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.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.taker.tasks.TakerTradeTask;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -28,7 +28,7 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*;
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);
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.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.taker.tasks.TakerTradeTask;
import io.bitsquare.trade.states.TakerState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerSendsPayoutTxPublishedMessage extends TakerTradeTask {
public class TakerSendsPayoutTxPublishedMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsPayoutTxPublishedMessage.class);
public TakerSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
@ -56,9 +56,9 @@ public class TakerSendsPayoutTxPublishedMessage extends TakerTradeTask {
appendToErrorMessage("Sending PayoutTxPublishedMessage failed");
trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof 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);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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;
@ -33,7 +33,7 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerSignsAndPublishPayoutTx extends TakerTradeTask {
public class TakerSignsAndPublishPayoutTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishPayoutTx.class);
public TakerSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade trade) {
@ -58,9 +58,9 @@ public class TakerSignsAndPublishPayoutTx extends TakerTradeTask {
public void onSuccess(Transaction transaction) {
processModel.setPayoutTx(transaction);
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof BuyerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade)
else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED);
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.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.LoggerFactory;
public class VerifyTakeOfferFeePayment extends OffererTradeTask {
public class VerifyTakeOfferFeePayment extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyTakeOfferFeePayment.class);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.OffererState;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
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.LoggerFactory;
public class VerifyTakerAccount extends OffererTradeTask {
public class VerifyTakerAccount extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyTakerAccount.class);
public VerifyTakerAccount(TaskRunner taskHandler, Trade trade) {
@ -53,18 +53,18 @@ public class VerifyTakerAccount extends OffererTradeTask {
else {
failed("Account registration validation for peer failed.");
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
}
} catch (Throwable t) {
t.printStackTrace();
trade.setThrowable(t);
if (trade instanceof OffererAsBuyerTrade)
if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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;
@ -33,7 +33,7 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
public class BroadcastTakeOfferFeeTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(BroadcastTakeOfferFeeTx.class);
public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, Trade trade) {
@ -49,9 +49,9 @@ public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
public void onSuccess(Transaction transaction) {
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);
else if (trade instanceof TakerAsSellerTrade)
else if (trade instanceof SellerAsTakerTrade)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
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.");
trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof BuyerAsTakerTrade)
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);
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;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerState;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CreateTakeOfferFeeTx extends TakerTradeTask {
public class CreateTakeOfferFeeTx extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateTakeOfferFeeTx.class);
public CreateTakeOfferFeeTx(TaskRunner taskHandler, Trade trade) {
@ -43,9 +43,9 @@ public class CreateTakeOfferFeeTx extends TakerTradeTask {
processModel.setTakeOfferFeeTx(createTakeOfferFeeTx);
if (trade instanceof TakerAsBuyerTrade)
if (trade instanceof BuyerAsTakerTrade)
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);
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.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.LoggerFactory;
public class VerifyOfferFeePayment extends TakerTradeTask {
public class VerifyOfferFeePayment extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyOfferFeePayment.class);
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.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.LoggerFactory;
public class VerifyOffererAccount extends TakerTradeTask {
public class VerifyOffererAccount extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyOffererAccount.class);
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/>.
*/
package io.bitsquare.trade;
package io.bitsquare.trade.states;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -23,7 +23,7 @@ import org.slf4j.LoggerFactory;
public class OffererState {
private static final Logger log = LoggerFactory.getLogger(OffererState.class);
public enum LifeCycleState implements Trade.LifeCycleState {
public enum LifeCycleState implements TradeState.LifeCycleState {
OFFER_OPEN,
OFFER_RESERVED,
OFFER_CANCELED,
@ -32,7 +32,7 @@ public class OffererState {
FAILED
}
public enum ProcessState implements Trade.ProcessState {
public enum ProcessState implements TradeState.ProcessState {
UNDEFINED,
DEPOSIT_PUBLISHED,
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/>.
*/
package io.bitsquare.trade;
package io.bitsquare.trade.states;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -23,13 +23,13 @@ import org.slf4j.LoggerFactory;
public class TakerState {
private static final Logger log = LoggerFactory.getLogger(TakerState.class);
public enum LifeCycleState implements Trade.LifeCycleState {
public enum LifeCycleState implements TradeState.LifeCycleState {
PENDING,
COMPLETED,
FAILED
}
public enum ProcessState implements Trade.ProcessState {
public enum ProcessState implements TradeState.ProcessState {
UNDEFINED,
TAKE_OFFER_FEE_TX_CREATED,
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/>.
*/
package io.bitsquare.trade.protocol.trade.offerer.tasks;
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;
package io.bitsquare.trade.states;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererTradeTask extends Task<Trade> {
private static final Logger log = LoggerFactory.getLogger(OffererTradeTask.class);
protected final ProcessModel processModel;
protected final Trade trade;
public class TradeState {
private static final Logger log = LoggerFactory.getLogger(TradeState.class);
public OffererTradeTask(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
this.trade = trade;
processModel = trade.getProcessModel();
public interface LifeCycleState {
}
@Override
protected void doRun() {
public interface ProcessState {
}
}