Add timeout

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

@@ -64,6 +64,7 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
         BUYER_COMPLETED,
 
         MESSAGE_SENDING_FAILED,
+        TIMEOUT,
         EXCEPTION
     }
 
@@ -301,6 +302,9 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
                     case MESSAGE_SENDING_FAILED:
                         viewState.set(ViewState.MESSAGE_SENDING_FAILED);
                         break;
+                    case TIMEOUT:
+                        viewState.set(ViewState.TIMEOUT);
+                        break;
                     case EXCEPTION:
                         viewState.set(ViewState.EXCEPTION);
                         break;
@@ -343,6 +347,9 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
                     case MESSAGE_SENDING_FAILED:
                         viewState.set(ViewState.MESSAGE_SENDING_FAILED);
                         break;
+                    case TIMEOUT:
+                        viewState.set(ViewState.TIMEOUT);
+                        break;
                     case EXCEPTION:
                         viewState.set(ViewState.EXCEPTION);
                         break;
@@ -388,6 +395,9 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
                     case MESSAGE_SENDING_FAILED:
                         viewState.set(ViewState.MESSAGE_SENDING_FAILED);
                         break;
+                    case TIMEOUT:
+                        viewState.set(ViewState.TIMEOUT);
+                        break;
                     case EXCEPTION:
                         viewState.set(ViewState.EXCEPTION);
                         break;
@@ -424,6 +434,9 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
                     case MESSAGE_SENDING_FAILED:
                         viewState.set(ViewState.MESSAGE_SENDING_FAILED);
                         break;
+                    case TIMEOUT:
+                        viewState.set(ViewState.TIMEOUT);
+                        break;
                     case EXCEPTION:
                         viewState.set(ViewState.EXCEPTION);
                         break;

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

@@ -283,7 +283,12 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
                             takeOfferRequested = false;
                             break;
                         case MESSAGE_SENDING_FAILED:
