Changed state handling

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),

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<BaseFuture>() {
             @Override

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() {
+    public void handleTakeOfferRequest(TradeMessage message, Peer taker) {
-        assert tradeProtocol instanceof BuyerProtocol;
+        ((OffererProtocol) tradeProtocol).handleTakeOfferRequest(message, taker);
-        ((BuyerProtocol) tradeProtocol).onFiatPaymentStarted();
     }
 
     @Override

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() {
+    public void takeAvailableOffer() {
-        assert tradeProtocol instanceof BuyerProtocol;
+        assert tradeProtocol instanceof TakerProtocol;
-        ((BuyerProtocol) tradeProtocol).onFiatPaymentStarted();
+        ((TakerProtocol) tradeProtocol).takeAvailableOffer();
     }
 
     @Override

core/src/main/java/io/bitsquare/trade/BuyerTrade.java

@@ -17,6 +17,94 @@
 
 package io.bitsquare.trade;
 
-public interface BuyerTrade {
+import io.bitsquare.p2p.Peer;
-    void onFiatPaymentStarted();
+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<? extends TradableList> storage) {
+        super(offer, tradeAmount, tradingPeer, storage);
+        log.trace("Created by constructor");
+    }
+
+    public BuyerTrade(Offer offer, Storage<? extends TradableList> 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);
+    }
 }

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;
+public interface OffererTrade {
-
+    void handleTakeOfferRequest(TradeMessage message, Peer taker);
-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<? extends TradableList> 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);
-    }
 }

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() {
+    public void handleTakeOfferRequest(TradeMessage message, Peer taker) {
-        assert tradeProtocol instanceof SellerProtocol;
+        ((OffererProtocol) tradeProtocol).handleTakeOfferRequest(message, taker);
-        ((SellerProtocol) tradeProtocol).onFiatPaymentReceived();
     }
 }

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.protocol.trade.TakerProtocol;
-import io.bitsquare.trade.states.TakerTradeState;
 
 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() {
+    public void takeAvailableOffer() {
-        assert tradeProtocol instanceof SellerProtocol;
+        assert tradeProtocol instanceof TakerProtocol;
-        ((SellerProtocol) tradeProtocol).onFiatPaymentReceived();
+        ((TakerProtocol) tradeProtocol).takeAvailableOffer();
     }
 }

core/src/main/java/io/bitsquare/trade/SellerTrade.java

@@ -17,6 +17,93 @@
 
 package io.bitsquare.trade;
 
-public interface SellerTrade {
+import io.bitsquare.p2p.Peer;
-    void onFiatPaymentReceived();
+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<? extends TradableList> storage) {
+        super(offer, tradeAmount, tradingPeer, storage);
+        log.trace("Created by constructor");
+    }
+
+    public SellerTrade(Offer offer, Storage<? extends TradableList> 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);
+    }
 }

core/src/main/java/io/bitsquare/trade/TakerTrade.java

@@ -17,89 +17,6 @@
 
 package io.bitsquare.trade;
 
-import io.bitsquare.p2p.Peer;
+public interface TakerTrade {
-import io.bitsquare.storage.Storage;
+    void takeAvailableOffer();
-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<? extends TradableList> 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);
-    }
 }

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.DepositTxInputsRequest;
-import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
+import io.bitsquare.trade.protocol.trade.messages.PayDepositRequest;
-import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage;
 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<MailboxMessage> cryptoService;
-    private OpenOfferManager openOfferManager;
+    private final OpenOfferManager openOfferManager;
-    private ClosedTradableManager closedTradableManager;
+    private final ClosedTradableManager closedTradableManager;
     private final ArbitrationRepository arbitrationRepository;
 
-    private final Map<String, OfferAvailabilityProtocol> checkOfferAvailabilityProtocolMap = new HashMap<>();
     private final Storage<TradableList<Trade>> pendingTradesStorage;
     private final TradableList<Trade> 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 ||
+                if (message instanceof DepositTxInputsRequest ||
-                        (message instanceof RequestPayDepositMessage && ((RequestPayDepositMessage) message).isInitialRequest))
+                        (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,112 +278,33 @@ 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<Trade> 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) {
+    public void onCheckOfferAvailability(Offer offer) {
-        if (!checkOfferAvailabilityProtocolMap.containsKey(offer.getId())) {
+        offer.checkOfferAvailability(getOfferAvailabilityModel(offer));
-            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());
-        }
     }
 
     // When closing take offer view, we are not interested in the onCheckOfferAvailability result anymore, so remove from the map
