Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-04-20 23:56:30 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add interfaces for trade variants

Browse Source
This commit is contained in:
Manfred Karrer 2015-04-02 17:50:43 +02:00
parent 47ff54e0d6
commit ecf07d0b91
33 changed files with 289 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

@ -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)
((BuyerAsOffererTrade) getTrade()).onFiatPaymentStarted();
else if (getTrade() instanceof BuyerAsTakerTrade)
((BuyerAsTakerTrade) getTrade()).onFiatPaymentStarted();
if (getTrade() instanceof BuyerTrade)
((BuyerTrade) getTrade()).onFiatPaymentStarted();
}
void fiatPaymentReceived() {
if (getTrade() instanceof SellerAsTakerTrade)
((SellerAsTakerTrade) getTrade()).onFiatPaymentReceived();
else if (getTrade() instanceof SellerAsOffererTrade)
((SellerAsOffererTrade) getTrade()).onFiatPaymentReceived();
if (getTrade() instanceof SellerTrade)
((SellerTrade) getTrade()).onFiatPaymentReceived();
}
void withdraw(String toAddress) {
@ -259,13 +259,8 @@ class PendingTradesDataModel implements Activatable, DataModel {
offererAsSellerProcessState.unbind();
}
public Coin getAmountToWithdraw() {
Trade trade = selectedItem.getTrade();
Coin amountToWithdraw = trade.getSecurityDeposit();
assert trade.getTradeAmount() != null;
if (trade instanceof BuyerAsOffererTrade || trade instanceof BuyerAsTakerTrade)
amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount());
return amountToWithdraw;
public Coin getPayoutAmount() {
return getTrade().getPayoutAmount();
}
public Contract getContract() {

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

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

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

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

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

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

1
core/src/main/java/io/bitsquare/offer/Offer.java
View File

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

2
core/src/main/java/io/bitsquare/p2p/tomp2p/TomP2PMessageService.java
View File

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

14
core/src/main/java/io/bitsquare/trade/BuyerAsOffererTrade.java
View File

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

11
core/src/main/java/io/bitsquare/trade/BuyerAsTakerTrade.java
View File

@ -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,
Storage<? extends TradeList> storage) {
public BuyerAsTakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, 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);
}

18
core/src/main/java/io/bitsquare/trade/protocol/trade/messages/ConfirmReserveOfferMessage.java → core/src/main/java/io/bitsquare/trade/BuyerTrade.java
View File

@ -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;
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);
}
public interface BuyerTrade {
void onFiatPaymentStarted();
}

21
core/src/main/java/io/bitsquare/trade/OffererTrade.java Normal file
View File

@ -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 {
}

7
core/src/main/java/io/bitsquare/trade/SellerAsOffererTrade.java
View File

@ -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
///////////////////////////////////////////////////////////////////////////////////////////

42
core/src/main/java/io/bitsquare/trade/SellerAsTakerTrade.java
View File

@ -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,
Storage<? extends TradeList> storage) {
public SellerAsTakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, 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;
this.processState = processState;
processStateProperty.set(processState);
super.setProcessState(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);
}

22
core/src/main/java/io/bitsquare/trade/SellerTrade.java Normal file
View File

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

22
core/src/main/java/io/bitsquare/trade/TakerTrade.java Normal file
View File

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

192
core/src/main/java/io/bitsquare/trade/Trade.java
View File

@ -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;
protected Peer tradingPeer;
transient protected ObjectProperty<Coin> tradeAmountProperty;
transient protected ObjectProperty<Fiat> tradeVolumeProperty;
private Coin tradeAmount;
private Peer tradingPeer;
private transient ObjectProperty<Coin> tradeAmountProperty;
private transient ObjectProperty<Fiat> tradeVolumeProperty;
///////////////////////////////////////////////////////////////////////////////////////////
@ -82,21 +82,22 @@ abstract public class Trade implements Model, Serializable {
///////////////////////////////////////////////////////////////////////////////////////////
// Transient/Immutable
transient protected ObjectProperty<TradeState.ProcessState> processStateProperty;
transient protected ObjectProperty<TradeState.LifeCycleState> lifeCycleStateProperty;
private transient ObjectProperty<TradeState.ProcessState> processStateProperty;
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 + '\'' +
", offererContractSignature='" + buyerContractSignature + '\'' +
", sellerContractSignature='" + sellerContractSignature + '\'' +
", buyerContractSignature='" + buyerContractSignature + '\'' +
", payoutTx=" + payoutTx +
", errorMessage='" + errorMessage + '\'' +
", throwable=" + throwable +

31
core/src/main/java/io/bitsquare/trade/TradeManager.java
View File

@ -170,10 +170,10 @@ public class TradeManager {
// continue the trade, but that might fail.
boolean failed = false;
if (trade instanceof SellerAsTakerTrade)
failed = trade.lifeCycleState == TakerState.LifeCycleState.FAILED;
else if (trade instanceof BuyerAsTakerTrade)
if (trade instanceof TakerTrade)
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)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_CANCELED);
else if (trade instanceof SellerAsOffererTrade)
if (trade instanceof OffererTrade)
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)
trade.setLifeCycleState(TakerState.LifeCycleState.COMPLETED);
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.COMPLETED);
else if (trade instanceof BuyerAsTakerTrade)
else if (trade instanceof TakerTrade)
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());

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

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

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

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

12
core/src/main/java/io/bitsquare/trade/protocol/trade/StateUtil.java
View File

@ -17,10 +17,8 @@
package io.bitsquare.trade.protocol.trade;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.TakerTrade;
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);
}
}

2
core/src/main/java/io/bitsquare/trade/protocol/trade/TradeTask.java
View File

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

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

@ -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.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.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();

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

@ -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.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.TakerTrade;
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();

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

@ -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.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.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);

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

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

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

@ -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.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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;
@ -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();

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

@ -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.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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;
@ -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();

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

@ -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.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
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.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();

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

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

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

@ -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)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
StateUtil.setOfferOpenState(trade);
}
} catch (Throwable t) {
t.printStackTrace();
trade.setThrowable(t);
if (trade instanceof BuyerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
else if (trade instanceof SellerAsOffererTrade)
trade.setLifeCycleState(OffererState.LifeCycleState.OFFER_OPEN);
StateUtil.setOfferOpenState(trade);
failed(t);
}

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

@ -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.SellerAsTakerTrade;
import io.bitsquare.trade.TakerTrade;
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)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
else if (trade instanceof SellerAsTakerTrade)
if (trade instanceof TakerTrade)
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)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
else if (trade instanceof SellerAsTakerTrade)
if (trade instanceof TakerTrade)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
failed(t);

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

@ -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.SellerAsTakerTrade;
import io.bitsquare.trade.TakerTrade;
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)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
else if (trade instanceof SellerAsTakerTrade)
if (trade instanceof TakerTrade)
trade.setProcessState(TakerState.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
complete();