Add interfaces for trade variants

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

@@ -122,7 +122,7 @@ public class OffererAsBuyerSubView extends TradeSubView {
                 completedView.setSecurityDepositTextFieldText(model.getSecurityDeposit());
                 completedView.setSummaryInfoDisplayText("Your security deposit has been refunded to you. " +
                         "You can review the details to that trade any time in the closed trades screen.");
-                completedView.setWithdrawAmountTextFieldText(model.getAmountToWithdraw());
+                completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount());
                 break;
             case MESSAGE_SENDING_FAILED:
                 Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage());

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

@@ -135,7 +135,7 @@ public class OffererAsSellerSubView extends TradeSubView {
                 completedView.setSummaryInfoDisplayText("Your security deposit has been refunded to you. " +
                         "You can review the details to that trade any time in the closed trades screen.");
 
-                completedView.setWithdrawAmountTextFieldText(model.getAmountToWithdraw());
+                completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount());
                 break;
             case MESSAGE_SENDING_FAILED:
                 Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage());

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

@@ -25,9 +25,11 @@ import io.bitsquare.gui.components.Popups;
 import io.bitsquare.offer.Offer;
 import io.bitsquare.trade.BuyerAsOffererTrade;
 import io.bitsquare.trade.BuyerAsTakerTrade;
+import io.bitsquare.trade.BuyerTrade;
 import io.bitsquare.trade.Contract;
 import io.bitsquare.trade.SellerAsOffererTrade;
 import io.bitsquare.trade.SellerAsTakerTrade;
+import io.bitsquare.trade.SellerTrade;
 import io.bitsquare.trade.Trade;
 import io.bitsquare.trade.TradeManager;
 import io.bitsquare.trade.states.TradeState;
@@ -136,6 +138,8 @@ class PendingTradesDataModel implements Activatable, DataModel {
 
             Trade trade = item.getTrade();
             isOfferer = trade.getOffer().getP2pSigPubKey().equals(user.getP2pSigPubKey());
+
+            // TODO merge states
             if (trade instanceof SellerAsTakerTrade)
                 takerAsSellerProcessState.bind(trade.processStateProperty());
             else if (trade instanceof BuyerAsOffererTrade)
@@ -151,17 +155,13 @@ class PendingTradesDataModel implements Activatable, DataModel {
     }
 
     void fiatPaymentStarted() {
-        if (getTrade() instanceof BuyerAsOffererTrade)
+        if (getTrade() instanceof BuyerTrade)
-            ((BuyerAsOffererTrade) getTrade()).onFiatPaymentStarted();
+            ((BuyerTrade) getTrade()).onFiatPaymentStarted();
-        else if (getTrade() instanceof BuyerAsTakerTrade)
-            ((BuyerAsTakerTrade) getTrade()).onFiatPaymentStarted();
     }
 
     void fiatPaymentReceived() {
-        if (getTrade() instanceof SellerAsTakerTrade)
+        if (getTrade() instanceof SellerTrade)
-            ((SellerAsTakerTrade) getTrade()).onFiatPaymentReceived();
+            ((SellerTrade) getTrade()).onFiatPaymentReceived();
-        else if (getTrade() instanceof SellerAsOffererTrade)
-            ((SellerAsOffererTrade) getTrade()).onFiatPaymentReceived();
     }
 
     void withdraw(String toAddress) {
@@ -259,13 +259,8 @@ class PendingTradesDataModel implements Activatable, DataModel {
         offererAsSellerProcessState.unbind();
     }
 
-    public Coin getAmountToWithdraw() {
+    public Coin getPayoutAmount() {
-        Trade trade = selectedItem.getTrade();
+        return getTrade().getPayoutAmount();
-        Coin amountToWithdraw = trade.getSecurityDeposit();
-        assert trade.getTradeAmount() != null;
-        if (trade instanceof BuyerAsOffererTrade || trade instanceof BuyerAsTakerTrade)
-            amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount());
-        return amountToWithdraw;
     }
 
     public Contract getContract() {

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

@@ -165,8 +165,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
         withdrawalButtonDisable.set(!btcAddressValidator.validate(text).isValid);
     }
 
-    public String getAmountToWithdraw() {
+    public String getPayoutAmount() {
-        return formatter.formatCoinWithCode(dataModel.getAmountToWithdraw());
+        return formatter.formatCoinWithCode(dataModel.getPayoutAmount());
     }
 
     ObservableList<PendingTradesListItem> getList() {

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

@@ -123,7 +123,7 @@ public class TakerAsBuyerSubView extends TradeSubView {
                 completedView.setSecurityDepositTextFieldText(model.getSecurityDeposit());
                 completedView.setSummaryInfoDisplayText("Your security deposit has been refunded to you. " +
                         "You can review the details to that trade any time in the closed trades screen.");
-                completedView.setWithdrawAmountTextFieldText(model.getAmountToWithdraw());
+                completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount());
                 break;
             case MESSAGE_SENDING_FAILED:
                 Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage());

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

@@ -137,7 +137,7 @@ public class TakerAsSellerSubView extends TradeSubView {
                 completedView.setSummaryInfoDisplayText("Your security deposit has been refunded to you. " +
                         "You can review the details to that trade any time in the closed trades screen.");
 
-                completedView.setWithdrawAmountTextFieldText(model.getAmountToWithdraw());
+                completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount());
                 break;
             case MESSAGE_SENDING_FAILED:
                 Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage());

core/src/main/java/io/bitsquare/offer/Offer.java

@@ -247,6 +247,7 @@ public class Offer implements Serializable {
         return arbitratorIds;
     }
 
+    @NotNull
     public Coin getSecurityDeposit() {
         return securityDeposit;
     }

core/src/main/java/io/bitsquare/p2p/tomp2p/TomP2PMessageService.java

@@ -120,7 +120,7 @@ public class TomP2PMessageService extends TomP2PService implements MessageServic
         });
     }
 