-    public void cancelCheckOfferAvailabilityRequest(Offer offer) {
+    public void onCancelAvailabilityRequest(Offer offer) {
-        disposeCheckOfferAvailabilityRequest(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) {
+    public void onTakeOffer(Coin amount, Offer offer, TakeOfferResultHandler takeOfferResultHandler) {
-        OfferAvailabilityModel model = new OfferAvailabilityModel(offer, keyRing.getPubKeyRing(), messageService, addressService);
+        final OfferAvailabilityModel model = getOfferAvailabilityModel(offer);
-        OfferAvailabilityProtocol availabilityProtocol = new OfferAvailabilityProtocol(model,
+        offer.checkOfferAvailability(model, () -> {
-                () -> createTrade(amount, offer, model, takeOfferResultHandler),
+            if (offer.getState() == Offer.State.AVAILABLE)
-                (errorMessage) -> disposeCheckOfferAvailabilityRequest(offer));
+                createTrade(amount, offer, model, takeOfferResultHandler);
-        checkOfferAvailabilityProtocolMap.put(offer.getId(), availabilityProtocol);
+        });
-        availabilityProtocol.checkOfferAvailability();
     }
 
-    private void createTrade(Coin amount, Offer offer, OfferAvailabilityModel model, TakeOfferResultHandler
+    private void createTrade(Coin amount, Offer offer, OfferAvailabilityModel model, TakeOfferResultHandler 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);
@@ -385,10 +314,16 @@ public class TradeManager {
         trade.setTakeOfferDate(new Date());
         initTrade(trade);
         pendingTrades.add(trade);
-            if (trade instanceof TakerTrade)
         ((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<Trade> getOpenOfferTrades() {
-        return openOfferTrades.getObservableList();
-    }*/
-
     public ObservableList<Trade> getPendingTrades() {
         return pendingTrades.getObservableList();
     }
 
-   /* public ObservableList<Trade> 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);
     }
+
+
 }

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<State> stateProperty = new SimpleObjectProperty<>(state);
+    transient private OfferAvailabilityProtocol availabilityProtocol;
 
 
     ///////////////////////////////////////////////////////////////////////////////////////////
@@ -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
     ///////////////////////////////////////////////////////////////////////////////////////////

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);
 

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.FinalizePayoutTxRequest;
-import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage;
+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.ProcessDepositTxInputsRequest;
-import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestFinalizePayoutTxMessage;
+import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessFinalizePayoutTxRequest;
-import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage;
+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) {
+                    if (message instanceof FinalizePayoutTxRequest) {
-                        handle((RequestFinalizePayoutTxMessage) message);
+                        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) {
+        if (tradeMessage instanceof PublishDepositTxRequest) {
-            handle((RequestPublishDepositTxMessage) tradeMessage);
+            handle((PublishDepositTxRequest) tradeMessage);
         }
-        else if (tradeMessage instanceof RequestFinalizePayoutTxMessage) {
+        else if (tradeMessage instanceof FinalizePayoutTxRequest) {
-            handle((RequestFinalizePayoutTxMessage) tradeMessage);
+            handle((FinalizePayoutTxRequest) tradeMessage);
         }
         else {
             log.error("Incoming decrypted tradeMessage not supported. " + tradeMessage);

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.FinalizePayoutTxRequest;
-import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage;
+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.ProcessFinalizePayoutTxRequest;
-import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage;
+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) {
+                    if (message instanceof FinalizePayoutTxRequest) {
-                        handle((RequestFinalizePayoutTxMessage) message);
+                        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) {
+        if (tradeMessage instanceof PublishDepositTxRequest) {
-            handle((RequestPublishDepositTxMessage) tradeMessage);
+            handle((PublishDepositTxRequest) tradeMessage);
         }
-        else if (tradeMessage instanceof RequestFinalizePayoutTxMessage) {
+        else if (tradeMessage instanceof FinalizePayoutTxRequest) {
-            handle((RequestFinalizePayoutTxMessage) tradeMessage);
+            handle((FinalizePayoutTxRequest) tradeMessage);
         }
         else {
             log.error("Incoming message not supported. " + tradeMessage);

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.SendFinalizePayoutTxRequest;
-import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestFinalizePayoutTxMessage;
+import io.bitsquare.trade.protocol.trade.tasks.seller.SendPublishDepositTxRequest;
-import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestPublishDepositTxMessage;
 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();
     }

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.SendDepositTxInputsRequest;
-import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestDepositTxInputsMessage;
+import io.bitsquare.trade.protocol.trade.tasks.seller.SendFinalizePayoutTxRequest;
-import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestFinalizePayoutTxMessage;
+import io.bitsquare.trade.protocol.trade.tasks.seller.SendPublishDepositTxRequest;
-import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestPublishDepositTxMessage;
 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) {
+        if (tradeMessage instanceof PayDepositRequest) {
-            handle((RequestPayDepositMessage) tradeMessage);
+            handle((PayDepositRequest) tradeMessage);
         }
         else if (tradeMessage instanceof DepositTxPublishedMessage) {
             handle((DepositTxPublishedMessage) tradeMessage);

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.BuyerTrade;
-import io.bitsquare.trade.TakerTrade;
+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.BuyerTradeState;
-import io.bitsquare.trade.states.TakerTradeState;
+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)
+        if (trade instanceof SellerTrade)
-            needPayoutTxBroadcast = trade.processStateProperty().get() == TakerTradeState.ProcessState.PAYOUT_FINALIZED;
+            needPayoutTxBroadcast = trade.processStateProperty().get() == SellerTradeState.ProcessState.PAYOUT_TX_COMMITTED;
-        else if (trade instanceof OffererTrade)
+        else if (trade instanceof BuyerTrade)
-            needPayoutTxBroadcast = trade.processStateProperty().get() == OffererTradeState.ProcessState.PAYOUT_FINALIZED;
+            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)
+                   /* if (trade instanceof SellerTrade)
-                        trade.setProcessState(TakerTradeState.ProcessState.TIMEOUT);
+                        trade.setProcessState(SellerTradeState.ProcessState.TIMEOUT);
-                    else if (trade instanceof OffererTrade)
+                    else if (trade instanceof BuyerTrade)
-                        trade.setProcessState(OffererTradeState.ProcessState.TIMEOUT);
+                        trade.setProcessState(BuyerTradeState.ProcessState.TIMEOUT);*/
                 });
             }
         };

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;

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,7 +32,7 @@ public class RequestFinalizePayoutTxMessage extends TradeMessage implements Mail
     public final String sellerPayoutAddress;
     public final long lockTime;
 
-    public RequestFinalizePayoutTxMessage(String tradeId,
+    public FinalizePayoutTxRequest(String tradeId,
                                    byte[] sellerSignature,
                                    String sellerPayoutAddress,
                                    long lockTime) {

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,7 +43,7 @@ public class RequestPayDepositMessage extends TradeMessage implements Serializab
     public final String buyerAccountId;
     public final Coin tradeAmount;
 
-    public RequestPayDepositMessage(String tradeId,
+    public PayDepositRequest(String tradeId,
                              Coin tradeAmount,
                              boolean isInitialRequest,
                              List<TransactionOutput> buyerConnectedOutputsForAllInputs,

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,7 +42,7 @@ public class RequestPublishDepositTxMessage extends TradeMessage implements Seri
     public final List<TransactionOutput> sellerConnectedOutputsForAllInputs;
     public final byte[] sellerTradeWalletPubKey;
 
-    public RequestPublishDepositTxMessage(String tradeId,
+    public PublishDepositTxRequest(String tradeId,
                                    FiatAccount sellerFiatAccount,
                                    String sellerAccountId,
                                    byte[] sellerTradeWalletPubKey,

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 {
+public class ProcessDepositTxInputsRequest extends TradeTask {
-    private static final Logger log = LoggerFactory.getLogger(ProcessRequestDepositTxInputsMessage.class);
+    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);
 

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 {
+public class ProcessFinalizePayoutTxRequest extends TradeTask {
-    private static final Logger log = LoggerFactory.getLogger(ProcessRequestFinalizePayoutTxMessage.class);
+    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();

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 {
+public class ProcessPublishDepositTxRequest extends TradeTask {
-    private static final Logger log = LoggerFactory.getLogger(ProcessRequestPublishDepositTxMessage.class);
+    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);
 

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();
                         }
 

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(BuyerTradeState.ProcessState.FIAT_PAYMENT_STARTED_MSG_SENT);
-                                trade.setProcessState(OffererTradeState.ProcessState.FIAT_PAYMENT_STARTED);
-                            if (trade instanceof TakerTrade)
-                                trade.setProcessState(TakerTradeState.ProcessState.FIAT_PAYMENT_STARTED);
 
                             complete();
                         }

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 {
+public class SendPayDepositRequest extends TradeTask {
-    private static final Logger log = LoggerFactory.getLogger(SendRequestPayDepositMessage.class);
+    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,

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();
                         }
 

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) {

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.BuyerTrade;
-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.BuyerTradeState;
-import io.bitsquare.trade.states.TakerTradeState;
 
 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(BuyerTradeState.ProcessState.DEPOSIT_PUBLISHED);
-                                trade.setProcessState(TakerTradeState.ProcessState.DEPOSIT_PUBLISHED);
-                            else if (trade instanceof OffererTrade)
-                                trade.setProcessState(OffererTradeState.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);

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.SellerTradeState;
-import io.bitsquare.trade.states.TakerTradeState;
 
 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(SellerTradeState.ProcessState.DEPOSIT_PUBLISHED_MSG_RECEIVED);
-                trade.setProcessState(OffererTradeState.ProcessState.DEPOSIT_PUBLISHED);
-            else if (trade instanceof TakerTrade)
-                trade.setProcessState(TakerTradeState.ProcessState.DEPOSIT_PUBLISHED);
 
             complete();
         } catch (Throwable t) {

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.SellerTradeState;
-import io.bitsquare.trade.states.TakerTradeState;
 
 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(SellerTradeState.ProcessState.FIAT_PAYMENT_STARTED_MSG_RECEIVED);
-                trade.setProcessState(OffererTradeState.ProcessState.FIAT_PAYMENT_STARTED);
-            else if (trade instanceof TakerTrade)
-                trade.setProcessState(TakerTradeState.ProcessState.FIAT_PAYMENT_STARTED);
 
             complete();
         } catch (Throwable t) {

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 {
+public class ProcessPayDepositRequest extends TradeTask {
-    private static final Logger log = LoggerFactory.getLogger(ProcessRequestPayDepositMessage.class);
+    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);
 

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.SellerTradeState;
-import io.bitsquare.trade.states.TakerTradeState;
 
 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(SellerTradeState.ProcessState.PAYOUT_TX_RECEIVED);
-                trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_FINALIZED);
-            else if (trade instanceof TakerTrade)
-                trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_FINALIZED);
 
             complete();
         } catch (Throwable t) {

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 {
+public class SendDepositTxInputsRequest extends TradeTask {
-    private static final Logger log = LoggerFactory.getLogger(SendRequestDepositTxInputsMessage.class);
+    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 " +

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.protocol.trade.messages.FinalizePayoutTxRequest;
-import io.bitsquare.trade.states.OffererTradeState;
+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 {
+public class SendFinalizePayoutTxRequest extends TradeTask {
-    private static final Logger log = LoggerFactory.getLogger(SendRequestFinalizePayoutTxMessage.class);
+    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(SellerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT_MSG_SENT);
-                                trade.setProcessState(TakerTradeState.ProcessState.REQUEST_PAYOUT_FINALIZE_MSG_SENT);
-                            else if (trade instanceof OffererTrade)
-                                trade.setProcessState(OffererTradeState.ProcessState.REQUEST_PAYOUT_FINALIZE_MSG_SENT);
 
                             complete();
                         }

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 {
+public class SendPublishDepositTxRequest extends TradeTask {
-    private static final Logger log = LoggerFactory.getLogger(SendRequestPublishDepositTxMessage.class);
+    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(),

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();

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.BuyerTrade;
-import io.bitsquare.trade.TakerTrade;
+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.BuyerTradeState;
-import io.bitsquare.trade.states.TakerTradeState;
+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)
+                if (trade instanceof BuyerTrade)
-                    trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_BROAD_CASTED);
+                    trade.setProcessState(BuyerTradeState.ProcessState.PAYOUT_BROAD_CASTED);
-                else if (trade instanceof OffererTrade)
+                else if (trade instanceof SellerTrade)
-                    trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_BROAD_CASTED);
+                    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);

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)
+                           /* if (trade instanceof SellerTrade)
-                                trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
+                                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)
+                          /*  if (trade instanceof SellerTrade)
-                                trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
+                                trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);*/
 
                             failed(t);
                         }

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)
+            /*if (trade instanceof SellerTrade)
-                trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
+                trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_TX_CREATED);*/
 
             complete();
         } catch (Throwable t) {

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 {
+public class BuyerTradeState {
-    private static final Logger log = LoggerFactory.getLogger(OffererTradeState.class);
+    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
+        FIAT_PAYMENT_RECEIPT_MSG_RECEIVED,
-        PAYOUT_FINALIZED,
 
-        PAYOUT_BROAD_CASTED,
+        PAYOUT_TX_COMMITTED,
-        PAYOUT_BROAD_CASTED_FAILED,
+        PAYOUT_TX_SENT,
 
-        MESSAGE_SENDING_FAILED,
+        PAYOUT_BROAD_CASTED
-        TIMEOUT,
-        EXCEPTION
     }
 }

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 {
+public class SellerTradeState {
-    private static final Logger log = LoggerFactory.getLogger(TakerTradeState.class);
+    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
+        FIAT_PAYMENT_RECEIPT,
-        PAYOUT_FINALIZED,
+        FIAT_PAYMENT_RECEIPT_MSG_SENT,
 
-        PAYOUT_BROAD_CASTED,
+        PAYOUT_TX_RECEIVED,
-        PAYOUT_BROAD_CASTED_FAILED,
+        PAYOUT_TX_COMMITTED,
 
-        MESSAGE_SENDING_FAILED,
+        PAYOUT_BROAD_CASTED
-        TIMEOUT,
-        EXCEPTION
     }
 }

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.BuyerTrade;
-import io.bitsquare.trade.TakerTrade;
 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)
+       /* if (trade instanceof BuyerTrade)
-            trade.setProcessState(OffererTradeState.ProcessState.MESSAGE_SENDING_FAILED);
+            trade.setProcessState(BuyerTradeState.ProcessState.MESSAGE_SENDING_FAILED);
-        else if (trade instanceof TakerTrade)
+        else if (trade instanceof SellerTrade)
-            trade.setProcessState(TakerTradeState.ProcessState.MESSAGE_SENDING_FAILED);
+            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);
     }
 } 

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.ProcessDepositTxInputsRequest;
-import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage;
+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.SendDepositTxInputsRequest;
-import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestDepositTxInputsMessage;
 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,
 

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) {
+    void onTakeOffer(TakeOfferResultHandler handler) {
-        tradeManager.requestTakeOffer(amountAsCoin.get(), offer, handler::handleResult);
+        tradeManager.onTakeOffer(amountAsCoin.get(), offer, handler::handleResult);
     }
 
     void calculateVolume() {

gui/src/main/java/io/bitsquare/gui/main/offer/takeoffer/TakeOfferView.java

@@ -158,7 +158,7 @@ public class TakeOfferView extends ActivatableViewAndModel<AnchorPane, TakeOffer
 
     @FXML
     void onTakeOffer() {
-        model.takeOffer();
+        model.onTakeOffer();
     }
 
     @FXML

gui/src/main/java/io/bitsquare/gui/main/offer/takeoffer/TakeOfferViewModel.java

@@ -28,7 +28,8 @@ import io.bitsquare.locale.CurrencyUtil;
 import io.bitsquare.trade.BuyerAsTakerTrade;
 import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.offer.Offer;
-import io.bitsquare.trade.states.TakerTradeState;
+import io.bitsquare.trade.states.BuyerTradeState;
+import io.bitsquare.trade.states.SellerTradeState;
 
 import org.bitcoinj.core.Address;
 import org.bitcoinj.core.Coin;
@@ -220,13 +221,13 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> 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<TakeOfferDataModel> im
                 if (trade.getErrorMessage() != null)
                     msg = "\nError message: " + trade.getErrorMessage();
 
-                if (trade instanceof BuyerAsTakerTrade) {
+                if (trade instanceof SellerAsTakerTrade) {
-                    switch ((TakerTradeState.ProcessState) newValue) {
+                    switch ((SellerTradeState.ProcessState) newValue) {
-                        case TAKE_OFFER_FEE_TX_CREATED:
+                        case UNDEFINED:
                             break;
-                        case DEPOSIT_PUBLISHED:
+                        case DEPOSIT_PUBLISHED_MSG_RECEIVED:
-                        case DEPOSIT_CONFIRMED:
                             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<TakeOfferDataModel> im
                         case EXCEPTION:
                             errorMessage.set(msg);
                             takeOfferRequested = false;
-                            break;
+                            break;*/
                         default:
                             log.warn("Unhandled trade state: " + newValue);
                             break;
                     }
                 }
-                else if (trade instanceof SellerAsTakerTrade) {
+                else if (trade instanceof BuyerAsTakerTrade) {
-                    switch ((TakerTradeState.ProcessState) newValue) {
+                    switch ((BuyerTradeState.ProcessState) newValue) {
-                        case TAKE_OFFER_FEE_TX_CREATED:
+                        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<TakeOfferDataModel> im
                         case EXCEPTION:
                             errorMessage.set(msg);
                             takeOfferRequested = false;
-                            break;
+                            break;*/
                         default:
                             log.warn("Unhandled trade state: " + newValue);
                             break;

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<PendingTradesViewModel.BuyerState> 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.BuyerState state) {
-    protected void applyState(PendingTradesViewModel.ViewState viewState) {
+        log.debug("applyState " + state);
-        log.debug("applyState " + viewState);
 
         waitTxInBlockchain.setDisabled();
         startFiat.setDisabled();
@@ -76,10 +91,8 @@ public class BuyerSubView extends TradeSubView {
         if (tradeStepDetailsView != null)
             tradeStepDetailsView.deactivate();
 
-        switch (viewState) {
+        switch (state) {
-            case UNDEFINED:
+            case WAIT_FOR_BLOCKCHAIN_CONFIRMATION:
-                break;
-            case BUYER_WAIT_TX_CONF:
                 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;
         }
 

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.BuyerTradeState;
-import io.bitsquare.trade.states.TakerTradeState;
+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<PendingTradesDataModel> implements ViewModel {
     private static final Logger log = LoggerFactory.getLogger(PendingTradesViewModel.class);
 
-    enum ViewState {
+   /* enum ViewState {
         UNDEFINED,
-        SELLER_WAIT_TX_CONF,
+        WAIT_FOR_BLOCKCHAIN_CONFIRMATION,
-        SELLER_WAIT_PAYMENT_STARTED,
+        WAIT_FOR_FIAT_PAYMENT_STARTED,
-        SELLER_CONFIRM_RECEIVE_PAYMENT,
+        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<PendingTrad
         MESSAGE_SENDING_FAILED,
         TIMEOUT,
         EXCEPTION
+    }*/
+
+    interface State {
+    }
+
+    enum BuyerState implements State {
+        WAIT_FOR_BLOCKCHAIN_CONFIRMATION,
+        REQUEST_START_FIAT_PAYMENT,
+        WAIT_FOR_FIAT_PAYMENT_RECEIPT,
+        WAIT_FOR_UNLOCK_PAYOUT,
+        REQUEST_WITHDRAWAL
+    }
+
+    enum SellerState implements State {
+        WAIT_FOR_BLOCKCHAIN_CONFIRMATION,
+        WAIT_FOR_FIAT_PAYMENT_STARTED,
+        REQUEST_CONFIRM_FIAT_PAYMENT_RECEIVED,
+        WAIT_FOR_PAYOUT_TX,
+        WAIT_FOR_UNLOCK_PAYOUT,
+        REQUEST_WITHDRAWAL
     }
 
     private final BSFormatter formatter;
     private final InvalidationListener sellerStateListener;
     private final InvalidationListener buyerStateListener;
     private final BtcAddressValidator btcAddressValidator;
-    private final ObjectProperty<ViewState> viewState = new SimpleObjectProperty<>(ViewState.UNDEFINED);
+
+    private final ObjectProperty<BuyerState> buyerState = new SimpleObjectProperty<>(BuyerState.WAIT_FOR_BLOCKCHAIN_CONFIRMATION);
+    private final ObjectProperty<SellerState> 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<PendingTrad
 
         this.formatter = formatter;
         this.btcAddressValidator = btcAddressValidator;
-        this.sellerStateListener = (ov) -> updateSellerState();
+        this.sellerStateListener = (ov) -> applySellerState();
-        this.buyerStateListener = (ov) -> updateBuyerState();
+        this.buyerStateListener = (ov) -> applyBuyerState();
     }
 
     @Override
@@ -105,8 +128,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
         dataModel.getBuyerProcessState().addListener(buyerStateListener);
 
         if (dataModel.getTrade() != null) {
-            updateSellerState();
+            applySellerState();
-            updateBuyerState();
+            applyBuyerState();
         }
     }
 
@@ -130,8 +153,12 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
     // Getters
     ///////////////////////////////////////////////////////////////////////////////////////////
 
-    ReadOnlyObjectProperty<ViewState> getViewState() {
+    ReadOnlyObjectProperty<BuyerState> getBuyerState() {
-        return viewState;
+        return buyerState;
+    }
+
+    ReadOnlyObjectProperty<SellerState> getSellerState() {
+        return sellerState;
     }
 
     public ReadOnlyStringProperty getTxId() {
@@ -304,97 +331,58 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
     // States
     ///////////////////////////////////////////////////////////////////////////////////////////
 
-    private void updateSellerState() {
+    private void applySellerState() {
-        if (dataModel.getSellerProcessState().get() instanceof TakerTradeState.ProcessState) {
+        if (dataModel.getSellerProcessState().get() instanceof SellerTradeState.ProcessState) {
-            TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.getSellerProcessState().get();
+            SellerTradeState.ProcessState processState = (SellerTradeState.ProcessState) dataModel.getSellerProcessState().get();
-            log.debug("updateSellerState (TakerTradeState) " + processState);
+            log.debug("updateSellerState (SellerTradeState) " + processState);
             if (processState != null) {
                 switch (processState) {
                     case UNDEFINED:
-                    case TAKE_OFFER_FEE_TX_CREATED:
+
-                    case TAKE_OFFER_FEE_PUBLISHED:
+                    case DEPOSIT_PUBLISHED_MSG_RECEIVED:
-                        break;
+                        sellerState.set(SellerState.WAIT_FOR_BLOCKCHAIN_CONFIRMATION);
-                    case TAKE_OFFER_FEE_PUBLISH_FAILED:
-                        viewState.set(ViewState.EXCEPTION);
                         break;
 
-                    case DEPOSIT_PUBLISHED:
+
-                        viewState.set(ViewState.SELLER_WAIT_TX_CONF);
-                        break;
                     case DEPOSIT_CONFIRMED:
-                        viewState.set(ViewState.SELLER_WAIT_PAYMENT_STARTED);
+                        sellerState.set(SellerState.WAIT_FOR_FIAT_PAYMENT_STARTED);
                         break;
 
-                    case FIAT_PAYMENT_STARTED:
+
-                        viewState.set(ViewState.SELLER_CONFIRM_RECEIVE_PAYMENT);
+                    case FIAT_PAYMENT_STARTED_MSG_RECEIVED:
+                        sellerState.set(SellerState.REQUEST_CONFIRM_FIAT_PAYMENT_RECEIVED);
                         break;
 
-                    case REQUEST_PAYOUT_FINALIZE_MSG_SENT:
+
-                        viewState.set(ViewState.SELLER_REQUEST_PAYOUT_FINALIZE_MSG_SENT);
+                    case FIAT_PAYMENT_RECEIPT:
                         break;
-                    case PAYOUT_FINALIZED:
+                    case FIAT_PAYMENT_RECEIPT_MSG_SENT:
-                        viewState.set(ViewState.SELLER_PAYOUT_FINALIZED);
+                        sellerState.set(SellerState.WAIT_FOR_PAYOUT_TX);
                         break;
 
+
+                    case PAYOUT_TX_RECEIVED:
+                        break;
+                    case PAYOUT_TX_COMMITTED:
+                        sellerState.set(SellerState.WAIT_FOR_UNLOCK_PAYOUT);
+                        break;
+
+
                     case PAYOUT_BROAD_CASTED:
-                        viewState.set(ViewState.SELLER_COMPLETED);
+                        sellerState.set(SellerState.REQUEST_WITHDRAWAL);
                         break;
-                    case PAYOUT_BROAD_CASTED_FAILED:
+
-                        viewState.set(ViewState.EXCEPTION);
+
+                   /* case PAYOUT_BROAD_CASTED_FAILED:
+                        // sellerState.set(SellerState.EXCEPTION);
                         break;
 
                     case MESSAGE_SENDING_FAILED:
-                        viewState.set(ViewState.MESSAGE_SENDING_FAILED);
+                        //sellerState.set(SellerState.MESSAGE_SENDING_FAILED);
                         break;
                     case EXCEPTION:
-                        viewState.set(ViewState.EXCEPTION);
+                        // sellerState.set(SellerState.EXCEPTION);
-                        break;
+                        break;*/
-
-                    default:
-                        log.warn("unhandled processState " + processState);
-                        break;
-                }
-            }
-        }
-        else if (dataModel.getSellerProcessState().get() instanceof OffererTradeState.ProcessState) {
-            OffererTradeState.ProcessState processState = (OffererTradeState.ProcessState) dataModel.getSellerProcessState().get();
-            log.debug("updateSellerState (OffererTradeState) " + processState);
-            if (processState != null) {
-                switch (processState) {
-                    case UNDEFINED:
-                        break;
-
-                    case DEPOSIT_PUBLISHED:
-                        viewState.set(ViewState.SELLER_WAIT_TX_CONF);
-                        break;
-                    case DEPOSIT_CONFIRMED:
-                        viewState.set(ViewState.SELLER_WAIT_PAYMENT_STARTED);
-                        break;
-
-                    case FIAT_PAYMENT_STARTED:
-                        viewState.set(ViewState.SELLER_CONFIRM_RECEIVE_PAYMENT);
-                        break;
-
-                    case REQUEST_PAYOUT_FINALIZE_MSG_SENT:
-                        viewState.set(ViewState.SELLER_REQUEST_PAYOUT_FINALIZE_MSG_SENT);
-                        break;
-                    case PAYOUT_FINALIZED:
-                        viewState.set(ViewState.SELLER_PAYOUT_FINALIZED);
-                        break;
-
-                    case PAYOUT_BROAD_CASTED:
-                        viewState.set(ViewState.SELLER_COMPLETED);
-                        break;
-                    case PAYOUT_BROAD_CASTED_FAILED:
-                        viewState.set(ViewState.EXCEPTION);
-                        break;
-
-                    case MESSAGE_SENDING_FAILED:
-                        viewState.set(ViewState.MESSAGE_SENDING_FAILED);
-                        break;
-                    case EXCEPTION:
-                        viewState.set(ViewState.EXCEPTION);
-                        break;
 
                     default:
                         log.warn("unhandled processState " + processState);
@@ -407,94 +395,59 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
         }
     }
 
-    private void updateBuyerState() {
+    private void applyBuyerState() {
-        if (dataModel.getBuyerProcessState().get() instanceof TakerTradeState.ProcessState) {
+        if (dataModel.getBuyerProcessState().get() instanceof BuyerTradeState.ProcessState) {
-            TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.getBuyerProcessState().get();
+            BuyerTradeState.ProcessState processState = (BuyerTradeState.ProcessState) dataModel.getBuyerProcessState().get();
-            log.debug("updateBuyerState (TakerTradeState)" + processState);
+            log.debug("updateBuyerState (BuyerTradeState) " + processState);
-            if (processState != null) {
-                switch (processState) {
-                    case UNDEFINED:
-                    case TAKE_OFFER_FEE_TX_CREATED:
-                    case TAKE_OFFER_FEE_PUBLISHED:
-                        break;
-                    case TAKE_OFFER_FEE_PUBLISH_FAILED:
-                        viewState.set(ViewState.EXCEPTION);
-                        break;
-
-                    case DEPOSIT_PUBLISHED:
-                        viewState.set(ViewState.BUYER_WAIT_TX_CONF);
-                        break;
-                    case DEPOSIT_CONFIRMED:
-                        viewState.set(ViewState.BUYER_START_PAYMENT);
-                        break;
-
-                    case FIAT_PAYMENT_STARTED:
-                        viewState.set(ViewState.BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED);
-                        break;
-
-                    case PAYOUT_FINALIZED:
-                        viewState.set(ViewState.BUYER_PAYOUT_FINALIZED);
-                        break;
-
-                    case PAYOUT_BROAD_CASTED:
-                        viewState.set(ViewState.BUYER_COMPLETED);
-                        break;
-                    case PAYOUT_BROAD_CASTED_FAILED:
-                        viewState.set(ViewState.EXCEPTION);
-                        break;
-
-                    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;
-
-                    default:
-                        log.warn("unhandled viewState " + processState);
-                        break;
-                }
-            }
-        }
-        else if (dataModel.getBuyerProcessState().get() instanceof OffererTradeState.ProcessState) {
-            OffererTradeState.ProcessState processState = (OffererTradeState.ProcessState) dataModel.getBuyerProcessState().get();
-            log.debug("updateBuyerState (OffererTradeState) " + processState);
             if (processState != null) {
                 switch (processState) {
                     case UNDEFINED:
                         break;
+
+
                     case DEPOSIT_PUBLISHED:
-                        viewState.set(ViewState.BUYER_WAIT_TX_CONF);
+                    case DEPOSIT_PUBLISHED_MSG_SENT:
+                        buyerState.set(BuyerState.WAIT_FOR_BLOCKCHAIN_CONFIRMATION);
                         break;
+
+
                     case DEPOSIT_CONFIRMED:
-                        viewState.set(ViewState.BUYER_START_PAYMENT);
+                        buyerState.set(BuyerState.REQUEST_START_FIAT_PAYMENT);
                         break;
 
+
                     case FIAT_PAYMENT_STARTED:
-                        viewState.set(ViewState.BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED);
+                        break;
+                    case FIAT_PAYMENT_STARTED_MSG_SENT:
+                        buyerState.set(BuyerState.WAIT_FOR_FIAT_PAYMENT_RECEIPT);
                         break;
 
-                    case PAYOUT_FINALIZED:
+
-                        viewState.set(ViewState.BUYER_PAYOUT_FINALIZED);
+                    case FIAT_PAYMENT_RECEIPT_MSG_RECEIVED:
+                    case PAYOUT_TX_COMMITTED:
                         break;
+                    case PAYOUT_TX_SENT:
+                        buyerState.set(BuyerState.WAIT_FOR_UNLOCK_PAYOUT);
+                        break;
+
 
                     case PAYOUT_BROAD_CASTED:
-                        viewState.set(ViewState.BUYER_COMPLETED);
+                        buyerState.set(BuyerState.REQUEST_WITHDRAWAL);
                         break;
-                    case PAYOUT_BROAD_CASTED_FAILED:
+
-                        viewState.set(ViewState.EXCEPTION);
+
+                   /* case PAYOUT_BROAD_CASTED_FAILED:
+                        // buyerState.set(BuyerState.EXCEPTION);
                         break;
 
+
                     case MESSAGE_SENDING_FAILED:
-                        viewState.set(ViewState.MESSAGE_SENDING_FAILED);
+                        // buyerState.set(BuyerState.MESSAGE_SENDING_FAILED);
                         break;
                     case EXCEPTION:
-                        viewState.set(ViewState.EXCEPTION);
+                        // buyerState.set(BuyerState.EXCEPTION);
                         break;
-
+*/
                     default:
                         log.warn("unhandled viewState " + processState);
                         break;

gui/src/main/java/io/bitsquare/gui/main/portfolio/pendingtrades/SellerSubView.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.ConfirmFiatReceivedView;
 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 SellerSubView extends TradeSubView {
     private TradeWizardItem payoutUnlock;
     private TradeWizardItem completed;
 
+    private final ChangeListener<PendingTradesViewModel.SellerState> 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.SellerState viewState) {
-    protected void applyState(PendingTradesViewModel.ViewState viewState) {
         log.debug("applyState " + viewState);
 
         waitTxInBlockchain.setDisabled();
@@ -77,9 +92,7 @@ public class SellerSubView extends TradeSubView {
             tradeStepDetailsView.deactivate();
 
         switch (viewState) {
-            case UNDEFINED:
+            case WAIT_FOR_BLOCKCHAIN_CONFIRMATION:
-                break;
-            case SELLER_WAIT_TX_CONF:
                 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;

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<PendingTradesViewModel.ViewState> 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();

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();
     }