-                            errorMessage.set("An error occurred when sending a message to the offerer. Maybe there are connection problems. " +
+                            errorMessage.set("Sending a message to the offerer failed. Maybe there are connection problems. " +
+                                    "Please try later again." + msg);
+                            takeOfferRequested = false;
+                            break;
+                        case TIMEOUT:
+                            errorMessage.set("Timeout: We did not received a message from the offerer. Maybe there are connection problems. " +
                                     "Please try later again." + msg);
                             takeOfferRequested = false;
                             break;

core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsOffererProtocol.java

@@ -20,7 +20,6 @@ package io.bitsquare.trade.protocol.trade;
 import io.bitsquare.common.taskrunner.TaskRunner;
 import io.bitsquare.p2p.MailboxMessage;
 import io.bitsquare.p2p.Message;
-import io.bitsquare.p2p.MessageHandler;
 import io.bitsquare.p2p.Peer;
 import io.bitsquare.p2p.listener.SendMessageListener;
 import io.bitsquare.trade.BuyerAsOffererTrade;
@@ -51,21 +50,19 @@ import org.slf4j.LoggerFactory;
 
 import static io.bitsquare.util.Validator.*;
 
-public class BuyerAsOffererProtocol implements TradeProtocol {
+public class BuyerAsOffererProtocol extends TradeProtocol {
     private static final Logger log = LoggerFactory.getLogger(BuyerAsOffererProtocol.class);
 
-    private MessageHandler messageHandler;
+    private final BuyerAsOffererTrade buyerAsOffererTrade;
-    private final BuyerAsOffererTrade trade;
-    private final ProcessModel processModel;
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Constructor
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     public BuyerAsOffererProtocol(BuyerAsOffererTrade trade) {
+        super(trade.getProcessModel());
         log.debug("New OffererProtocol " + this);
-        this.trade = trade;
+        this.buyerAsOffererTrade = trade;
-        processModel = this.trade.getProcessModel();
         messageHandler = this::handleMessage;
 
         processModel.getMessageService().addMessageHandler(messageHandler);
@@ -76,6 +73,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
     // Public methods
     ///////////////////////////////////////////////////////////////////////////////////////////
 
+    @Override
     public void setMailboxMessage(MailboxMessage mailboxMessage) {
         log.debug("setMailboxMessage " + mailboxMessage);
         // Might be called twice, so check that its only processed once
@@ -87,14 +85,6 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
         }
     }
 
-    public void cleanup() {
-        log.debug("cleanup " + this);
-
-        if (messageHandler != null) {
-            processModel.getMessageService().removeMessageHandler(messageHandler);
-            messageHandler = null;
-        }
-    }
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Incoming message handling
@@ -109,7 +99,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
             // to take the
             // offer
             // at the same time
-            boolean isOfferOpen = trade.lifeCycleStateProperty().get() == OffererTradeState.LifeCycleState.OFFER_OPEN;
+            boolean isOfferOpen = buyerAsOffererTrade.lifeCycleStateProperty().get() == OffererTradeState.LifeCycleState.OFFER_OPEN;
             ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(processModel.getId(), isOfferOpen);
             processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
                 @Override
@@ -134,11 +124,11 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
     private void handle(RequestDepositTxInputsMessage tradeMessage, Peer taker) {
         checkTradeId(processModel.getId(), tradeMessage);
         processModel.setTradeMessage(tradeMessage);
-        trade.setTradingPeer(taker);
+        buyerAsOffererTrade.setTradingPeer(taker);
 
-        trade.setLifeCycleState(OffererTradeState.LifeCycleState.OFFER_RESERVED);
+        buyerAsOffererTrade.setLifeCycleState(OffererTradeState.LifeCycleState.OFFER_RESERVED);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
                 () -> log.debug("taskRunner at handleRequestDepositTxInputsMessage completed"),
                 this::handleTaskRunnerFault);
         taskRunner.addTasks(
@@ -152,7 +142,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
     private void handle(RequestPublishDepositTxMessage tradeMessage) {
         processModel.setTradeMessage(tradeMessage);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
                 () -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
                 this::handleTaskRunnerFault);
         taskRunner.addTasks(
@@ -172,7 +162,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
 
     // User clicked the "bank transfer started" button
     public void onFiatPaymentStarted() {
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
                 () -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"),
                 this::handleTaskRunnerFault);
         taskRunner.addTasks(
@@ -191,7 +181,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
     private void handle(PayoutTxPublishedMessage tradeMessage) {
         processModel.setTradeMessage(tradeMessage);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsOffererTrade,
                 () -> {
                     log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
                     // we are done!
@@ -215,7 +205,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
             TradeMessage tradeMessage = (TradeMessage) message;
             nonEmptyStringOf(tradeMessage.tradeId);
 
-            if (tradeMessage.tradeId.equals(trade.getId())) {
+            if (tradeMessage.tradeId.equals(buyerAsOffererTrade.getId())) {
                 if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
                     handle((RequestIsOfferAvailableMessage) tradeMessage, sender);
                 }
@@ -234,9 +224,4 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
             }
         }
     }
-
-    private void handleTaskRunnerFault(String errorMessage) {
-        log.error(errorMessage);
-        cleanup();
-    }
 }

core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsTakerProtocol.java

@@ -20,7 +20,6 @@ package io.bitsquare.trade.protocol.trade;
 import io.bitsquare.common.taskrunner.TaskRunner;
 import io.bitsquare.p2p.MailboxMessage;
 import io.bitsquare.p2p.Message;
-import io.bitsquare.p2p.MessageHandler;
 import io.bitsquare.p2p.Peer;
 import io.bitsquare.trade.BuyerAsTakerTrade;
 import io.bitsquare.trade.Trade;
@@ -47,12 +46,10 @@ import org.slf4j.LoggerFactory;
 
 import static io.bitsquare.util.Validator.nonEmptyStringOf;
 
-public class BuyerAsTakerProtocol implements TradeProtocol {
+public class BuyerAsTakerProtocol extends TradeProtocol {
     private static final Logger log = LoggerFactory.getLogger(BuyerAsTakerProtocol.class);
 
-    private final BuyerAsTakerTrade trade;
+    private final BuyerAsTakerTrade buyerAsTakerTrade;
-    private final ProcessModel processModel;
-    private final MessageHandler messageHandler;
 
 
     ///////////////////////////////////////////////////////////////////////////////////////////
@@ -60,9 +57,9 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     public BuyerAsTakerProtocol(BuyerAsTakerTrade trade) {
+        super(trade.getProcessModel());
         log.debug("New SellerAsTakerProtocol " + this);
-        this.trade = trade;
+        this.buyerAsTakerTrade = trade;
-        processModel = trade.getProcessModel();
 
         messageHandler = this::handleMessage;
         processModel.getMessageService().addMessageHandler(messageHandler);
@@ -73,6 +70,7 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
     // Public methods
     ///////////////////////////////////////////////////////////////////////////////////////////
 
+    @Override
     public void setMailboxMessage(MailboxMessage mailboxMessage) {
         log.debug("setMailboxMessage " + mailboxMessage);
         // Might be called twice, so check that its only processed once
@@ -85,7 +83,7 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
     }
 
     public void takeAvailableOffer() {
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
                 () -> log.debug("taskRunner at takeAvailableOffer completed"),
                 this::handleTaskRunnerFault);
 
@@ -98,10 +96,6 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
         taskRunner.run();
     }
 
-    public void cleanup() {
-        log.debug("cleanup " + this);
-        processModel.getMessageService().removeMessageHandler(messageHandler);
-    }
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Incoming message handling
@@ -110,7 +104,7 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
     private void handle(RequestPublishDepositTxMessage tradeMessage) {
         processModel.setTradeMessage(tradeMessage);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
                 () -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
                 this::handleTaskRunnerFault);
         taskRunner.addTasks(
@@ -130,7 +124,7 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
 
     // User clicked the "bank transfer started" button
     public void onFiatPaymentStarted() {
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
                 () -> log.debug("taskRunner at onFiatPaymentStarted completed"),
                 this::handleTaskRunnerFault);
         taskRunner.addTasks(
@@ -149,7 +143,7 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
     private void handle(PayoutTxPublishedMessage tradeMessage) {
         processModel.setTradeMessage(tradeMessage);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(buyerAsTakerTrade,
                 () -> {
                     log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
                     // we are done!
@@ -187,10 +181,4 @@ public class BuyerAsTakerProtocol implements TradeProtocol {
             }
         }
     }
-
-    private void handleTaskRunnerFault(String errorMessage) {
-        log.error(errorMessage);
-        cleanup();
-    }
-
 }

core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsOffererProtocol.java

@@ -20,7 +20,6 @@ package io.bitsquare.trade.protocol.trade;
 import io.bitsquare.common.taskrunner.TaskRunner;
 import io.bitsquare.p2p.MailboxMessage;
 import io.bitsquare.p2p.Message;
-import io.bitsquare.p2p.MessageHandler;
 import io.bitsquare.p2p.Peer;
 import io.bitsquare.p2p.listener.SendMessageListener;
 import io.bitsquare.trade.SellerAsOffererTrade;
@@ -49,21 +48,20 @@ import org.slf4j.LoggerFactory;
 
 import static io.bitsquare.util.Validator.*;
 
-public class SellerAsOffererProtocol implements TradeProtocol {
+public class SellerAsOffererProtocol extends TradeProtocol {
     private static final Logger log = LoggerFactory.getLogger(SellerAsOffererProtocol.class);
 
-    private final MessageHandler messageHandler;
+    private final SellerAsOffererTrade sellerAsOffererTrade;
-    private final SellerAsOffererTrade trade;
+
-    private final ProcessModel processModel;
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Constructor
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     public SellerAsOffererProtocol(SellerAsOffererTrade trade) {
+        super(trade.getProcessModel());
         log.debug("New OffererProtocol " + this);
-        this.trade = trade;
+        this.sellerAsOffererTrade = trade;
-        processModel = this.trade.getProcessModel();
         messageHandler = this::handleMessage;
 
         processModel.getMessageService().addMessageHandler(messageHandler);
@@ -74,6 +72,7 @@ public class SellerAsOffererProtocol implements TradeProtocol {
     // Public methods
     ///////////////////////////////////////////////////////////////////////////////////////////
 
+    @Override
     public void setMailboxMessage(MailboxMessage mailboxMessage) {
         log.debug("setMailboxMessage " + mailboxMessage);
         // Might be called twice, so check that its only processed once
@@ -88,11 +87,6 @@ public class SellerAsOffererProtocol implements TradeProtocol {
         }
     }
 
-    public void cleanup() {
-        log.debug("cleanup " + this);
-
-        processModel.getMessageService().removeMessageHandler(messageHandler);
-    }
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Incoming message handling 
@@ -110,7 +104,7 @@ public class SellerAsOffererProtocol implements TradeProtocol {
             // to take the
             // offer
             // at the same time
-            boolean isOfferOpen = trade.lifeCycleStateProperty().get() == OffererTradeState.LifeCycleState.OFFER_OPEN;
+            boolean isOfferOpen = sellerAsOffererTrade.lifeCycleStateProperty().get() == OffererTradeState.LifeCycleState.OFFER_OPEN;
 
             ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(processModel.getId(), isOfferOpen);
             processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@@ -140,9 +134,9 @@ public class SellerAsOffererProtocol implements TradeProtocol {
     private void handle(RequestPayDepositMessage tradeMessage, Peer sender) {
         processModel.setTradeMessage(tradeMessage);
 
-        trade.setTradingPeer(sender);
+        sellerAsOffererTrade.setTradingPeer(sender);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
                 () -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"),
                 this::handleTaskRunnerFault);
 
@@ -159,7 +153,7 @@ public class SellerAsOffererProtocol implements TradeProtocol {
     private void handle(DepositTxPublishedMessage tradeMessage) {
         processModel.setTradeMessage(tradeMessage);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
                 () -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"),
                 this::handleTaskRunnerFault);
 
@@ -173,7 +167,7 @@ public class SellerAsOffererProtocol implements TradeProtocol {
     private void handle(FiatTransferStartedMessage tradeMessage) {
         processModel.setTradeMessage(tradeMessage);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
                 () -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"),
                 this::handleTaskRunnerFault);
 
@@ -188,9 +182,9 @@ public class SellerAsOffererProtocol implements TradeProtocol {
 
     // User clicked the "bank transfer received" button, so we release the funds for pay out
     public void onFiatPaymentReceived() {
-        trade.setProcessState(OffererTradeState.ProcessState.FIAT_PAYMENT_RECEIVED);
+        sellerAsOffererTrade.setProcessState(OffererTradeState.ProcessState.FIAT_PAYMENT_RECEIVED);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsOffererTrade,
                 () -> {
                     log.debug("taskRunner at handleFiatReceivedUIEvent completed");
 
@@ -217,7 +211,7 @@ public class SellerAsOffererProtocol implements TradeProtocol {
         if (message instanceof TradeMessage) {
             TradeMessage tradeMessage = (TradeMessage) message;
             nonEmptyStringOf(tradeMessage.tradeId);
-            if (tradeMessage.tradeId.equals(trade.getId())) {
+            if (tradeMessage.tradeId.equals(sellerAsOffererTrade.getId())) {
                 if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
                     handle((RequestIsOfferAvailableMessage) tradeMessage, sender);
                 }
@@ -236,9 +230,4 @@ public class SellerAsOffererProtocol implements TradeProtocol {
             }
         }
     }
-
-    private void handleTaskRunnerFault(String errorMessage) {
-        log.error(errorMessage);
-        cleanup();
-    }
 }

core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsTakerProtocol.java

@@ -20,7 +20,6 @@ package io.bitsquare.trade.protocol.trade;
 import io.bitsquare.common.taskrunner.TaskRunner;
 import io.bitsquare.p2p.MailboxMessage;
 import io.bitsquare.p2p.Message;
-import io.bitsquare.p2p.MessageHandler;
 import io.bitsquare.p2p.Peer;
 import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.Trade;
@@ -49,12 +48,10 @@ import org.slf4j.LoggerFactory;
 
 import static io.bitsquare.util.Validator.nonEmptyStringOf;
 
-public class SellerAsTakerProtocol implements TradeProtocol {
+public class SellerAsTakerProtocol extends TradeProtocol {
     private static final Logger log = LoggerFactory.getLogger(SellerAsTakerProtocol.class);
 
-    private final SellerAsTakerTrade trade;
+    private final SellerAsTakerTrade sellerAsTakerTrade;
-    private final ProcessModel processModel;
-    private final MessageHandler messageHandler;
 
 
     ///////////////////////////////////////////////////////////////////////////////////////////
@@ -62,9 +59,9 @@ public class SellerAsTakerProtocol implements TradeProtocol {
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     public SellerAsTakerProtocol(SellerAsTakerTrade trade) {
+        super(trade.getProcessModel());
         log.debug("New SellerAsTakerProtocol " + this);
-        this.trade = trade;
+        this.sellerAsTakerTrade = trade;
-        processModel = trade.getProcessModel();
 
         messageHandler = this::handleMessage;
         processModel.getMessageService().addMessageHandler(messageHandler);
@@ -75,6 +72,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
     // Public methods
     ///////////////////////////////////////////////////////////////////////////////////////////
 
+    @Override
     public void setMailboxMessage(MailboxMessage mailboxMessage) {
         log.debug("setMailboxMessage " + mailboxMessage);
         // Might be called twice, so check that its only processed once
@@ -90,8 +88,11 @@ public class SellerAsTakerProtocol implements TradeProtocol {
     }
 
     public void takeAvailableOffer() {
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
-                () -> log.debug("taskRunner at takeAvailableOffer completed"),
+                () -> {
+                    log.debug("taskRunner at takeAvailableOffer completed");
+                    startTimeout();
+                },
                 this::handleTaskRunnerFault);
 
         taskRunner.addTasks(
@@ -102,20 +103,17 @@ public class SellerAsTakerProtocol implements TradeProtocol {
         taskRunner.run();
     }
 
-    public void cleanup() {
-        log.debug("cleanup " + this);
-        processModel.getMessageService().removeMessageHandler(messageHandler);
-    }
-
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Incoming message handling
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     private void handle(RequestPayDepositMessage tradeMessage) {
+        log.debug("handle RequestPayDepositMessage");
+        stopTimeout();
         processModel.setTradeMessage(tradeMessage);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
                 () -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"),
                 this::handleTaskRunnerFault);
 
@@ -132,7 +130,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
     private void handle(DepositTxPublishedMessage tradeMessage) {
         processModel.setTradeMessage(tradeMessage);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
                 () -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"),
                 this::handleTaskRunnerFault);
 
@@ -146,7 +144,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
     private void handle(FiatTransferStartedMessage tradeMessage) {
         processModel.setTradeMessage(tradeMessage);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
                 () -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"),
                 this::handleTaskRunnerFault);
 
@@ -161,9 +159,9 @@ public class SellerAsTakerProtocol implements TradeProtocol {
 
     // User clicked the "bank transfer received" button, so we release the funds for pay out
     public void onFiatPaymentReceived() {
-        trade.setProcessState(TakerTradeState.ProcessState.FIAT_PAYMENT_RECEIVED);
+        sellerAsTakerTrade.setProcessState(TakerTradeState.ProcessState.FIAT_PAYMENT_RECEIVED);
 
-        TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
+        TaskRunner<Trade> taskRunner = new TaskRunner<>(sellerAsTakerTrade,
                 () -> {
                     log.debug("taskRunner at handleFiatReceivedUIEvent completed");
 
@@ -206,10 +204,4 @@ public class SellerAsTakerProtocol implements TradeProtocol {
             }
         }
     }
-
-    private void handleTaskRunnerFault(String errorMessage) {
-        log.error(errorMessage);
-        cleanup();
-    }
-
 }

core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProtocol.java

@@ -18,9 +18,70 @@
 package io.bitsquare.trade.protocol.trade;
 
 import io.bitsquare.p2p.MailboxMessage;
+import io.bitsquare.p2p.MessageHandler;
+import io.bitsquare.trade.TakerTrade;
+import io.bitsquare.trade.Trade;
+import io.bitsquare.trade.states.OffererTradeState;
+import io.bitsquare.trade.states.TakerTradeState;
 
-public interface TradeProtocol {
+import java.util.Timer;
-    void cleanup();
+import java.util.TimerTask;
 
-    void setMailboxMessage(MailboxMessage mailboxMessage);
+import javafx.application.Platform;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public abstract class TradeProtocol {
+    private static final Logger log = LoggerFactory.getLogger(TradeProtocol.class);
+
+    protected final ProcessModel processModel;
+    protected MessageHandler messageHandler;
+    protected Timer timeoutTimer;
+    protected Trade trade;
+
+    public TradeProtocol(ProcessModel processModel) {
+        this.processModel = processModel;
+    }
+
+    public void cleanup() {
+        log.debug("cleanup " + this);
+        processModel.getMessageService().removeMessageHandler(messageHandler);
+    }
+
+    abstract public void setMailboxMessage(MailboxMessage mailboxMessage);
+
+    protected void startTimeout() {
+        log.debug("startTimeout");
+        stopTimeout();
+
+        timeoutTimer = new Timer();
+        TimerTask task = new TimerTask() {
+            @Override
+            public void run() {
+                Platform.runLater(() -> {
+                    log.debug("Timeout reached");
+                    if (trade instanceof TakerTrade)
+                        trade.setProcessState(TakerTradeState.ProcessState.TIMEOUT);
+                    else
+                        trade.setProcessState(OffererTradeState.ProcessState.TIMEOUT);
+                });
+            }
+        };
+
+        timeoutTimer.schedule(task, 3000);
+    }
+
+    protected void stopTimeout() {
+        log.debug("stopTimeout");
+        if (timeoutTimer != null) {
+            timeoutTimer.cancel();
+            timeoutTimer = null;
+        }
+    }
+
+    protected void handleTaskRunnerFault(String errorMessage) {
+        log.error(errorMessage);
+        cleanup();
+    }
 }

core/src/main/java/io/bitsquare/trade/states/OffererTradeState.java

@@ -44,6 +44,7 @@ public class OffererTradeState {
         PAYOUT_PUBLISHED_MSG_SENT,
 
         MESSAGE_SENDING_FAILED,
+        TIMEOUT,
         EXCEPTION
     }
 }

core/src/main/java/io/bitsquare/trade/states/TakerTradeState.java

@@ -45,6 +45,7 @@ public class TakerTradeState {
         PAYOUT_PUBLISHED_MSG_SENT,
 
         MESSAGE_SENDING_FAILED,
+        TIMEOUT,
         EXCEPTION
     }
 }