-    private void sendMailboxMessage(PublicKey recipientP2pSigPubKey, PublicKey recipientP2pEncryptPubKey, MailboxMessage message, SendMessageListener 
+    private void sendMailboxMessage(PublicKey recipientP2pSigPubKey, PublicKey recipientP2pEncryptPubKey, MailboxMessage message, SendMessageListener
             listener) {
         Bucket bucket = null;
         log.info("sendMailboxMessage called");

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

@@ -23,6 +23,8 @@ import io.bitsquare.trade.protocol.trade.buyer.BuyerAsOffererProtocol;
 import io.bitsquare.trade.states.OffererState;
 import io.bitsquare.trade.states.TradeState;
 
+import org.bitcoinj.core.Coin;
+
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.Serializable;
@@ -30,7 +32,7 @@ import java.io.Serializable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class BuyerAsOffererTrade extends Trade implements Serializable {
+public class BuyerAsOffererTrade extends Trade implements OffererTrade, BuyerTrade, Serializable {
     // That object is saved to disc. We need to take care of changes to not break deserialization.
     private static final long serialVersionUID = 1L;
 
@@ -68,14 +70,20 @@ public class BuyerAsOffererTrade extends Trade implements Serializable {
 
 
     ///////////////////////////////////////////////////////////////////////////////////////////
-    // Fiat
+    // API
     ///////////////////////////////////////////////////////////////////////////////////////////
 
+    @Override
     public void onFiatPaymentStarted() {
         assert tradeProtocol instanceof BuyerAsOffererProtocol;
         ((BuyerAsOffererProtocol) tradeProtocol).onFiatPaymentStarted();
     }
 
+    @Override
+    public Coin getPayoutAmount() {
+        return getSecurityDeposit().add(getTradeAmount());
+    }
+
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Setter for Mutable objects
@@ -107,10 +115,10 @@ public class BuyerAsOffererTrade extends Trade implements Serializable {
         }
     }
 
-
     @Override
     public void setThrowable(Throwable throwable) {
         super.setThrowable(throwable);
+
         setProcessState(OffererState.ProcessState.EXCEPTION);
     }
 

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

@@ -32,7 +32,7 @@ import java.io.Serializable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class BuyerAsTakerTrade extends Trade implements Serializable {
+public class BuyerAsTakerTrade extends Trade implements TakerTrade, BuyerTrade, Serializable {
     // That object is saved to disc. We need to take care of changes to not break deserialization.
     private static final long serialVersionUID = 1L;
 
@@ -43,8 +43,7 @@ public class BuyerAsTakerTrade extends Trade implements Serializable {
     // Constructor, initialization
     ///////////////////////////////////////////////////////////////////////////////////////////
 
-    public BuyerAsTakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer,
+    public BuyerAsTakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, Storage<? extends TradeList> storage) {
-                             Storage<? extends TradeList> storage) {
         super(offer, tradeAmount, tradingPeer, storage);
         log.trace("Created by constructor");
     }
@@ -80,11 +79,16 @@ public class BuyerAsTakerTrade extends Trade implements Serializable {
         ((BuyerAsTakerProtocol) tradeProtocol).takeAvailableOffer();
     }
 
+    @Override
     public void onFiatPaymentStarted() {
         assert tradeProtocol instanceof BuyerAsTakerProtocol;
         ((BuyerAsTakerProtocol) tradeProtocol).onFiatPaymentStarted();
     }
 
+    @Override
+    public Coin getPayoutAmount() {
+        return getSecurityDeposit().add(getTradeAmount());
+    }
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Setter for Mutable objects
@@ -119,6 +123,7 @@ public class BuyerAsTakerTrade extends Trade implements Serializable {
     @Override
     public void setThrowable(Throwable throwable) {
         super.setThrowable(throwable);
+
         setProcessState(TakerState.ProcessState.EXCEPTION);
     }
 

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

@@ -15,20 +15,8 @@
  * along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package io.bitsquare.trade.protocol.trade.messages;
+package io.bitsquare.trade;
 
-import java.io.Serializable;
+public interface BuyerTrade {
-
+    void onFiatPaymentStarted();
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class ConfirmReserveOfferMessage 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;
-
-    private static final Logger log = LoggerFactory.getLogger(ConfirmReserveOfferMessage.class);
-
-    public ConfirmReserveOfferMessage(String tradeId) {
-        super(tradeId);
-    }
 }

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

@@ -0,0 +1,21 @@
+/*
+ * This file is part of Bitsquare.
+ *
+ * Bitsquare is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or (at
+ * your option) any later version.
+ *
+ * Bitsquare is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package io.bitsquare.trade;
+
+public interface OffererTrade {
+}

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

@@ -30,7 +30,7 @@ import java.io.Serializable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class SellerAsOffererTrade extends Trade implements Serializable {
+public class SellerAsOffererTrade extends Trade implements OffererTrade, SellerTrade, Serializable {
     // That object is saved to disc. We need to take care of changes to not break deserialization.
     private static final long serialVersionUID = 1L;
 
@@ -68,9 +68,10 @@ public class SellerAsOffererTrade extends Trade implements Serializable {
 
 
     ///////////////////////////////////////////////////////////////////////////////////////////
-    // Fiat
+    // API
     ///////////////////////////////////////////////////////////////////////////////////////////
 
+    @Override
     public void onFiatPaymentReceived() {
         assert tradeProtocol instanceof SellerAsOffererProtocol;
         ((SellerAsOffererProtocol) tradeProtocol).onFiatPaymentReceived();
@@ -110,9 +111,11 @@ public class SellerAsOffererTrade extends Trade implements Serializable {
     @Override
     public void setThrowable(Throwable throwable) {
         super.setThrowable(throwable);
+
         setProcessState(OffererState.ProcessState.EXCEPTION);
     }
 
+
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Protected
     ///////////////////////////////////////////////////////////////////////////////////////////

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

@@ -32,7 +32,7 @@ import java.io.Serializable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class SellerAsTakerTrade extends Trade implements Serializable {
+public class SellerAsTakerTrade extends Trade implements TakerTrade, SellerTrade, Serializable {
     // That object is saved to disc. We need to take care of changes to not break deserialization.
     private static final long serialVersionUID = 1L;
 
@@ -43,8 +43,7 @@ public class SellerAsTakerTrade extends Trade implements Serializable {
     // Constructor, initialization
     ///////////////////////////////////////////////////////////////////////////////////////////
 
-    public SellerAsTakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer,
+    public SellerAsTakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, Storage<? extends TradeList> storage) {
-                              Storage<? extends TradeList> storage) {
         super(offer, tradeAmount, tradingPeer, storage);
         log.trace("Created by constructor");
     }
@@ -57,6 +56,20 @@ public class SellerAsTakerTrade extends Trade implements Serializable {
         initAmountProperty();
     }
 
+    @Override
+    public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
+        super.setLifeCycleState(lifeCycleState);
+
+        switch ((TakerState.LifeCycleState) lifeCycleState) {
+            case FAILED:
+                disposeProtocol();
+                break;
+            case COMPLETED:
+                disposeProtocol();
+                break;
+        }
+    }
+
     @Override
     protected void initStates() {
         processState = TakerState.ProcessState.UNDEFINED;
@@ -80,6 +93,7 @@ public class SellerAsTakerTrade extends Trade implements Serializable {
         ((SellerAsTakerProtocol) tradeProtocol).takeAvailableOffer();
     }
 
+    @Override
     public void onFiatPaymentReceived() {
         assert tradeProtocol instanceof SellerAsTakerProtocol;
         ((SellerAsTakerProtocol) tradeProtocol).onFiatPaymentReceived();
@@ -92,11 +106,9 @@ public class SellerAsTakerTrade extends Trade implements Serializable {
 
     @Override
     public void setProcessState(TradeState.ProcessState processState) {
-        TakerState.ProcessState state = (TakerState.ProcessState) processState;
+        super.setProcessState(processState);
-        this.processState = processState;
-        processStateProperty.set(processState);
 
-        switch (state) {
+        switch ((TakerState.ProcessState) processState) {
             case EXCEPTION:
                 disposeProtocol();
                 setLifeCycleState(TakerState.LifeCycleState.FAILED);
@@ -104,24 +116,10 @@ public class SellerAsTakerTrade extends Trade implements Serializable {
         }
     }
 
-    @Override
-    public void setLifeCycleState(TradeState.LifeCycleState lifeCycleState) {
-        TakerState.LifeCycleState state = (TakerState.LifeCycleState) lifeCycleState;
-        switch (state) {
-            case FAILED:
-                disposeProtocol();
-                break;
-            case COMPLETED:
-                disposeProtocol();
-                break;
-        }
-        this.lifeCycleState = lifeCycleState;
-        lifeCycleStateProperty.set(lifeCycleState);
-    }
-
     @Override
     public void setThrowable(Throwable throwable) {
         super.setThrowable(throwable);
+
         setProcessState(TakerState.ProcessState.EXCEPTION);
     }
 

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

@@ -0,0 +1,22 @@
+/*
+ * This file is part of Bitsquare.
+ *
+ * Bitsquare is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or (at
+ * your option) any later version.
+ *
+ * Bitsquare is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package io.bitsquare.trade;
+
+public interface SellerTrade {
+    void onFiatPaymentReceived();
+}

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

@@ -0,0 +1,22 @@
+/*
+ * This file is part of Bitsquare.
+ *
+ * Bitsquare is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or (at
+ * your option) any later version.
+ *
+ * Bitsquare is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package io.bitsquare.trade;
+
+public interface TakerTrade {
+    void takeAvailableOffer();
+}

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

@@ -71,10 +71,10 @@ abstract public class Trade implements Model, Serializable {
     private transient static final Logger log = LoggerFactory.getLogger(Trade.class);
 
     // Mutable
-    protected Coin tradeAmount;
+    private Coin tradeAmount;
-    protected Peer tradingPeer;
+    private Peer tradingPeer;
-    transient protected ObjectProperty<Coin> tradeAmountProperty;
+    private transient ObjectProperty<Coin> tradeAmountProperty;
-    transient protected ObjectProperty<Fiat> tradeVolumeProperty;
+    private transient ObjectProperty<Fiat> tradeVolumeProperty;
 
 
     ///////////////////////////////////////////////////////////////////////////////////////////
@@ -82,21 +82,22 @@ abstract public class Trade implements Model, Serializable {
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     // Transient/Immutable
-    transient protected ObjectProperty<TradeState.ProcessState> processStateProperty;
+    private transient ObjectProperty<TradeState.ProcessState> processStateProperty;
-    transient protected ObjectProperty<TradeState.LifeCycleState> lifeCycleStateProperty;
+    private transient ObjectProperty<TradeState.LifeCycleState> lifeCycleStateProperty;
+    // Trades are saved in the TradeList
     transient private Storage<? extends TradeList> storage;
     transient protected TradeProtocol tradeProtocol;
 
     // Immutable
-    protected final Offer offer;
+    private final Offer offer;
     private final Date date;
-    protected final ProcessModel processModel;
+    private final ProcessModel processModel;
 
     // Mutable
     protected TradeState.ProcessState processState;
     protected TradeState.LifeCycleState lifeCycleState;
     private MailboxMessage mailboxMessage;
-    protected Transaction depositTx;
+    private Transaction depositTx;
     private Contract contract;
     private String contractAsJson;
     private String sellerContractSignature;
@@ -118,7 +119,7 @@ abstract public class Trade implements Model, Serializable {
         this.storage = storage;
 
         date = new Date();
-        processModel = createProcessModel();
+        processModel = new ProcessModel();
         tradeVolumeProperty = new SimpleObjectProperty<>();
         tradeAmountProperty = new SimpleObjectProperty<>();
 
@@ -133,6 +134,8 @@ abstract public class Trade implements Model, Serializable {
         this(offer, storage);
         this.tradeAmount = tradeAmount;
         this.tradingPeer = tradingPeer;
+        tradeAmountProperty.set(tradeAmount);
+        tradeVolumeProperty.set(getTradeVolume());
     }
 
     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
@@ -171,6 +174,20 @@ abstract public class Trade implements Model, Serializable {
         lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState);
     }
 
+    protected void initAmountProperty() {
+        tradeAmountProperty = new SimpleObjectProperty<>();
+        tradeVolumeProperty = new SimpleObjectProperty<>();
+
+        if (tradeAmount != null) {
+            tradeAmountProperty.set(tradeAmount);
+            tradeVolumeProperty.set(getTradeVolume());
+        }
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // API
+    ///////////////////////////////////////////////////////////////////////////////////////////
 
     // The deserialized tx has not actual confidence data, so we need to get the fresh one from the wallet.
     public void updateDepositTxFromWallet(TradeWalletService tradeWalletService) {
@@ -215,58 +232,6 @@ abstract public class Trade implements Model, Serializable {
         storage.queueUpForSave();
     }
 
-    protected void setupConfidenceListener() {
-        if (depositTx != null) {
-            TransactionConfidence transactionConfidence = depositTx.getConfidence();
-            ListenableFuture<TransactionConfidence> future = transactionConfidence.getDepthFuture(1);
-            Futures.addCallback(future, new FutureCallback<TransactionConfidence>() {
-                @Override
-                public void onSuccess(TransactionConfidence result) {
-                    handleConfidenceResult();
-                }
-
-                @Override
-                public void onFailure(@NotNull Throwable t) {
-                    t.printStackTrace();
-                    log.error(t.getMessage());
-                    Throwables.propagate(t);
-                }
-            });
-        }
-    }
-
-    // taker only
-    public void takeAvailableOffer() {
-    }
-
-    abstract protected void createProtocol();
-
-    public ReadOnlyObjectProperty<Coin> tradeAmountProperty() {
-        return tradeAmountProperty;
-    }
-
-    public ReadOnlyObjectProperty<Fiat> tradeVolumeProperty() {
-        return tradeVolumeProperty;
-    }
-
-    protected void initAmountProperty() {
-        tradeAmountProperty = new SimpleObjectProperty<>();
-        tradeVolumeProperty = new SimpleObjectProperty<>();
-
-        if (tradeAmount != null) {
-            tradeAmountProperty.set(tradeAmount);
-            tradeVolumeProperty.set(getTradeVolume());
-        }
-    }
-
-    abstract protected void handleConfidenceResult();
-
-    abstract protected void initStates();
-
-    public ProcessModel createProcessModel() {
-        return new ProcessModel();
-    }
-
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Storage
@@ -305,14 +270,48 @@ abstract public class Trade implements Model, Serializable {
         return depositTx;
     }
 
+    @NotNull
     public Coin getSecurityDeposit() {
         return offer.getSecurityDeposit();
     }
 
+    public Coin getPayoutAmount() {
+        return getSecurityDeposit();
+    }
+
     public ProcessModel getProcessModel() {
         return processModel;
     }
 
+    @Nullable
+    public Fiat getTradeVolume() {
+        if (tradeAmount != null)
+            return offer.getVolumeByAmount(tradeAmount);
+        else
+            return null;
+    }
+
+    public ReadOnlyObjectProperty<? extends TradeState.ProcessState> processStateProperty() {
+        return processStateProperty;
+    }
+
+    public ReadOnlyObjectProperty<? extends TradeState.LifeCycleState> lifeCycleStateProperty() {
+        return lifeCycleStateProperty;
+    }
+
+    public ReadOnlyObjectProperty<Coin> tradeAmountProperty() {
+        return tradeAmountProperty;
+    }
+
+    public ReadOnlyObjectProperty<Fiat> tradeVolumeProperty() {
+        return tradeVolumeProperty;
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // Getter/Setter for Mutable objects
+    ///////////////////////////////////////////////////////////////////////////////////////////
+
     public void setTradingPeer(Peer tradingPeer) {
         this.tradingPeer = tradingPeer;
     }
@@ -333,27 +332,6 @@ abstract public class Trade implements Model, Serializable {
         return tradeAmount;
     }
 
-    @Nullable
-    public Fiat getTradeVolume() {
-        if (tradeAmount != null)
-            return offer.getVolumeByAmount(tradeAmount);
-        else
-            return null;
-    }
-
-    public ReadOnlyObjectProperty<? extends TradeState.ProcessState> processStateProperty() {
-        return processStateProperty;
-    }
-
-    public ReadOnlyObjectProperty<? extends TradeState.LifeCycleState> lifeCycleStateProperty() {
-        return lifeCycleStateProperty;
-    }
-
-
-    ///////////////////////////////////////////////////////////////////////////////////////////
-    // Getter/Setter for Mutable objects
-    ///////////////////////////////////////////////////////////////////////////////////////////
-
     public void setSellerContractSignature(String takerSignature) {
         this.sellerContractSignature = takerSignature;
     }
@@ -395,6 +373,7 @@ abstract public class Trade implements Model, Serializable {
     }
 
     // Not used now, but will be used in some reporting UI
+    @Nullable
     public Transaction getPayoutTx() {
         return payoutTx;
     }
@@ -408,7 +387,6 @@ abstract public class Trade implements Model, Serializable {
         return errorMessage;
     }
 
-
     public void setThrowable(Throwable throwable) {
         this.throwable = throwable;
     }
@@ -418,9 +396,49 @@ abstract public class Trade implements Model, Serializable {
         return throwable;
     }
 
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // Private
+    ///////////////////////////////////////////////////////////////////////////////////////////
+
+    private void setupConfidenceListener() {
+        if (depositTx != null) {
+            TransactionConfidence transactionConfidence = depositTx.getConfidence();
+            ListenableFuture<TransactionConfidence> future = transactionConfidence.getDepthFuture(1);
+            Futures.addCallback(future, new FutureCallback<TransactionConfidence>() {
+                @Override
+                public void onSuccess(TransactionConfidence result) {
+                    handleConfidenceResult();
+                }
+
+                @Override
+                public void onFailure(@NotNull Throwable t) {
+                    t.printStackTrace();
+                    log.error(t.getMessage());
+                    Throwables.propagate(t);
+                }
+            });
+        }
+    }
+
+    abstract protected void createProtocol();
+
+    abstract protected void handleConfidenceResult();
+
+    abstract protected void initStates();
+
+
     @Override
     public String toString() {
-        return ", protocol=" + tradeProtocol +
+        return "Trade{" +
+                "tradeAmount=" + tradeAmount +
+                ", tradingPeer=" + tradingPeer +
+                ", tradeAmountProperty=" + tradeAmountProperty +
+                ", tradeVolumeProperty=" + tradeVolumeProperty +
+                ", processStateProperty=" + processStateProperty +
+                ", lifeCycleStateProperty=" + lifeCycleStateProperty +
+                ", storage=" + storage +
+                ", tradeProtocol=" + tradeProtocol +
                 ", offer=" + offer +
                 ", date=" + date +
                 ", processModel=" + processModel +
@@ -430,8 +448,8 @@ abstract public class Trade implements Model, Serializable {
                 ", depositTx=" + depositTx +
                 ", contract=" + contract +
                 ", contractAsJson='" + contractAsJson + '\'' +
-                ", takerContractSignature='" + sellerContractSignature + '\'' +
+                ", sellerContractSignature='" + sellerContractSignature + '\'' +
-                ", offererContractSignature='" + buyerContractSignature + '\'' +
+                ", buyerContractSignature='" + buyerContractSignature + '\'' +
                 ", payoutTx=" + payoutTx +
                 ", errorMessage='" + errorMessage + '\'' +
                 ", throwable=" + throwable +

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

@@ -170,10 +170,10 @@ public class TradeManager {
             // continue the trade, but that might fail.
 
             boolean failed = false;
-            if (trade instanceof SellerAsTakerTrade)
+            if (trade instanceof TakerTrade)
-                failed = trade.lifeCycleState == TakerState.LifeCycleState.FAILED;
-            else if (trade instanceof BuyerAsTakerTrade)
                 failed = trade.lifeCycleState == TakerState.LifeCycleState.FAILED;
+            else if (trade instanceof OffererTrade)
+                failed = trade.lifeCycleState == OffererState.LifeCycleState.FAILED;
 
             if (failed) {
                 failedTrades.add(trade);
@@ -293,7 +293,7 @@ public class TradeManager {
     private void setupDepositPublishedListener(Trade trade) {
         trade.processStateProperty().addListener((ov, oldValue, newValue) -> {
             log.debug("setupDepositPublishedListener state = " + newValue);
-            if (newValue == OffererState.ProcessState.DEPOSIT_PUBLISHED || newValue == OffererState.ProcessState.DEPOSIT_PUBLISHED) {
+            if (newValue == OffererState.ProcessState.DEPOSIT_PUBLISHED) {
                 removeOpenOffer(trade.getOffer(),
                         () -> log.debug("remove offer was successful"),
                         log::error,
@@ -321,9 +321,7 @@ public class TradeManager {
                         openOfferTrades.remove(trade);
 
                         if (isCancelRequest) {
-                            if (trade instanceof BuyerAsOffererTrade)
+                            if (trade instanceof OffererTrade)
-                                trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_CANCELED);
-                            else if (trade instanceof SellerAsOffererTrade)
                                 trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_CANCELED);
                             closedTrades.add(trade);
                             trade.disposeProtocol();
@@ -387,7 +385,8 @@ public class TradeManager {
 
             initTrade(trade);
             pendingTrades.add(trade);
-            trade.takeAvailableOffer();
+            if (trade instanceof TakerTrade)
+                ((TakerTrade) trade).takeAvailableOffer();
             takeOfferResultHandler.handleResult(trade);
         }
     }
@@ -401,24 +400,14 @@ public class TradeManager {
         AddressEntry addressEntry = walletService.getAddressEntry(trade.getId());
         String fromAddress = addressEntry.getAddressString();
 
-        // TODO handle overpaid securityDeposit
-        Coin amountToWithdraw = trade.getSecurityDeposit();
-        assert trade.getTradeAmount() != null;
-        if (trade instanceof BuyerAsOffererTrade || trade instanceof BuyerAsTakerTrade)
-            amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount());
-
         FutureCallback<Transaction> callback = new FutureCallback<Transaction>() {
             @Override
             public void onSuccess(@javax.annotation.Nullable Transaction transaction) {
                 if (transaction != null) {
                     log.info("onWithdraw onSuccess tx ID:" + transaction.getHashAsString());
-                    if (trade instanceof BuyerAsOffererTrade)
+                    if (trade instanceof OffererTrade)
                         trade.setLifeCycleState(OffererState.LifeCycleState.COMPLETED);
-                    else if (trade instanceof SellerAsTakerTrade)
+                    else if (trade instanceof TakerTrade)
-                        trade.setLifeCycleState(TakerState.LifeCycleState.COMPLETED);
-                    else if (trade instanceof SellerAsOffererTrade)
-                        trade.setLifeCycleState(OffererState.LifeCycleState.COMPLETED);
-                    else if (trade instanceof BuyerAsTakerTrade)
                         trade.setLifeCycleState(TakerState.LifeCycleState.COMPLETED);
 
                     pendingTrades.remove(trade);
@@ -436,7 +425,7 @@ public class TradeManager {
             }
         };
         try {
-            walletService.sendFunds(fromAddress, toAddress, amountToWithdraw, callback);
+            walletService.sendFunds(fromAddress, toAddress, trade.getPayoutAmount(), callback);
         } catch (AddressFormatException | InsufficientMoneyException e) {
             e.printStackTrace();
             log.error(e.getMessage());

core/src/main/java/io/bitsquare/trade/protocol/availability/CheckOfferAvailabilityModel.java

@@ -61,7 +61,7 @@ public class CheckOfferAvailabilityModel implements Model {
 
     @Override
     public void persist() {
-        
+
     }
 
     @Override

core/src/main/java/io/bitsquare/trade/protocol/placeoffer/PlaceOfferModel.java

@@ -58,7 +58,7 @@ public class PlaceOfferModel implements Model {
 
     @Override
     public void persist() {
-        
+
     }
 
     @Override

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

@@ -17,10 +17,8 @@
 
 package io.bitsquare.trade.protocol.trade;
 
-import io.bitsquare.trade.BuyerAsOffererTrade;
+import io.bitsquare.trade.OffererTrade;
-import io.bitsquare.trade.BuyerAsTakerTrade;
+import io.bitsquare.trade.TakerTrade;
-import io.bitsquare.trade.SellerAsOffererTrade;
-import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.Trade;
 import io.bitsquare.trade.states.OffererState;
 import io.bitsquare.trade.states.TakerState;
@@ -32,14 +30,14 @@ public class StateUtil {
     private static final Logger log = LoggerFactory.getLogger(StateUtil.class);
 
     public static void setSendFailedState(Trade trade) {
-        if (trade instanceof BuyerAsOffererTrade || trade instanceof SellerAsOffererTrade)
+        if (trade instanceof OffererTrade)
             trade.setProcessState(OffererState.ProcessState.MESSAGE_SENDING_FAILED);
-        else if (trade instanceof BuyerAsTakerTrade || trade instanceof SellerAsTakerTrade)
+        else if (trade instanceof TakerTrade)
             trade.setProcessState(TakerState.ProcessState.MESSAGE_SENDING_FAILED);
     }
 
     public static void setOfferOpenState(Trade trade) {
-        if (trade instanceof BuyerAsOffererTrade || trade instanceof SellerAsOffererTrade)
+        if (trade instanceof OffererTrade)
             trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
     }
 } 

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

@@ -27,7 +27,7 @@ import org.slf4j.LoggerFactory;
 
 public class TradeTask extends Task<Trade> {
     private static final Logger log = LoggerFactory.getLogger(TradeTask.class);
-    
+
     protected final ProcessModel processModel;
     protected final Trade trade;
 

core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/tasks/BuyerProcessPayoutTxPublishedMessage.java

@@ -18,10 +18,8 @@
 package io.bitsquare.trade.protocol.trade.buyer.tasks;
 
 import io.bitsquare.common.taskrunner.TaskRunner;
-import io.bitsquare.trade.BuyerAsOffererTrade;
+import io.bitsquare.trade.OffererTrade;
-import io.bitsquare.trade.BuyerAsTakerTrade;
+import io.bitsquare.trade.TakerTrade;
-import io.bitsquare.trade.SellerAsOffererTrade;
-import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.Trade;
 import io.bitsquare.trade.protocol.trade.TradeTask;
 import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
@@ -50,9 +48,9 @@ public class BuyerProcessPayoutTxPublishedMessage extends TradeTask {
 
             trade.setPayoutTx(checkNotNull(message.payoutTx));
 
-            if (trade instanceof BuyerAsOffererTrade || trade instanceof SellerAsOffererTrade)
+            if (trade instanceof OffererTrade)
                 trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED);
-            else if (trade instanceof BuyerAsTakerTrade || trade instanceof SellerAsTakerTrade)
+            else if (trade instanceof TakerTrade)
                 trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED);
 
             complete();

core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/tasks/BuyerSendsFiatTransferStartedMessage.java

@@ -19,10 +19,8 @@ package io.bitsquare.trade.protocol.trade.buyer.tasks;
 
 import io.bitsquare.common.taskrunner.TaskRunner;
 import io.bitsquare.p2p.listener.SendMessageListener;
-import io.bitsquare.trade.BuyerAsOffererTrade;
+import io.bitsquare.trade.OffererTrade;
-import io.bitsquare.trade.BuyerAsTakerTrade;
+import io.bitsquare.trade.TakerTrade;
-import io.bitsquare.trade.SellerAsOffererTrade;
-import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.Trade;
 import io.bitsquare.trade.protocol.trade.StateUtil;
 import io.bitsquare.trade.protocol.trade.TradeTask;
@@ -58,9 +56,9 @@ public class BuyerSendsFiatTransferStartedMessage extends TradeTask {
                         public void handleResult() {
                             log.trace("Sending FiatTransferStartedMessage succeeded.");
 
-                            if (trade instanceof BuyerAsOffererTrade || trade instanceof SellerAsOffererTrade)
+                            if (trade instanceof OffererTrade)
                                 trade.setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
-                            if (trade instanceof BuyerAsTakerTrade || trade instanceof SellerAsTakerTrade)
+                            if (trade instanceof TakerTrade)
                                 trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED);
 
                             complete();

core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/tasks/BuyerSignsAndPublishDepositTx.java

@@ -19,10 +19,8 @@ package io.bitsquare.trade.protocol.trade.buyer.tasks;
 
 import io.bitsquare.btc.FeePolicy;
 import io.bitsquare.common.taskrunner.TaskRunner;
-import io.bitsquare.trade.BuyerAsOffererTrade;
+import io.bitsquare.trade.OffererTrade;
-import io.bitsquare.trade.BuyerAsTakerTrade;
+import io.bitsquare.trade.TakerTrade;
-import io.bitsquare.trade.SellerAsOffererTrade;
-import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.Trade;
 import io.bitsquare.trade.protocol.trade.TradeTask;
 import io.bitsquare.trade.states.OffererState;
@@ -66,11 +64,11 @@ public class BuyerSignsAndPublishDepositTx extends TradeTask {
 
                             trade.setDepositTx(transaction);
 
-                            if (trade instanceof BuyerAsTakerTrade || trade instanceof SellerAsTakerTrade) {
+                            if (trade instanceof TakerTrade) {
                                 trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED);
                                 trade.setLifeCycleState(TakerState.LifeCycleState.PENDING);
                             }
-                            else if (trade instanceof BuyerAsOffererTrade || trade instanceof SellerAsOffererTrade) {
+                            else if (trade instanceof OffererTrade) {
                                 trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED);
                                 trade.setLifeCycleState(OffererState.LifeCycleState.PENDING);
                             }
@@ -92,7 +90,7 @@ public class BuyerSignsAndPublishDepositTx extends TradeTask {
         t.printStackTrace();
         trade.setThrowable(t);
 
-        if (trade instanceof BuyerAsOffererTrade || trade instanceof SellerAsOffererTrade)
+        if (trade instanceof OffererTrade)
             trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
 
         failed(t);

core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestPublishDepositTxMessage.java

@@ -44,8 +44,8 @@ public class RequestPublishDepositTxMessage extends TradeMessage implements Seri
     public final String sellerPayoutAddressString;
     public final Transaction sellersPreparedDepositTx;
     public final List<TransactionOutput> sellerConnectedOutputsForAllInputs;
-    public byte[] sellerTradeWalletPubKey;
+    public final byte[] sellerTradeWalletPubKey;
-    
+
     public RequestPublishDepositTxMessage(String tradeId,
                                           FiatAccount sellerFiatAccount,
                                           String sellerAccountId,

core/src/main/java/io/bitsquare/trade/protocol/trade/seller/tasks/SellerProcessDepositTxPublishedMessage.java

@@ -18,10 +18,8 @@
 package io.bitsquare.trade.protocol.trade.seller.tasks;
 
 import io.bitsquare.common.taskrunner.TaskRunner;
-import io.bitsquare.trade.BuyerAsOffererTrade;
+import io.bitsquare.trade.OffererTrade;
-import io.bitsquare.trade.BuyerAsTakerTrade;
+import io.bitsquare.trade.TakerTrade;
-import io.bitsquare.trade.SellerAsOffererTrade;
-import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.Trade;
 import io.bitsquare.trade.protocol.trade.TradeTask;
 import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
@@ -50,9 +48,9 @@ public class SellerProcessDepositTxPublishedMessage extends TradeTask {
 
             trade.setDepositTx(checkNotNull(message.depositTx));
 
-            if (trade instanceof BuyerAsOffererTrade || trade instanceof SellerAsOffererTrade)
+            if (trade instanceof OffererTrade)
                 trade.setProcessState(OffererState.ProcessState.DEPOSIT_PUBLISHED);
-            else if (trade instanceof BuyerAsTakerTrade || trade instanceof SellerAsTakerTrade)
+            else if (trade instanceof TakerTrade)
                 trade.setProcessState(TakerState.ProcessState.DEPOSIT_PUBLISHED);
 
             complete();

core/src/main/java/io/bitsquare/trade/protocol/trade/seller/tasks/SellerProcessFiatTransferStartedMessage.java

@@ -18,10 +18,8 @@
 package io.bitsquare.trade.protocol.trade.seller.tasks;
 
 import io.bitsquare.common.taskrunner.TaskRunner;
-import io.bitsquare.trade.BuyerAsOffererTrade;
+import io.bitsquare.trade.OffererTrade;
-import io.bitsquare.trade.BuyerAsTakerTrade;
+import io.bitsquare.trade.TakerTrade;
-import io.bitsquare.trade.SellerAsOffererTrade;
-import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.Trade;
 import io.bitsquare.trade.protocol.trade.TradeTask;
 import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
@@ -53,9 +51,9 @@ public class SellerProcessFiatTransferStartedMessage extends TradeTask {
             processModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount)));
             processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
 
-            if (trade instanceof BuyerAsOffererTrade || trade instanceof SellerAsOffererTrade)
+            if (trade instanceof OffererTrade)
                 trade.setProcessState(OffererState.ProcessState.FIAT_PAYMENT_STARTED);
-            else if (trade instanceof BuyerAsTakerTrade || trade instanceof SellerAsTakerTrade)
+            else if (trade instanceof TakerTrade)
                 trade.setProcessState(TakerState.ProcessState.FIAT_PAYMENT_STARTED);
 
             complete();

core/src/main/java/io/bitsquare/trade/protocol/trade/seller/tasks/SellerSignsAndPublishPayoutTx.java

@@ -18,10 +18,8 @@
 package io.bitsquare.trade.protocol.trade.seller.tasks;
 
 import io.bitsquare.common.taskrunner.TaskRunner;
-import io.bitsquare.trade.BuyerAsOffererTrade;
+import io.bitsquare.trade.OffererTrade;
-import io.bitsquare.trade.BuyerAsTakerTrade;
+import io.bitsquare.trade.TakerTrade;
-import io.bitsquare.trade.SellerAsOffererTrade;
-import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.Trade;
 import io.bitsquare.trade.protocol.trade.TradeTask;
 import io.bitsquare.trade.states.OffererState;
@@ -61,9 +59,9 @@ public class SellerSignsAndPublishPayoutTx extends TradeTask {
                         public void onSuccess(Transaction transaction) {
                             processModel.setPayoutTx(transaction);
 
-                            if (trade instanceof BuyerAsTakerTrade || trade instanceof SellerAsTakerTrade)
+                            if (trade instanceof TakerTrade)
                                 trade.setProcessState(TakerState.ProcessState.PAYOUT_PUBLISHED);
-                            else if (trade instanceof BuyerAsOffererTrade || trade instanceof SellerAsOffererTrade)
+                            else if (trade instanceof OffererTrade)
                                 trade.setProcessState(OffererState.ProcessState.PAYOUT_PUBLISHED);
 
                             complete();

core/src/main/java/io/bitsquare/trade/protocol/trade/shared/models/ProcessModel.java

@@ -63,7 +63,7 @@ public class ProcessModel implements Model, Serializable {
     transient private SignatureService signatureService;
     transient private ArbitrationRepository arbitrationRepository;
     transient private Offer offer;
-    transient protected User user;
+    private transient User user;
 
     // Mutable
     public final TradingPeer tradingPeer;

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

@@ -18,11 +18,9 @@
 package io.bitsquare.trade.protocol.trade.shared.offerer.tasks;
 
 import io.bitsquare.common.taskrunner.TaskRunner;
-import io.bitsquare.trade.BuyerAsOffererTrade;
-import io.bitsquare.trade.SellerAsOffererTrade;
 import io.bitsquare.trade.Trade;
+import io.bitsquare.trade.protocol.trade.StateUtil;
 import io.bitsquare.trade.protocol.trade.TradeTask;
-import io.bitsquare.trade.states.OffererState;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -53,19 +51,13 @@ public class VerifyTakerAccount extends TradeTask {
             else {
                 failed("Account registration validation for peer failed.");
 
-                if (trade instanceof BuyerAsOffererTrade)
+                StateUtil.setOfferOpenState(trade);
-                    trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
-                else if (trade instanceof SellerAsOffererTrade)
-                    trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
             }
         } catch (Throwable t) {
             t.printStackTrace();
             trade.setThrowable(t);
 
-            if (trade instanceof BuyerAsOffererTrade)
+            StateUtil.setOfferOpenState(trade);
-                trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
-            else if (trade instanceof SellerAsOffererTrade)
-                trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
 
             failed(t);
         }

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

@@ -18,8 +18,7 @@
 package io.bitsquare.trade.protocol.trade.shared.taker.tasks;
 
 import io.bitsquare.common.taskrunner.TaskRunner;
-import io.bitsquare.trade.BuyerAsTakerTrade;
+import io.bitsquare.trade.TakerTrade;
-import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.Trade;
 import io.bitsquare.trade.protocol.trade.TradeTask;
 import io.bitsquare.trade.states.TakerState;
@@ -49,9 +48,7 @@ public class BroadcastTakeOfferFeeTx extends TradeTask {
                         public void onSuccess(Transaction transaction) {
                             log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString());
 
-                            if (trade instanceof BuyerAsTakerTrade)
+                            if (trade instanceof TakerTrade)
-                                trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
-                            else if (trade instanceof SellerAsTakerTrade)
                                 trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
                             complete();
                         }
@@ -62,9 +59,7 @@ 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 BuyerAsTakerTrade)
+                            if (trade instanceof TakerTrade)
-                                trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
-                            else if (trade instanceof SellerAsTakerTrade)
                                 trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
 
                             failed(t);

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

@@ -18,8 +18,7 @@
 package io.bitsquare.trade.protocol.trade.shared.taker.tasks;
 
 import io.bitsquare.common.taskrunner.TaskRunner;
-import io.bitsquare.trade.BuyerAsTakerTrade;
+import io.bitsquare.trade.TakerTrade;
-import io.bitsquare.trade.SellerAsTakerTrade;
 import io.bitsquare.trade.Trade;
 import io.bitsquare.trade.protocol.trade.TradeTask;
 import io.bitsquare.trade.states.TakerState;
@@ -44,9 +43,7 @@ public class CreateTakeOfferFeeTx extends TradeTask {
             processModel.setTakeOfferFeeTx(createTakeOfferFeeTx);
             processModel.setTakeOfferFeeTxId(createTakeOfferFeeTx.getHashAsString());
 
-            if (trade instanceof BuyerAsTakerTrade)
+            if (trade instanceof TakerTrade)
-                trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
-            else if (trade instanceof SellerAsTakerTrade)
                 trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
 
             complete();