From b9fe4660a36088a0b2804b396e2140f899c183a5 Mon Sep 17 00:00:00 2001 From: Manfred Karrer Date: Tue, 14 Apr 2015 02:37:49 +0200 Subject: [PATCH] Changed state handling --- .../java/io/bitsquare/fiat/FiatAccount.java | 2 +- .../p2p/tomp2p/BootstrappedPeerBuilder.java | 4 + .../bitsquare/trade/BuyerAsOffererTrade.java | 11 +- .../io/bitsquare/trade/BuyerAsTakerTrade.java | 10 +- .../java/io/bitsquare/trade/BuyerTrade.java | 92 ++++++- .../java/io/bitsquare/trade/OffererTrade.java | 82 +----- .../bitsquare/trade/SellerAsOffererTrade.java | 11 +- .../bitsquare/trade/SellerAsTakerTrade.java | 13 +- .../java/io/bitsquare/trade/SellerTrade.java | 91 ++++++- .../java/io/bitsquare/trade/TakerTrade.java | 87 +----- .../java/io/bitsquare/trade/TradeManager.java | 213 ++++----------- .../java/io/bitsquare/trade/offer/Offer.java | 36 ++- .../OfferAvailabilityProtocol.java | 4 +- .../trade/BuyerAsOffererProtocol.java | 57 ++-- .../protocol/trade/BuyerAsTakerProtocol.java | 54 ++-- .../trade/SellerAsOffererProtocol.java | 33 ++- .../protocol/trade/SellerAsTakerProtocol.java | 48 +++- .../trade/protocol/trade/TradeProtocol.java | 24 +- ...ssage.java => DepositTxInputsRequest.java} | 4 +- ...sage.java => FinalizePayoutTxRequest.java} | 10 +- ...sitMessage.java => PayDepositRequest.java} | 20 +- ...sage.java => PublishDepositTxRequest.java} | 20 +- ...ava => ProcessDepositTxInputsRequest.java} | 10 +- ...va => ProcessFinalizePayoutTxRequest.java} | 13 +- ...va => ProcessPublishDepositTxRequest.java} | 10 +- .../buyer/SendDepositTxPublishedMessage.java | 3 + .../buyer/SendFiatTransferStartedMessage.java | 10 +- ...essage.java => SendPayDepositRequest.java} | 10 +- .../buyer/SendPayoutTxFinalizedMessage.java | 3 + .../tasks/buyer/SignAndFinalizePayoutTx.java | 8 - .../tasks/buyer/SignAndPublishDepositTx.java | 14 +- .../ProcessDepositTxPublishedMessage.java | 10 +- .../ProcessFiatTransferStartedMessage.java | 10 +- ...age.java => ProcessPayDepositRequest.java} | 10 +- .../ProcessPayoutTxFinalizedMessage.java | 10 +- ...e.java => SendDepositTxInputsRequest.java} | 12 +- ....java => SendFinalizePayoutTxRequest.java} | 20 +- ....java => SendPublishDepositTxRequest.java} | 10 +- .../trade/tasks/shared/CommitPayoutTx.java | 9 + .../SetupPayoutTxLockTimeReachedListener.java | 21 +- .../tasks/taker/BroadcastTakeOfferFeeTx.java | 11 +- .../tasks/taker/CreateTakeOfferFeeTx.java | 6 +- ...erTradeState.java => BuyerTradeState.java} | 18 +- ...rTradeState.java => SellerTradeState.java} | 23 +- .../io/bitsquare/trade/states/StateUtil.java | 13 +- .../bitsquare/gui/main/debug/DebugView.java | 20 +- .../offer/takeoffer/TakeOfferDataModel.java | 8 +- .../main/offer/takeoffer/TakeOfferView.java | 2 +- .../offer/takeoffer/TakeOfferViewModel.java | 46 ++-- .../portfolio/pendingtrades/BuyerSubView.java | 43 +-- .../pendingtrades/PendingTradesViewModel.java | 255 +++++++----------- .../pendingtrades/SellerSubView.java | 39 ++- .../portfolio/pendingtrades/TradeSubView.java | 9 - .../pendingtrades/steps/StartFiatView.java | 3 +- 54 files changed, 798 insertions(+), 817 deletions(-) rename core/src/main/java/io/bitsquare/trade/protocol/trade/messages/{RequestDepositTxInputsMessage.java => DepositTxInputsRequest.java} (86%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/messages/{RequestFinalizePayoutTxMessage.java => FinalizePayoutTxRequest.java} (78%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/messages/{RequestPayDepositMessage.java => PayDepositRequest.java} (74%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/messages/{RequestPublishDepositTxMessage.java => PublishDepositTxRequest.java} (73%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/{ProcessRequestDepositTxInputsMessage.java => ProcessDepositTxInputsRequest.java} (83%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/{ProcessRequestFinalizePayoutTxMessage.java => ProcessFinalizePayoutTxRequest.java} (78%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/{ProcessRequestPublishDepositTxMessage.java => ProcessPublishDepositTxRequest.java} (86%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/{SendRequestPayDepositMessage.java => SendPayDepositRequest.java} (89%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/{ProcessRequestPayDepositMessage.java => ProcessPayDepositRequest.java} (85%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/{SendRequestDepositTxInputsMessage.java => SendDepositTxInputsRequest.java} (89%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/{SendRequestFinalizePayoutTxMessage.java => SendFinalizePayoutTxRequest.java} (73%) rename core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/{SendRequestPublishDepositTxMessage.java => SendPublishDepositTxRequest.java} (87%) rename core/src/main/java/io/bitsquare/trade/states/{OffererTradeState.java => BuyerTradeState.java} (74%) rename core/src/main/java/io/bitsquare/trade/states/{TakerTradeState.java => SellerTradeState.java} (64%) diff --git a/core/src/main/java/io/bitsquare/fiat/FiatAccount.java b/core/src/main/java/io/bitsquare/fiat/FiatAccount.java index 81f488f244..38c5b184bd 100644 --- a/core/src/main/java/io/bitsquare/fiat/FiatAccount.java +++ b/core/src/main/java/io/bitsquare/fiat/FiatAccount.java @@ -37,7 +37,7 @@ public class FiatAccount implements Serializable { public static final long WEEK_IN_BLOCKS = DAY_IN_BLOCKS * 7; public enum Type { - IRC("", "", 2), + IRC("", "", 4), SEPA("IBAN", "BIC", WEEK_IN_BLOCKS), WIRE("primary ID", "secondary ID", WEEK_IN_BLOCKS), INTERNATIONAL("primary ID", "secondary ID", 2 * WEEK_IN_BLOCKS), diff --git a/core/src/main/java/io/bitsquare/p2p/tomp2p/BootstrappedPeerBuilder.java b/core/src/main/java/io/bitsquare/p2p/tomp2p/BootstrappedPeerBuilder.java index 1f573976b0..e4e8e7b34a 100644 --- a/core/src/main/java/io/bitsquare/p2p/tomp2p/BootstrappedPeerBuilder.java +++ b/core/src/main/java/io/bitsquare/p2p/tomp2p/BootstrappedPeerBuilder.java @@ -253,6 +253,10 @@ public class BootstrappedPeerBuilder { private void bootstrap() { log.trace("start bootstrap"); + + // We don't wait until bootstrap is done for speeding up startup process + // settableFuture.set(peerDHT); + FutureBootstrap futureBootstrap = peer.bootstrap().peerAddress(getBootstrapAddress()).start(); futureBootstrap.addListener(new BaseFutureListener() { @Override diff --git a/core/src/main/java/io/bitsquare/trade/BuyerAsOffererTrade.java b/core/src/main/java/io/bitsquare/trade/BuyerAsOffererTrade.java index d23641fcbf..6215731854 100644 --- a/core/src/main/java/io/bitsquare/trade/BuyerAsOffererTrade.java +++ b/core/src/main/java/io/bitsquare/trade/BuyerAsOffererTrade.java @@ -17,10 +17,12 @@ package io.bitsquare.trade; +import io.bitsquare.p2p.Peer; import io.bitsquare.storage.Storage; import io.bitsquare.trade.offer.Offer; import io.bitsquare.trade.protocol.trade.BuyerAsOffererProtocol; -import io.bitsquare.trade.protocol.trade.BuyerProtocol; +import io.bitsquare.trade.protocol.trade.OffererProtocol; +import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import org.bitcoinj.core.Coin; @@ -31,7 +33,7 @@ import java.io.Serializable; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class BuyerAsOffererTrade extends OffererTrade implements BuyerTrade, Serializable { +public class BuyerAsOffererTrade extends BuyerTrade implements OffererTrade, Serializable { // That object is saved to disc. We need to take care of changes to not break deserialization. private static final long serialVersionUID = 1L; @@ -66,9 +68,8 @@ public class BuyerAsOffererTrade extends OffererTrade implements BuyerTrade, Ser /////////////////////////////////////////////////////////////////////////////////////////// @Override - public void onFiatPaymentStarted() { - assert tradeProtocol instanceof BuyerProtocol; - ((BuyerProtocol) tradeProtocol).onFiatPaymentStarted(); + public void handleTakeOfferRequest(TradeMessage message, Peer taker) { + ((OffererProtocol) tradeProtocol).handleTakeOfferRequest(message, taker); } @Override diff --git a/core/src/main/java/io/bitsquare/trade/BuyerAsTakerTrade.java b/core/src/main/java/io/bitsquare/trade/BuyerAsTakerTrade.java index 22a0997d0b..6928ebe875 100644 --- a/core/src/main/java/io/bitsquare/trade/BuyerAsTakerTrade.java +++ b/core/src/main/java/io/bitsquare/trade/BuyerAsTakerTrade.java @@ -21,7 +21,7 @@ import io.bitsquare.p2p.Peer; import io.bitsquare.storage.Storage; import io.bitsquare.trade.offer.Offer; import io.bitsquare.trade.protocol.trade.BuyerAsTakerProtocol; -import io.bitsquare.trade.protocol.trade.BuyerProtocol; +import io.bitsquare.trade.protocol.trade.TakerProtocol; import org.bitcoinj.core.Coin; @@ -32,7 +32,7 @@ import java.io.Serializable; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class BuyerAsTakerTrade extends TakerTrade implements BuyerTrade, Serializable { +public class BuyerAsTakerTrade extends BuyerTrade implements TakerTrade, Serializable { // That object is saved to disc. We need to take care of changes to not break deserialization. private static final long serialVersionUID = 1L; @@ -67,9 +67,9 @@ public class BuyerAsTakerTrade extends TakerTrade implements BuyerTrade, Seriali /////////////////////////////////////////////////////////////////////////////////////////// @Override - public void onFiatPaymentStarted() { - assert tradeProtocol instanceof BuyerProtocol; - ((BuyerProtocol) tradeProtocol).onFiatPaymentStarted(); + public void takeAvailableOffer() { + assert tradeProtocol instanceof TakerProtocol; + ((TakerProtocol) tradeProtocol).takeAvailableOffer(); } @Override diff --git a/core/src/main/java/io/bitsquare/trade/BuyerTrade.java b/core/src/main/java/io/bitsquare/trade/BuyerTrade.java index cb91c31670..511e300bef 100644 --- a/core/src/main/java/io/bitsquare/trade/BuyerTrade.java +++ b/core/src/main/java/io/bitsquare/trade/BuyerTrade.java @@ -17,6 +17,94 @@ package io.bitsquare.trade; -public interface BuyerTrade { - void onFiatPaymentStarted(); +import io.bitsquare.p2p.Peer; +import io.bitsquare.storage.Storage; +import io.bitsquare.trade.offer.Offer; +import io.bitsquare.trade.protocol.trade.BuyerProtocol; +import io.bitsquare.trade.states.BuyerTradeState; +import io.bitsquare.trade.states.TradeState; + +import org.bitcoinj.core.Coin; + +import java.io.Serializable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class BuyerTrade 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(BuyerAsOffererTrade.class); + + public BuyerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, Storage storage) { + super(offer, tradeAmount, tradingPeer, storage); + log.trace("Created by constructor"); + } + + public BuyerTrade(Offer offer, Storage storage) { + super(offer, storage); + log.trace("Created by constructor"); + } + + @Override + protected void initStates() { + processState = BuyerTradeState.ProcessState.UNDEFINED; + lifeCycleState = Trade.LifeCycleState.PREPARATION; + initStateProperties(); + } + + public void onFiatPaymentStarted() { + assert tradeProtocol instanceof BuyerProtocol; + ((BuyerProtocol) tradeProtocol).onFiatPaymentStarted(); + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + @Override + public void setProcessState(TradeState.ProcessState processState) { + super.setProcessState(processState); + + /* switch ((BuyerTradeState.ProcessState) processState) { + case EXCEPTION: + disposeProtocol(); + setLifeCycleState(Trade.LifeCycleState.FAILED); + break; + }*/ + } + + @Override + public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) { + super.setLifeCycleState(lifeCycleState); + + switch (lifeCycleState) { + case FAILED: + disposeProtocol(); + break; + case COMPLETED: + disposeProtocol(); + break; + } + } + + @Override + public void setThrowable(Throwable throwable) { + super.setThrowable(throwable); + + // setProcessState(BuyerTradeState.ProcessState.EXCEPTION); + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Protected + /////////////////////////////////////////////////////////////////////////////////////////// + + @Override + protected void handleConfidenceResult() { + if (((BuyerTradeState.ProcessState) processState).ordinal() < BuyerTradeState.ProcessState.DEPOSIT_CONFIRMED.ordinal()) + setProcessState(BuyerTradeState.ProcessState.DEPOSIT_CONFIRMED); + } } diff --git a/core/src/main/java/io/bitsquare/trade/OffererTrade.java b/core/src/main/java/io/bitsquare/trade/OffererTrade.java index c4d32fb7f5..4059bc53b8 100644 --- a/core/src/main/java/io/bitsquare/trade/OffererTrade.java +++ b/core/src/main/java/io/bitsquare/trade/OffererTrade.java @@ -18,86 +18,8 @@ package io.bitsquare.trade; import io.bitsquare.p2p.Peer; -import io.bitsquare.storage.Storage; -import io.bitsquare.trade.offer.Offer; -import io.bitsquare.trade.protocol.trade.OffererProtocol; import io.bitsquare.trade.protocol.trade.messages.TradeMessage; -import io.bitsquare.trade.states.OffererTradeState; -import io.bitsquare.trade.states.TradeState; -import java.io.Serializable; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public abstract class OffererTrade 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(BuyerAsOffererTrade.class); - - public OffererTrade(Offer offer, Storage storage) { - super(offer, storage); - log.trace("Created by constructor"); - } - - @Override - protected void initStates() { - processState = OffererTradeState.ProcessState.UNDEFINED; - lifeCycleState = Trade.LifeCycleState.PREPARATION; - initStateProperties(); - } - - public void handleTakeOfferRequest(TradeMessage message, Peer taker) { - ((OffererProtocol) tradeProtocol).handleTakeOfferRequest(message, taker); - } - - - /////////////////////////////////////////////////////////////////////////////////////////// - // Setter for Mutable objects - /////////////////////////////////////////////////////////////////////////////////////////// - - @Override - public void setProcessState(TradeState.ProcessState processState) { - super.setProcessState(processState); - - switch ((OffererTradeState.ProcessState) processState) { - case EXCEPTION: - disposeProtocol(); - setLifeCycleState(Trade.LifeCycleState.FAILED); - break; - } - } - - @Override - public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) { - super.setLifeCycleState(lifeCycleState); - - switch (lifeCycleState) { - case FAILED: - disposeProtocol(); - break; - case COMPLETED: - disposeProtocol(); - break; - } - } - - @Override - public void setThrowable(Throwable throwable) { - super.setThrowable(throwable); - - setProcessState(OffererTradeState.ProcessState.EXCEPTION); - } - - - /////////////////////////////////////////////////////////////////////////////////////////// - // Protected - /////////////////////////////////////////////////////////////////////////////////////////// - - @Override - protected void handleConfidenceResult() { - if (((OffererTradeState.ProcessState) processState).ordinal() < OffererTradeState.ProcessState.DEPOSIT_CONFIRMED.ordinal()) - setProcessState(OffererTradeState.ProcessState.DEPOSIT_CONFIRMED); - } +public interface OffererTrade { + void handleTakeOfferRequest(TradeMessage message, Peer taker); } diff --git a/core/src/main/java/io/bitsquare/trade/SellerAsOffererTrade.java b/core/src/main/java/io/bitsquare/trade/SellerAsOffererTrade.java index c5d2b385b4..e5f61d269c 100644 --- a/core/src/main/java/io/bitsquare/trade/SellerAsOffererTrade.java +++ b/core/src/main/java/io/bitsquare/trade/SellerAsOffererTrade.java @@ -17,10 +17,12 @@ package io.bitsquare.trade; +import io.bitsquare.p2p.Peer; import io.bitsquare.storage.Storage; import io.bitsquare.trade.offer.Offer; +import io.bitsquare.trade.protocol.trade.OffererProtocol; import io.bitsquare.trade.protocol.trade.SellerAsOffererProtocol; -import io.bitsquare.trade.protocol.trade.SellerProtocol; +import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import java.io.IOException; import java.io.ObjectInputStream; @@ -29,7 +31,7 @@ import java.io.Serializable; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class SellerAsOffererTrade extends OffererTrade implements SellerTrade, Serializable { +public class SellerAsOffererTrade extends SellerTrade implements OffererTrade, Serializable { // That object is saved to disc. We need to take care of changes to not break deserialization. private static final long serialVersionUID = 1L; @@ -64,8 +66,7 @@ public class SellerAsOffererTrade extends OffererTrade implements SellerTrade, S /////////////////////////////////////////////////////////////////////////////////////////// @Override - public void onFiatPaymentReceived() { - assert tradeProtocol instanceof SellerProtocol; - ((SellerProtocol) tradeProtocol).onFiatPaymentReceived(); + public void handleTakeOfferRequest(TradeMessage message, Peer taker) { + ((OffererProtocol) tradeProtocol).handleTakeOfferRequest(message, taker); } } \ No newline at end of file diff --git a/core/src/main/java/io/bitsquare/trade/SellerAsTakerTrade.java b/core/src/main/java/io/bitsquare/trade/SellerAsTakerTrade.java index 9375c23975..d0b2c99bea 100644 --- a/core/src/main/java/io/bitsquare/trade/SellerAsTakerTrade.java +++ b/core/src/main/java/io/bitsquare/trade/SellerAsTakerTrade.java @@ -21,8 +21,7 @@ import io.bitsquare.p2p.Peer; import io.bitsquare.storage.Storage; import io.bitsquare.trade.offer.Offer; import io.bitsquare.trade.protocol.trade.SellerAsTakerProtocol; -import io.bitsquare.trade.protocol.trade.SellerProtocol; -import io.bitsquare.trade.states.TakerTradeState; +import io.bitsquare.trade.protocol.trade.TakerProtocol; import org.bitcoinj.core.Coin; @@ -32,11 +31,11 @@ import java.io.Serializable; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class SellerAsTakerTrade extends TakerTrade implements SellerTrade, Serializable { +public class SellerAsTakerTrade extends SellerTrade implements TakerTrade, 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(TakerTradeState.class); + transient private static final Logger log = LoggerFactory.getLogger(SellerAsTakerTrade.class); /////////////////////////////////////////////////////////////////////////////////////////// @@ -67,8 +66,8 @@ public class SellerAsTakerTrade extends TakerTrade implements SellerTrade, Seria /////////////////////////////////////////////////////////////////////////////////////////// @Override - public void onFiatPaymentReceived() { - assert tradeProtocol instanceof SellerProtocol; - ((SellerProtocol) tradeProtocol).onFiatPaymentReceived(); + public void takeAvailableOffer() { + assert tradeProtocol instanceof TakerProtocol; + ((TakerProtocol) tradeProtocol).takeAvailableOffer(); } } diff --git a/core/src/main/java/io/bitsquare/trade/SellerTrade.java b/core/src/main/java/io/bitsquare/trade/SellerTrade.java index dd268be8df..f7bf03944a 100644 --- a/core/src/main/java/io/bitsquare/trade/SellerTrade.java +++ b/core/src/main/java/io/bitsquare/trade/SellerTrade.java @@ -17,6 +17,93 @@ package io.bitsquare.trade; -public interface SellerTrade { - void onFiatPaymentReceived(); +import io.bitsquare.p2p.Peer; +import io.bitsquare.storage.Storage; +import io.bitsquare.trade.offer.Offer; +import io.bitsquare.trade.protocol.trade.SellerProtocol; +import io.bitsquare.trade.states.SellerTradeState; +import io.bitsquare.trade.states.TradeState; + +import org.bitcoinj.core.Coin; + +import java.io.Serializable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class SellerTrade 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(BuyerAsTakerTrade.class); + + public SellerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, Storage storage) { + super(offer, tradeAmount, tradingPeer, storage); + log.trace("Created by constructor"); + } + + public SellerTrade(Offer offer, Storage storage) { + super(offer, storage); + log.trace("Created by constructor"); + } + + @Override + protected void initStates() { + processState = SellerTradeState.ProcessState.UNDEFINED; + lifeCycleState = Trade.LifeCycleState.PENDING; + initStateProperties(); + } + + public void onFiatPaymentReceived() { + assert tradeProtocol instanceof SellerProtocol; + ((SellerProtocol) tradeProtocol).onFiatPaymentReceived(); + } + + /////////////////////////////////////////////////////////////////////////////////////////// + // Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + @Override + public void setProcessState(TradeState.ProcessState processState) { + super.setProcessState(processState); + + /* switch ((SellerTradeState.ProcessState) processState) { + case EXCEPTION: + disposeProtocol(); + setLifeCycleState(Trade.LifeCycleState.FAILED); + break; + }*/ + } + + @Override + public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) { + super.setLifeCycleState(lifeCycleState); + + switch (lifeCycleState) { + case FAILED: + disposeProtocol(); + break; + case COMPLETED: + disposeProtocol(); + break; + } + } + + @Override + public void setThrowable(Throwable throwable) { + super.setThrowable(throwable); + + // setProcessState(SellerTradeState.ProcessState.EXCEPTION); + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Protected + /////////////////////////////////////////////////////////////////////////////////////////// + + @Override + protected void handleConfidenceResult() { + if (((SellerTradeState.ProcessState) processState).ordinal() < SellerTradeState.ProcessState.DEPOSIT_CONFIRMED.ordinal()) + setProcessState(SellerTradeState.ProcessState.DEPOSIT_CONFIRMED); + } } diff --git a/core/src/main/java/io/bitsquare/trade/TakerTrade.java b/core/src/main/java/io/bitsquare/trade/TakerTrade.java index 44f5ce7ff2..f13b7d4775 100644 --- a/core/src/main/java/io/bitsquare/trade/TakerTrade.java +++ b/core/src/main/java/io/bitsquare/trade/TakerTrade.java @@ -17,89 +17,6 @@ package io.bitsquare.trade; -import io.bitsquare.p2p.Peer; -import io.bitsquare.storage.Storage; -import io.bitsquare.trade.offer.Offer; -import io.bitsquare.trade.protocol.trade.TakerProtocol; -import io.bitsquare.trade.states.TakerTradeState; -import io.bitsquare.trade.states.TradeState; - -import org.bitcoinj.core.Coin; - -import java.io.Serializable; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public abstract class TakerTrade 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(BuyerAsTakerTrade.class); - - public TakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, Storage storage) { - super(offer, tradeAmount, tradingPeer, storage); - log.trace("Created by constructor"); - } - - @Override - protected void initStates() { - processState = TakerTradeState.ProcessState.UNDEFINED; - lifeCycleState = Trade.LifeCycleState.PENDING; - initStateProperties(); - } - - public void takeAvailableOffer() { - assert tradeProtocol instanceof TakerProtocol; - ((TakerProtocol) tradeProtocol).takeAvailableOffer(); - } - - - /////////////////////////////////////////////////////////////////////////////////////////// - // Setter for Mutable objects - /////////////////////////////////////////////////////////////////////////////////////////// - - @Override - public void setProcessState(TradeState.ProcessState processState) { - super.setProcessState(processState); - - switch ((TakerTradeState.ProcessState) processState) { - case EXCEPTION: - disposeProtocol(); - setLifeCycleState(Trade.LifeCycleState.FAILED); - break; - } - } - - @Override - public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) { - super.setLifeCycleState(lifeCycleState); - - switch (lifeCycleState) { - case FAILED: - disposeProtocol(); - break; - case COMPLETED: - disposeProtocol(); - break; - } - } - - @Override - public void setThrowable(Throwable throwable) { - super.setThrowable(throwable); - - setProcessState(TakerTradeState.ProcessState.EXCEPTION); - } - - - /////////////////////////////////////////////////////////////////////////////////////////// - // Protected - /////////////////////////////////////////////////////////////////////////////////////////// - - @Override - protected void handleConfidenceResult() { - if (((TakerTradeState.ProcessState) processState).ordinal() < TakerTradeState.ProcessState.DEPOSIT_CONFIRMED.ordinal()) - setProcessState(TakerTradeState.ProcessState.DEPOSIT_CONFIRMED); - } +public interface TakerTrade { + void takeAvailableOffer(); } diff --git a/core/src/main/java/io/bitsquare/trade/TradeManager.java b/core/src/main/java/io/bitsquare/trade/TradeManager.java index 8ee8b0955d..cea2ae23ad 100644 --- a/core/src/main/java/io/bitsquare/trade/TradeManager.java +++ b/core/src/main/java/io/bitsquare/trade/TradeManager.java @@ -42,11 +42,10 @@ import io.bitsquare.trade.offer.Offer; import io.bitsquare.trade.offer.OpenOffer; import io.bitsquare.trade.offer.OpenOfferManager; import io.bitsquare.trade.protocol.availability.OfferAvailabilityModel; -import io.bitsquare.trade.protocol.availability.OfferAvailabilityProtocol; -import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage; -import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage; +import io.bitsquare.trade.protocol.trade.messages.DepositTxInputsRequest; +import io.bitsquare.trade.protocol.trade.messages.PayDepositRequest; import io.bitsquare.trade.protocol.trade.messages.TradeMessage; -import io.bitsquare.trade.states.OffererTradeState; +import io.bitsquare.trade.states.BuyerTradeState; import io.bitsquare.user.User; import org.bitcoinj.core.AddressFormatException; @@ -60,9 +59,7 @@ import java.io.File; import java.util.ArrayList; import java.util.Date; -import java.util.HashMap; import java.util.List; -import java.util.Map; import java.util.Optional; import javax.inject.Inject; @@ -89,11 +86,10 @@ public class TradeManager { private final WalletService walletService; private final TradeWalletService tradeWalletService; private final CryptoService cryptoService; - private OpenOfferManager openOfferManager; - private ClosedTradableManager closedTradableManager; + private final OpenOfferManager openOfferManager; + private final ClosedTradableManager closedTradableManager; private final ArbitrationRepository arbitrationRepository; - private final Map checkOfferAvailabilityProtocolMap = new HashMap<>(); private final Storage> pendingTradesStorage; private final TradableList pendingTrades; @@ -162,8 +158,8 @@ public class TradeManager { Message message = messageWithPubKey.getMessage(); // Those 2 messages are initial request form the taker. // RequestPayDepositMessage is used also in case of SellerAsTaker but there it is handled in the protocol as it is not an initial request - if (message instanceof RequestDepositTxInputsMessage || - (message instanceof RequestPayDepositMessage && ((RequestPayDepositMessage) message).isInitialRequest)) + if (message instanceof DepositTxInputsRequest || + (message instanceof PayDepositRequest && ((PayDepositRequest) message).isInitialRequest)) handleInitialTakeOfferRequest((TradeMessage) message, sender); } }); @@ -183,7 +179,7 @@ public class TradeManager { Offer offer = openOfferOptional.get().getOffer(); openOfferManager.reserveOpenOffer(openOfferOptional.get()); - OffererTrade trade; + Trade trade; if (offer.getDirection() == Offer.Direction.BUY) trade = new BuyerAsOffererTrade(offer, pendingTradesStorage); else @@ -192,7 +188,7 @@ public class TradeManager { trade.setStorage(pendingTradesStorage); pendingTrades.add(trade); initTrade(trade); - trade.handleTakeOfferRequest(message, sender); + ((OffererTrade) trade).handleTakeOfferRequest(message, sender); setupDepositPublishedListener(trade); } else { @@ -203,11 +199,23 @@ public class TradeManager { } } + private void initTrade(Trade trade) { + trade.init(messageService, + walletService, + addressService, + tradeWalletService, + blockChainService, + cryptoService, + arbitrationRepository, + user, + keyRing); + } + // Only after published we consider the openOffer as closed and the trade as completely initialized private void setupDepositPublishedListener(Trade trade) { trade.processStateProperty().addListener((ov, oldValue, newValue) -> { log.debug("setupDepositPublishedListener state = " + newValue); - if (newValue == OffererTradeState.ProcessState.DEPOSIT_PUBLISHED) { + if (newValue == BuyerTradeState.ProcessState.DEPOSIT_PUBLISHED) { openOfferManager.closeOpenOffer(trade.getOffer()); trade.setTakeOfferDate(new Date()); } @@ -270,125 +278,52 @@ public class TradeManager { /////////////////////////////////////////////////////////////////////////////////////////// public void onOfferRemovedFromRemoteOfferBook(Offer offer) { - disposeCheckOfferAvailabilityRequest(offer); + offer.cancelAvailabilityRequest(); } - /* private void handlePlaceOfferResult(Transaction transaction, Offer offer, TransactionResultHandler resultHandler) { - Trade trade; - if (offer.getDirection() == Offer.Direction.BUY) - trade = new BuyerAsOffererTrade(offer, openOfferTradesStorage); - else - trade = new SellerAsOffererTrade(offer, openOfferTradesStorage); - - openOfferTrades.add(trade); - initTrade(trade); - setupDepositPublishedListener(trade); - resultHandler.handleResult(transaction); - }*/ - - /* private void setupDepositPublishedListener(Trade trade) { - trade.processStateProperty().addListener((ov, oldValue, newValue) -> { - log.debug("setupDepositPublishedListener state = " + newValue); - if (newValue == OffererTradeState.ProcessState.DEPOSIT_PUBLISHED) { - removeOpenOffer(trade.getOffer(), - () -> log.debug("remove offer was successful"), - log::error, - false); - trade.setTakeOfferDate(new Date()); - pendingTrades.add(trade); - trade.setStorage(pendingTradesStorage); - } - }); - }*/ - - /* public void onCancelOpenOffer(Offer offer, ResultHandler resultHandler, ErrorMessageHandler errorMessageHandler) { - removeOpenOffer(offer, resultHandler, errorMessageHandler, true); - } -*/ - /* private void removeOpenOffer(Offer offer, - ResultHandler resultHandler, - ErrorMessageHandler errorMessageHandler, - boolean isCancelRequest) { - offerBookService.removeOffer(offer, - () -> { - offer.setState(Offer.State.REMOVED); - Optional offererTradeOptional = openOfferTrades.stream().filter(e -> e.getId().equals(offer.getId())).findAny(); - if (offererTradeOptional.isPresent()) { - Trade trade = offererTradeOptional.get(); - openOfferTrades.remove(trade); - - if (isCancelRequest) { - if (trade instanceof OffererTrade) - trade.setLifeCycleState(OffererTradeState.LifeCycleState.OFFER_CANCELED); - closedTrades.add(trade); - trade.disposeProtocol(); - } - } - - disposeCheckOfferAvailabilityRequest(offer); - - resultHandler.handleResult(); - }, - (message, throwable) -> errorMessageHandler.handleErrorMessage(message)); - }*/ - - /////////////////////////////////////////////////////////////////////////////////////////// // Take offer /////////////////////////////////////////////////////////////////////////////////////////// - public void checkOfferAvailability(Offer offer) { - if (!checkOfferAvailabilityProtocolMap.containsKey(offer.getId())) { - OfferAvailabilityModel model = new OfferAvailabilityModel( - offer, - keyRing.getPubKeyRing(), - messageService, - addressService); - - OfferAvailabilityProtocol protocol = new OfferAvailabilityProtocol(model, - () -> disposeCheckOfferAvailabilityRequest(offer), - (errorMessage) -> disposeCheckOfferAvailabilityRequest(offer)); - checkOfferAvailabilityProtocolMap.put(offer.getId(), protocol); - protocol.checkOfferAvailability(); - } - else { - log.error("That should never happen: onCheckOfferAvailability already called for offer with ID:" + offer.getId()); - } + public void onCheckOfferAvailability(Offer offer) { + offer.checkOfferAvailability(getOfferAvailabilityModel(offer)); } // When closing take offer view, we are not interested in the onCheckOfferAvailability result anymore, so remove from the map - public void cancelCheckOfferAvailabilityRequest(Offer offer) { - disposeCheckOfferAvailabilityRequest(offer); + public void onCancelAvailabilityRequest(Offer offer) { + offer.cancelAvailabilityRequest(); } // First we check if offer is still available then we create the trade with the protocol - public void requestTakeOffer(Coin amount, Offer offer, TakeOfferResultHandler takeOfferResultHandler) { - OfferAvailabilityModel model = new OfferAvailabilityModel(offer, keyRing.getPubKeyRing(), messageService, addressService); - OfferAvailabilityProtocol availabilityProtocol = new OfferAvailabilityProtocol(model, - () -> createTrade(amount, offer, model, takeOfferResultHandler), - (errorMessage) -> disposeCheckOfferAvailabilityRequest(offer)); - checkOfferAvailabilityProtocolMap.put(offer.getId(), availabilityProtocol); - availabilityProtocol.checkOfferAvailability(); + public void onTakeOffer(Coin amount, Offer offer, TakeOfferResultHandler takeOfferResultHandler) { + final OfferAvailabilityModel model = getOfferAvailabilityModel(offer); + offer.checkOfferAvailability(model, () -> { + if (offer.getState() == Offer.State.AVAILABLE) + createTrade(amount, offer, model, takeOfferResultHandler); + }); } - private void createTrade(Coin amount, Offer offer, OfferAvailabilityModel model, TakeOfferResultHandler - takeOfferResultHandler) { - disposeCheckOfferAvailabilityRequest(offer); - if (offer.getState() == Offer.State.AVAILABLE) { - Trade trade; - if (offer.getDirection() == Offer.Direction.BUY) - trade = new SellerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage); - else - trade = new BuyerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage); + private void createTrade(Coin amount, Offer offer, OfferAvailabilityModel model, TakeOfferResultHandler takeOfferResultHandler) { + Trade trade; + if (offer.getDirection() == Offer.Direction.BUY) + trade = new SellerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage); + else + trade = new BuyerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage); - trade.setTakeOfferDate(new Date()); - initTrade(trade); - pendingTrades.add(trade); - if (trade instanceof TakerTrade) - ((TakerTrade) trade).takeAvailableOffer(); - takeOfferResultHandler.handleResult(trade); - } + trade.setTakeOfferDate(new Date()); + initTrade(trade); + pendingTrades.add(trade); + ((TakerTrade) trade).takeAvailableOffer(); + takeOfferResultHandler.handleResult(trade); + } + + private OfferAvailabilityModel getOfferAvailabilityModel(Offer offer) { + return new OfferAvailabilityModel( + offer, + keyRing.getPubKeyRing(), + messageService, + addressService); } @@ -431,57 +366,17 @@ public class TradeManager { } - /////////////////////////////////////////////////////////////////////////////////////////// - // Called from Offerbook when offer gets removed from DHT - /////////////////////////////////////////////////////////////////////////////////////////// - - /* public void onOfferRemovedFromRemoteOfferBook(Offer offer) { - disposeCheckOfferAvailabilityRequest(offer); - } -*/ - /////////////////////////////////////////////////////////////////////////////////////////// // Getters /////////////////////////////////////////////////////////////////////////////////////////// - /* public ObservableList getOpenOfferTrades() { - return openOfferTrades.getObservableList(); - }*/ - public ObservableList getPendingTrades() { return pendingTrades.getObservableList(); } - /* public ObservableList getClosedTrades() { - return closedTrades.getObservableList(); - } -*/ - - /////////////////////////////////////////////////////////////////////////////////////////// - // Misc - /////////////////////////////////////////////////////////////////////////////////////////// - - private void disposeCheckOfferAvailabilityRequest(Offer offer) { - if (checkOfferAvailabilityProtocolMap.containsKey(offer.getId())) { - OfferAvailabilityProtocol protocol = checkOfferAvailabilityProtocolMap.get(offer.getId()); - protocol.cancel(); - checkOfferAvailabilityProtocolMap.remove(offer.getId()); - } - } - - private void initTrade(Trade trade) { - trade.init(messageService, - walletService, - addressService, - tradeWalletService, - blockChainService, - cryptoService, - arbitrationRepository, - user, - keyRing); - } - public boolean isMyOffer(Offer offer) { return offer.isMyOffer(keyRing); } + + } \ No newline at end of file diff --git a/core/src/main/java/io/bitsquare/trade/offer/Offer.java b/core/src/main/java/io/bitsquare/trade/offer/Offer.java index 161e95737e..44d63c6b85 100644 --- a/core/src/main/java/io/bitsquare/trade/offer/Offer.java +++ b/core/src/main/java/io/bitsquare/trade/offer/Offer.java @@ -18,10 +18,13 @@ package io.bitsquare.trade.offer; import io.bitsquare.btc.Restrictions; +import io.bitsquare.common.handlers.ResultHandler; import io.bitsquare.crypto.KeyRing; import io.bitsquare.crypto.PubKeyRing; import io.bitsquare.fiat.FiatAccount; import io.bitsquare.locale.Country; +import io.bitsquare.trade.protocol.availability.OfferAvailabilityModel; +import io.bitsquare.trade.protocol.availability.OfferAvailabilityProtocol; import org.bitcoinj.core.Coin; import org.bitcoinj.utils.ExchangeRate; @@ -46,8 +49,7 @@ import static com.google.common.base.Preconditions.*; public class Offer implements Serializable { // That object is sent over the wire, so we need to take care of version compatibility. private static final long serialVersionUID = 1L; - private transient static final Logger log = LoggerFactory.getLogger(Offer.class); - + transient private static final Logger log = LoggerFactory.getLogger(Offer.class); public enum Direction {BUY, SELL} @@ -88,6 +90,7 @@ public class Offer implements Serializable { // Those state properties are transient and only used at runtime! // don't access directly as it might be null; use getStateProperty() which creates an object if not instantiated transient private ObjectProperty stateProperty = new SimpleObjectProperty<>(state); + transient private OfferAvailabilityProtocol availabilityProtocol; /////////////////////////////////////////////////////////////////////////////////////////// @@ -163,7 +166,7 @@ public class Offer implements Serializable { public boolean isMyOffer(KeyRing keyRing) { return getPubKeyRing().getHashString().equals(keyRing.getPubKeyRing().getHashString()); } - + public Fiat getVolumeByAmount(Coin amount) { if (fiatPrice != 0 && amount != null && !amount.isZero()) return new ExchangeRate(Fiat.valueOf(currencyCode, fiatPrice)).coinToFiat(amount); @@ -180,6 +183,33 @@ public class Offer implements Serializable { } + /////////////////////////////////////////////////////////////////////////////////////////// + // Availability + /////////////////////////////////////////////////////////////////////////////////////////// + + public void checkOfferAvailability(OfferAvailabilityModel model) { + availabilityProtocol = new OfferAvailabilityProtocol(model, + () -> cancelAvailabilityRequest(), + (errorMessage) -> cancelAvailabilityRequest()); + availabilityProtocol.checkOfferAvailability(); + } + + + public void checkOfferAvailability(OfferAvailabilityModel model, ResultHandler resultHandler) { + availabilityProtocol = new OfferAvailabilityProtocol(model, + () -> { + cancelAvailabilityRequest(); + resultHandler.handleResult(); + }, + (errorMessage) -> availabilityProtocol.cancel()); + availabilityProtocol.checkOfferAvailability(); + } + + + public void cancelAvailabilityRequest() { + availabilityProtocol.cancel(); + } + /////////////////////////////////////////////////////////////////////////////////////////// // Setters /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/core/src/main/java/io/bitsquare/trade/protocol/availability/OfferAvailabilityProtocol.java b/core/src/main/java/io/bitsquare/trade/protocol/availability/OfferAvailabilityProtocol.java index 7ab5e2ec7f..de157f11f4 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/availability/OfferAvailabilityProtocol.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/availability/OfferAvailabilityProtocol.java @@ -112,12 +112,12 @@ public class OfferAvailabilityProtocol { if (message instanceof OfferMessage) { nonEmptyStringOf(((OfferMessage) message).offerId); if (message instanceof OfferAvailabilityResponse && model.offer.getId().equals(((OfferMessage) message).offerId)) - handleDecryptedMessage((OfferAvailabilityResponse) message); + handle((OfferAvailabilityResponse) message); } } - private void handleDecryptedMessage(OfferAvailabilityResponse message) { + private void handle(OfferAvailabilityResponse message) { stopTimeout(); model.setMessage(message); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsOffererProtocol.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsOffererProtocol.java index 1a942f4df7..10c086c3be 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsOffererProtocol.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsOffererProtocol.java @@ -21,17 +21,17 @@ import io.bitsquare.p2p.Message; import io.bitsquare.p2p.Peer; import io.bitsquare.trade.BuyerAsOffererTrade; import io.bitsquare.trade.Trade; -import io.bitsquare.trade.protocol.trade.messages.RequestFinalizePayoutTxMessage; -import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage; +import io.bitsquare.trade.protocol.trade.messages.FinalizePayoutTxRequest; +import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest; import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.CreateDepositTxInputs; -import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestDepositTxInputsMessage; -import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestFinalizePayoutTxMessage; -import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage; +import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessDepositTxInputsRequest; +import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessFinalizePayoutTxRequest; +import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessPublishDepositTxRequest; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendFiatTransferStartedMessage; +import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayDepositRequest; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayoutTxFinalizedMessage; -import io.bitsquare.trade.protocol.trade.tasks.buyer.SendRequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndFinalizePayoutTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndPublishDepositTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.VerifyAndSignContract; @@ -39,6 +39,8 @@ import io.bitsquare.trade.protocol.trade.tasks.offerer.VerifyTakeOfferFeePayment import io.bitsquare.trade.protocol.trade.tasks.offerer.VerifyTakerAccount; import io.bitsquare.trade.protocol.trade.tasks.shared.CommitPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener; +import io.bitsquare.trade.states.BuyerTradeState; +import io.bitsquare.trade.states.TradeState; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -60,6 +62,23 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc log.debug("New OffererProtocol " + this); this.buyerAsOffererTrade = trade; + + // If we are after the timelock state we need to setup the listener again + TradeState.ProcessState state = trade.processStateProperty().get(); + if (state == BuyerTradeState.ProcessState.PAYOUT_TX_COMMITTED || + state == BuyerTradeState.ProcessState.PAYOUT_TX_SENT || + state == BuyerTradeState.ProcessState.PAYOUT_BROAD_CASTED) { + TradeTaskRunner taskRunner = new TradeTaskRunner(trade, + () -> { + log.debug("taskRunner completed"); + // we are done! + processModel.onComplete(); + }, + this::handleTaskRunnerFault); + + taskRunner.addTasks(SetupPayoutTxLockTimeReachedListener.class); + taskRunner.run(); + } } @@ -79,9 +98,9 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc () -> log.debug("taskRunner at handleRequestDepositTxInputsMessage completed"), this::handleTaskRunnerFault); taskRunner.addTasks( - ProcessRequestDepositTxInputsMessage.class, + ProcessDepositTxInputsRequest.class, CreateDepositTxInputs.class, - SendRequestPayDepositMessage.class + SendPayDepositRequest.class ); taskRunner.run(); startTimeout(); @@ -94,8 +113,8 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc // Find first the actual peer address, as it might have changed in the meantime findPeerAddress(processModel.tradingPeer.getPubKeyRing(), () -> { - if (message instanceof RequestFinalizePayoutTxMessage) { - handle((RequestFinalizePayoutTxMessage) message); + if (message instanceof FinalizePayoutTxRequest) { + handle((FinalizePayoutTxRequest) message); } }, (errorMessage -> { @@ -108,7 +127,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc // Incoming message handling /////////////////////////////////////////////////////////////////////////////////////////// - private void handle(RequestPublishDepositTxMessage tradeMessage) { + private void handle(PublishDepositTxRequest tradeMessage) { stopTimeout(); processModel.setTradeMessage(tradeMessage); @@ -116,7 +135,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc () -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"), this::handleTaskRunnerFault); taskRunner.addTasks( - ProcessRequestPublishDepositTxMessage.class, + ProcessPublishDepositTxRequest.class, VerifyTakerAccount.class, VerifyAndSignContract.class, SignAndPublishDepositTx.class, @@ -133,6 +152,8 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc // User clicked the "bank transfer started" button @Override public void onFiatPaymentStarted() { + buyerAsOffererTrade.setProcessState(BuyerTradeState.ProcessState.FIAT_PAYMENT_STARTED); + TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsOffererTrade, () -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"), this::handleTaskRunnerFault); @@ -148,7 +169,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc // Incoming message handling /////////////////////////////////////////////////////////////////////////////////////////// - private void handle(RequestFinalizePayoutTxMessage tradeMessage) { + private void handle(FinalizePayoutTxRequest tradeMessage) { log.debug("handle RequestFinalizePayoutTxMessage called"); processModel.setTradeMessage(tradeMessage); @@ -161,7 +182,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc this::handleTaskRunnerFault); taskRunner.addTasks( - ProcessRequestFinalizePayoutTxMessage.class, + ProcessFinalizePayoutTxRequest.class, SignAndFinalizePayoutTx.class, CommitPayoutTx.class, SendPayoutTxFinalizedMessage.class, @@ -177,11 +198,11 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc @Override protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) { - if (tradeMessage instanceof RequestPublishDepositTxMessage) { - handle((RequestPublishDepositTxMessage) tradeMessage); + if (tradeMessage instanceof PublishDepositTxRequest) { + handle((PublishDepositTxRequest) tradeMessage); } - else if (tradeMessage instanceof RequestFinalizePayoutTxMessage) { - handle((RequestFinalizePayoutTxMessage) tradeMessage); + else if (tradeMessage instanceof FinalizePayoutTxRequest) { + handle((FinalizePayoutTxRequest) tradeMessage); } else { log.error("Incoming decrypted tradeMessage not supported. " + tradeMessage); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsTakerProtocol.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsTakerProtocol.java index 251961a531..6d018e10c0 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsTakerProtocol.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsTakerProtocol.java @@ -21,16 +21,16 @@ import io.bitsquare.p2p.Message; import io.bitsquare.p2p.Peer; import io.bitsquare.trade.BuyerAsTakerTrade; import io.bitsquare.trade.Trade; -import io.bitsquare.trade.protocol.trade.messages.RequestFinalizePayoutTxMessage; -import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage; +import io.bitsquare.trade.protocol.trade.messages.FinalizePayoutTxRequest; +import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest; import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.CreateDepositTxInputs; -import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestFinalizePayoutTxMessage; -import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage; +import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessFinalizePayoutTxRequest; +import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessPublishDepositTxRequest; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendFiatTransferStartedMessage; +import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayDepositRequest; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayoutTxFinalizedMessage; -import io.bitsquare.trade.protocol.trade.tasks.buyer.SendRequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndFinalizePayoutTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndPublishDepositTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.VerifyAndSignContract; @@ -41,6 +41,8 @@ import io.bitsquare.trade.protocol.trade.tasks.taker.BroadcastTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.tasks.taker.CreateTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOfferFeePayment; import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOffererAccount; +import io.bitsquare.trade.states.BuyerTradeState; +import io.bitsquare.trade.states.TradeState; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -62,6 +64,23 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol this.buyerAsTakerTrade = trade; processModel.tradingPeer.setPubKeyRing(trade.getOffer().getPubKeyRing()); + + // If we are after the timelock state we need to setup the listener again + TradeState.ProcessState state = trade.processStateProperty().get(); + if (state == BuyerTradeState.ProcessState.PAYOUT_TX_COMMITTED || + state == BuyerTradeState.ProcessState.PAYOUT_TX_SENT || + state == BuyerTradeState.ProcessState.PAYOUT_BROAD_CASTED) { + TradeTaskRunner taskRunner = new TradeTaskRunner(trade, + () -> { + log.debug("taskRunner completed"); + // we are done! + processModel.onComplete(); + }, + this::handleTaskRunnerFault); + + taskRunner.addTasks(SetupPayoutTxLockTimeReachedListener.class); + taskRunner.run(); + } } @@ -76,8 +95,8 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol // Find first the actual peer address, as it might have changed in the meantime findPeerAddress(trade.getOffer().getPubKeyRing(), () -> { - if (message instanceof RequestFinalizePayoutTxMessage) { - handle((RequestFinalizePayoutTxMessage) message); + if (message instanceof FinalizePayoutTxRequest) { + handle((FinalizePayoutTxRequest) message); } }, (errorMessage -> { @@ -95,7 +114,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol CreateTakeOfferFeeTx.class, BroadcastTakeOfferFeeTx.class, CreateDepositTxInputs.class, - SendRequestPayDepositMessage.class + SendPayDepositRequest.class ); taskRunner.run(); startTimeout(); @@ -106,7 +125,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol // Incoming message handling /////////////////////////////////////////////////////////////////////////////////////////// - private void handle(RequestPublishDepositTxMessage tradeMessage) { + private void handle(PublishDepositTxRequest tradeMessage) { stopTimeout(); processModel.setTradeMessage(tradeMessage); @@ -114,7 +133,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol () -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"), this::handleTaskRunnerFault); taskRunner.addTasks( - ProcessRequestPublishDepositTxMessage.class, + ProcessPublishDepositTxRequest.class, VerifyOffererAccount.class, VerifyAndSignContract.class, SignAndPublishDepositTx.class, @@ -131,6 +150,9 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol // User clicked the "bank transfer started" button @Override public void onFiatPaymentStarted() { + buyerAsTakerTrade.setProcessState(BuyerTradeState.ProcessState.FIAT_PAYMENT_STARTED); + + TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsTakerTrade, () -> log.debug("taskRunner at onFiatPaymentStarted completed"), this::handleTaskRunnerFault); @@ -147,7 +169,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol // Incoming message handling /////////////////////////////////////////////////////////////////////////////////////////// - private void handle(RequestFinalizePayoutTxMessage tradeMessage) { + private void handle(FinalizePayoutTxRequest tradeMessage) { processModel.setTradeMessage(tradeMessage); TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsTakerTrade, @@ -159,7 +181,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol this::handleTaskRunnerFault); taskRunner.addTasks( - ProcessRequestFinalizePayoutTxMessage.class, + ProcessFinalizePayoutTxRequest.class, SignAndFinalizePayoutTx.class, CommitPayoutTx.class, SendPayoutTxFinalizedMessage.class, @@ -174,11 +196,11 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol @Override protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) { - if (tradeMessage instanceof RequestPublishDepositTxMessage) { - handle((RequestPublishDepositTxMessage) tradeMessage); + if (tradeMessage instanceof PublishDepositTxRequest) { + handle((PublishDepositTxRequest) tradeMessage); } - else if (tradeMessage instanceof RequestFinalizePayoutTxMessage) { - handle((RequestFinalizePayoutTxMessage) tradeMessage); + else if (tradeMessage instanceof FinalizePayoutTxRequest) { + handle((FinalizePayoutTxRequest) tradeMessage); } else { log.error("Incoming message not supported. " + tradeMessage); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsOffererProtocol.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsOffererProtocol.java index 47b6bf7e34..667c61e7c2 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsOffererProtocol.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsOffererProtocol.java @@ -32,13 +32,15 @@ import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignContract; import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignDepositTx; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessFiatTransferStartedMessage; +import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayDepositRequest; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayoutTxFinalizedMessage; -import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessRequestPayDepositMessage; -import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestFinalizePayoutTxMessage; -import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestPublishDepositTxMessage; +import io.bitsquare.trade.protocol.trade.tasks.seller.SendFinalizePayoutTxRequest; +import io.bitsquare.trade.protocol.trade.tasks.seller.SendPublishDepositTxRequest; import io.bitsquare.trade.protocol.trade.tasks.seller.SignPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.shared.CommitPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener; +import io.bitsquare.trade.states.SellerTradeState; +import io.bitsquare.trade.states.TradeState; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -58,6 +60,23 @@ public class SellerAsOffererProtocol extends TradeProtocol implements SellerProt log.debug("New OffererProtocol " + this); this.sellerAsOffererTrade = trade; + + // If we are after the timelock state we need to setup the listener again + TradeState.ProcessState state = trade.processStateProperty().get(); + if (state == SellerTradeState.ProcessState.PAYOUT_TX_RECEIVED || + state == SellerTradeState.ProcessState.PAYOUT_TX_COMMITTED || + state == SellerTradeState.ProcessState.PAYOUT_BROAD_CASTED) { + TradeTaskRunner taskRunner = new TradeTaskRunner(trade, + () -> { + log.debug("taskRunner completed"); + // we are done! + processModel.onComplete(); + }, + this::handleTaskRunnerFault); + + taskRunner.addTasks(SetupPayoutTxLockTimeReachedListener.class); + taskRunner.run(); + } } @@ -75,11 +94,11 @@ public class SellerAsOffererProtocol extends TradeProtocol implements SellerProt this::handleTaskRunnerFault); taskRunner.addTasks( - ProcessRequestPayDepositMessage.class, + ProcessPayDepositRequest.class, VerifyTakerAccount.class, CreateAndSignContract.class, CreateAndSignDepositTx.class, - SendRequestPublishDepositTxMessage.class + SendPublishDepositTxRequest.class ); taskRunner.run(); startTimeout(); @@ -153,6 +172,8 @@ public class SellerAsOffererProtocol extends TradeProtocol implements SellerProt // User clicked the "bank transfer received" button, so we release the funds for pay out @Override public void onFiatPaymentReceived() { + sellerAsOffererTrade.setProcessState(SellerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT); + TradeTaskRunner taskRunner = new TradeTaskRunner(sellerAsOffererTrade, () -> { log.debug("taskRunner at handleFiatReceivedUIEvent completed"); @@ -165,7 +186,7 @@ public class SellerAsOffererProtocol extends TradeProtocol implements SellerProt taskRunner.addTasks( VerifyTakeOfferFeePayment.class, SignPayoutTx.class, - SendRequestFinalizePayoutTxMessage.class + SendFinalizePayoutTxRequest.class ); taskRunner.run(); } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsTakerProtocol.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsTakerProtocol.java index dba902e37a..b8f442835e 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsTakerProtocol.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsTakerProtocol.java @@ -20,22 +20,23 @@ package io.bitsquare.trade.protocol.trade; import io.bitsquare.p2p.Message; import io.bitsquare.p2p.Peer; import io.bitsquare.trade.SellerAsTakerTrade; +import io.bitsquare.trade.SellerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; +import io.bitsquare.trade.protocol.trade.messages.PayDepositRequest; import io.bitsquare.trade.protocol.trade.messages.PayoutTxFinalizedMessage; -import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.CommitDepositTx; import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignContract; import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignDepositTx; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessFiatTransferStartedMessage; +import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayDepositRequest; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayoutTxFinalizedMessage; -import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessRequestPayDepositMessage; -import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestDepositTxInputsMessage; -import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestFinalizePayoutTxMessage; -import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestPublishDepositTxMessage; +import io.bitsquare.trade.protocol.trade.tasks.seller.SendDepositTxInputsRequest; +import io.bitsquare.trade.protocol.trade.tasks.seller.SendFinalizePayoutTxRequest; +import io.bitsquare.trade.protocol.trade.tasks.seller.SendPublishDepositTxRequest; import io.bitsquare.trade.protocol.trade.tasks.seller.SignPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.shared.CommitPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener; @@ -43,6 +44,8 @@ import io.bitsquare.trade.protocol.trade.tasks.taker.BroadcastTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.tasks.taker.CreateTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOfferFeePayment; import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOffererAccount; +import io.bitsquare.trade.states.SellerTradeState; +import io.bitsquare.trade.states.TradeState; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -64,6 +67,25 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc this.sellerAsTakerTrade = trade; processModel.tradingPeer.setPubKeyRing(trade.getOffer().getPubKeyRing()); + + // If we are after the timelock state we need to setup the listener again + if (trade instanceof SellerTrade) { + TradeState.ProcessState state = trade.processStateProperty().get(); + if (state == SellerTradeState.ProcessState.PAYOUT_TX_RECEIVED || + state == SellerTradeState.ProcessState.PAYOUT_TX_COMMITTED || + state == SellerTradeState.ProcessState.PAYOUT_BROAD_CASTED) { + TradeTaskRunner taskRunner = new TradeTaskRunner(trade, + () -> { + log.debug("taskRunner completed"); + // we are done! + processModel.onComplete(); + }, + this::handleTaskRunnerFault); + + taskRunner.addTasks(SetupPayoutTxLockTimeReachedListener.class); + taskRunner.run(); + } + } } @@ -104,7 +126,7 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc taskRunner.addTasks( CreateTakeOfferFeeTx.class, BroadcastTakeOfferFeeTx.class, - SendRequestDepositTxInputsMessage.class + SendDepositTxInputsRequest.class ); taskRunner.run(); startTimeout(); @@ -115,7 +137,7 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc // Incoming message handling /////////////////////////////////////////////////////////////////////////////////////////// - private void handle(RequestPayDepositMessage tradeMessage) { + private void handle(PayDepositRequest tradeMessage) { log.debug("handle RequestPayDepositMessage"); stopTimeout(); processModel.setTradeMessage(tradeMessage); @@ -125,11 +147,11 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc this::handleTaskRunnerFault); taskRunner.addTasks( - ProcessRequestPayDepositMessage.class, + ProcessPayDepositRequest.class, VerifyOffererAccount.class, CreateAndSignContract.class, CreateAndSignDepositTx.class, - SendRequestPublishDepositTxMessage.class + SendPublishDepositTxRequest.class ); taskRunner.run(); startTimeout(); @@ -174,6 +196,8 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc // User clicked the "bank transfer received" button, so we release the funds for pay out @Override public void onFiatPaymentReceived() { + sellerAsTakerTrade.setProcessState(SellerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT); + TradeTaskRunner taskRunner = new TradeTaskRunner(sellerAsTakerTrade, () -> { log.debug("taskRunner at onFiatPaymentReceived completed"); @@ -186,7 +210,7 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc taskRunner.addTasks( VerifyOfferFeePayment.class, SignPayoutTx.class, - SendRequestFinalizePayoutTxMessage.class + SendFinalizePayoutTxRequest.class ); taskRunner.run(); } @@ -214,8 +238,8 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc @Override protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) { - if (tradeMessage instanceof RequestPayDepositMessage) { - handle((RequestPayDepositMessage) tradeMessage); + if (tradeMessage instanceof PayDepositRequest) { + handle((PayDepositRequest) tradeMessage); } else if (tradeMessage instanceof DepositTxPublishedMessage) { handle((DepositTxPublishedMessage) tradeMessage); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProtocol.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProtocol.java index dbd8fc10f2..345e910bfa 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProtocol.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProtocol.java @@ -25,13 +25,13 @@ import io.bitsquare.p2p.DecryptedMessageHandler; import io.bitsquare.p2p.Message; import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.listener.GetPeerAddressListener; -import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.TakerTrade; +import io.bitsquare.trade.BuyerTrade; +import io.bitsquare.trade.SellerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener; -import io.bitsquare.trade.states.OffererTradeState; -import io.bitsquare.trade.states.TakerTradeState; +import io.bitsquare.trade.states.BuyerTradeState; +import io.bitsquare.trade.states.SellerTradeState; import org.bitcoinj.utils.Threading; @@ -122,10 +122,10 @@ public abstract class TradeProtocol { this.trade = trade; boolean needPayoutTxBroadcast = false; - if (trade instanceof TakerTrade) - needPayoutTxBroadcast = trade.processStateProperty().get() == TakerTradeState.ProcessState.PAYOUT_FINALIZED; - else if (trade instanceof OffererTrade) - needPayoutTxBroadcast = trade.processStateProperty().get() == OffererTradeState.ProcessState.PAYOUT_FINALIZED; + if (trade instanceof SellerTrade) + needPayoutTxBroadcast = trade.processStateProperty().get() == SellerTradeState.ProcessState.PAYOUT_TX_COMMITTED; + else if (trade instanceof BuyerTrade) + needPayoutTxBroadcast = trade.processStateProperty().get() == BuyerTradeState.ProcessState.PAYOUT_TX_COMMITTED; if (needPayoutTxBroadcast) { TradeTaskRunner taskRunner = new TradeTaskRunner(trade, @@ -150,10 +150,10 @@ public abstract class TradeProtocol { public void run() { Threading.USER_THREAD.execute(() -> { log.debug("Timeout reached"); - if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.TIMEOUT); - else if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.TIMEOUT); + /* if (trade instanceof SellerTrade) + trade.setProcessState(SellerTradeState.ProcessState.TIMEOUT); + else if (trade instanceof BuyerTrade) + trade.setProcessState(BuyerTradeState.ProcessState.TIMEOUT);*/ }); } }; diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestDepositTxInputsMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/DepositTxInputsRequest.java similarity index 86% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestDepositTxInputsMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/messages/DepositTxInputsRequest.java index 610eaa570a..102648c10c 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestDepositTxInputsMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/DepositTxInputsRequest.java @@ -26,7 +26,7 @@ import java.io.Serializable; import javax.annotation.concurrent.Immutable; @Immutable -public class RequestDepositTxInputsMessage extends TradeMessage implements Serializable { +public class DepositTxInputsRequest extends TradeMessage implements Serializable { // That object is sent over the wire, so we need to take care of version compatibility. private static final long serialVersionUID = 1L; @@ -35,7 +35,7 @@ public class RequestDepositTxInputsMessage extends TradeMessage implements Seria public final String sellerOfferFeeTxId; public final byte[] sellerTradeWalletPubKey; - public RequestDepositTxInputsMessage(String tradeId, PubKeyRing sellerPubKeyRing, String sellerOfferFeeTxId, Coin tradeAmount, byte[] + public DepositTxInputsRequest(String tradeId, PubKeyRing sellerPubKeyRing, String sellerOfferFeeTxId, Coin tradeAmount, byte[] sellerTradeWalletPubKey) { super(tradeId); this.sellerPubKeyRing = sellerPubKeyRing; diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestFinalizePayoutTxMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/FinalizePayoutTxRequest.java similarity index 78% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestFinalizePayoutTxMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/messages/FinalizePayoutTxRequest.java index 0943b5aa71..f0842f1cca 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestFinalizePayoutTxMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/FinalizePayoutTxRequest.java @@ -24,7 +24,7 @@ import java.io.Serializable; import javax.annotation.concurrent.Immutable; @Immutable -public class RequestFinalizePayoutTxMessage extends TradeMessage implements MailboxMessage, Serializable { +public class FinalizePayoutTxRequest extends TradeMessage implements MailboxMessage, Serializable { // That object is sent over the wire, so we need to take care of version compatibility. private static final long serialVersionUID = 1L; @@ -32,10 +32,10 @@ public class RequestFinalizePayoutTxMessage extends TradeMessage implements Mail public final String sellerPayoutAddress; public final long lockTime; - public RequestFinalizePayoutTxMessage(String tradeId, - byte[] sellerSignature, - String sellerPayoutAddress, - long lockTime) { + public FinalizePayoutTxRequest(String tradeId, + byte[] sellerSignature, + String sellerPayoutAddress, + long lockTime) { super(tradeId); this.sellerSignature = sellerSignature; this.sellerPayoutAddress = sellerPayoutAddress; diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestPayDepositMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/PayDepositRequest.java similarity index 74% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestPayDepositMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/messages/PayDepositRequest.java index a4608453fa..a89b80911d 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestPayDepositMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/PayDepositRequest.java @@ -30,7 +30,7 @@ import java.util.List; import javax.annotation.concurrent.Immutable; @Immutable -public class RequestPayDepositMessage extends TradeMessage implements Serializable { +public class PayDepositRequest extends TradeMessage implements Serializable { // That object is sent over the wire, so we need to take care of version compatibility. private static final long serialVersionUID = 1L; @@ -43,15 +43,15 @@ public class RequestPayDepositMessage extends TradeMessage implements Serializab public final String buyerAccountId; public final Coin tradeAmount; - public RequestPayDepositMessage(String tradeId, - Coin tradeAmount, - boolean isInitialRequest, - List buyerConnectedOutputsForAllInputs, - List buyerOutputs, - byte[] buyerTradeWalletPubKey, - PubKeyRing buyerPubKeyRing, - FiatAccount buyerFiatAccount, - String buyerAccountId) { + public PayDepositRequest(String tradeId, + Coin tradeAmount, + boolean isInitialRequest, + List buyerConnectedOutputsForAllInputs, + List buyerOutputs, + byte[] buyerTradeWalletPubKey, + PubKeyRing buyerPubKeyRing, + FiatAccount buyerFiatAccount, + String buyerAccountId) { super(tradeId); this.tradeAmount = tradeAmount; this.isInitialRequest = isInitialRequest; diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestPublishDepositTxMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/PublishDepositTxRequest.java similarity index 73% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestPublishDepositTxMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/messages/PublishDepositTxRequest.java index 24f55ffd27..3f9848a411 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestPublishDepositTxMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/PublishDepositTxRequest.java @@ -29,7 +29,7 @@ import java.util.List; import javax.annotation.concurrent.Immutable; @Immutable -public class RequestPublishDepositTxMessage extends TradeMessage implements Serializable { +public class PublishDepositTxRequest extends TradeMessage implements Serializable { // That object is sent over the wire, so we need to take care of version compatibility. private static final long serialVersionUID = 1L; @@ -42,15 +42,15 @@ public class RequestPublishDepositTxMessage extends TradeMessage implements Seri public final List sellerConnectedOutputsForAllInputs; public final byte[] sellerTradeWalletPubKey; - public RequestPublishDepositTxMessage(String tradeId, - FiatAccount sellerFiatAccount, - String sellerAccountId, - byte[] sellerTradeWalletPubKey, - String sellerContractAsJson, - String sellerContractSignature, - String sellerPayoutAddressString, - Transaction sellersPreparedDepositTx, - List sellerConnectedOutputsForAllInputs) { + public PublishDepositTxRequest(String tradeId, + FiatAccount sellerFiatAccount, + String sellerAccountId, + byte[] sellerTradeWalletPubKey, + String sellerContractAsJson, + String sellerContractSignature, + String sellerPayoutAddressString, + Transaction sellersPreparedDepositTx, + List sellerConnectedOutputsForAllInputs) { super(tradeId); this.sellerFiatAccount = sellerFiatAccount; this.sellerAccountId = sellerAccountId; diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestDepositTxInputsMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessDepositTxInputsRequest.java similarity index 83% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestDepositTxInputsMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessDepositTxInputsRequest.java index 5499199119..8fa7c58759 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestDepositTxInputsMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessDepositTxInputsRequest.java @@ -20,7 +20,7 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer; 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.RequestDepositTxInputsMessage; +import io.bitsquare.trade.protocol.trade.messages.DepositTxInputsRequest; import io.bitsquare.trade.states.StateUtil; import org.slf4j.Logger; @@ -29,17 +29,17 @@ import org.slf4j.LoggerFactory; import static com.google.common.base.Preconditions.checkNotNull; import static io.bitsquare.util.Validator.*; -public class ProcessRequestDepositTxInputsMessage extends TradeTask { - private static final Logger log = LoggerFactory.getLogger(ProcessRequestDepositTxInputsMessage.class); +public class ProcessDepositTxInputsRequest extends TradeTask { + private static final Logger log = LoggerFactory.getLogger(ProcessDepositTxInputsRequest.class); - public ProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) { + public ProcessDepositTxInputsRequest(TaskRunner taskHandler, Trade trade) { super(taskHandler, trade); } @Override protected void doRun() { try { - RequestDepositTxInputsMessage message = (RequestDepositTxInputsMessage) processModel.getTradeMessage(); + DepositTxInputsRequest message = (DepositTxInputsRequest) processModel.getTradeMessage(); checkTradeId(processModel.getId(), message); checkNotNull(message); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestFinalizePayoutTxMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessFinalizePayoutTxRequest.java similarity index 78% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestFinalizePayoutTxMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessFinalizePayoutTxRequest.java index e5946e6d66..9372cda028 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestFinalizePayoutTxMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessFinalizePayoutTxRequest.java @@ -20,7 +20,8 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer; 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.RequestFinalizePayoutTxMessage; +import io.bitsquare.trade.protocol.trade.messages.FinalizePayoutTxRequest; +import io.bitsquare.trade.states.BuyerTradeState; import io.bitsquare.trade.states.StateUtil; import org.slf4j.Logger; @@ -29,17 +30,17 @@ import org.slf4j.LoggerFactory; import static com.google.common.base.Preconditions.checkNotNull; import static io.bitsquare.util.Validator.*; -public class ProcessRequestFinalizePayoutTxMessage extends TradeTask { - private static final Logger log = LoggerFactory.getLogger(ProcessRequestFinalizePayoutTxMessage.class); +public class ProcessFinalizePayoutTxRequest extends TradeTask { + private static final Logger log = LoggerFactory.getLogger(ProcessFinalizePayoutTxRequest.class); - public ProcessRequestFinalizePayoutTxMessage(TaskRunner taskHandler, Trade trade) { + public ProcessFinalizePayoutTxRequest(TaskRunner taskHandler, Trade trade) { super(taskHandler, trade); } @Override protected void doRun() { try { - RequestFinalizePayoutTxMessage message = (RequestFinalizePayoutTxMessage) processModel.getTradeMessage(); + FinalizePayoutTxRequest message = (FinalizePayoutTxRequest) processModel.getTradeMessage(); checkTradeId(processModel.getId(), message); checkNotNull(message); @@ -47,6 +48,8 @@ public class ProcessRequestFinalizePayoutTxMessage extends TradeTask { processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.sellerPayoutAddress)); trade.setLockTime(nonNegativeLongOf(message.lockTime)); + trade.setProcessState(BuyerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT_MSG_RECEIVED); + complete(); } catch (Throwable t) { t.printStackTrace(); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestPublishDepositTxMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessPublishDepositTxRequest.java similarity index 86% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestPublishDepositTxMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessPublishDepositTxRequest.java index a62e5bc349..f03170e9c6 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestPublishDepositTxMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessPublishDepositTxRequest.java @@ -20,7 +20,7 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer; 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.RequestPublishDepositTxMessage; +import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest; import io.bitsquare.trade.states.StateUtil; import org.slf4j.Logger; @@ -29,17 +29,17 @@ import org.slf4j.LoggerFactory; import static com.google.common.base.Preconditions.*; import static io.bitsquare.util.Validator.*; -public class ProcessRequestPublishDepositTxMessage extends TradeTask { - private static final Logger log = LoggerFactory.getLogger(ProcessRequestPublishDepositTxMessage.class); +public class ProcessPublishDepositTxRequest extends TradeTask { + private static final Logger log = LoggerFactory.getLogger(ProcessPublishDepositTxRequest.class); - public ProcessRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) { + public ProcessPublishDepositTxRequest(TaskRunner taskHandler, Trade trade) { super(taskHandler, trade); } @Override protected void doRun() { try { - RequestPublishDepositTxMessage message = (RequestPublishDepositTxMessage) processModel.getTradeMessage(); + PublishDepositTxRequest message = (PublishDepositTxRequest) processModel.getTradeMessage(); checkTradeId(processModel.getId(), message); checkNotNull(message); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendDepositTxPublishedMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendDepositTxPublishedMessage.java index f8416fceea..136db8ab5f 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendDepositTxPublishedMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendDepositTxPublishedMessage.java @@ -22,6 +22,7 @@ import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; +import io.bitsquare.trade.states.BuyerTradeState; import io.bitsquare.trade.states.StateUtil; import org.slf4j.Logger; @@ -48,6 +49,8 @@ public class SendDepositTxPublishedMessage extends TradeTask { public void handleResult() { log.trace("DepositTxPublishedMessage successfully arrived at peer"); + trade.setProcessState(BuyerTradeState.ProcessState.DEPOSIT_PUBLISHED_MSG_SENT); + complete(); } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendFiatTransferStartedMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendFiatTransferStartedMessage.java index e3ee5a0eb7..bc3048e97e 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendFiatTransferStartedMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendFiatTransferStartedMessage.java @@ -19,14 +19,11 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer; import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.p2p.listener.SendMessageListener; -import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; -import io.bitsquare.trade.states.OffererTradeState; +import io.bitsquare.trade.states.BuyerTradeState; import io.bitsquare.trade.states.StateUtil; -import io.bitsquare.trade.states.TakerTradeState; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -54,10 +51,7 @@ public class SendFiatTransferStartedMessage extends TradeTask { public void handleResult() { log.trace("Sending FiatTransferStartedMessage succeeded."); - if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.FIAT_PAYMENT_STARTED); - if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.FIAT_PAYMENT_STARTED); + trade.setProcessState(BuyerTradeState.ProcessState.FIAT_PAYMENT_STARTED_MSG_SENT); complete(); } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendRequestPayDepositMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendPayDepositRequest.java similarity index 89% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendRequestPayDepositMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendPayDepositRequest.java index 72121e19a7..30408e3209 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendRequestPayDepositMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendPayDepositRequest.java @@ -22,16 +22,16 @@ import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.trade.BuyerAsTakerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; -import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage; +import io.bitsquare.trade.protocol.trade.messages.PayDepositRequest; import io.bitsquare.trade.states.StateUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class SendRequestPayDepositMessage extends TradeTask { - private static final Logger log = LoggerFactory.getLogger(SendRequestPayDepositMessage.class); +public class SendPayDepositRequest extends TradeTask { + private static final Logger log = LoggerFactory.getLogger(SendPayDepositRequest.class); - public SendRequestPayDepositMessage(TaskRunner taskHandler, Trade trade) { + public SendPayDepositRequest(TaskRunner taskHandler, Trade trade) { super(taskHandler, trade); } @@ -39,7 +39,7 @@ public class SendRequestPayDepositMessage extends TradeTask { protected void doRun() { try { boolean isInitialRequest = trade instanceof BuyerAsTakerTrade; - RequestPayDepositMessage tradeMessage = new RequestPayDepositMessage( + PayDepositRequest tradeMessage = new PayDepositRequest( processModel.getId(), trade.getTradeAmount(), isInitialRequest, diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendPayoutTxFinalizedMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendPayoutTxFinalizedMessage.java index e363b0d14f..6f0afc3abf 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendPayoutTxFinalizedMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendPayoutTxFinalizedMessage.java @@ -22,6 +22,7 @@ import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.messages.PayoutTxFinalizedMessage; +import io.bitsquare.trade.states.BuyerTradeState; import io.bitsquare.trade.states.StateUtil; import org.slf4j.Logger; @@ -47,6 +48,8 @@ public class SendPayoutTxFinalizedMessage extends TradeTask { public void handleResult() { log.trace("PayoutTxFinalizedMessage successfully arrived at peer"); + trade.setProcessState(BuyerTradeState.ProcessState.PAYOUT_TX_SENT); + complete(); } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SignAndFinalizePayoutTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SignAndFinalizePayoutTx.java index 247274a6e3..1ac862439b 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SignAndFinalizePayoutTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SignAndFinalizePayoutTx.java @@ -18,12 +18,8 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer; import io.bitsquare.common.taskrunner.TaskRunner; -import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; -import io.bitsquare.trade.states.OffererTradeState; -import io.bitsquare.trade.states.TakerTradeState; import org.bitcoinj.core.Coin; import org.bitcoinj.core.Transaction; @@ -60,10 +56,6 @@ public class SignAndFinalizePayoutTx extends TradeTask { ); trade.setPayoutTx(transaction); - if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_FINALIZED); - else if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_FINALIZED); complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SignAndPublishDepositTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SignAndPublishDepositTx.java index 0db201b5ce..e8aabaa808 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SignAndPublishDepositTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SignAndPublishDepositTx.java @@ -19,12 +19,10 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer; import io.bitsquare.btc.FeePolicy; import io.bitsquare.common.taskrunner.TaskRunner; -import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.TakerTrade; +import io.bitsquare.trade.BuyerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; -import io.bitsquare.trade.states.OffererTradeState; -import io.bitsquare.trade.states.TakerTradeState; +import io.bitsquare.trade.states.BuyerTradeState; import org.bitcoinj.core.Coin; import org.bitcoinj.core.Transaction; @@ -67,11 +65,7 @@ public class SignAndPublishDepositTx extends TradeTask { trade.setDepositTx(transaction); trade.setLifeCycleState(Trade.LifeCycleState.PENDING); - if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.DEPOSIT_PUBLISHED); - else if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.DEPOSIT_PUBLISHED); - + trade.setProcessState(BuyerTradeState.ProcessState.DEPOSIT_PUBLISHED); trade.setTakeOfferDate(new Date()); complete(); @@ -91,7 +85,7 @@ public class SignAndPublishDepositTx extends TradeTask { t.printStackTrace(); trade.setThrowable(t); - if (trade instanceof OffererTrade) + if (trade instanceof BuyerTrade) trade.setLifeCycleState(Trade.LifeCycleState.PREPARATION); failed(t); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessDepositTxPublishedMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessDepositTxPublishedMessage.java index 4a350bcd23..119158b021 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessDepositTxPublishedMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessDepositTxPublishedMessage.java @@ -18,13 +18,10 @@ package io.bitsquare.trade.protocol.trade.tasks.seller; import io.bitsquare.common.taskrunner.TaskRunner; -import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; -import io.bitsquare.trade.states.OffererTradeState; -import io.bitsquare.trade.states.TakerTradeState; +import io.bitsquare.trade.states.SellerTradeState; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -48,10 +45,7 @@ public class ProcessDepositTxPublishedMessage extends TradeTask { trade.setDepositTx(checkNotNull(message.depositTx)); - if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.DEPOSIT_PUBLISHED); - else if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.DEPOSIT_PUBLISHED); + trade.setProcessState(SellerTradeState.ProcessState.DEPOSIT_PUBLISHED_MSG_RECEIVED); complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessFiatTransferStartedMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessFiatTransferStartedMessage.java index 161d10c33a..940cb1cfcb 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessFiatTransferStartedMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessFiatTransferStartedMessage.java @@ -18,13 +18,10 @@ package io.bitsquare.trade.protocol.trade.tasks.seller; import io.bitsquare.common.taskrunner.TaskRunner; -import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; -import io.bitsquare.trade.states.OffererTradeState; -import io.bitsquare.trade.states.TakerTradeState; +import io.bitsquare.trade.states.SellerTradeState; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -48,10 +45,7 @@ public class ProcessFiatTransferStartedMessage extends TradeTask { processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress)); - if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.FIAT_PAYMENT_STARTED); - else if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.FIAT_PAYMENT_STARTED); + trade.setProcessState(SellerTradeState.ProcessState.FIAT_PAYMENT_STARTED_MSG_RECEIVED); complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessRequestPayDepositMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessPayDepositRequest.java similarity index 85% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessRequestPayDepositMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessPayDepositRequest.java index 3667674fa1..acfebc8909 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessRequestPayDepositMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessPayDepositRequest.java @@ -20,7 +20,7 @@ package io.bitsquare.trade.protocol.trade.tasks.seller; 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.messages.PayDepositRequest; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -28,17 +28,17 @@ import org.slf4j.LoggerFactory; import static com.google.common.base.Preconditions.*; import static io.bitsquare.util.Validator.*; -public class ProcessRequestPayDepositMessage extends TradeTask { - private static final Logger log = LoggerFactory.getLogger(ProcessRequestPayDepositMessage.class); +public class ProcessPayDepositRequest extends TradeTask { + private static final Logger log = LoggerFactory.getLogger(ProcessPayDepositRequest.class); - public ProcessRequestPayDepositMessage(TaskRunner taskHandler, Trade trade) { + public ProcessPayDepositRequest(TaskRunner taskHandler, Trade trade) { super(taskHandler, trade); } @Override protected void doRun() { try { - RequestPayDepositMessage message = (RequestPayDepositMessage) processModel.getTradeMessage(); + PayDepositRequest message = (PayDepositRequest) processModel.getTradeMessage(); checkTradeId(processModel.getId(), message); checkNotNull(message); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessPayoutTxFinalizedMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessPayoutTxFinalizedMessage.java index e2ec51e80c..5605d76a43 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessPayoutTxFinalizedMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessPayoutTxFinalizedMessage.java @@ -18,13 +18,10 @@ package io.bitsquare.trade.protocol.trade.tasks.seller; import io.bitsquare.common.taskrunner.TaskRunner; -import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.messages.PayoutTxFinalizedMessage; -import io.bitsquare.trade.states.OffererTradeState; -import io.bitsquare.trade.states.TakerTradeState; +import io.bitsquare.trade.states.SellerTradeState; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -48,10 +45,7 @@ public class ProcessPayoutTxFinalizedMessage extends TradeTask { trade.setPayoutTx(checkNotNull(message.payoutTx)); - if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_FINALIZED); - else if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_FINALIZED); + trade.setProcessState(SellerTradeState.ProcessState.PAYOUT_TX_RECEIVED); complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestDepositTxInputsMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendDepositTxInputsRequest.java similarity index 89% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestDepositTxInputsMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendDepositTxInputsRequest.java index 4654cc80d6..17ea6124c8 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestDepositTxInputsMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendDepositTxInputsRequest.java @@ -21,7 +21,7 @@ import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; -import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage; +import io.bitsquare.trade.protocol.trade.messages.DepositTxInputsRequest; import io.bitsquare.trade.states.StateUtil; import org.bitcoinj.utils.Threading; @@ -29,10 +29,10 @@ import org.bitcoinj.utils.Threading; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class SendRequestDepositTxInputsMessage extends TradeTask { - private static final Logger log = LoggerFactory.getLogger(SendRequestDepositTxInputsMessage.class); +public class SendDepositTxInputsRequest extends TradeTask { + private static final Logger log = LoggerFactory.getLogger(SendDepositTxInputsRequest.class); - public SendRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) { + public SendDepositTxInputsRequest(TaskRunner taskHandler, Trade trade) { super(taskHandler, trade); } @@ -42,7 +42,7 @@ public class SendRequestDepositTxInputsMessage extends TradeTask { protected void doRun() { try { assert processModel.getTakeOfferFeeTx() != null; - RequestDepositTxInputsMessage message = new RequestDepositTxInputsMessage( + DepositTxInputsRequest message = new DepositTxInputsRequest( processModel.getId(), processModel.getPubKeyRing(), processModel.getTakeOfferFeeTx().getHashAsString(), @@ -67,7 +67,7 @@ public class SendRequestDepositTxInputsMessage extends TradeTask { // We try to repeat once and if that fails as well we persist the state for a later retry. if (retryCounter == 0) { retryCounter++; - Threading.USER_THREAD.execute(SendRequestDepositTxInputsMessage.this::doRun); + Threading.USER_THREAD.execute(SendDepositTxInputsRequest.this::doRun); } else { appendToErrorMessage("Sending TakeOfferFeePayedMessage to offerer failed. Maybe the network connection was " + diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestFinalizePayoutTxMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendFinalizePayoutTxRequest.java similarity index 73% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestFinalizePayoutTxMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendFinalizePayoutTxRequest.java index 72936edeb8..0d3538fb4a 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestFinalizePayoutTxMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendFinalizePayoutTxRequest.java @@ -19,29 +19,26 @@ package io.bitsquare.trade.protocol.trade.tasks.seller; import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.p2p.listener.SendMessageListener; -import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; -import io.bitsquare.trade.protocol.trade.messages.RequestFinalizePayoutTxMessage; -import io.bitsquare.trade.states.OffererTradeState; +import io.bitsquare.trade.protocol.trade.messages.FinalizePayoutTxRequest; +import io.bitsquare.trade.states.SellerTradeState; import io.bitsquare.trade.states.StateUtil; -import io.bitsquare.trade.states.TakerTradeState; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class SendRequestFinalizePayoutTxMessage extends TradeTask { - private static final Logger log = LoggerFactory.getLogger(SendRequestFinalizePayoutTxMessage.class); +public class SendFinalizePayoutTxRequest extends TradeTask { + private static final Logger log = LoggerFactory.getLogger(SendFinalizePayoutTxRequest.class); - public SendRequestFinalizePayoutTxMessage(TaskRunner taskHandler, Trade trade) { + public SendFinalizePayoutTxRequest(TaskRunner taskHandler, Trade trade) { super(taskHandler, trade); } @Override protected void doRun() { try { - RequestFinalizePayoutTxMessage message = new RequestFinalizePayoutTxMessage( + FinalizePayoutTxRequest message = new FinalizePayoutTxRequest( processModel.getId(), processModel.getPayoutTxSignature(), processModel.getAddressEntry().getAddressString(), @@ -57,10 +54,7 @@ public class SendRequestFinalizePayoutTxMessage extends TradeTask { public void handleResult() { log.trace("PayoutTxPublishedMessage successfully arrived at peer"); - if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.REQUEST_PAYOUT_FINALIZE_MSG_SENT); - else if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.REQUEST_PAYOUT_FINALIZE_MSG_SENT); + trade.setProcessState(SellerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT_MSG_SENT); complete(); } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestPublishDepositTxMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendPublishDepositTxRequest.java similarity index 87% rename from core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestPublishDepositTxMessage.java rename to core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendPublishDepositTxRequest.java index 3e21cf2b74..bf8493cb18 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestPublishDepositTxMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendPublishDepositTxRequest.java @@ -21,23 +21,23 @@ import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; -import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage; +import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest; import io.bitsquare.trade.states.StateUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class SendRequestPublishDepositTxMessage extends TradeTask { - private static final Logger log = LoggerFactory.getLogger(SendRequestPublishDepositTxMessage.class); +public class SendPublishDepositTxRequest extends TradeTask { + private static final Logger log = LoggerFactory.getLogger(SendPublishDepositTxRequest.class); - public SendRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) { + public SendPublishDepositTxRequest(TaskRunner taskHandler, Trade trade) { super(taskHandler, trade); } @Override protected void doRun() { try { - RequestPublishDepositTxMessage tradeMessage = new RequestPublishDepositTxMessage( + PublishDepositTxRequest tradeMessage = new PublishDepositTxRequest( processModel.getId(), processModel.getFiatAccount(), processModel.getAccountId(), diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/shared/CommitPayoutTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/shared/CommitPayoutTx.java index 3bb5cb2b0c..12ab6730b3 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/shared/CommitPayoutTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/shared/CommitPayoutTx.java @@ -18,8 +18,12 @@ package io.bitsquare.trade.protocol.trade.tasks.shared; import io.bitsquare.common.taskrunner.TaskRunner; +import io.bitsquare.trade.BuyerTrade; +import io.bitsquare.trade.SellerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; +import io.bitsquare.trade.states.BuyerTradeState; +import io.bitsquare.trade.states.SellerTradeState; import org.bitcoinj.core.Transaction; @@ -40,6 +44,11 @@ public class CommitPayoutTx extends TradeTask { trade.setPayoutTx(transaction); + if (trade instanceof BuyerTrade) + trade.setProcessState(BuyerTradeState.ProcessState.PAYOUT_TX_COMMITTED); + else if (trade instanceof SellerTrade) + trade.setProcessState(SellerTradeState.ProcessState.PAYOUT_TX_COMMITTED); + complete(); } catch (Throwable t) { t.printStackTrace(); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/shared/SetupPayoutTxLockTimeReachedListener.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/shared/SetupPayoutTxLockTimeReachedListener.java index 9c8a99924f..4a1467be77 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/shared/SetupPayoutTxLockTimeReachedListener.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/shared/SetupPayoutTxLockTimeReachedListener.java @@ -18,12 +18,12 @@ package io.bitsquare.trade.protocol.trade.tasks.shared; import io.bitsquare.common.taskrunner.TaskRunner; -import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.TakerTrade; +import io.bitsquare.trade.BuyerTrade; +import io.bitsquare.trade.SellerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; -import io.bitsquare.trade.states.OffererTradeState; -import io.bitsquare.trade.states.TakerTradeState; +import io.bitsquare.trade.states.BuyerTradeState; +import io.bitsquare.trade.states.SellerTradeState; import org.bitcoinj.core.StoredBlock; import org.bitcoinj.core.Transaction; @@ -79,10 +79,11 @@ public class SetupPayoutTxLockTimeReachedListener extends TradeTask { public void onSuccess(Transaction transaction) { log.debug("BroadcastTx succeeded. Transaction:" + transaction); - if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_BROAD_CASTED); - else if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_BROAD_CASTED); + if (trade instanceof BuyerTrade) + trade.setProcessState(BuyerTradeState.ProcessState.PAYOUT_BROAD_CASTED); + else if (trade instanceof SellerTrade) + trade.setProcessState(SellerTradeState.ProcessState.PAYOUT_BROAD_CASTED); + complete(); } @@ -91,11 +92,11 @@ public class SetupPayoutTxLockTimeReachedListener extends TradeTask { public void onFailure(@NotNull Throwable t) { t.printStackTrace(); trade.setThrowable(t); - +/* if (trade instanceof TakerTrade) trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_BROAD_CASTED_FAILED); else if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_BROAD_CASTED_FAILED); + trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_BROAD_CASTED_FAILED);*/ failed(t); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/taker/BroadcastTakeOfferFeeTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/taker/BroadcastTakeOfferFeeTx.java index ec3177bfd2..5ef25ce8d4 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/taker/BroadcastTakeOfferFeeTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/taker/BroadcastTakeOfferFeeTx.java @@ -18,10 +18,8 @@ package io.bitsquare.trade.protocol.trade.tasks.taker; import io.bitsquare.common.taskrunner.TaskRunner; -import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; -import io.bitsquare.trade.states.TakerTradeState; import org.bitcoinj.core.Transaction; @@ -48,8 +46,9 @@ public class BroadcastTakeOfferFeeTx extends TradeTask { public void onSuccess(Transaction transaction) { log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString()); - if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISHED); + /* if (trade instanceof SellerTrade) + trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);*/ + complete(); } @@ -59,8 +58,8 @@ public class BroadcastTakeOfferFeeTx extends TradeTask { appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again."); trade.setErrorMessage(errorMessage); - if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED); + /* if (trade instanceof SellerTrade) + trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);*/ failed(t); } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/taker/CreateTakeOfferFeeTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/taker/CreateTakeOfferFeeTx.java index 93aa706db2..5c3e9159f2 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/taker/CreateTakeOfferFeeTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/taker/CreateTakeOfferFeeTx.java @@ -18,10 +18,8 @@ package io.bitsquare.trade.protocol.trade.tasks.taker; import io.bitsquare.common.taskrunner.TaskRunner; -import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.Trade; import io.bitsquare.trade.protocol.trade.TradeTask; -import io.bitsquare.trade.states.TakerTradeState; import org.bitcoinj.core.Transaction; @@ -43,8 +41,8 @@ public class CreateTakeOfferFeeTx extends TradeTask { processModel.setTakeOfferFeeTx(createTakeOfferFeeTx); processModel.setTakeOfferFeeTxId(createTakeOfferFeeTx.getHashAsString()); - if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_TX_CREATED); + /*if (trade instanceof SellerTrade) + trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_TX_CREATED);*/ complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/states/OffererTradeState.java b/core/src/main/java/io/bitsquare/trade/states/BuyerTradeState.java similarity index 74% rename from core/src/main/java/io/bitsquare/trade/states/OffererTradeState.java rename to core/src/main/java/io/bitsquare/trade/states/BuyerTradeState.java index 1183c714c7..a2c49eb472 100644 --- a/core/src/main/java/io/bitsquare/trade/states/OffererTradeState.java +++ b/core/src/main/java/io/bitsquare/trade/states/BuyerTradeState.java @@ -20,24 +20,24 @@ package io.bitsquare.trade.states; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class OffererTradeState { - private static final Logger log = LoggerFactory.getLogger(OffererTradeState.class); +public class BuyerTradeState { + private static final Logger log = LoggerFactory.getLogger(BuyerTradeState.class); public enum ProcessState implements TradeState.ProcessState { UNDEFINED, + DEPOSIT_PUBLISHED, + DEPOSIT_PUBLISHED_MSG_SENT, DEPOSIT_CONFIRMED, FIAT_PAYMENT_STARTED, + FIAT_PAYMENT_STARTED_MSG_SENT, - REQUEST_PAYOUT_FINALIZE_MSG_SENT, // seller only - PAYOUT_FINALIZED, + FIAT_PAYMENT_RECEIPT_MSG_RECEIVED, - PAYOUT_BROAD_CASTED, - PAYOUT_BROAD_CASTED_FAILED, + PAYOUT_TX_COMMITTED, + PAYOUT_TX_SENT, - MESSAGE_SENDING_FAILED, - TIMEOUT, - EXCEPTION + PAYOUT_BROAD_CASTED } } diff --git a/core/src/main/java/io/bitsquare/trade/states/TakerTradeState.java b/core/src/main/java/io/bitsquare/trade/states/SellerTradeState.java similarity index 64% rename from core/src/main/java/io/bitsquare/trade/states/TakerTradeState.java rename to core/src/main/java/io/bitsquare/trade/states/SellerTradeState.java index 258fdc48ff..093df88b65 100644 --- a/core/src/main/java/io/bitsquare/trade/states/TakerTradeState.java +++ b/core/src/main/java/io/bitsquare/trade/states/SellerTradeState.java @@ -20,28 +20,23 @@ package io.bitsquare.trade.states; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class TakerTradeState { - private static final Logger log = LoggerFactory.getLogger(TakerTradeState.class); +public class SellerTradeState { + private static final Logger log = LoggerFactory.getLogger(SellerTradeState.class); public enum ProcessState implements TradeState.ProcessState { UNDEFINED, - TAKE_OFFER_FEE_TX_CREATED, - TAKE_OFFER_FEE_PUBLISHED, - TAKE_OFFER_FEE_PUBLISH_FAILED, - DEPOSIT_PUBLISHED, + DEPOSIT_PUBLISHED_MSG_RECEIVED, DEPOSIT_CONFIRMED, - FIAT_PAYMENT_STARTED, + FIAT_PAYMENT_STARTED_MSG_RECEIVED, - REQUEST_PAYOUT_FINALIZE_MSG_SENT, // seller only - PAYOUT_FINALIZED, + FIAT_PAYMENT_RECEIPT, + FIAT_PAYMENT_RECEIPT_MSG_SENT, - PAYOUT_BROAD_CASTED, - PAYOUT_BROAD_CASTED_FAILED, + PAYOUT_TX_RECEIVED, + PAYOUT_TX_COMMITTED, - MESSAGE_SENDING_FAILED, - TIMEOUT, - EXCEPTION + PAYOUT_BROAD_CASTED } } diff --git a/core/src/main/java/io/bitsquare/trade/states/StateUtil.java b/core/src/main/java/io/bitsquare/trade/states/StateUtil.java index 98726e6822..486d98ec7c 100644 --- a/core/src/main/java/io/bitsquare/trade/states/StateUtil.java +++ b/core/src/main/java/io/bitsquare/trade/states/StateUtil.java @@ -17,8 +17,7 @@ package io.bitsquare.trade.states; -import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.TakerTrade; +import io.bitsquare.trade.BuyerTrade; import io.bitsquare.trade.Trade; import org.slf4j.Logger; @@ -28,14 +27,14 @@ public class StateUtil { private static final Logger log = LoggerFactory.getLogger(StateUtil.class); public static void setSendFailedState(Trade trade) { - if (trade instanceof OffererTrade) - trade.setProcessState(OffererTradeState.ProcessState.MESSAGE_SENDING_FAILED); - else if (trade instanceof TakerTrade) - trade.setProcessState(TakerTradeState.ProcessState.MESSAGE_SENDING_FAILED); + /* if (trade instanceof BuyerTrade) + trade.setProcessState(BuyerTradeState.ProcessState.MESSAGE_SENDING_FAILED); + else if (trade instanceof SellerTrade) + trade.setProcessState(SellerTradeState.ProcessState.MESSAGE_SENDING_FAILED);*/ } public static void setOfferOpenState(Trade trade) { - if (trade instanceof OffererTrade) + if (trade instanceof BuyerTrade) trade.setLifeCycleState(Trade.LifeCycleState.PREPARATION); } } diff --git a/gui/src/main/java/io/bitsquare/gui/main/debug/DebugView.java b/gui/src/main/java/io/bitsquare/gui/main/debug/DebugView.java index e9eeab1c43..e1ad27932e 100644 --- a/gui/src/main/java/io/bitsquare/gui/main/debug/DebugView.java +++ b/gui/src/main/java/io/bitsquare/gui/main/debug/DebugView.java @@ -31,12 +31,12 @@ import io.bitsquare.trade.protocol.placeoffer.tasks.ValidateOffer; import io.bitsquare.trade.protocol.trade.BuyerAsOffererProtocol; import io.bitsquare.trade.protocol.trade.SellerAsTakerProtocol; import io.bitsquare.trade.protocol.trade.tasks.buyer.CreateDepositTxInputs; -import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestDepositTxInputsMessage; -import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage; +import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessDepositTxInputsRequest; +import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessPublishDepositTxRequest; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendFiatTransferStartedMessage; +import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayDepositRequest; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayoutTxFinalizedMessage; -import io.bitsquare.trade.protocol.trade.tasks.buyer.SendRequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndFinalizePayoutTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndPublishDepositTx; import io.bitsquare.trade.protocol.trade.tasks.offerer.VerifyTakeOfferFeePayment; @@ -45,9 +45,9 @@ import io.bitsquare.trade.protocol.trade.tasks.seller.CommitDepositTx; import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignDepositTx; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessFiatTransferStartedMessage; +import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayDepositRequest; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayoutTxFinalizedMessage; -import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessRequestPayDepositMessage; -import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestDepositTxInputsMessage; +import io.bitsquare.trade.protocol.trade.tasks.seller.SendDepositTxInputsRequest; import io.bitsquare.trade.protocol.trade.tasks.seller.SignPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.taker.CreateTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOfferFeePayment; @@ -98,11 +98,11 @@ public class DebugView extends InitializableView { /*---- Protocol ----*/ BuyerAsOffererProtocol.class, - ProcessRequestDepositTxInputsMessage.class, + ProcessDepositTxInputsRequest.class, CreateDepositTxInputs.class, - SendRequestPayDepositMessage.class, + SendPayDepositRequest.class, - ProcessRequestPublishDepositTxMessage.class, + ProcessPublishDepositTxRequest.class, VerifyTakerAccount.class, SignAndPublishDepositTx.class, SendDepositTxPublishedMessage.class, @@ -118,9 +118,9 @@ public class DebugView extends InitializableView { /*---- Protocol ----*/ SellerAsTakerProtocol.class, CreateTakeOfferFeeTx.class, - SendRequestDepositTxInputsMessage.class, + SendDepositTxInputsRequest.class, - ProcessRequestPayDepositMessage.class, + ProcessPayDepositRequest.class, VerifyOffererAccount.class, CreateAndSignDepositTx.class, diff --git a/gui/src/main/java/io/bitsquare/gui/main/offer/takeoffer/TakeOfferDataModel.java b/gui/src/main/java/io/bitsquare/gui/main/offer/takeoffer/TakeOfferDataModel.java index ea6177ef81..aecaa64586 100644 --- a/gui/src/main/java/io/bitsquare/gui/main/offer/takeoffer/TakeOfferDataModel.java +++ b/gui/src/main/java/io/bitsquare/gui/main/offer/takeoffer/TakeOfferDataModel.java @@ -93,7 +93,7 @@ class TakeOfferDataModel implements Activatable, DataModel { @Override public void deactivate() { btcCode.unbind(); - tradeManager.cancelCheckOfferAvailabilityRequest(offer); + tradeManager.onCancelAvailabilityRequest(offer); } void initWithData(Coin amount, Offer offer) { @@ -121,11 +121,11 @@ class TakeOfferDataModel implements Activatable, DataModel { }); updateBalance(walletService.getBalanceForAddress(addressEntry.getAddress())); - tradeManager.checkOfferAvailability(offer); + tradeManager.onCheckOfferAvailability(offer); } - void takeOffer(TakeOfferResultHandler handler) { - tradeManager.requestTakeOffer(amountAsCoin.get(), offer, handler::handleResult); + void onTakeOffer(TakeOfferResultHandler handler) { + tradeManager.onTakeOffer(amountAsCoin.get(), offer, handler::handleResult); } void calculateVolume() { diff --git a/gui/src/main/java/io/bitsquare/gui/main/offer/takeoffer/TakeOfferView.java b/gui/src/main/java/io/bitsquare/gui/main/offer/takeoffer/TakeOfferView.java index 11105bc13a..e17f890063 100644 --- a/gui/src/main/java/io/bitsquare/gui/main/offer/takeoffer/TakeOfferView.java +++ b/gui/src/main/java/io/bitsquare/gui/main/offer/takeoffer/TakeOfferView.java @@ -158,7 +158,7 @@ public class TakeOfferView extends ActivatableViewAndModel im evaluateState(); } - void takeOffer() { + void onTakeOffer() { takeOfferRequested = true; applyTakeOfferRequestResult(false); isTakeOfferSpinnerVisible.set(true); - dataModel.takeOffer((trade) -> { + dataModel.onTakeOffer((trade) -> { trade.processStateProperty().addListener((ov, oldValue, newValue) -> { log.debug("trade state = " + newValue); @@ -234,19 +235,24 @@ class TakeOfferViewModel extends ActivatableWithDataModel im if (trade.getErrorMessage() != null) msg = "\nError message: " + trade.getErrorMessage(); - if (trade instanceof BuyerAsTakerTrade) { - switch ((TakerTradeState.ProcessState) newValue) { - case TAKE_OFFER_FEE_TX_CREATED: + if (trade instanceof SellerAsTakerTrade) { + switch ((SellerTradeState.ProcessState) newValue) { + case UNDEFINED: break; - case DEPOSIT_PUBLISHED: - case DEPOSIT_CONFIRMED: + case DEPOSIT_PUBLISHED_MSG_RECEIVED: assert trade.getDepositTx() != null; transactionId.set(trade.getDepositTx().getHashAsString()); applyTakeOfferRequestResult(true); break; - case FIAT_PAYMENT_STARTED: + case DEPOSIT_CONFIRMED: + case FIAT_PAYMENT_STARTED_MSG_RECEIVED: + case FIAT_PAYMENT_RECEIPT: + case FIAT_PAYMENT_RECEIPT_MSG_SENT: + case PAYOUT_TX_RECEIVED: + case PAYOUT_TX_COMMITTED: + case PAYOUT_BROAD_CASTED: break; - case TAKE_OFFER_FEE_PUBLISH_FAILED: + /* case TAKE_OFFER_FEE_PUBLISH_FAILED: errorMessage.set("An error occurred when paying the trade fee." + msg); takeOfferRequested = false; break; @@ -258,25 +264,31 @@ class TakeOfferViewModel extends ActivatableWithDataModel im case EXCEPTION: errorMessage.set(msg); takeOfferRequested = false; - break; + break;*/ default: log.warn("Unhandled trade state: " + newValue); break; } } - else if (trade instanceof SellerAsTakerTrade) { - switch ((TakerTradeState.ProcessState) newValue) { - case TAKE_OFFER_FEE_TX_CREATED: + else if (trade instanceof BuyerAsTakerTrade) { + switch ((BuyerTradeState.ProcessState) newValue) { + case UNDEFINED: break; case DEPOSIT_PUBLISHED: - case DEPOSIT_CONFIRMED: assert trade.getDepositTx() != null; transactionId.set(trade.getDepositTx().getHashAsString()); applyTakeOfferRequestResult(true); break; + case DEPOSIT_PUBLISHED_MSG_SENT: + case DEPOSIT_CONFIRMED: case FIAT_PAYMENT_STARTED: + case FIAT_PAYMENT_STARTED_MSG_SENT: + case FIAT_PAYMENT_RECEIPT_MSG_RECEIVED: + case PAYOUT_TX_COMMITTED: + case PAYOUT_TX_SENT: + case PAYOUT_BROAD_CASTED: break; - case TAKE_OFFER_FEE_PUBLISH_FAILED: + /* case TAKE_OFFER_FEE_PUBLISH_FAILED: errorMessage.set("An error occurred when paying the trade fee." + msg); takeOfferRequested = false; break; @@ -293,7 +305,7 @@ class TakeOfferViewModel extends ActivatableWithDataModel im case EXCEPTION: errorMessage.set(msg); takeOfferRequested = false; - break; + break;*/ default: log.warn("Unhandled trade state: " + newValue); break; diff --git a/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/BuyerSubView.java b/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/BuyerSubView.java index babab201ae..f00b0f517b 100644 --- a/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/BuyerSubView.java +++ b/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/BuyerSubView.java @@ -17,7 +17,6 @@ package io.bitsquare.gui.main.portfolio.pendingtrades; -import io.bitsquare.gui.components.Popups; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.CompletedView; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.StartFiatView; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.TradeWizardItem; @@ -26,6 +25,8 @@ import io.bitsquare.gui.main.portfolio.pendingtrades.steps.WaitPayoutLockTimeVie import io.bitsquare.gui.main.portfolio.pendingtrades.steps.WaitTxInBlockchainView; import io.bitsquare.locale.BSResources; +import javafx.beans.value.ChangeListener; + import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -38,6 +39,7 @@ public class BuyerSubView extends TradeSubView { private TradeWizardItem payoutUnlock; private TradeWizardItem completed; + private final ChangeListener stateChangeListener; /////////////////////////////////////////////////////////////////////////////////////////// // Constructor, Initialisation @@ -45,6 +47,20 @@ public class BuyerSubView extends TradeSubView { public BuyerSubView(PendingTradesViewModel model) { super(model); + stateChangeListener = (ov, oldValue, newValue) -> applyState(newValue); + } + + @Override + public void activate() { + super.activate(); + model.getBuyerState().addListener(stateChangeListener); + applyState(model.getBuyerState().get()); + } + + @Override + public void deactivate() { + super.deactivate(); + model.getBuyerState().removeListener(stateChangeListener); } @Override @@ -63,9 +79,8 @@ public class BuyerSubView extends TradeSubView { // State /////////////////////////////////////////////////////////////////////////////////////////// - @Override - protected void applyState(PendingTradesViewModel.ViewState viewState) { - log.debug("applyState " + viewState); + protected void applyState(PendingTradesViewModel.BuyerState state) { + log.debug("applyState " + state); waitTxInBlockchain.setDisabled(); startFiat.setDisabled(); @@ -76,10 +91,8 @@ public class BuyerSubView extends TradeSubView { if (tradeStepDetailsView != null) tradeStepDetailsView.deactivate(); - switch (viewState) { - case UNDEFINED: - break; - case BUYER_WAIT_TX_CONF: + switch (state) { + case WAIT_FOR_BLOCKCHAIN_CONFIRMATION: showItem(waitTxInBlockchain); ((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. You need to wait for at least " + @@ -88,11 +101,11 @@ public class BuyerSubView extends TradeSubView { " be sure that the deposit funding has not been double spent. For higher trade volumes we" + " recommend to wait up to 6 confirmations.");*/ break; - case BUYER_START_PAYMENT: + case REQUEST_START_FIAT_PAYMENT: waitTxInBlockchain.setCompleted(); showItem(startFiat); break; - case BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED: + case WAIT_FOR_FIAT_PAYMENT_RECEIPT: waitTxInBlockchain.setCompleted(); startFiat.setCompleted(); showItem(waitFiatReceived); @@ -104,7 +117,7 @@ public class BuyerSubView extends TradeSubView { "the Bitcoin sellers payment account, the payout transaction will be published.", model.getCurrencyCode()));*/ break; - case BUYER_PAYOUT_FINALIZED: + case WAIT_FOR_UNLOCK_PAYOUT: waitTxInBlockchain.setCompleted(); startFiat.setCompleted(); waitFiatReceived.setCompleted(); @@ -113,7 +126,7 @@ public class BuyerSubView extends TradeSubView { ((WaitPayoutLockTimeView) tradeStepDetailsView).setInfoLabelText("The payout transaction is signed and finalized by both parties." + "\nFor reducing bank charge back risks you need to wait until the payout gets unlocked to transfer your Bitcoin."); break; - case BUYER_COMPLETED: + case REQUEST_WITHDRAWAL: waitTxInBlockchain.setCompleted(); startFiat.setCompleted(); waitFiatReceived.setCompleted(); @@ -131,7 +144,7 @@ public class BuyerSubView extends TradeSubView { "You can review the details to that trade any time in the closed trades screen."); completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount()); break; - case MESSAGE_SENDING_FAILED: + /*case MESSAGE_SENDING_FAILED: Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage()); break; case EXCEPTION: @@ -139,9 +152,9 @@ public class BuyerSubView extends TradeSubView { Popups.openExceptionPopup(model.getTradeException()); else Popups.openErrorPopup("An error occurred", model.getErrorMessage()); - break; + break;*/ default: - log.warn("unhandled viewState " + viewState); + log.warn("unhandled buyerState " + state); break; } diff --git a/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/PendingTradesViewModel.java b/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/PendingTradesViewModel.java index b63a93cd1b..4cff7a5e05 100644 --- a/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/PendingTradesViewModel.java +++ b/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/PendingTradesViewModel.java @@ -24,8 +24,8 @@ import io.bitsquare.gui.util.BSFormatter; import io.bitsquare.gui.util.validation.BtcAddressValidator; import io.bitsquare.locale.BSResources; import io.bitsquare.trade.Trade; -import io.bitsquare.trade.states.OffererTradeState; -import io.bitsquare.trade.states.TakerTradeState; +import io.bitsquare.trade.states.BuyerTradeState; +import io.bitsquare.trade.states.SellerTradeState; import org.bitcoinj.core.BlockChainListener; import org.bitcoinj.core.Coin; @@ -53,16 +53,16 @@ import org.slf4j.LoggerFactory; public class PendingTradesViewModel extends ActivatableWithDataModel implements ViewModel { private static final Logger log = LoggerFactory.getLogger(PendingTradesViewModel.class); - enum ViewState { + /* enum ViewState { UNDEFINED, - SELLER_WAIT_TX_CONF, - SELLER_WAIT_PAYMENT_STARTED, - SELLER_CONFIRM_RECEIVE_PAYMENT, + WAIT_FOR_BLOCKCHAIN_CONFIRMATION, + WAIT_FOR_FIAT_PAYMENT_STARTED, + REQUEST_CONFIRM_FIAT_PAYMENT_RECEIVED, SELLER_REQUEST_PAYOUT_FINALIZE_MSG_SENT, SELLER_PAYOUT_FINALIZED, SELLER_COMPLETED, - BUYER_WAIT_TX_CONF, + WAIT_FOR_BLOCKCHAIN_CONFIRMATION, BUYER_START_PAYMENT, BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED, BUYER_PAYOUT_FINALIZED, @@ -71,13 +71,36 @@ public class PendingTradesViewModel extends ActivatableWithDataModel viewState = new SimpleObjectProperty<>(ViewState.UNDEFINED); + + private final ObjectProperty buyerState = new SimpleObjectProperty<>(BuyerState.WAIT_FOR_BLOCKCHAIN_CONFIRMATION); + private final ObjectProperty sellerState = new SimpleObjectProperty<>(SellerState.WAIT_FOR_BLOCKCHAIN_CONFIRMATION); + private final StringProperty txId = new SimpleStringProperty(); private final BooleanProperty withdrawalButtonDisable = new SimpleBooleanProperty(true); @@ -93,8 +116,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel updateSellerState(); - this.buyerStateListener = (ov) -> updateBuyerState(); + this.sellerStateListener = (ov) -> applySellerState(); + this.buyerStateListener = (ov) -> applyBuyerState(); } @Override @@ -105,8 +128,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel getViewState() { - return viewState; + ReadOnlyObjectProperty getBuyerState() { + return buyerState; + } + + ReadOnlyObjectProperty getSellerState() { + return sellerState; } public ReadOnlyStringProperty getTxId() { @@ -304,97 +331,58 @@ public class PendingTradesViewModel extends ActivatableWithDataModel stateChangeListener; /////////////////////////////////////////////////////////////////////////////////////////// // Constructor, Initialisation @@ -45,6 +47,20 @@ public class SellerSubView extends TradeSubView { public SellerSubView(PendingTradesViewModel model) { super(model); + stateChangeListener = (ov, oldValue, newValue) -> applyState(newValue); + } + + @Override + public void activate() { + super.activate(); + model.getSellerState().addListener(stateChangeListener); + applyState(model.getSellerState().get()); + } + + @Override + public void deactivate() { + super.deactivate(); + model.getSellerState().removeListener(stateChangeListener); } @Override @@ -63,8 +79,7 @@ public class SellerSubView extends TradeSubView { // State /////////////////////////////////////////////////////////////////////////////////////////// - @Override - protected void applyState(PendingTradesViewModel.ViewState viewState) { + protected void applyState(PendingTradesViewModel.SellerState viewState) { log.debug("applyState " + viewState); waitTxInBlockchain.setDisabled(); @@ -77,9 +92,7 @@ public class SellerSubView extends TradeSubView { tradeStepDetailsView.deactivate(); switch (viewState) { - case UNDEFINED: - break; - case SELLER_WAIT_TX_CONF: + case WAIT_FOR_BLOCKCHAIN_CONFIRMATION: showItem(waitTxInBlockchain); ((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. " + @@ -91,7 +104,7 @@ public class SellerSubView extends TradeSubView { "For higher trade volumes it is recommended to wait up to 6 confirmations.", model.getCurrencyCode()));*/ break; - case SELLER_WAIT_PAYMENT_STARTED: + case WAIT_FOR_FIAT_PAYMENT_STARTED: waitTxInBlockchain.setCompleted(); showItem(waitFiatStarted); @@ -104,7 +117,7 @@ public class SellerSubView extends TradeSubView { "the {0} payment has been started.", model.getCurrencyCode()));*/ break; - case SELLER_CONFIRM_RECEIVE_PAYMENT: + case REQUEST_CONFIRM_FIAT_PAYMENT_RECEIVED: waitTxInBlockchain.setCompleted(); waitFiatStarted.setCompleted(); showItem(confirmFiatReceived); @@ -119,7 +132,7 @@ public class SellerSubView extends TradeSubView { model.getCurrencyCode()));*/ break; - case SELLER_REQUEST_PAYOUT_FINALIZE_MSG_SENT: + case WAIT_FOR_PAYOUT_TX: waitTxInBlockchain.setCompleted(); waitFiatStarted.setCompleted(); confirmFiatReceived.setCompleted(); @@ -132,7 +145,7 @@ public class SellerSubView extends TradeSubView { ((WaitPayoutFinalizedView) tradeStepDetailsView).setInfoLabelText("We requested the trading peer to sign and finalize the payout transaction." + "\nIt might be that the other peer is offline, so we need to wait until he finalize the transaction when he goes online again."); break; - case SELLER_PAYOUT_FINALIZED: + case WAIT_FOR_UNLOCK_PAYOUT: waitTxInBlockchain.setCompleted(); waitFiatStarted.setCompleted(); confirmFiatReceived.setCompleted(); @@ -141,7 +154,7 @@ public class SellerSubView extends TradeSubView { ((WaitPayoutLockTimeView) tradeStepDetailsView).setInfoLabelText("The payout transaction is signed and finalized by both parties." + "\nFor reducing bank charge back risks you need to wait until the payout gets unlocked to transfer your Bitcoin."); break; - case SELLER_COMPLETED: + case REQUEST_WITHDRAWAL: waitTxInBlockchain.setCompleted(); waitFiatStarted.setCompleted(); confirmFiatReceived.setCompleted(); @@ -160,7 +173,7 @@ public class SellerSubView extends TradeSubView { completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount()); break; - case MESSAGE_SENDING_FAILED: + /* case MESSAGE_SENDING_FAILED: Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage()); break; case EXCEPTION: @@ -168,7 +181,7 @@ public class SellerSubView extends TradeSubView { Popups.openExceptionPopup(model.getTradeException()); else Popups.openErrorPopup("An error occurred", model.getErrorMessage()); - break; + break;*/ default: log.warn("unhandled viewState " + viewState); break; diff --git a/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/TradeSubView.java b/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/TradeSubView.java index 080b37f31c..d03d7021b0 100644 --- a/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/TradeSubView.java +++ b/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/TradeSubView.java @@ -21,7 +21,6 @@ import io.bitsquare.gui.main.portfolio.pendingtrades.steps.TradeStepDetailsView; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.TradeWizardItem; import io.bitsquare.gui.util.Layout; -import javafx.beans.value.ChangeListener; import javafx.scene.layout.*; import org.slf4j.Logger; @@ -31,7 +30,6 @@ public abstract class TradeSubView extends HBox { private static final Logger log = LoggerFactory.getLogger(TradeSubView.class); protected final PendingTradesViewModel model; - protected final ChangeListener offererStateChangeListener; protected VBox leftVBox; protected AnchorPane contentPane; protected TradeStepDetailsView tradeStepDetailsView; @@ -47,17 +45,12 @@ public abstract class TradeSubView extends HBox { setSpacing(Layout.PADDING_WINDOW); buildViews(); - offererStateChangeListener = (ov, oldValue, newValue) -> applyState(newValue); } public void activate() { - model.getViewState().addListener(offererStateChangeListener); - applyState(model.getViewState().get()); } public void deactivate() { - model.getViewState().removeListener(offererStateChangeListener); - if (tradeStepDetailsView != null) tradeStepDetailsView.deactivate(); } @@ -67,8 +60,6 @@ public abstract class TradeSubView extends HBox { // Misc /////////////////////////////////////////////////////////////////////////////////////////// - protected abstract void applyState(PendingTradesViewModel.ViewState state); - private void buildViews() { addLeftBox(); addContentPane(); diff --git a/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/steps/StartFiatView.java b/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/steps/StartFiatView.java index 84179b46fb..ecf87fd099 100644 --- a/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/steps/StartFiatView.java +++ b/gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/steps/StartFiatView.java @@ -105,7 +105,6 @@ public class StartFiatView extends TradeStepDetailsView { private void onPaymentStarted(ActionEvent actionEvent) { log.debug("onPaymentStarted"); - model.fiatPaymentStarted(); paymentStartedButton.setDisable(true); statusProgressIndicator.setVisible(true); statusProgressIndicator.setProgress(-1); @@ -113,6 +112,8 @@ public class StartFiatView extends TradeStepDetailsView { root = statusProgressIndicator.getScene().getRoot(); // We deactivate mouse interaction to avoid that user leaves screen root.setMouseTransparent(true); + + model.fiatPaymentStarted(); }