From fa1fdc3f12c7e6574e5b57b536496d8e954acd2c Mon Sep 17 00:00:00 2001 From: Manfred Karrer Date: Sat, 28 Mar 2015 14:18:56 +0100 Subject: [PATCH] Handle trade interruption --- .../arbitration/ArbitrationRepository.java | 6 +- .../java/io/bitsquare/btc/BitcoinModule.java | 2 +- .../io/bitsquare/btc/TradeWalletService.java | 10 +- .../common/taskrunner/TaskRunner.java | 6 +- .../main/java/io/bitsquare/gui/GuiModule.java | 2 +- .../main/trade/takeoffer/TakeOfferView.java | 2 +- .../main/java/io/bitsquare/offer/Offer.java | 5 +- .../p2p/tomp2p/TomP2PAddressService.java | 9 +- .../p2p/tomp2p/TomP2PMessageService.java | 1 + .../io/bitsquare/storage/FileManager.java | 2 +- .../java/io/bitsquare/trade/Contract.java | 1 + .../java/io/bitsquare/trade/OffererTrade.java | 153 +++++---- .../java/io/bitsquare/trade/TakerTrade.java | 178 ++++++----- .../main/java/io/bitsquare/trade/Trade.java | 301 +++++++++--------- .../java/io/bitsquare/trade/TradeList.java | 15 +- .../java/io/bitsquare/trade/TradeManager.java | 297 ++++++++--------- .../java/io/bitsquare/trade/TradeModule.java | 1 - .../handlers/OfferStateResultHandler.java | 25 -- .../CheckOfferAvailabilityProtocol.java | 12 +- .../protocol/placeoffer/PlaceOfferModel.java | 2 +- .../tasks/AddOfferToRemoteOfferBook.java | 8 +- .../tasks/BroadcastCreateOfferFeeTx.java | 8 +- .../trade/protocol/trade/ProcessModel.java | 154 +++++++++ .../protocol/trade/TradeProcessModel.java | 106 ------ .../protocol/trade/messages/OfferMessage.java | 2 +- ...RequestOffererPublishDepositTxMessage.java | 5 +- .../protocol/trade/messages/TradeMessage.java | 2 +- .../trade/offerer/OffererProtocol.java | 25 +- .../trade/offerer/models/Offerer.java | 150 ++++++++- .../offerer/models/OffererProcessModel.java | 111 +++++++ .../models/OffererTradeProcessModel.java | 90 ------ .../protocol/trade/offerer/models/Taker.java | 157 ++++++++- .../offerer/tasks/CreateAndSignPayoutTx.java | 19 +- .../tasks/CreateOffererDepositTxInputs.java | 8 +- .../trade/offerer/tasks/OffererTradeTask.java | 8 +- .../ProcessPayoutTxPublishedMessage.java | 6 +- .../ProcessRequestDepositTxInputsMessage.java | 11 +- ...RequestOffererPublishDepositTxMessage.java | 21 +- .../tasks/RequestTakerDepositPayment.java | 18 +- .../tasks/SendBankTransferStartedMessage.java | 16 +- .../offerer/tasks/SendDepositTxToTaker.java | 4 +- .../tasks/SignAndPublishDepositTx.java | 16 +- .../offerer/tasks/VerifyAndSignContract.java | 19 +- .../tasks/VerifyTakeOfferFeePayment.java | 2 +- .../offerer/tasks/VerifyTakerAccount.java | 7 +- .../protocol/trade/taker/TakerProtocol.java | 39 +-- .../protocol/trade/taker/models/Offerer.java | 157 ++++++++- .../protocol/trade/taker/models/Taker.java | 134 +++++++- .../trade/taker/models/TakerProcessModel.java | 130 ++++++++ .../taker/models/TakerTradeProcessModel.java | 109 ------- .../taker/tasks/BroadcastTakeOfferFeeTx.java | 2 +- .../taker/tasks/CreateAndSignContract.java | 17 +- .../taker/tasks/CreateTakeOfferFeeTx.java | 3 +- .../ProcessDepositTxPublishedMessage.java | 5 +- .../ProcessFiatTransferStartedMessage.java | 11 +- ...cessRequestTakerDepositPaymentMessage.java | 17 +- .../taker/tasks/SendPayoutTxToOfferer.java | 8 +- .../SendRequestDepositTxInputsMessage.java | 7 +- .../taker/tasks/SendSignedTakerDepositTx.java | 19 +- .../taker/tasks/SignAndPublishPayoutTx.java | 18 +- .../taker/tasks/TakerCommitDepositTx.java | 2 +- .../tasks/TakerCreatesAndSignsDepositTx.java | 20 +- .../trade/taker/tasks/TakerTradeTask.java | 8 +- .../taker/tasks/VerifyOfferFeePayment.java | 2 +- .../taker/tasks/VerifyOffererAccount.java | 7 +- .../java/io/bitsquare/util/Validator.java | 2 - 66 files changed, 1660 insertions(+), 1060 deletions(-) delete mode 100644 core/src/main/java/io/bitsquare/trade/handlers/OfferStateResultHandler.java create mode 100644 core/src/main/java/io/bitsquare/trade/protocol/trade/ProcessModel.java delete mode 100644 core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProcessModel.java create mode 100644 core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererProcessModel.java delete mode 100644 core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererTradeProcessModel.java create mode 100644 core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerProcessModel.java delete mode 100644 core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerTradeProcessModel.java diff --git a/core/src/main/java/io/bitsquare/arbitration/ArbitrationRepository.java b/core/src/main/java/io/bitsquare/arbitration/ArbitrationRepository.java index b4f852d56e..d5b815ece3 100644 --- a/core/src/main/java/io/bitsquare/arbitration/ArbitrationRepository.java +++ b/core/src/main/java/io/bitsquare/arbitration/ArbitrationRepository.java @@ -56,7 +56,7 @@ public class ArbitrationRepository implements Serializable { // Persisted fields private final Map arbitratorsMap = new HashMap<>(); - + @Inject public ArbitrationRepository(Storage storage, @@ -82,13 +82,13 @@ public class ArbitrationRepository implements Serializable { Arrays.asList(Arbitrator.ID_VERIFICATION.PASSPORT), "https://bitsquare.io", "Bla bla..."); - + ArbitrationRepository persisted = storage.initAndGetPersisted(this); if (persisted != null) { arbitratorsMap.putAll(persisted.getArbitratorsMap()); } arbitratorsMap.put(defaultArbitrator.getId(), defaultArbitrator); - + arbitratorsObservableMap.putAll(arbitratorsMap); arbitratorsObservableMap.addListener((MapChangeListener) change -> storage.queueUpForSave()); allArbitratorsSynced = false; diff --git a/core/src/main/java/io/bitsquare/btc/BitcoinModule.java b/core/src/main/java/io/bitsquare/btc/BitcoinModule.java index cf9af57aae..f587df499b 100644 --- a/core/src/main/java/io/bitsquare/btc/BitcoinModule.java +++ b/core/src/main/java/io/bitsquare/btc/BitcoinModule.java @@ -59,7 +59,7 @@ public class BitcoinModule extends BitsquareModule { @Override protected void doClose(Injector injector) { - log.trace("doClose "+getClass().getSimpleName()); + log.trace("doClose " + getClass().getSimpleName()); injector.getInstance(WalletService.class).shutDown(); } } diff --git a/core/src/main/java/io/bitsquare/btc/TradeWalletService.java b/core/src/main/java/io/bitsquare/btc/TradeWalletService.java index df3cd9f2b3..450d3751d6 100644 --- a/core/src/main/java/io/bitsquare/btc/TradeWalletService.java +++ b/core/src/main/java/io/bitsquare/btc/TradeWalletService.java @@ -398,7 +398,7 @@ public class TradeWalletService { Futures.addCallback(broadcastComplete, callback); } - // Returns local transaction which has a different state as the serialized publishedDepositTx we get from the offerer + // Commits the tx to the wallet and returns that public Transaction commitsDepositTx(Transaction publishedDepositTx) throws VerificationException { log.trace("takerCommitsDepositTx called"); log.trace("publishedDepositTx " + publishedDepositTx.toString()); @@ -411,6 +411,14 @@ public class TradeWalletService { return depositTx; } + // Returns local existing wallet transaction + public Transaction getWalletTx(Transaction tx) throws VerificationException { + log.trace("getWalleTx called"); + log.trace("tx " + tx.toString()); + + return wallet.getTransaction(tx.getHash()); + } + public byte[] offererCreatesAndSignsPayoutTx(Transaction depositTx, Coin offererPayoutAmount, Coin takerPayoutAmount, diff --git a/core/src/main/java/io/bitsquare/common/taskrunner/TaskRunner.java b/core/src/main/java/io/bitsquare/common/taskrunner/TaskRunner.java index b8aff9cbcf..7cbef20c0c 100644 --- a/core/src/main/java/io/bitsquare/common/taskrunner/TaskRunner.java +++ b/core/src/main/java/io/bitsquare/common/taskrunner/TaskRunner.java @@ -30,7 +30,7 @@ import org.slf4j.LoggerFactory; public class TaskRunner { private static final Logger log = LoggerFactory.getLogger(TaskRunner.class); - private final Queue tasks = new LinkedBlockingQueue<>(); + private final Queue> tasks = new LinkedBlockingQueue<>(); protected final T sharedModel; private final ResultHandler resultHandler; private final ErrorMessageHandler errorMessageHandler; @@ -44,8 +44,8 @@ public class TaskRunner { this.resultHandler = resultHandler; this.errorMessageHandler = errorMessageHandler; } - - public void addTasks(Class... items) { + + public final void addTasks(Class... items) { tasks.addAll(Arrays.asList(items)); } diff --git a/core/src/main/java/io/bitsquare/gui/GuiModule.java b/core/src/main/java/io/bitsquare/gui/GuiModule.java index 8e7ab1dd8c..4a23dd5bc8 100644 --- a/core/src/main/java/io/bitsquare/gui/GuiModule.java +++ b/core/src/main/java/io/bitsquare/gui/GuiModule.java @@ -63,7 +63,7 @@ public class GuiModule extends BitsquareModule { bind(CachingViewLoader.class).in(Singleton.class); bind(Navigation.class).in(Singleton.class); - + bind(OfferBook.class).in(Singleton.class); bind(OverlayManager.class).in(Singleton.class); bind(BSFormatter.class).in(Singleton.class); diff --git a/core/src/main/java/io/bitsquare/gui/main/trade/takeoffer/TakeOfferView.java b/core/src/main/java/io/bitsquare/gui/main/trade/takeoffer/TakeOfferView.java index 0da396f7f8..029b98fac0 100644 --- a/core/src/main/java/io/bitsquare/gui/main/trade/takeoffer/TakeOfferView.java +++ b/core/src/main/java/io/bitsquare/gui/main/trade/takeoffer/TakeOfferView.java @@ -143,7 +143,7 @@ public class TakeOfferView extends ActivatableViewAndModel(state); @@ -194,7 +193,7 @@ public class Offer implements Serializable { /////////////////////////////////////////////////////////////////////////////////////////// // Getters /////////////////////////////////////////////////////////////////////////////////////////// - + @NotNull public String getId() { return id; @@ -282,6 +281,7 @@ public class Offer implements Serializable { ", fiatPrice=" + fiatPrice + ", amount=" + amount + ", minAmount=" + minAmount + + ", p2pSigPubKey=" + p2pSigPubKey + ", fiatAccountType=" + fiatAccountType + ", bankAccountCountry=" + bankAccountCountry + ", securityDeposit=" + securityDeposit + @@ -291,7 +291,6 @@ public class Offer implements Serializable { ", arbitratorIds=" + arbitratorIds + ", offerFeePaymentTxID='" + offerFeePaymentTxID + '\'' + ", state=" + state + - ", stateProperty=" + stateProperty + '}'; } } diff --git a/core/src/main/java/io/bitsquare/p2p/tomp2p/TomP2PAddressService.java b/core/src/main/java/io/bitsquare/p2p/tomp2p/TomP2PAddressService.java index 301cf04e14..f1012a1ebb 100644 --- a/core/src/main/java/io/bitsquare/p2p/tomp2p/TomP2PAddressService.java +++ b/core/src/main/java/io/bitsquare/p2p/tomp2p/TomP2PAddressService.java @@ -173,8 +173,13 @@ public class TomP2PAddressService extends TomP2PDHTService implements AddressSer } private void removeAddress() { - boolean success = removeDataFromMyProtectedDomain(locationKey).awaitUninterruptibly(1000); - log.debug("removeDataFromMyProtectedDomain success=" + success); + try { + boolean success = removeDataFromMyProtectedDomain(locationKey).awaitUninterruptibly(1000); + log.debug("removeDataFromMyProtectedDomain success=" + success); + } catch (Throwable t) { + t.printStackTrace(); + log.error(t.getMessage()); + } } } diff --git a/core/src/main/java/io/bitsquare/p2p/tomp2p/TomP2PMessageService.java b/core/src/main/java/io/bitsquare/p2p/tomp2p/TomP2PMessageService.java index 3cf8ebab55..8474d52c93 100644 --- a/core/src/main/java/io/bitsquare/p2p/tomp2p/TomP2PMessageService.java +++ b/core/src/main/java/io/bitsquare/p2p/tomp2p/TomP2PMessageService.java @@ -122,6 +122,7 @@ public class TomP2PMessageService extends TomP2PService implements MessageServic private void sendMailboxMessage(PublicKey p2pSigPubKey, PublicKey p2pEncryptPubKey, MailboxMessage message, SendMessageListener listener) { Bucket bucket = null; + log.info("sendMailboxMessage called"); try { bucket = encryptionService.encryptObject(p2pEncryptPubKey, message); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/storage/FileManager.java b/core/src/main/java/io/bitsquare/storage/FileManager.java index bd0f23cd47..6b6c45a48f 100644 --- a/core/src/main/java/io/bitsquare/storage/FileManager.java +++ b/core/src/main/java/io/bitsquare/storage/FileManager.java @@ -273,7 +273,7 @@ public class FileManager { } finally { if (tempFile != null && tempFile.exists()) { log.warn("Temp file still exists after failed save. storageFile=" + storageFile); - if (!tempFile.delete()) + if (!tempFile.delete()) log.error("Cannot delete temp file."); } diff --git a/core/src/main/java/io/bitsquare/trade/Contract.java b/core/src/main/java/io/bitsquare/trade/Contract.java index cf3fd25778..cd24a23c26 100644 --- a/core/src/main/java/io/bitsquare/trade/Contract.java +++ b/core/src/main/java/io/bitsquare/trade/Contract.java @@ -29,6 +29,7 @@ import java.security.PublicKey; import javax.annotation.concurrent.Immutable; +@SuppressWarnings("WeakerAccess") @Immutable public class Contract implements Serializable { // That object is sent over the wire, so we need to take care of version compatibility. diff --git a/core/src/main/java/io/bitsquare/trade/OffererTrade.java b/core/src/main/java/io/bitsquare/trade/OffererTrade.java index 571918402c..0dc434ba8f 100644 --- a/core/src/main/java/io/bitsquare/trade/OffererTrade.java +++ b/core/src/main/java/io/bitsquare/trade/OffererTrade.java @@ -20,9 +20,9 @@ package io.bitsquare.trade; import io.bitsquare.offer.Offer; import io.bitsquare.p2p.Peer; import io.bitsquare.storage.Storage; -import io.bitsquare.trade.protocol.trade.TradeProcessModel; +import io.bitsquare.trade.protocol.trade.ProcessModel; import io.bitsquare.trade.protocol.trade.offerer.OffererProtocol; -import io.bitsquare.trade.protocol.trade.offerer.models.OffererTradeProcessModel; +import io.bitsquare.trade.protocol.trade.offerer.models.OffererProcessModel; import org.bitcoinj.core.Coin; import org.bitcoinj.core.TransactionConfidence; @@ -34,6 +34,7 @@ import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import java.io.IOException; +import java.io.ObjectInputStream; import java.io.Serializable; import javax.annotation.Nullable; @@ -50,6 +51,7 @@ import org.slf4j.LoggerFactory; public class OffererTrade extends Trade implements Serializable { // That object is saved to disc. We need to take care of changes to not break deserialization. private static final long serialVersionUID = 1L; + transient private static final Logger log = LoggerFactory.getLogger(OffererTrade.class); @@ -78,54 +80,67 @@ public class OffererTrade extends Trade implements Serializable { MESSAGE_SENDING_FAILED, EXCEPTION } - + /////////////////////////////////////////////////////////////////////////////////////////// // Fields /////////////////////////////////////////////////////////////////////////////////////////// - @Nullable private Coin tradeAmount; - @Nullable private Peer tradingPeer; - @NotNull private OffererProcessState processState = OffererProcessState.UNDEFINED; - @NotNull private OffererLifeCycleState lifeCycleState = OffererLifeCycleState.OFFER_OPEN; - @NotNull transient private ObjectProperty processStateProperty = new SimpleObjectProperty<>(processState); - @NotNull transient private ObjectProperty lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState); + // Transient/Immutable + transient private ObjectProperty processStateProperty; + transient private ObjectProperty lifeCycleStateProperty; + + // Mutable + private Coin tradeAmount; + private Peer tradingPeer; + private OffererProcessState processState; + private OffererLifeCycleState lifeCycleState; /////////////////////////////////////////////////////////////////////////////////////////// - // Constructor + // Constructor, initialization /////////////////////////////////////////////////////////////////////////////////////////// - public OffererTrade(@NotNull Offer offer, @NotNull Storage storage) { + public OffererTrade(Offer offer, Storage storage) { super(offer, storage); - } + log.trace("Created by constructor"); - @Override - protected TradeProcessModel createProcessModel() { - return new OffererTradeProcessModel(); - } - - @Override - public void createProtocol() { - protocol = new OffererProtocol(this); - } - - - // Serialized object does not create our transient objects - private void readObject(@NotNull java.io.ObjectInputStream in) throws IOException, ClassNotFoundException { - in.defaultReadObject(); + processState = OffererProcessState.UNDEFINED; + lifeCycleState = OffererLifeCycleState.OFFER_OPEN; processStateProperty = new SimpleObjectProperty<>(processState); lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState); tradeAmountProperty = new SimpleObjectProperty<>(); tradeVolumeProperty = new SimpleObjectProperty<>(); + } + + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + + processStateProperty = new SimpleObjectProperty<>(processState); + lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState); + + tradeAmountProperty = new SimpleObjectProperty<>(); + tradeVolumeProperty = new SimpleObjectProperty<>(); + if (tradeAmount != null) { tradeAmountProperty.set(tradeAmount); tradeVolumeProperty.set(getTradeVolume()); } } + @Override + protected ProcessModel createProcessModel() { + return new OffererProcessModel(); + } + + @Override + public void createProtocol() { + protocol = new OffererProtocol(this); + } + public void onFiatPaymentStarted() { assert protocol != null; ((OffererProtocol) protocol).onFiatPaymentStarted(); @@ -133,10 +148,29 @@ public class OffererTrade extends Trade implements Serializable { /////////////////////////////////////////////////////////////////////////////////////////// - // Setters + // Getter only /////////////////////////////////////////////////////////////////////////////////////////// - public void setProcessState(@NotNull OffererProcessState processState) { + @Override + public ReadOnlyObjectProperty processStateProperty() { + return processStateProperty; + } + + @Override + public ReadOnlyObjectProperty lifeCycleStateProperty() { + return lifeCycleStateProperty; + } + + public OffererProcessModel getProcessModel() { + return (OffererProcessModel) processModel; + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + public void setProcessState(OffererProcessState processState) { this.processState = processState; processStateProperty.set(processState); @@ -148,7 +182,7 @@ public class OffererTrade extends Trade implements Serializable { } } - public void setLifeCycleState(@NotNull OffererLifeCycleState lifeCycleState) { + public void setLifeCycleState(OffererLifeCycleState lifeCycleState) { switch (lifeCycleState) { case FAILED: disposeProtocol(); @@ -161,36 +195,24 @@ public class OffererTrade extends Trade implements Serializable { lifeCycleStateProperty.set(lifeCycleState); } - public void setTradeAmount(@NotNull Coin tradeAmount) { - this.tradeAmount = tradeAmount; - tradeAmountProperty.set(tradeAmount); - tradeVolumeProperty.set(getTradeVolume()); - } - public void setTradingPeer(@NotNull Peer tradingPeer) { + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter/Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + public void setTradingPeer(Peer tradingPeer) { this.tradingPeer = tradingPeer; } - - /////////////////////////////////////////////////////////////////////////////////////////// - // Getters - /////////////////////////////////////////////////////////////////////////////////////////// - - @NotNull - public OffererTradeProcessModel getProcessModel() { - return (OffererTradeProcessModel) processModel; + @Nullable + public Peer getTradingPeer() { + return tradingPeer; } - @NotNull - @Override - public ReadOnlyObjectProperty processStateProperty() { - return processStateProperty; - } - - @NotNull - @Override - public ReadOnlyObjectProperty lifeCycleStateProperty() { - return lifeCycleStateProperty; + public void setTradeAmount(Coin tradeAmount) { + this.tradeAmount = tradeAmount; + tradeAmountProperty.set(tradeAmount); + tradeVolumeProperty.set(getTradeVolume()); } @Nullable @@ -202,22 +224,19 @@ public class OffererTrade extends Trade implements Serializable { @Nullable @Override public Fiat getTradeVolume() { - return offer.getVolumeByAmount(tradeAmount); - } - - @Nullable - @Override - public Peer getTradingPeer() { - return tradingPeer; + if (tradeAmount != null) + return offer.getVolumeByAmount(tradeAmount); + else + return null; } /////////////////////////////////////////////////////////////////////////////////////////// - // Private + // Protected /////////////////////////////////////////////////////////////////////////////////////////// @Override - protected void setConfidenceListener() { + protected void setupConfidenceListener() { assert depositTx != null; TransactionConfidence transactionConfidence = depositTx.getConfidence(); ListenableFuture future = transactionConfidence.getDepthFuture(1); @@ -236,4 +255,14 @@ public class OffererTrade extends Trade implements Serializable { } }); } + + @Override + public String toString() { + return "OffererTrade{" + + "tradeAmount=" + tradeAmount + + ", tradingPeer=" + tradingPeer + + ", processState=" + processState + + ", lifeCycleState=" + lifeCycleState + + '}'; + } } diff --git a/core/src/main/java/io/bitsquare/trade/TakerTrade.java b/core/src/main/java/io/bitsquare/trade/TakerTrade.java index 972887567a..46f60d0def 100644 --- a/core/src/main/java/io/bitsquare/trade/TakerTrade.java +++ b/core/src/main/java/io/bitsquare/trade/TakerTrade.java @@ -20,9 +20,9 @@ package io.bitsquare.trade; import io.bitsquare.offer.Offer; import io.bitsquare.p2p.Peer; import io.bitsquare.storage.Storage; -import io.bitsquare.trade.protocol.trade.TradeProcessModel; +import io.bitsquare.trade.protocol.trade.ProcessModel; import io.bitsquare.trade.protocol.trade.taker.TakerProtocol; -import io.bitsquare.trade.protocol.trade.taker.models.TakerTradeProcessModel; +import io.bitsquare.trade.protocol.trade.taker.models.TakerProcessModel; import org.bitcoinj.core.Coin; import org.bitcoinj.core.TransactionConfidence; @@ -48,6 +48,7 @@ import org.slf4j.LoggerFactory; public class TakerTrade extends Trade implements Serializable { // That object is saved to disc. We need to take care of changes to not break deserialization. private static final long serialVersionUID = 1L; + transient private static final Logger log = LoggerFactory.getLogger(TakerTrade.class); @@ -84,33 +85,55 @@ public class TakerTrade extends Trade implements Serializable { // Fields /////////////////////////////////////////////////////////////////////////////////////////// - @NotNull private final Coin tradeAmount; - @NotNull private final Peer tradingPeer; + // Transient/Immutable + transient private ObjectProperty processStateProperty; + transient private ObjectProperty lifeCycleStateProperty; - @NotNull private TakerProcessState processState = TakerProcessState.UNDEFINED; - @NotNull private TakerLifeCycleState lifeCycleState = TakerLifeCycleState.PENDING; + // Immutable + private final Coin tradeAmount; + private final Peer tradingPeer; - @NotNull transient private ObjectProperty processStateProperty = new SimpleObjectProperty<>(processState); - @NotNull transient private ObjectProperty lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState); + // Mutable + private TakerProcessState processState; + private TakerLifeCycleState lifeCycleState; /////////////////////////////////////////////////////////////////////////////////////////// - // Constructor + // Constructor, initialization /////////////////////////////////////////////////////////////////////////////////////////// - public TakerTrade(@NotNull Offer offer, @NotNull Coin tradeAmount, @NotNull Peer peer, - @NotNull Storage storage) { + public TakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, + Storage storage) { super(offer, storage); + log.trace("Created by constructor"); this.tradeAmount = tradeAmount; - this.tradingPeer = peer; + this.tradingPeer = tradingPeer; + + processState = TakerProcessState.UNDEFINED; + lifeCycleState = TakerLifeCycleState.PENDING; + + processStateProperty = new SimpleObjectProperty<>(processState); + lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState); tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount); - tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume()); // cannot be set before offer is set + tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume()); } + + private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + + processStateProperty = new SimpleObjectProperty<>(processState); + lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState); + + tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount); + tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume()); + } + @Override - protected TradeProcessModel createProcessModel() { - return new TakerTradeProcessModel(); + protected ProcessModel createProcessModel() { + return new TakerProcessModel(); } @Override @@ -118,21 +141,16 @@ public class TakerTrade extends Trade implements Serializable { protocol = new TakerProtocol(this); } + + /////////////////////////////////////////////////////////////////////////////////////////// + // API + /////////////////////////////////////////////////////////////////////////////////////////// + public void takeAvailableOffer() { assert processModel != null; ((TakerProtocol) protocol).takeAvailableOffer(); } - // Serialized object does not create our transient objects - private void readObject(@NotNull java.io.ObjectInputStream in) throws IOException, ClassNotFoundException { - in.defaultReadObject(); - - processStateProperty = new SimpleObjectProperty<>(processState); - lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState); - tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount); - tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume()); - } - public void onFiatPaymentReceived() { assert protocol != null; ((TakerProtocol) protocol).onFiatPaymentReceived(); @@ -140,53 +158,9 @@ public class TakerTrade extends Trade implements Serializable { /////////////////////////////////////////////////////////////////////////////////////////// - // Setters + // Getter only /////////////////////////////////////////////////////////////////////////////////////////// - public void setLifeCycleState(@NotNull TakerLifeCycleState lifeCycleState) { - this.lifeCycleState = lifeCycleState; - lifeCycleStateProperty.set(lifeCycleState); - } - - public void setProcessState(@NotNull TakerProcessState processState) { - this.processState = processState; - processStateProperty.set(processState); - - if (processState == TakerProcessState.EXCEPTION) { - setLifeCycleState(TakerLifeCycleState.FAILED); - disposeProtocol(); - } - } - - @Override - public void setThrowable(@NotNull Throwable throwable) { - super.setThrowable(throwable); - setProcessState(TakerTrade.TakerProcessState.EXCEPTION); - } - - - /////////////////////////////////////////////////////////////////////////////////////////// - // Getters - /////////////////////////////////////////////////////////////////////////////////////////// - - @NotNull - public TakerTradeProcessModel getProcessModel() { - return (TakerTradeProcessModel) processModel; - } - - @NotNull - @Override - public ReadOnlyObjectProperty processStateProperty() { - return processStateProperty; - } - - @NotNull - @Override - public ReadOnlyObjectProperty lifeCycleStateProperty() { - return lifeCycleStateProperty; - } - - @NotNull @Override public Coin getTradeAmount() { return tradeAmount; @@ -197,21 +171,57 @@ public class TakerTrade extends Trade implements Serializable { return offer.getVolumeByAmount(tradeAmount); } - @NotNull - @Override public Peer getTradingPeer() { return tradingPeer; } - - /////////////////////////////////////////////////////////////////////////////////////////// - // Private - /////////////////////////////////////////////////////////////////////////////////////////// - - + @Override + public ReadOnlyObjectProperty processStateProperty() { + return processStateProperty; + } @Override - protected void setConfidenceListener() { + public ReadOnlyObjectProperty lifeCycleStateProperty() { + return lifeCycleStateProperty; + } + + public TakerProcessModel getProcessModel() { + return (TakerProcessModel) processModel; + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + public void setLifeCycleState(TakerLifeCycleState lifeCycleState) { + this.lifeCycleState = lifeCycleState; + lifeCycleStateProperty.set(lifeCycleState); + } + + public void setProcessState(TakerProcessState processState) { + this.processState = processState; + processStateProperty.set(processState); + + if (processState == TakerProcessState.EXCEPTION) { + setLifeCycleState(TakerLifeCycleState.FAILED); + disposeProtocol(); + } + } + + @Override + public void setThrowable(Throwable throwable) { + super.setThrowable(throwable); + setProcessState(TakerTrade.TakerProcessState.EXCEPTION); + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Protected + /////////////////////////////////////////////////////////////////////////////////////////// + + @Override + protected void setupConfidenceListener() { assert depositTx != null; TransactionConfidence transactionConfidence = depositTx.getConfidence(); ListenableFuture future = transactionConfidence.getDepthFuture(1); @@ -230,4 +240,14 @@ public class TakerTrade extends Trade implements Serializable { } }); } + + @Override + public String toString() { + return "TakerTrade{" + + "tradeAmount=" + tradeAmount + + ", tradingPeer=" + tradingPeer + + ", processState=" + processState + + ", lifeCycleState=" + lifeCycleState + + '}'; + } } diff --git a/core/src/main/java/io/bitsquare/trade/Trade.java b/core/src/main/java/io/bitsquare/trade/Trade.java index 12299479fc..4df64dfec3 100644 --- a/core/src/main/java/io/bitsquare/trade/Trade.java +++ b/core/src/main/java/io/bitsquare/trade/Trade.java @@ -25,18 +25,18 @@ import io.bitsquare.common.taskrunner.Model; import io.bitsquare.crypto.SignatureService; import io.bitsquare.offer.Offer; import io.bitsquare.p2p.MailboxMessage; -import io.bitsquare.p2p.MailboxService; import io.bitsquare.p2p.MessageService; -import io.bitsquare.p2p.Peer; import io.bitsquare.storage.Storage; import io.bitsquare.trade.protocol.Protocol; -import io.bitsquare.trade.protocol.trade.TradeProcessModel; +import io.bitsquare.trade.protocol.trade.ProcessModel; import io.bitsquare.user.User; import org.bitcoinj.core.Coin; import org.bitcoinj.core.Transaction; import org.bitcoinj.utils.Fiat; +import java.io.IOException; +import java.io.ObjectInputStream; import java.io.Serializable; import java.util.Date; @@ -45,9 +45,6 @@ import javax.annotation.Nullable; import javafx.beans.property.ObjectProperty; import javafx.beans.property.ReadOnlyObjectProperty; -import javafx.beans.property.SimpleObjectProperty; - -import org.jetbrains.annotations.NotNull; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -60,7 +57,7 @@ abstract public class Trade extends Model implements Serializable { // That object is saved to disc. We need to take care of changes to not break deserialization. private static final long serialVersionUID = 1L; - transient protected static final Logger log = LoggerFactory.getLogger(Trade.class); + private transient static final Logger log = LoggerFactory.getLogger(Trade.class); /////////////////////////////////////////////////////////////////////////////////////////// @@ -78,53 +75,59 @@ abstract public class Trade extends Model implements Serializable { // Fields /////////////////////////////////////////////////////////////////////////////////////////// + // Transient/Immutable + transient private Storage storage; + transient protected Protocol protocol; + + // Immutable protected final Offer offer; - @NotNull private final Date date; - @NotNull protected TradeProcessModel processModel = createProcessModel(); + private final Date date; + protected final ProcessModel processModel; - protected abstract TradeProcessModel createProcessModel(); + // Mutable + private MailboxMessage mailboxMessage; + protected Transaction depositTx; + private Contract contract; + private String contractAsJson; + private String takerContractSignature; + private String offererContractSignature; + private Transaction payoutTx; - @NotNull transient protected Protocol protocol; - - @Nullable MailboxMessage mailboxMessage; - @Nullable Transaction depositTx; - @Nullable private Transaction payoutTx; - @Nullable private Contract contract; - @Nullable private String contractAsJson; - @Nullable private String takerContractSignature; - @Nullable private String offererContractSignature; - - @NotNull transient private Storage storage; - - @Nullable private transient String errorMessage; - @Nullable private transient Throwable throwable; - @NotNull transient ObjectProperty tradeAmountProperty = new SimpleObjectProperty<>(); - @NotNull transient ObjectProperty tradeVolumeProperty = new SimpleObjectProperty<>(); + // Transient/Mutable + transient private String errorMessage; + transient private Throwable throwable; + transient protected ObjectProperty tradeAmountProperty; + transient protected ObjectProperty tradeVolumeProperty; /////////////////////////////////////////////////////////////////////////////////////////// - // Constructor + // Constructor, initialization /////////////////////////////////////////////////////////////////////////////////////////// - Trade(Offer offer, @NotNull Storage storage) { + Trade(Offer offer, Storage storage) { + log.trace("Created by constructor"); this.offer = offer; this.storage = storage; date = new Date(); + processModel = createProcessModel(); } - public void initProcessModel(@NotNull MessageService messageService, - @NotNull MailboxService mailboxService, - @NotNull WalletService walletService, - @NotNull TradeWalletService tradeWalletService, - @NotNull BlockChainService blockChainService, - @NotNull SignatureService signatureService, - @NotNull ArbitrationRepository arbitrationRepository, - @NotNull User user) { + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + } - processModel.init(offer, + public void init(MessageService messageService, + WalletService walletService, + TradeWalletService tradeWalletService, + BlockChainService blockChainService, + SignatureService signatureService, + ArbitrationRepository arbitrationRepository, + User user) { + + processModel.onAllServicesInitialized(offer, messageService, - mailboxService, walletService, tradeWalletService, blockChainService, @@ -133,25 +136,33 @@ abstract public class Trade extends Model implements Serializable { user); createProtocol(); - + if (mailboxMessage != null) protocol.setMailboxMessage(mailboxMessage); } - - + + public void setStorage(Storage storage) { + this.storage = storage; + } + + abstract protected ProcessModel createProcessModel(); + + abstract protected void createProtocol(); + + /////////////////////////////////////////////////////////////////////////////////////////// // API /////////////////////////////////////////////////////////////////////////////////////////// // The deserialized tx has not actual confidence data, so we need to get the fresh one from the wallet. - public void syncDepositTxWithWallet(@NotNull TradeWalletService tradeWalletService) { + public void updateDepositTxFromWallet(TradeWalletService tradeWalletService) { if (depositTx != null) - setDepositTx(tradeWalletService.commitsDepositTx(depositTx)); + setDepositTx(tradeWalletService.getWalletTx(depositTx)); } - public void setDepositTx(@NotNull Transaction tx) { + public void setDepositTx(Transaction tx) { this.depositTx = tx; - setConfidenceListener(); + setupConfidenceListener(); } public void disposeProtocol() { @@ -161,15 +172,15 @@ abstract public class Trade extends Model implements Serializable { } } - public void setMailboxMessage(@NotNull MailboxMessage mailboxMessage) { + public void setMailboxMessage(MailboxMessage mailboxMessage) { this.mailboxMessage = mailboxMessage; - assert protocol != null; - protocol.setMailboxMessage(mailboxMessage); + if (protocol != null) + protocol.setMailboxMessage(mailboxMessage); + + storage.queueUpForSave(); } - public void setStorage(@NotNull Storage storage) { - this.storage = storage; - } + protected abstract void setupConfidenceListener(); /////////////////////////////////////////////////////////////////////////////////////////// @@ -187,72 +198,13 @@ abstract public class Trade extends Model implements Serializable { storage.queueUpForSave(); } - /////////////////////////////////////////////////////////////////////////////////////////// - // Setters - /////////////////////////////////////////////////////////////////////////////////////////// - - protected abstract void setConfidenceListener(); - - public void setTakerContractSignature(@NotNull String takerSignature) { - this.takerContractSignature = takerSignature; - } - - public void setOffererContractSignature(@NotNull String offererContractSignature) { - this.offererContractSignature = offererContractSignature; - } - - public void setContractAsJson(@NotNull String contractAsJson) { - this.contractAsJson = contractAsJson; - } - - public void setContract(@NotNull Contract contract) { - this.contract = contract; - } - - public void setPayoutTx(@NotNull Transaction tx) { - this.payoutTx = tx; - } - - public void setErrorMessage(@NotNull String errorMessage) { - this.errorMessage = errorMessage; - } - - public void setThrowable(@NotNull Throwable throwable) { - this.throwable = throwable; - } - /////////////////////////////////////////////////////////////////////////////////////////// - // Getters + // Getter only /////////////////////////////////////////////////////////////////////////////////////////// - @Nullable - public String getTakerContractSignature() { - return takerContractSignature; - } - - @Nullable - public String getOffererContractSignature() { - return offererContractSignature; - } - - @Nullable - public Transaction getDepositTx() { - return depositTx; - } - - @Nullable - public Transaction getPayoutTx() { - return payoutTx; - } - - @Nullable - public Contract getContract() { - return contract; - } - - public Coin getSecurityDeposit() { - return offer.getSecurityDeposit(); + public Date getDate() { + return date; } public String getId() { @@ -263,14 +215,86 @@ abstract public class Trade extends Model implements Serializable { return offer; } + @Nullable + public Transaction getDepositTx() { + return depositTx; + } + + public Coin getSecurityDeposit() { + return offer.getSecurityDeposit(); + } + + public ReadOnlyObjectProperty tradeAmountProperty() { + return tradeAmountProperty; + } + + + public ReadOnlyObjectProperty tradeVolumeProperty() { + return tradeVolumeProperty; + } + + @Nullable + abstract public Coin getTradeAmount(); + + @Nullable + abstract public Fiat getTradeVolume(); + + abstract public ReadOnlyObjectProperty processStateProperty(); + + abstract public ReadOnlyObjectProperty lifeCycleStateProperty(); + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter/Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + public void setTakerContractSignature(String takerSignature) { + this.takerContractSignature = takerSignature; + } + + @Nullable + public String getTakerContractSignature() { + return takerContractSignature; + } + + public void setOffererContractSignature(String offererContractSignature) { + this.offererContractSignature = offererContractSignature; + } + + @Nullable + public String getOffererContractSignature() { + return offererContractSignature; + } + + public void setContractAsJson(String contractAsJson) { + this.contractAsJson = contractAsJson; + } + @Nullable public String getContractAsJson() { return contractAsJson; } - @NotNull - public Date getDate() { - return date; + public void setContract(Contract contract) { + this.contract = contract; + } + + @Nullable + public Contract getContract() { + return contract; + } + + public void setPayoutTx(Transaction payoutTx) { + this.payoutTx = payoutTx; + } + + // Not used now, but will be used in some reporting UI + public Transaction getPayoutTx() { + return payoutTx; + } + + public void setErrorMessage(String errorMessage) { + this.errorMessage = errorMessage; } @Nullable @@ -278,53 +302,30 @@ abstract public class Trade extends Model implements Serializable { return errorMessage; } + + public void setThrowable(Throwable throwable) { + this.throwable = throwable; + } + @Nullable public Throwable getThrowable() { return throwable; } - @NotNull - public ReadOnlyObjectProperty tradeAmountProperty() { - return tradeAmountProperty; - } - - @NotNull - public ReadOnlyObjectProperty tradeVolumeProperty() { - return tradeVolumeProperty; - } - - abstract void createProtocol(); - - @NotNull - public abstract ReadOnlyObjectProperty processStateProperty(); - - @NotNull - public abstract ReadOnlyObjectProperty lifeCycleStateProperty(); - - @org.jetbrains.annotations.Nullable - public abstract Coin getTradeAmount(); - - @org.jetbrains.annotations.Nullable - public abstract Fiat getTradeVolume(); - - @org.jetbrains.annotations.Nullable - public abstract Peer getTradingPeer(); - - @NotNull @Override public String toString() { return "Trade{" + - "protocol=" + protocol + - ", mailboxMessage=" + mailboxMessage + + "throwable=" + throwable + ", offer=" + offer + ", date=" + date + + ", mailboxMessage=" + mailboxMessage + + ", depositTx=" + depositTx + ", contract=" + contract + ", contractAsJson='" + contractAsJson + '\'' + ", takerContractSignature='" + takerContractSignature + '\'' + ", offererContractSignature='" + offererContractSignature + '\'' + - ", depositTx=" + depositTx + - ", payoutTx=" + payoutTx + + ", errorMessage='" + errorMessage + '\'' + + ", processModel=" + processModel + '}'; } - -} +} \ No newline at end of file diff --git a/core/src/main/java/io/bitsquare/trade/TradeList.java b/core/src/main/java/io/bitsquare/trade/TradeList.java index 8c0ce2d625..b2a3c50a84 100644 --- a/core/src/main/java/io/bitsquare/trade/TradeList.java +++ b/core/src/main/java/io/bitsquare/trade/TradeList.java @@ -19,6 +19,8 @@ package io.bitsquare.trade; import io.bitsquare.storage.Storage; +import java.io.IOException; +import java.io.ObjectInputStream; import java.io.Serializable; import java.util.ArrayList; @@ -36,6 +38,7 @@ public class TradeList extends ArrayList implements Serializable { transient private static final Logger log = LoggerFactory.getLogger(TradeList.class); transient final private Storage storage; + // Use getObservableList() also class locally, to be sure that object exists in case we use the object as deserialized form transient private ObservableList observableList; // Superclass is ArrayList, which will be persisted @@ -45,6 +48,7 @@ public class TradeList extends ArrayList implements Serializable { /////////////////////////////////////////////////////////////////////////////////////////// public TradeList(Storage storage, String fileName) { + log.trace("Created by constructor"); this.storage = storage; TradeList persisted = storage.initAndGetPersisted(this, fileName); @@ -54,10 +58,15 @@ public class TradeList extends ArrayList implements Serializable { observableList = FXCollections.observableArrayList(this); } + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + } + @Override public boolean add(T trade) { boolean result = super.add(trade); - observableList.add(trade); + getObservableList().add(trade); storage.queueUpForSave(); return result; } @@ -65,12 +74,14 @@ public class TradeList extends ArrayList implements Serializable { @Override public boolean remove(Object trade) { boolean result = super.remove(trade); - observableList.remove(trade); + getObservableList().remove(trade); storage.queueUpForSave(); return result; } public ObservableList getObservableList() { + if (observableList == null) + observableList = FXCollections.observableArrayList(this); return observableList; } diff --git a/core/src/main/java/io/bitsquare/trade/TradeManager.java b/core/src/main/java/io/bitsquare/trade/TradeManager.java index 0c807a3a9a..342faa1ab6 100644 --- a/core/src/main/java/io/bitsquare/trade/TradeManager.java +++ b/core/src/main/java/io/bitsquare/trade/TradeManager.java @@ -35,7 +35,6 @@ import io.bitsquare.p2p.EncryptedMailboxMessage; import io.bitsquare.p2p.MailboxMessage; import io.bitsquare.p2p.MailboxService; import io.bitsquare.p2p.MessageService; -import io.bitsquare.p2p.Peer; import io.bitsquare.storage.Storage; import io.bitsquare.trade.handlers.TakeOfferResultHandler; import io.bitsquare.trade.handlers.TransactionResultHandler; @@ -89,8 +88,8 @@ public class TradeManager { private final ArbitrationRepository arbitrationRepository; private final Map checkOfferAvailabilityProtocolMap = new HashMap<>(); - private final Storage pendingTradesStorage; - private final Storage openOfferTradesStorage; + private final Storage pendingTradesStorage; + private final Storage openOfferTradesStorage; private final TradeList openOfferTrades; private final TradeList pendingTrades; private final TradeList closedTrades; @@ -129,12 +128,12 @@ public class TradeManager { this.offerBookService = offerBookService; this.arbitrationRepository = arbitrationRepository; - openOfferTradesStorage = new Storage(storageDir); - pendingTradesStorage = new Storage(storageDir); + openOfferTradesStorage = new Storage<>(storageDir); + pendingTradesStorage = new Storage<>(storageDir); this.openOfferTrades = new TradeList<>(openOfferTradesStorage, "OpenOfferTrades"); this.pendingTrades = new TradeList<>(pendingTradesStorage, "PendingTrades"); - this.closedTrades = new TradeList<>(new Storage(storageDir), "ClosedTrades"); + this.closedTrades = new TradeList<>(new Storage<>(storageDir), "ClosedTrades"); // In case the app did get killed the shutDown from the modules is not called, so we use a shutdown hook @@ -144,9 +143,66 @@ public class TradeManager { /////////////////////////////////////////////////////////////////////////////////////////// - // Public API + // Lifecycle /////////////////////////////////////////////////////////////////////////////////////////// + // When all services are initialized we create the protocols for our open offers and persisted pendingTrades + // OffererAsBuyerProtocol listens for take offer requests, so we need to instantiate it early. + public void onAllServicesInitialized() { + for (OffererTrade offererTrade : openOfferTrades) { + Offer offer = offererTrade.getOffer(); + // We add own offers to offerbook when we go online again + offerBookService.addOffer(offer, + () -> log.debug("Successful removed open offer from DHT"), + (message, throwable) -> log.error("Remove open offer from DHT failed. " + message)); + offererTrade.setStorage(openOfferTradesStorage); + initTrade(offererTrade); + + } + for (Trade trade : pendingTrades) { + // We continue an interrupted trade. + // TODO if the peer has changed its IP address, we need to make another findPeer request. At the moment we use the peer stored in trade to + // continue the trade, but that might fail. + initTrade(trade); + trade.updateDepositTxFromWallet(tradeWalletService); + trade.setStorage(pendingTradesStorage); + } + + // if there are messages in our mailbox we apply it and remove them from the DHT + mailboxService.getAllMessages(user.getP2PSigPubKey(), + (encryptedMailboxMessages) -> { + setMailboxMessagesToTrades(encryptedMailboxMessages); + emptyMailbox(); + }); + } + + private void setMailboxMessagesToTrades(List encryptedMailboxMessages) { + log.trace("applyMailboxMessage encryptedMailboxMessage.size=" + encryptedMailboxMessages.size()); + for (EncryptedMailboxMessage encrypted : encryptedMailboxMessages) { + try { + MailboxMessage mailboxMessage = encryptionService.decryptToObject(user.getP2pEncryptPrivateKey(), encrypted.getBucket()); + + if (mailboxMessage instanceof TradeMessage) { + String tradeId = ((TradeMessage) mailboxMessage).tradeId; + Optional tradeOptional = pendingTrades.stream().filter(e -> e.getId().equals(tradeId)).findAny(); + if (tradeOptional.isPresent()) + tradeOptional.get().setMailboxMessage(mailboxMessage); + } + } catch (Throwable e) { + e.printStackTrace(); + log.error(e.getMessage()); + } + } + } + + private void emptyMailbox() { + mailboxService.removeAllMessages(user.getP2PSigPubKey(), + () -> log.debug("All mailbox entries removed"), + (errorMessage, fault) -> { + log.error(errorMessage); + log.error(fault.getMessage()); + }); + } public void shutDown() { if (!shutDownRequested) { @@ -160,50 +216,6 @@ public class TradeManager { } } - // When all services are initialized we create the protocols for our open offers and persisted not completed pendingTrades - // OffererAsBuyerProtocol listens for take offer requests, so we need to instantiate it early. - public void onAllServicesInitialized() { - - for (OffererTrade offererTrade : openOfferTrades) { - Offer offer = offererTrade.getOffer(); - // we add own offers to offerbook when we go online again - offerBookService.addOffer(offer, - () -> log.debug("Successful removed open offer from DHT"), - (message, throwable) -> log.error("Remove open offer from DHT failed. " + message)); - offererTrade.setStorage(openOfferTradesStorage); - offererTrade.initProcessModel(messageService, - mailboxService, - walletService, - tradeWalletService, - blockChainService, - signatureService, - arbitrationRepository, - user); - - } - for (Trade trade : pendingTrades) { - // We continue an interrupted trade. - // TODO if the peer has changed its IP address, we need to make another findPeer request. At the moment we use the peer stored in trade to - // continue the trade, but that might fail. - trade.initProcessModel(messageService, - mailboxService, - walletService, - tradeWalletService, - blockChainService, - signatureService, - arbitrationRepository, - user); - trade.syncDepositTxWithWallet(tradeWalletService); - trade.setStorage(pendingTradesStorage); - } - - mailboxService.getAllMessages(user.getP2PSigPubKey(), - (encryptedMailboxMessages) -> { - decryptMailboxMessages(encryptedMailboxMessages); - emptyMailbox(); - }); - } - /////////////////////////////////////////////////////////////////////////////////////////// // Offer @@ -217,17 +229,17 @@ public class TradeManager { TransactionResultHandler resultHandler, ErrorMessageHandler errorMessageHandler) { - FiatAccount currentFiatAccount = user.currentFiatAccountProperty().get(); + FiatAccount fiatAccount = user.currentFiatAccountProperty().get(); Offer offer = new Offer(id, user.getP2PSigPubKey(), direction, price.getValue(), amount, minAmount, - currentFiatAccount.type, - currentFiatAccount.currencyCode, - currentFiatAccount.country, - currentFiatAccount.id, + fiatAccount.type, + fiatAccount.currencyCode, + fiatAccount.country, + fiatAccount.id, accountSettings.getAcceptedArbitratorIds(), accountSettings.getSecurityDeposit(), accountSettings.getAcceptedCountries(), @@ -237,42 +249,63 @@ public class TradeManager { PlaceOfferProtocol placeOfferProtocol = new PlaceOfferProtocol( model, - (transaction) -> { - OffererTrade offererTrade = new OffererTrade(offer, openOfferTradesStorage); - openOfferTrades.add(offererTrade); - offererTrade.initProcessModel(messageService, - mailboxService, - walletService, - tradeWalletService, - blockChainService, - signatureService, - arbitrationRepository, - user); - - offererTrade.processStateProperty().addListener((ov, oldValue, newValue) -> { - log.debug("offererTrade state = " + newValue); - if (newValue == OffererTrade.OffererProcessState.DEPOSIT_PUBLISHED) { - removeOpenOffer(offererTrade.getOffer(), - () -> log.debug("remove offer was successful"), - (message) -> log.error(message), - false); - pendingTrades.add(offererTrade); - offererTrade.setStorage(pendingTradesStorage); - } - }); - - resultHandler.handleResult(transaction); - }, - (message) -> errorMessageHandler.handleErrorMessage(message) + transaction -> handlePlaceOfferResult(transaction, offer, resultHandler), + errorMessageHandler::handleErrorMessage ); placeOfferProtocol.placeOffer(); } + private void handlePlaceOfferResult(Transaction transaction, Offer offer, TransactionResultHandler resultHandler) { + OffererTrade offererTrade = new OffererTrade(offer, openOfferTradesStorage); + openOfferTrades.add(offererTrade); + initTrade(offererTrade); + + offererTrade.processStateProperty().addListener((ov, oldValue, newValue) -> { + log.debug("offererTrade state = " + newValue); + if (newValue == OffererTrade.OffererProcessState.DEPOSIT_PUBLISHED) { + removeOpenOffer(offererTrade.getOffer(), + () -> log.debug("remove offer was successful"), + log::error, + false); + pendingTrades.add(offererTrade); + offererTrade.setStorage(pendingTradesStorage); + } + }); + + resultHandler.handleResult(transaction); + } + public void cancelOpenOffer(Offer offer, ResultHandler resultHandler, ErrorMessageHandler errorMessageHandler) { removeOpenOffer(offer, resultHandler, errorMessageHandler, true); } + private void removeOpenOffer(Offer offer, + ResultHandler resultHandler, + ErrorMessageHandler errorMessageHandler, + boolean isCancelRequest) { + offerBookService.removeOffer(offer, + () -> { + offer.setState(Offer.State.REMOVED); + Optional offererTradeOptional = openOfferTrades.stream().filter(e -> e.getId().equals(offer.getId())).findAny(); + if (offererTradeOptional.isPresent()) { + OffererTrade offererTrade = offererTradeOptional.get(); + openOfferTrades.remove(offererTrade); + + if (isCancelRequest) { + offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_CANCELED); + closedTrades.add(offererTrade); + offererTrade.disposeProtocol(); + } + } + + disposeCheckOfferAvailabilityRequest(offer); + + resultHandler.handleResult(); + }, + (message, throwable) -> errorMessageHandler.handleErrorMessage(message)); + } + /////////////////////////////////////////////////////////////////////////////////////////// // Take offer @@ -305,18 +338,24 @@ public class TradeManager { public void requestTakeOffer(Coin amount, Offer offer, TakeOfferResultHandler takeOfferResultHandler) { CheckOfferAvailabilityModel model = new CheckOfferAvailabilityModel(offer, messageService, addressService); CheckOfferAvailabilityProtocol availabilityProtocol = new CheckOfferAvailabilityProtocol(model, - () -> { - disposeCheckOfferAvailabilityRequest(offer); - if (offer.getState() == Offer.State.AVAILABLE) { - TakerTrade trade = takeAvailableOffer(amount, offer, model.getPeer()); - takeOfferResultHandler.handleResult(trade); - } - }, + () -> handleCheckOfferAvailabilityResult(amount, offer, model, takeOfferResultHandler), (errorMessage) -> disposeCheckOfferAvailabilityRequest(offer)); checkOfferAvailabilityProtocolMap.put(offer.getId(), availabilityProtocol); availabilityProtocol.checkOfferAvailability(); } + private void handleCheckOfferAvailabilityResult(Coin amount, Offer offer, CheckOfferAvailabilityModel model, TakeOfferResultHandler + takeOfferResultHandler) { + disposeCheckOfferAvailabilityRequest(offer); + if (offer.getState() == Offer.State.AVAILABLE) { + TakerTrade takerTrade = new TakerTrade(offer, amount, model.getPeer(), pendingTradesStorage); + initTrade(takerTrade); + pendingTrades.add(takerTrade); + takerTrade.takeAvailableOffer(); + takeOfferResultHandler.handleResult(takerTrade); + } + } + /////////////////////////////////////////////////////////////////////////////////////////// // Trade @@ -328,8 +367,9 @@ public class TradeManager { // TODO handle overpaid securityDeposit Coin amountToWithdraw = trade.getSecurityDeposit(); + assert trade.getTradeAmount() != null; if (trade instanceof OffererTrade) - amountToWithdraw = amountToWithdraw.add(((OffererTrade) trade).getTradeAmount()); + amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount()); FutureCallback callback = new FutureCallback() { @Override @@ -392,35 +432,9 @@ public class TradeManager { /////////////////////////////////////////////////////////////////////////////////////////// - // Private methods + // Misc /////////////////////////////////////////////////////////////////////////////////////////// - private void removeOpenOffer(Offer offer, - ResultHandler resultHandler, - ErrorMessageHandler errorMessageHandler, - boolean isCancelRequest) { - offerBookService.removeOffer(offer, - () -> { - offer.setState(Offer.State.REMOVED); - Optional offererTradeOptional = openOfferTrades.stream().filter(e -> e.getId().equals(offer.getId())).findAny(); - if (offererTradeOptional.isPresent()) { - OffererTrade offererTrade = offererTradeOptional.get(); - openOfferTrades.remove(offererTrade); - - if (isCancelRequest) { - offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_CANCELED); - closedTrades.add(offererTrade); - offererTrade.disposeProtocol(); - } - } - - disposeCheckOfferAvailabilityRequest(offer); - - resultHandler.handleResult(); - }, - (message, throwable) -> errorMessageHandler.handleErrorMessage(message)); - } - private void disposeCheckOfferAvailabilityRequest(Offer offer) { if (checkOfferAvailabilityProtocolMap.containsKey(offer.getId())) { CheckOfferAvailabilityProtocol protocol = checkOfferAvailabilityProtocolMap.get(offer.getId()); @@ -429,57 +443,14 @@ public class TradeManager { } } - - /////////////////////////////////////////////////////////////////////////////////////////// - // Trade - /////////////////////////////////////////////////////////////////////////////////////////// - - private TakerTrade takeAvailableOffer(Coin amount, Offer offer, Peer peer) { - TakerTrade takerTrade = new TakerTrade(offer, amount, peer, pendingTradesStorage); - takerTrade.initProcessModel(messageService, - mailboxService, + private void initTrade(Trade trade) { + trade.init(messageService, walletService, tradeWalletService, blockChainService, signatureService, arbitrationRepository, user); - pendingTrades.add(takerTrade); - takerTrade.takeAvailableOffer(); - return takerTrade; } - /////////////////////////////////////////////////////////////////////////////////////////// - // Mailbox - /////////////////////////////////////////////////////////////////////////////////////////// - - private void decryptMailboxMessages(List encryptedMailboxMessages) { - log.trace("applyMailboxMessage encryptedMailboxMessage.size=" + encryptedMailboxMessages.size()); - for (EncryptedMailboxMessage encrypted : encryptedMailboxMessages) { - try { - MailboxMessage mailboxMessage = encryptionService.decryptToObject(user.getP2pEncryptPrivateKey(), encrypted.getBucket()); - - if (mailboxMessage instanceof TradeMessage) { - String tradeId = ((TradeMessage) mailboxMessage).tradeId; - Optional tradeOptional = pendingTrades.stream().filter(e -> e.getId().equals(tradeId)).findAny(); - if (tradeOptional.isPresent()) - tradeOptional.get().setMailboxMessage(mailboxMessage); - } - } catch (Throwable e) { - e.printStackTrace(); - log.error(e.getMessage()); - } - } - } - - private void emptyMailbox() { - mailboxService.removeAllMessages(user.getP2PSigPubKey(), - () -> { - log.debug("All mailbox entries removed"); - }, - (errorMessage, fault) -> { - log.error(errorMessage); - log.error(fault.getMessage()); - }); - } } \ No newline at end of file diff --git a/core/src/main/java/io/bitsquare/trade/TradeModule.java b/core/src/main/java/io/bitsquare/trade/TradeModule.java index 6dd12c5b26..9a4f122805 100644 --- a/core/src/main/java/io/bitsquare/trade/TradeModule.java +++ b/core/src/main/java/io/bitsquare/trade/TradeModule.java @@ -42,7 +42,6 @@ public class TradeModule extends BitsquareModule { @Override protected void doClose(Injector injector) { log.trace("doClose " + getClass().getSimpleName()); - // First shut down AddressService to remove address from DHT injector.getInstance(TradeManager.class).shutDown(); } } diff --git a/core/src/main/java/io/bitsquare/trade/handlers/OfferStateResultHandler.java b/core/src/main/java/io/bitsquare/trade/handlers/OfferStateResultHandler.java deleted file mode 100644 index 46f00b682a..0000000000 --- a/core/src/main/java/io/bitsquare/trade/handlers/OfferStateResultHandler.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * 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 . - */ - -package io.bitsquare.trade.handlers; - -import io.bitsquare.offer.Offer; - - -public interface OfferStateResultHandler { - void handleStateResult(Offer.State state); -} diff --git a/core/src/main/java/io/bitsquare/trade/protocol/availability/CheckOfferAvailabilityProtocol.java b/core/src/main/java/io/bitsquare/trade/protocol/availability/CheckOfferAvailabilityProtocol.java index a69d0472db..06314555fe 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/availability/CheckOfferAvailabilityProtocol.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/availability/CheckOfferAvailabilityProtocol.java @@ -55,7 +55,7 @@ public class CheckOfferAvailabilityProtocol { messageHandler = this::handleMessage; } - public void cleanup() { + private void cleanup() { model.messageService.removeMessageHandler(messageHandler); } @@ -71,12 +71,8 @@ public class CheckOfferAvailabilityProtocol { model.messageService.addMessageHandler(messageHandler); taskRunner = new TaskRunner<>(model, - () -> { - log.debug("sequence at onCheckOfferAvailability completed"); - }, - (errorMessage) -> { - log.error(errorMessage); - } + () -> log.debug("sequence at onCheckOfferAvailability completed"), + log::error ); taskRunner.addTasks( GetPeerAddress.class, @@ -96,7 +92,7 @@ public class CheckOfferAvailabilityProtocol { // Incoming message handling /////////////////////////////////////////////////////////////////////////////////////////// - private void handleMessage(Message message, Peer sender) { + private void handleMessage(Message message, @SuppressWarnings("UnusedParameters") Peer sender) { if (!isCanceled) { if (message instanceof ReportOfferAvailabilityMessage && model.offer.getId().equals(((ReportOfferAvailabilityMessage) message).offerId)) handleReportOfferAvailabilityMessage((ReportOfferAvailabilityMessage) message); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/PlaceOfferModel.java b/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/PlaceOfferModel.java index c65117a824..b73cc1b495 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/PlaceOfferModel.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/PlaceOfferModel.java @@ -33,7 +33,7 @@ public class PlaceOfferModel extends Model { public final Offer offer; public final WalletService walletService; - public TradeWalletService tradeWalletService; + public final TradeWalletService tradeWalletService; public final OfferBookService offerBookService; private Transaction transaction; diff --git a/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/AddOfferToRemoteOfferBook.java b/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/AddOfferToRemoteOfferBook.java index 68a0a28cc0..532afbadc3 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/AddOfferToRemoteOfferBook.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/AddOfferToRemoteOfferBook.java @@ -35,11 +35,7 @@ public class AddOfferToRemoteOfferBook extends Task { @Override protected void doRun() { model.offerBookService.addOffer(model.offer, - () -> { - complete(); - }, - (message, throwable) -> { - failed(throwable); - }); + this::complete, + (message, throwable) -> failed(throwable)); } } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/BroadcastCreateOfferFeeTx.java b/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/BroadcastCreateOfferFeeTx.java index 8f7123c0fd..061b91bf9c 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/BroadcastCreateOfferFeeTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/BroadcastCreateOfferFeeTx.java @@ -72,9 +72,7 @@ public class BroadcastCreateOfferFeeTx extends Task { // We store now the changed txID to the offer and add that again. model.offer.setOfferFeePaymentTxID(transaction.getHashAsString()); model.offerBookService.addOffer(model.offer, - () -> { - complete(); - }, + BroadcastCreateOfferFeeTx.this::complete, (message, throwable) -> { log.error("addOffer failed"); addOfferFailed = true; @@ -108,9 +106,7 @@ public class BroadcastCreateOfferFeeTx extends Task { if (!removeOfferFailed && !addOfferFailed) { // If broadcast fails we need to remove offer from offerbook model.offerBookService.removeOffer(model.offer, - () -> { - log.info("Offer removed from offerbook because broadcast failed."); - }, + () -> log.info("Offer removed from offerbook because broadcast failed."), (message, throwable) -> { log.error("removeOffer failed"); failed(throwable); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/ProcessModel.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/ProcessModel.java new file mode 100644 index 0000000000..18d93921bc --- /dev/null +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/ProcessModel.java @@ -0,0 +1,154 @@ +/* + * 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 . + */ + +package io.bitsquare.trade.protocol.trade; + +import io.bitsquare.arbitration.ArbitrationRepository; +import io.bitsquare.btc.BlockChainService; +import io.bitsquare.btc.TradeWalletService; +import io.bitsquare.btc.WalletService; +import io.bitsquare.common.taskrunner.Model; +import io.bitsquare.crypto.SignatureService; +import io.bitsquare.offer.Offer; +import io.bitsquare.p2p.MailboxMessage; +import io.bitsquare.p2p.MessageService; +import io.bitsquare.trade.protocol.trade.messages.TradeMessage; +import io.bitsquare.user.User; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.Serializable; + +import javax.annotation.Nullable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class ProcessModel extends Model implements Serializable { + // That object is saved to disc. We need to take care of changes to not break deserialization. + private static final long serialVersionUID = 1L; + + private static final Logger log = LoggerFactory.getLogger(ProcessModel.class); + + // Transient/Immutable + transient private MessageService messageService; + transient private WalletService walletService; + transient private TradeWalletService tradeWalletService; + transient private BlockChainService blockChainService; + transient private SignatureService signatureService; + transient private ArbitrationRepository arbitrationRepository; + transient private Offer offer; + + // Mutable + transient private MailboxMessage mailboxMessage; + transient private TradeMessage tradeMessage; + + + protected ProcessModel() { + log.trace("Created by constructor"); + } + + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + } + + public void onAllServicesInitialized(Offer offer, + MessageService messageService, + WalletService walletService, + TradeWalletService tradeWalletService, + BlockChainService blockChainService, + SignatureService signatureService, + ArbitrationRepository arbitrationRepository, + User user) { + this.offer = offer; + this.messageService = messageService; + this.walletService = walletService; + this.tradeWalletService = tradeWalletService; + this.blockChainService = blockChainService; + this.signatureService = signatureService; + this.arbitrationRepository = arbitrationRepository; + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter only + /////////////////////////////////////////////////////////////////////////////////////////// + + public MessageService getMessageService() { + return messageService; + } + + public WalletService getWalletService() { + return walletService; + } + + public TradeWalletService getTradeWalletService() { + return tradeWalletService; + } + + public BlockChainService getBlockChainService() { + return blockChainService; + } + + public SignatureService getSignatureService() { + return signatureService; + } + + public byte[] getArbitratorPubKey() { + return arbitrationRepository.getDefaultArbitrator().getPubKey(); + } + + public Offer getOffer() { + return offer; + } + + public String getId() { + return offer.getId(); + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter/Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + public void setTradeMessage(TradeMessage tradeMessage) { + this.tradeMessage = tradeMessage; + } + + @Nullable + public TradeMessage getTradeMessage() { + return tradeMessage; + } + + public void setMailboxMessage(MailboxMessage mailboxMessage) { + this.mailboxMessage = mailboxMessage; + } + + @Nullable + public MailboxMessage getMailboxMessage() { + return mailboxMessage; + } + + + @Override + public String toString() { + return "ProcessModel{" + + "offer=" + offer + + '}'; + } +} diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProcessModel.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProcessModel.java deleted file mode 100644 index eda008acde..0000000000 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProcessModel.java +++ /dev/null @@ -1,106 +0,0 @@ -/* - * 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 . - */ - -package io.bitsquare.trade.protocol.trade; - -import io.bitsquare.arbitration.ArbitrationRepository; -import io.bitsquare.btc.BlockChainService; -import io.bitsquare.btc.TradeWalletService; -import io.bitsquare.btc.WalletService; -import io.bitsquare.common.taskrunner.Model; -import io.bitsquare.crypto.SignatureService; -import io.bitsquare.offer.Offer; -import io.bitsquare.p2p.MailboxMessage; -import io.bitsquare.p2p.MailboxService; -import io.bitsquare.p2p.MessageService; -import io.bitsquare.trade.protocol.trade.messages.TradeMessage; -import io.bitsquare.user.User; - -import java.io.Serializable; - -import javax.annotation.Nullable; - -import org.jetbrains.annotations.NotNull; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class TradeProcessModel extends Model implements Serializable { - // That object is saved to disc. We need to take care of changes to not break deserialization. - private static final long serialVersionUID = 1L; - - protected static final Logger log = LoggerFactory.getLogger(TradeProcessModel.class); - - // those fields are re-assigned in case of deserialized object after backend is ready. - // Therefore they are not final but annotated with @NotNull - @NotNull transient public MessageService messageService; - @NotNull transient public MailboxService mailboxService; - @NotNull transient public WalletService walletService; - @NotNull transient public TradeWalletService tradeWalletService; - @NotNull transient public BlockChainService blockChainService; - @NotNull transient public SignatureService signatureService; - - @NotNull public Offer offer; - @NotNull public String id; - @NotNull public byte[] arbitratorPubKey; - - @Nullable private transient MailboxMessage mailboxMessage; - @Nullable transient private TradeMessage tradeMessage; - - protected TradeProcessModel() { - } - - public void init(@NotNull Offer offer, - @NotNull MessageService messageService, - @NotNull MailboxService mailboxService, - @NotNull WalletService walletService, - @NotNull TradeWalletService tradeWalletService, - @NotNull BlockChainService blockChainService, - @NotNull SignatureService signatureService, - @NotNull ArbitrationRepository arbitrationRepository, - @NotNull User user) { - this.offer = offer; - this.messageService = messageService; - this.mailboxService = mailboxService; - this.walletService = walletService; - this.tradeWalletService = tradeWalletService; - this.blockChainService = blockChainService; - this.signatureService = signatureService; - - id = offer.getId(); - arbitratorPubKey = arbitrationRepository.getDefaultArbitrator().getPubKey(); - assert arbitratorPubKey != null; - } - - public void setTradeMessage(@NotNull TradeMessage tradeMessage) { - this.tradeMessage = tradeMessage; - } - - public void setMailboxMessage(@NotNull MailboxMessage mailboxMessage) { - this.mailboxMessage = mailboxMessage; - } - - @Nullable - public TradeMessage getTradeMessage() { - return tradeMessage; - } - - @Nullable - public MailboxMessage getMailboxMessage() { - return mailboxMessage; - } -} diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/OfferMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/OfferMessage.java index 628f7baa2b..559af3bb56 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/OfferMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/OfferMessage.java @@ -30,7 +30,7 @@ public abstract class OfferMessage implements Message, Serializable { public final String offerId; - public OfferMessage(String offerId) { + protected OfferMessage(String offerId) { this.offerId = offerId; } } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestOffererPublishDepositTxMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestOffererPublishDepositTxMessage.java index 59e4a81fba..3e970697a5 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestOffererPublishDepositTxMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestOffererPublishDepositTxMessage.java @@ -44,7 +44,6 @@ public class RequestOffererPublishDepositTxMessage extends TradeMessage implemen public final String takerPayoutAddressString; public final Transaction takersPreparedDepositTx; public final List takerConnectedOutputsForAllInputs; - public final List takerOutputs; public RequestOffererPublishDepositTxMessage(String tradeId, FiatAccount takerFiatAccount, @@ -55,8 +54,7 @@ public class RequestOffererPublishDepositTxMessage extends TradeMessage implemen String takerContractSignature, String takerPayoutAddressString, Transaction takersPreparedDepositTx, - List takerConnectedOutputsForAllInputs, - List takerOutputs) { + List takerConnectedOutputsForAllInputs) { super(tradeId); this.takerFiatAccount = takerFiatAccount; this.takerAccountId = takerAccountId; @@ -67,6 +65,5 @@ public class RequestOffererPublishDepositTxMessage extends TradeMessage implemen this.takerPayoutAddressString = takerPayoutAddressString; this.takersPreparedDepositTx = takersPreparedDepositTx; this.takerConnectedOutputsForAllInputs = takerConnectedOutputsForAllInputs; - this.takerOutputs = takerOutputs; } } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/TradeMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/TradeMessage.java index e359b9a705..f5cfa41cc0 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/TradeMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/messages/TradeMessage.java @@ -30,7 +30,7 @@ public abstract class TradeMessage implements Message, Serializable { public final String tradeId; - public TradeMessage(String tradeId) { + protected TradeMessage(String tradeId) { this.tradeId = tradeId; } } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/OffererProtocol.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/OffererProtocol.java index 4830cda5a5..74eebfd07e 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/OffererProtocol.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/OffererProtocol.java @@ -31,7 +31,7 @@ import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage; -import io.bitsquare.trade.protocol.trade.offerer.models.OffererTradeProcessModel; +import io.bitsquare.trade.protocol.trade.offerer.models.OffererProcessModel; import io.bitsquare.trade.protocol.trade.offerer.tasks.CreateAndSignPayoutTx; import io.bitsquare.trade.protocol.trade.offerer.tasks.CreateOffererDepositTxInputs; import io.bitsquare.trade.protocol.trade.offerer.tasks.ProcessPayoutTxPublishedMessage; @@ -55,7 +55,7 @@ public class OffererProtocol implements Protocol { private final MessageHandler messageHandler; private final OffererTrade offererTrade; - private final OffererTradeProcessModel offererTradeProcessModel; + private final OffererProcessModel offererTradeProcessModel; /////////////////////////////////////////////////////////////////////////////////////////// // Constructor @@ -67,7 +67,7 @@ public class OffererProtocol implements Protocol { offererTradeProcessModel = offererTrade.getProcessModel(); messageHandler = this::handleMessage; - offererTradeProcessModel.messageService.addMessageHandler(messageHandler); + offererTradeProcessModel.getMessageService().addMessageHandler(messageHandler); } @@ -89,7 +89,7 @@ public class OffererProtocol implements Protocol { public void cleanup() { log.debug("cleanup " + this); - offererTradeProcessModel.messageService.removeMessageHandler(messageHandler); + offererTradeProcessModel.getMessageService().removeMessageHandler(messageHandler); } /////////////////////////////////////////////////////////////////////////////////////////// @@ -99,15 +99,15 @@ public class OffererProtocol implements Protocol { // OpenOffer requests private void handleRequestIsOfferAvailableMessage(RequestIsOfferAvailableMessage tradeMessage, Peer sender) { try { - checkTradeId(offererTradeProcessModel.id, tradeMessage); + checkTradeId(offererTradeProcessModel.getId(), tradeMessage); // We don't store anything in the offererTradeProcessModel as we might be in a trade process and receive that request from another peer who wants // to take the // offer // at the same time boolean isOfferOpen = offererTrade.lifeCycleStateProperty().get() == OffererTrade.OffererLifeCycleState.OFFER_OPEN; - ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(offererTradeProcessModel.id, isOfferOpen); - offererTradeProcessModel.messageService.sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() { + ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(offererTradeProcessModel.getId(), isOfferOpen); + offererTradeProcessModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() { @Override public void handleResult() { // Offerer does not do anything at that moment. Peer might only watch the offer and does not start a trade. @@ -128,14 +128,14 @@ public class OffererProtocol implements Protocol { // Trade started. We reserve the offer for that taker. If anything goes wrong we reset the offer as open. private void handleRequestDepositTxInputsMessage(RequestDepositTxInputsMessage tradeMessage, Peer taker) { - checkTradeId(offererTradeProcessModel.id, tradeMessage); + checkTradeId(offererTradeProcessModel.getId(), tradeMessage); offererTradeProcessModel.setTradeMessage(tradeMessage); offererTrade.setTradingPeer(taker); offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_RESERVED); TaskRunner taskRunner = new TaskRunner<>(offererTrade, () -> log.debug("taskRunner at handleTakeOfferFeePayedMessage completed"), - (errorMessage) -> handleTaskRunnerFault(errorMessage)); + this::handleTaskRunnerFault); taskRunner.addTasks( ProcessRequestDepositTxInputsMessage.class, CreateOffererDepositTxInputs.class, @@ -149,7 +149,7 @@ public class OffererProtocol implements Protocol { TaskRunner taskRunner = new TaskRunner<>(offererTrade, () -> log.debug("taskRunner at handleRequestOffererPublishDepositTxMessage completed"), - (errorMessage) -> handleTaskRunnerFault(errorMessage)); + this::handleTaskRunnerFault); taskRunner.addTasks( ProcessRequestOffererPublishDepositTxMessage.class, VerifyTakerAccount.class, @@ -169,7 +169,7 @@ public class OffererProtocol implements Protocol { public void onFiatPaymentStarted() { TaskRunner taskRunner = new TaskRunner<>(offererTrade, () -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"), - (errorMessage) -> handleTaskRunnerFault(errorMessage)); + this::handleTaskRunnerFault); taskRunner.addTasks( CreateAndSignPayoutTx.class, VerifyTakeOfferFeePayment.class, @@ -192,7 +192,7 @@ public class OffererProtocol implements Protocol { // we are done! offererTradeProcessModel.onComplete(); }, - (errorMessage) -> handleTaskRunnerFault(errorMessage)); + this::handleTaskRunnerFault); taskRunner.addTasks(ProcessPayoutTxPublishedMessage.class); taskRunner.run(); @@ -230,6 +230,7 @@ public class OffererProtocol implements Protocol { } private void handleTaskRunnerFault(String errorMessage) { + log.error(errorMessage); cleanup(); } } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/Offerer.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/Offerer.java index e3bf9fd314..736846ada3 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/Offerer.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/Offerer.java @@ -18,34 +18,158 @@ package io.bitsquare.trade.protocol.trade.offerer.models; import io.bitsquare.btc.AddressEntry; +import io.bitsquare.btc.WalletService; import io.bitsquare.fiat.FiatAccount; +import io.bitsquare.offer.Offer; +import io.bitsquare.user.User; import org.bitcoinj.core.Coin; import org.bitcoinj.core.TransactionOutput; import org.bitcoinj.crypto.DeterministicKey; +import java.io.IOException; +import java.io.ObjectInputStream; import java.io.Serializable; import java.security.PublicKey; +import java.util.Arrays; import java.util.List; +import javax.annotation.Nullable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + public class Offerer implements Serializable { // That object is saved to disc. We need to take care of changes to not break deserialization. private static final long serialVersionUID = 1L; - public FiatAccount fiatAccount; - public String accountId; - public PublicKey p2pSigPubKey; - public PublicKey p2pEncryptPubKey; - public byte[] registrationPubKey; - transient public DeterministicKey registrationKeyPair; - public AddressEntry addressEntry; - public byte[] tradeWalletPubKey; + transient private static final Logger log = LoggerFactory.getLogger(Offerer.class); - // written by tasks - public byte[] payoutTxSignature; - public Coin payoutAmount; - public List connectedOutputsForAllInputs; - public List outputs; // used to verify amounts with change outputs + // Transient/Immutable + private transient Offer offer; + private transient WalletService walletService; + private transient User user; + + // Mutable + private byte[] payoutTxSignature; + private Coin payoutAmount; + private List connectedOutputsForAllInputs; + private List outputs; // used to verify amounts with change outputs + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Constructor, initialization + /////////////////////////////////////////////////////////////////////////////////////////// + + public Offerer() { + log.trace("Created by constructor"); + } + + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + } + + // We need to wait until backend services are ready to set the required dependencies + public void onAllServicesInitialized(Offer offer, + WalletService walletService, + User user) { + log.trace("onBackendReady"); + this.offer = offer; + this.walletService = walletService; + this.user = user; + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter only + /////////////////////////////////////////////////////////////////////////////////////////// + + public FiatAccount getFiatAccount() { + return user.getFiatAccount(offer.getBankAccountId()); + } + + public String getAccountId() { + return user.getAccountId(); + } + + public PublicKey getP2pSigPubKey() { + return user.getP2PSigPubKey(); + } + + public PublicKey getP2pEncryptPubKey() { + return user.getP2PEncryptPubKey(); + } + + public byte[] getRegistrationPubKey() { + return walletService.getRegistrationAddressEntry().getPubKey(); + } + + public DeterministicKey getRegistrationKeyPair() { + return walletService.getRegistrationAddressEntry().getKeyPair(); + } + + public AddressEntry getAddressEntry() { + return walletService.getAddressEntry(offer.getId()); + } + + public byte[] getTradeWalletPubKey() { + return getAddressEntry().getPubKey(); + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter/Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + @Nullable + public List getOutputs() { + return outputs; + } + + public void setOutputs(List outputs) { + this.outputs = outputs; + } + + @Nullable + public byte[] getPayoutTxSignature() { + return payoutTxSignature; + } + + public void setPayoutTxSignature(byte[] payoutTxSignature) { + this.payoutTxSignature = payoutTxSignature; + } + + @Nullable + public Coin getPayoutAmount() { + return payoutAmount; + } + + public void setPayoutAmount(Coin payoutAmount) { + this.payoutAmount = payoutAmount; + } + + @Nullable + public List getConnectedOutputsForAllInputs() { + return connectedOutputsForAllInputs; + } + + public void setConnectedOutputsForAllInputs(List connectedOutputsForAllInputs) { + this.connectedOutputsForAllInputs = connectedOutputsForAllInputs; + } + + @Override + public String toString() { + return "Offerer{" + + "offer=" + offer + + ", walletService=" + walletService + + ", user=" + user + + ", payoutTxSignature=" + Arrays.toString(payoutTxSignature) + + ", payoutAmount=" + payoutAmount + + ", connectedOutputsForAllInputs=" + connectedOutputsForAllInputs + + ", outputs=" + outputs + + '}'; + } } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererProcessModel.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererProcessModel.java new file mode 100644 index 0000000000..90062f65b5 --- /dev/null +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererProcessModel.java @@ -0,0 +1,111 @@ +/* + * 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 . + */ + +package io.bitsquare.trade.protocol.trade.offerer.models; + +import io.bitsquare.arbitration.ArbitrationRepository; +import io.bitsquare.btc.BlockChainService; +import io.bitsquare.btc.TradeWalletService; +import io.bitsquare.btc.WalletService; +import io.bitsquare.crypto.SignatureService; +import io.bitsquare.offer.Offer; +import io.bitsquare.p2p.MessageService; +import io.bitsquare.trade.protocol.trade.ProcessModel; +import io.bitsquare.user.User; + +import java.io.IOException; +import java.io.Serializable; + +import javax.annotation.Nullable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class OffererProcessModel extends ProcessModel implements Serializable { + // That object is saved to disc. We need to take care of changes to not break deserialization. + private static final long serialVersionUID = 1L; + + transient private static final Logger log = LoggerFactory.getLogger(OffererProcessModel.class); + + // Immutable + public final Taker taker; + public final Offerer offerer; + + // Mutable + private String takeOfferFeeTxId; + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Constructor, initialization + /////////////////////////////////////////////////////////////////////////////////////////// + + public OffererProcessModel() { + log.trace("Created by constructor"); + taker = new Taker(); + offerer = new Offerer(); + } + + private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + } + + public void onAllServicesInitialized(Offer offer, + MessageService messageService, + WalletService walletService, + TradeWalletService tradeWalletService, + BlockChainService blockChainService, + SignatureService signatureService, + ArbitrationRepository arbitrationRepository, + User user) { + log.trace("onAllServicesInitialized"); + super.onAllServicesInitialized(offer, + messageService, + walletService, + tradeWalletService, + blockChainService, + signatureService, + arbitrationRepository, + user); + + offerer.onAllServicesInitialized(offer, walletService, user); + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter/Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + @Nullable + public String getTakeOfferFeeTxId() { + return takeOfferFeeTxId; + } + + public void setTakeOfferFeeTxId(String takeOfferFeeTxId) { + this.takeOfferFeeTxId = takeOfferFeeTxId; + } + + + @Override + public String toString() { + return "OffererProcessModel{" + + "taker=" + taker + + ", offerer=" + offerer + + ", takeOfferFeeTxId='" + takeOfferFeeTxId + '\'' + + '}'; + } +} diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererTradeProcessModel.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererTradeProcessModel.java deleted file mode 100644 index 0da37db725..0000000000 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererTradeProcessModel.java +++ /dev/null @@ -1,90 +0,0 @@ -/* - * 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 . - */ - -package io.bitsquare.trade.protocol.trade.offerer.models; - -import io.bitsquare.arbitration.ArbitrationRepository; -import io.bitsquare.btc.BlockChainService; -import io.bitsquare.btc.TradeWalletService; -import io.bitsquare.btc.WalletService; -import io.bitsquare.crypto.SignatureService; -import io.bitsquare.offer.Offer; -import io.bitsquare.p2p.MailboxService; -import io.bitsquare.p2p.MessageService; -import io.bitsquare.trade.protocol.trade.TradeProcessModel; -import io.bitsquare.user.User; - -import java.io.Serializable; - -import org.jetbrains.annotations.NotNull; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class OffererTradeProcessModel extends TradeProcessModel implements Serializable { - // That object is saved to disc. We need to take care of changes to not break deserialization. - private static final long serialVersionUID = 1L; - - transient private static final Logger log = LoggerFactory.getLogger(OffererTradeProcessModel.class); - - public final Taker taker = new Taker(); - public final Offerer offerer = new Offerer(); - - // written by tasks - private String takeOfferFeeTxId; - - public OffererTradeProcessModel() { - } - - public void init(@NotNull Offer offer, - @NotNull MessageService messageService, - @NotNull MailboxService mailboxService, - @NotNull WalletService walletService, - @NotNull TradeWalletService tradeWalletService, - @NotNull BlockChainService blockChainService, - @NotNull SignatureService signatureService, - @NotNull ArbitrationRepository arbitrationRepository, - @NotNull User user) { - super.init(offer, - messageService, - mailboxService, - walletService, - tradeWalletService, - blockChainService, - signatureService, - arbitrationRepository, - user); - - offerer.registrationPubKey = walletService.getRegistrationAddressEntry().getPubKey(); - offerer.registrationKeyPair = walletService.getRegistrationAddressEntry().getKeyPair(); - offerer.addressEntry = walletService.getAddressEntry(id); - offerer.fiatAccount = user.getFiatAccount(offer.getBankAccountId()); - offerer.accountId = user.getAccountId(); - offerer.p2pSigPubKey = user.getP2PSigPubKey(); - offerer.p2pEncryptPubKey = user.getP2PEncryptPubKey(); - offerer.tradeWalletPubKey = offerer.addressEntry.getPubKey(); - log.debug("BuyerAsOffererModel addressEntry " + offerer.addressEntry); - } - - public String getTakeOfferFeeTxId() { - return takeOfferFeeTxId; - } - - public void setTakeOfferFeeTxId(String takeOfferFeeTxId) { - this.takeOfferFeeTxId = takeOfferFeeTxId; - } -} diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/Taker.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/Taker.java index da7ea92e9b..9e4d2ace04 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/Taker.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/Taker.java @@ -23,26 +23,159 @@ import org.bitcoinj.core.Coin; import org.bitcoinj.core.Transaction; import org.bitcoinj.core.TransactionOutput; +import java.io.IOException; +import java.io.ObjectInputStream; import java.io.Serializable; import java.security.PublicKey; +import java.util.Arrays; import java.util.List; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + public class Taker implements Serializable { // That object is saved to disc. We need to take care of changes to not break deserialization. private static final long serialVersionUID = 1L; - // written by tasks - public String accountId; - public FiatAccount fiatAccount; - public PublicKey p2pSigPublicKey; - public PublicKey p2pEncryptPubKey; - public String contractAsJson;//TODO only write access now, missing impl. - public String contractSignature; - public Coin payoutAmount; - public Transaction preparedDepositTx; - public List connectedOutputsForAllInputs; - public String payoutAddressString; - public byte[] tradeWalletPubKey; + transient private static final Logger log = LoggerFactory.getLogger(Taker.class); + + // Mutable + private String accountId; + private FiatAccount fiatAccount; + private PublicKey p2pSigPublicKey; + private PublicKey p2pEncryptPubKey; + private String contractAsJson; + private String contractSignature; + private Coin payoutAmount; + private Transaction preparedDepositTx; + private List connectedOutputsForAllInputs; + private String payoutAddressString; + private byte[] tradeWalletPubKey; + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Constructor, initialization + /////////////////////////////////////////////////////////////////////////////////////////// + + public Taker() { + log.trace("Created by constructor"); + } + + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter/Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + public String getAccountId() { + return accountId; + } + + public void setAccountId(String accountId) { + this.accountId = accountId; + } + + public FiatAccount getFiatAccount() { + return fiatAccount; + } + + public void setFiatAccount(FiatAccount fiatAccount) { + this.fiatAccount = fiatAccount; + } + + public PublicKey getP2pSigPublicKey() { + return p2pSigPublicKey; + } + + public void setP2pSigPublicKey(PublicKey p2pSigPublicKey) { + this.p2pSigPublicKey = p2pSigPublicKey; + } + + public PublicKey getP2pEncryptPubKey() { + return p2pEncryptPubKey; + } + + public void setP2pEncryptPubKey(PublicKey p2pEncryptPubKey) { + this.p2pEncryptPubKey = p2pEncryptPubKey; + } + + public String getContractAsJson() { + return contractAsJson; + } + + public void setContractAsJson(String contractAsJson) { + this.contractAsJson = contractAsJson; + } + + public String getContractSignature() { + return contractSignature; + } + + public void setContractSignature(String contractSignature) { + this.contractSignature = contractSignature; + } + + public Coin getPayoutAmount() { + return payoutAmount; + } + + public void setPayoutAmount(Coin payoutAmount) { + this.payoutAmount = payoutAmount; + } + + public Transaction getPreparedDepositTx() { + return preparedDepositTx; + } + + public void setPreparedDepositTx(Transaction preparedDepositTx) { + this.preparedDepositTx = preparedDepositTx; + } + + public List getConnectedOutputsForAllInputs() { + return connectedOutputsForAllInputs; + } + + public void setConnectedOutputsForAllInputs(List connectedOutputsForAllInputs) { + this.connectedOutputsForAllInputs = connectedOutputsForAllInputs; + } + + public String getPayoutAddressString() { + return payoutAddressString; + } + + public void setPayoutAddressString(String payoutAddressString) { + this.payoutAddressString = payoutAddressString; + } + + public byte[] getTradeWalletPubKey() { + return tradeWalletPubKey; + } + + public void setTradeWalletPubKey(byte[] tradeWalletPubKey) { + this.tradeWalletPubKey = tradeWalletPubKey; + } + + + @Override + public String toString() { + return "Taker{" + + "accountId='" + accountId + '\'' + + ", fiatAccount=" + fiatAccount + + ", p2pSigPublicKey=" + p2pSigPublicKey + + ", p2pEncryptPubKey=" + p2pEncryptPubKey + + ", contractAsJson='" + contractAsJson + '\'' + + ", contractSignature='" + contractSignature + '\'' + + ", payoutAmount=" + payoutAmount + + ", preparedDepositTx=" + preparedDepositTx + + ", connectedOutputsForAllInputs=" + connectedOutputsForAllInputs + + ", payoutAddressString='" + payoutAddressString + '\'' + + ", tradeWalletPubKey=" + Arrays.toString(tradeWalletPubKey) + + '}'; + } } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateAndSignPayoutTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateAndSignPayoutTx.java index c95847a010..8764a15e85 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateAndSignPayoutTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateAndSignPayoutTx.java @@ -35,23 +35,24 @@ public class CreateAndSignPayoutTx extends OffererTradeTask { @Override protected void doRun() { try { + assert offererTrade.getTradeAmount() != null; Coin securityDeposit = offererTrade.getSecurityDeposit(); Coin offererPayoutAmount = offererTrade.getTradeAmount().add(securityDeposit); @SuppressWarnings("UnnecessaryLocalVariable") Coin takerPayoutAmount = securityDeposit; - byte[] offererPayoutTxSignature = offererTradeProcessModel.tradeWalletService.offererCreatesAndSignsPayoutTx( + byte[] offererPayoutTxSignature = offererTradeProcessModel.getTradeWalletService().offererCreatesAndSignsPayoutTx( offererTrade.getDepositTx(), offererPayoutAmount, takerPayoutAmount, - offererTradeProcessModel.offerer.addressEntry, - offererTradeProcessModel.taker.payoutAddressString, - offererTradeProcessModel.offerer.tradeWalletPubKey, - offererTradeProcessModel.taker.tradeWalletPubKey, - offererTradeProcessModel.arbitratorPubKey); + offererTradeProcessModel.offerer.getAddressEntry(), + offererTradeProcessModel.taker.getPayoutAddressString(), + offererTradeProcessModel.offerer.getTradeWalletPubKey(), + offererTradeProcessModel.taker.getTradeWalletPubKey(), + offererTradeProcessModel.getArbitratorPubKey()); - offererTradeProcessModel.offerer.payoutTxSignature = offererPayoutTxSignature; - offererTradeProcessModel.offerer.payoutAmount = offererPayoutAmount; - offererTradeProcessModel.taker.payoutAmount = takerPayoutAmount; + offererTradeProcessModel.offerer.setPayoutTxSignature(offererPayoutTxSignature); + offererTradeProcessModel.offerer.setPayoutAmount(offererPayoutAmount); + offererTradeProcessModel.taker.setPayoutAmount(takerPayoutAmount); complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateOffererDepositTxInputs.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateOffererDepositTxInputs.java index ddb90c053f..59843a44f4 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateOffererDepositTxInputs.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateOffererDepositTxInputs.java @@ -39,11 +39,11 @@ public class CreateOffererDepositTxInputs extends OffererTradeTask { try { log.debug("offererTrade.id" + offererTrade.getId()); Coin offererInputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE); - TradeWalletService.Result result = offererTradeProcessModel.tradeWalletService.createOffererDepositTxInputs(offererInputAmount, - offererTradeProcessModel.offerer.addressEntry); + TradeWalletService.Result result = offererTradeProcessModel.getTradeWalletService().createOffererDepositTxInputs(offererInputAmount, + offererTradeProcessModel.offerer.getAddressEntry()); - offererTradeProcessModel.offerer.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs(); - offererTradeProcessModel.offerer.outputs = result.getOutputs(); + offererTradeProcessModel.offerer.setConnectedOutputsForAllInputs(result.getConnectedOutputsForAllInputs()); + offererTradeProcessModel.offerer.setOutputs(result.getOutputs()); complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/OffererTradeTask.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/OffererTradeTask.java index 0f7765e983..bf7ede4d46 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/OffererTradeTask.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/OffererTradeTask.java @@ -23,17 +23,17 @@ import io.bitsquare.btc.exceptions.WalletException; import io.bitsquare.common.taskrunner.Task; import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.trade.OffererTrade; -import io.bitsquare.trade.protocol.trade.offerer.models.OffererTradeProcessModel; +import io.bitsquare.trade.protocol.trade.offerer.models.OffererProcessModel; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class OffererTradeTask extends Task { +class OffererTradeTask extends Task { private static final Logger log = LoggerFactory.getLogger(OffererTradeTask.class); - protected final OffererTradeProcessModel offererTradeProcessModel; + protected final OffererProcessModel offererTradeProcessModel; protected final OffererTrade offererTrade; - public OffererTradeTask(TaskRunner taskHandler, OffererTrade model) { + OffererTradeTask(TaskRunner taskHandler, OffererTrade model) { super(taskHandler, model); offererTrade = model; diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessPayoutTxPublishedMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessPayoutTxPublishedMessage.java index 9c3b73fc1c..44a9491c7b 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessPayoutTxPublishedMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessPayoutTxPublishedMessage.java @@ -37,9 +37,11 @@ public class ProcessPayoutTxPublishedMessage extends OffererTradeTask { @Override protected void doRun() { try { - checkTradeId(offererTradeProcessModel.id, offererTradeProcessModel.getTradeMessage()); + PayoutTxPublishedMessage message = (PayoutTxPublishedMessage) offererTradeProcessModel.getTradeMessage(); + checkTradeId(offererTradeProcessModel.getId(), message); + checkNotNull(message); - offererTrade.setPayoutTx(checkNotNull(((PayoutTxPublishedMessage) offererTradeProcessModel.getTradeMessage()).payoutTx)); + offererTrade.setPayoutTx(checkNotNull(message.payoutTx)); offererTrade.setProcessState(OffererTrade.OffererProcessState.PAYOUT_PUBLISHED); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestDepositTxInputsMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestDepositTxInputsMessage.java index cee17210ff..23c85e90aa 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestDepositTxInputsMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestDepositTxInputsMessage.java @@ -37,12 +37,13 @@ public class ProcessRequestDepositTxInputsMessage extends OffererTradeTask { @Override protected void doRun() { try { - checkTradeId(offererTradeProcessModel.id, offererTradeProcessModel.getTradeMessage()); - RequestDepositTxInputsMessage requestDepositTxInputsMessage = (RequestDepositTxInputsMessage) offererTradeProcessModel.getTradeMessage(); + RequestDepositTxInputsMessage message = (RequestDepositTxInputsMessage) offererTradeProcessModel.getTradeMessage(); + checkTradeId(offererTradeProcessModel.getId(), message); + checkNotNull(message); - offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(requestDepositTxInputsMessage.tradeAmount))); - offererTradeProcessModel.setTakeOfferFeeTxId(nonEmptyStringOf(requestDepositTxInputsMessage.takeOfferFeeTxId)); - offererTradeProcessModel.taker.tradeWalletPubKey = checkNotNull(requestDepositTxInputsMessage.takerTradeWalletPubKey); + offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount))); + offererTradeProcessModel.setTakeOfferFeeTxId(nonEmptyStringOf(message.takeOfferFeeTxId)); + offererTradeProcessModel.taker.setTradeWalletPubKey(checkNotNull(message.takerTradeWalletPubKey)); complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestOffererPublishDepositTxMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestOffererPublishDepositTxMessage.java index 95d2425498..2c0657a905 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestOffererPublishDepositTxMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestOffererPublishDepositTxMessage.java @@ -37,18 +37,19 @@ public class ProcessRequestOffererPublishDepositTxMessage extends OffererTradeTa @Override protected void doRun() { try { - checkTradeId(offererTradeProcessModel.id, offererTradeProcessModel.getTradeMessage()); RequestOffererPublishDepositTxMessage message = (RequestOffererPublishDepositTxMessage) offererTradeProcessModel.getTradeMessage(); + checkTradeId(offererTradeProcessModel.getId(), message); + checkNotNull(message); - offererTradeProcessModel.taker.fiatAccount = checkNotNull(message.takerFiatAccount); - offererTradeProcessModel.taker.accountId = nonEmptyStringOf(message.takerAccountId); - offererTradeProcessModel.taker.p2pSigPublicKey = checkNotNull(message.takerP2PSigPublicKey); - offererTradeProcessModel.taker.p2pEncryptPubKey = checkNotNull(message.takerP2PEncryptPublicKey); - offererTradeProcessModel.taker.contractAsJson = nonEmptyStringOf(message.takerContractAsJson); - offererTradeProcessModel.taker.contractSignature = nonEmptyStringOf(message.takerContractSignature); - offererTradeProcessModel.taker.payoutAddressString = nonEmptyStringOf(message.takerPayoutAddressString); - offererTradeProcessModel.taker.preparedDepositTx = checkNotNull(message.takersPreparedDepositTx); - offererTradeProcessModel.taker.connectedOutputsForAllInputs = checkNotNull(message.takerConnectedOutputsForAllInputs); + offererTradeProcessModel.taker.setFiatAccount(checkNotNull(message.takerFiatAccount)); + offererTradeProcessModel.taker.setAccountId(nonEmptyStringOf(message.takerAccountId)); + offererTradeProcessModel.taker.setP2pSigPublicKey(checkNotNull(message.takerP2PSigPublicKey)); + offererTradeProcessModel.taker.setP2pEncryptPubKey(checkNotNull(message.takerP2PEncryptPublicKey)); + offererTradeProcessModel.taker.setContractAsJson(nonEmptyStringOf(message.takerContractAsJson)); + offererTradeProcessModel.taker.setContractSignature(nonEmptyStringOf(message.takerContractSignature)); + offererTradeProcessModel.taker.setPayoutAddressString(nonEmptyStringOf(message.takerPayoutAddressString)); + offererTradeProcessModel.taker.setPreparedDepositTx(checkNotNull(message.takersPreparedDepositTx)); + offererTradeProcessModel.taker.setConnectedOutputsForAllInputs(checkNotNull(message.takerConnectedOutputsForAllInputs)); checkArgument(message.takerConnectedOutputsForAllInputs.size() > 0); complete(); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/RequestTakerDepositPayment.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/RequestTakerDepositPayment.java index c0981bed4d..9e674b7977 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/RequestTakerDepositPayment.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/RequestTakerDepositPayment.java @@ -36,16 +36,16 @@ public class RequestTakerDepositPayment extends OffererTradeTask { protected void doRun() { try { RequestTakerDepositPaymentMessage tradeMessage = new RequestTakerDepositPaymentMessage( - offererTradeProcessModel.id, - offererTradeProcessModel.offerer.connectedOutputsForAllInputs, - offererTradeProcessModel.offerer.outputs, - offererTradeProcessModel.offerer.tradeWalletPubKey, - offererTradeProcessModel.offerer.p2pSigPubKey, - offererTradeProcessModel.offerer.p2pEncryptPubKey, - offererTradeProcessModel.offerer.fiatAccount, - offererTradeProcessModel.offerer.accountId); + offererTradeProcessModel.getId(), + offererTradeProcessModel.offerer.getConnectedOutputsForAllInputs(), + offererTradeProcessModel.offerer.getOutputs(), + offererTradeProcessModel.offerer.getTradeWalletPubKey(), + offererTradeProcessModel.offerer.getP2pSigPubKey(), + offererTradeProcessModel.offerer.getP2pEncryptPubKey(), + offererTradeProcessModel.offerer.getFiatAccount(), + offererTradeProcessModel.offerer.getAccountId()); - offererTradeProcessModel.messageService.sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { + offererTradeProcessModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { @Override public void handleResult() { log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer"); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SendBankTransferStartedMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SendBankTransferStartedMessage.java index 053bf1226d..20d04bfae7 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SendBankTransferStartedMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SendBankTransferStartedMessage.java @@ -35,15 +35,15 @@ public class SendBankTransferStartedMessage extends OffererTradeTask { @Override protected void doRun() { try { - FiatTransferStartedMessage tradeMessage = new FiatTransferStartedMessage(offererTradeProcessModel.id, - offererTradeProcessModel.offerer.payoutTxSignature, - offererTradeProcessModel.offerer.payoutAmount, - offererTradeProcessModel.taker.payoutAmount, - offererTradeProcessModel.offerer.addressEntry.getAddressString()); + FiatTransferStartedMessage tradeMessage = new FiatTransferStartedMessage(offererTradeProcessModel.getId(), + offererTradeProcessModel.offerer.getPayoutTxSignature(), + offererTradeProcessModel.offerer.getPayoutAmount(), + offererTradeProcessModel.taker.getPayoutAmount(), + offererTradeProcessModel.offerer.getAddressEntry().getAddressString()); - offererTradeProcessModel.messageService.sendMessage(offererTrade.getTradingPeer(), tradeMessage, - offererTradeProcessModel.taker.p2pSigPublicKey, - offererTradeProcessModel.taker.p2pEncryptPubKey, + offererTradeProcessModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, + offererTradeProcessModel.taker.getP2pSigPublicKey(), + offererTradeProcessModel.taker.getP2pEncryptPubKey(), new SendMessageListener() { @Override public void handleResult() { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SendDepositTxToTaker.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SendDepositTxToTaker.java index 115ac17416..658901a3bf 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SendDepositTxToTaker.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SendDepositTxToTaker.java @@ -35,9 +35,9 @@ public class SendDepositTxToTaker extends OffererTradeTask { @Override protected void doRun() { try { - DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(offererTradeProcessModel.id, offererTrade.getDepositTx()); + DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(offererTradeProcessModel.getId(), offererTrade.getDepositTx()); - offererTradeProcessModel.messageService.sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { + offererTradeProcessModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { @Override public void handleResult() { log.trace("DepositTxPublishedMessage successfully arrived at peer"); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SignAndPublishDepositTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SignAndPublishDepositTx.java index b5dc0f06fe..f6a03f07ad 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SignAndPublishDepositTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SignAndPublishDepositTx.java @@ -42,15 +42,15 @@ public class SignAndPublishDepositTx extends OffererTradeTask { protected void doRun() { try { Coin offererInputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE); - offererTradeProcessModel.tradeWalletService.offererSignsAndPublishDepositTx( - offererTradeProcessModel.taker.preparedDepositTx, - offererTradeProcessModel.offerer.connectedOutputsForAllInputs, - offererTradeProcessModel.taker.connectedOutputsForAllInputs, - offererTradeProcessModel.offerer.outputs, + offererTradeProcessModel.getTradeWalletService().offererSignsAndPublishDepositTx( + offererTradeProcessModel.taker.getPreparedDepositTx(), + offererTradeProcessModel.offerer.getConnectedOutputsForAllInputs(), + offererTradeProcessModel.taker.getConnectedOutputsForAllInputs(), + offererTradeProcessModel.offerer.getOutputs(), offererInputAmount, - offererTradeProcessModel.offerer.tradeWalletPubKey, - offererTradeProcessModel.taker.tradeWalletPubKey, - offererTradeProcessModel.arbitratorPubKey, + offererTradeProcessModel.offerer.getTradeWalletPubKey(), + offererTradeProcessModel.taker.getTradeWalletPubKey(), + offererTradeProcessModel.getArbitratorPubKey(), new FutureCallback() { @Override public void onSuccess(Transaction transaction) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyAndSignContract.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyAndSignContract.java index 6daab465aa..77b4efbf09 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyAndSignContract.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyAndSignContract.java @@ -36,22 +36,23 @@ public class VerifyAndSignContract extends OffererTradeTask { protected void doRun() { try { Contract contract = new Contract( - offererTradeProcessModel.offer, + offererTradeProcessModel.getOffer(), offererTrade.getTradeAmount(), offererTradeProcessModel.getTakeOfferFeeTxId(), - offererTradeProcessModel.offerer.accountId, - offererTradeProcessModel.taker.accountId, - offererTradeProcessModel.offerer.fiatAccount, - offererTradeProcessModel.taker.fiatAccount, - offererTradeProcessModel.offerer.p2pSigPubKey, - offererTradeProcessModel.taker.p2pSigPublicKey); + offererTradeProcessModel.offerer.getAccountId(), + offererTradeProcessModel.taker.getAccountId(), + offererTradeProcessModel.offerer.getFiatAccount(), + offererTradeProcessModel.taker.getFiatAccount(), + offererTradeProcessModel.offerer.getP2pSigPubKey(), + offererTradeProcessModel.taker.getP2pSigPublicKey()); String contractAsJson = Utilities.objectToJson(contract); - String signature = offererTradeProcessModel.signatureService.signMessage(offererTradeProcessModel.offerer.registrationKeyPair, contractAsJson); + String signature = offererTradeProcessModel.getSignatureService().signMessage(offererTradeProcessModel.offerer.getRegistrationKeyPair(), + contractAsJson); offererTrade.setContract(contract); offererTrade.setContractAsJson(contractAsJson); offererTrade.setOffererContractSignature(signature); - offererTrade.setTakerContractSignature(offererTradeProcessModel.taker.contractSignature); + offererTrade.setTakerContractSignature(offererTradeProcessModel.taker.getContractSignature()); complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyTakeOfferFeePayment.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyTakeOfferFeePayment.java index 0a5f4663e4..d42f4ff9ee 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyTakeOfferFeePayment.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyTakeOfferFeePayment.java @@ -34,7 +34,7 @@ public class VerifyTakeOfferFeePayment extends OffererTradeTask { protected void doRun() { try { //TODO mocked yet, need a confidence listeners - int numOfPeersSeenTx = offererTradeProcessModel.walletService.getNumOfPeersSeenTx(offererTradeProcessModel.getTakeOfferFeeTxId()); + int numOfPeersSeenTx = offererTradeProcessModel.getWalletService().getNumOfPeersSeenTx(offererTradeProcessModel.getTakeOfferFeeTxId()); /* if (numOfPeersSeenTx > 2) { resultHandler.handleResult(); }*/ diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyTakerAccount.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyTakerAccount.java index 919cc05816..f586d90e75 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyTakerAccount.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyTakerAccount.java @@ -34,9 +34,10 @@ public class VerifyTakerAccount extends OffererTradeTask { protected void doRun() { try { //TODO mocked yet - if (offererTradeProcessModel.blockChainService.verifyAccountRegistration()) { - if (offererTradeProcessModel.blockChainService.isAccountBlackListed(offererTradeProcessModel.taker.accountId, offererTradeProcessModel.taker - .fiatAccount)) { + if (offererTradeProcessModel.getBlockChainService().verifyAccountRegistration()) { + if (offererTradeProcessModel.getBlockChainService().isAccountBlackListed(offererTradeProcessModel.taker.getAccountId(), offererTradeProcessModel + .taker + .getFiatAccount())) { log.error("Taker is blacklisted"); failed("Taker is blacklisted"); } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/TakerProtocol.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/TakerProtocol.java index acd6adfd6b..b73c5baf91 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/TakerProtocol.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/TakerProtocol.java @@ -28,7 +28,7 @@ import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.RequestTakerDepositPaymentMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage; -import io.bitsquare.trade.protocol.trade.taker.models.TakerTradeProcessModel; +import io.bitsquare.trade.protocol.trade.taker.models.TakerProcessModel; import io.bitsquare.trade.protocol.trade.taker.tasks.BroadcastTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.taker.tasks.CreateAndSignContract; import io.bitsquare.trade.protocol.trade.taker.tasks.CreateTakeOfferFeeTx; @@ -53,7 +53,7 @@ public class TakerProtocol implements Protocol { private static final Logger log = LoggerFactory.getLogger(TakerProtocol.class); private final TakerTrade takerTrade; - private final TakerTradeProcessModel takerTradeProcessModel; + private final TakerProcessModel takerTradeProcessModel; private final MessageHandler messageHandler; @@ -65,9 +65,9 @@ public class TakerProtocol implements Protocol { log.debug("New SellerAsTakerProtocol " + this); this.takerTrade = takerTrade; takerTradeProcessModel = takerTrade.getProcessModel(); - + messageHandler = this::handleMessage; - takerTradeProcessModel.messageService.addMessageHandler(messageHandler); + takerTradeProcessModel.getMessageService().addMessageHandler(messageHandler); } @@ -77,7 +77,7 @@ public class TakerProtocol implements Protocol { public void cleanup() { log.debug("cleanup " + this); - takerTradeProcessModel.messageService.removeMessageHandler(messageHandler); + takerTradeProcessModel.getMessageService().removeMessageHandler(messageHandler); } public void setMailboxMessage(MailboxMessage mailboxMessage) { @@ -96,10 +96,8 @@ public class TakerProtocol implements Protocol { public void takeAvailableOffer() { TaskRunner taskRunner = new TaskRunner<>(takerTrade, - () -> { - log.debug("taskRunner at takeAvailableOffer completed"); - }, - (errorMessage) -> handleTaskRunnerFault(errorMessage)); + () -> log.debug("taskRunner at takeAvailableOffer completed"), + this::handleTaskRunnerFault); taskRunner.addTasks( CreateTakeOfferFeeTx.class, @@ -118,10 +116,8 @@ public class TakerProtocol implements Protocol { takerTradeProcessModel.setTradeMessage(tradeMessage); TaskRunner taskRunner = new TaskRunner<>(takerTrade, - () -> { - log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"); - }, - (errorMessage) -> handleTaskRunnerFault(errorMessage)); + () -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"), + this::handleTaskRunnerFault); taskRunner.addTasks( ProcessRequestTakerDepositPaymentMessage.class, @@ -137,10 +133,8 @@ public class TakerProtocol implements Protocol { takerTradeProcessModel.setTradeMessage(tradeMessage); TaskRunner taskRunner = new TaskRunner<>(takerTrade, - () -> { - log.debug("taskRunner at handleDepositTxPublishedMessage completed"); - }, - (errorMessage) -> handleTaskRunnerFault(errorMessage)); + () -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"), + this::handleTaskRunnerFault); taskRunner.addTasks( ProcessDepositTxPublishedMessage.class, @@ -153,10 +147,8 @@ public class TakerProtocol implements Protocol { takerTradeProcessModel.setTradeMessage(tradeMessage); TaskRunner taskRunner = new TaskRunner<>(takerTrade, - () -> { - log.debug("taskRunner at handleFiatTransferStartedMessage completed"); - }, - (errorMessage) -> handleTaskRunnerFault(errorMessage)); + () -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"), + this::handleTaskRunnerFault); taskRunner.addTasks(ProcessFiatTransferStartedMessage.class); taskRunner.run(); @@ -178,7 +170,7 @@ public class TakerProtocol implements Protocol { // we are done! takerTradeProcessModel.onComplete(); }, - (errorMessage) -> handleTaskRunnerFault(errorMessage)); + this::handleTaskRunnerFault); taskRunner.addTasks( SignAndPublishPayoutTx.class, @@ -198,7 +190,7 @@ public class TakerProtocol implements Protocol { TradeMessage tradeMessage = (TradeMessage) message; nonEmptyStringOf(tradeMessage.tradeId); - if (tradeMessage.tradeId.equals(takerTradeProcessModel.id)) { + if (tradeMessage.tradeId.equals(takerTradeProcessModel.getId())) { if (tradeMessage instanceof RequestTakerDepositPaymentMessage) { handleRequestTakerDepositPaymentMessage((RequestTakerDepositPaymentMessage) tradeMessage); } @@ -216,6 +208,7 @@ public class TakerProtocol implements Protocol { } private void handleTaskRunnerFault(String errorMessage) { + log.error(errorMessage); cleanup(); } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/Offerer.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/Offerer.java index 84f09cfdda..06f6705b97 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/Offerer.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/Offerer.java @@ -22,29 +22,164 @@ import io.bitsquare.fiat.FiatAccount; import org.bitcoinj.core.Coin; import org.bitcoinj.core.TransactionOutput; +import java.io.IOException; +import java.io.ObjectInputStream; import java.io.Serializable; import java.security.PublicKey; +import java.util.Arrays; import java.util.List; +import javax.annotation.Nullable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Fully serializable, no transient fields + */ public class Offerer implements Serializable { // That object is saved to disc. We need to take care of changes to not break deserialization. private static final long serialVersionUID = 1L; + transient private static final Logger log = LoggerFactory.getLogger(Offerer.class); + + // Mutable + private byte[] tradeWalletPubKey; + private Coin payoutAmount; + private String payoutAddressString; + private List connectedOutputsForAllInputs; + private List outputs; + private byte[] signature; + private FiatAccount fiatAccount; + private String accountId; + private PublicKey p2pSigPublicKey; + private PublicKey p2pEncryptPubKey; + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Constructor, initialization + /////////////////////////////////////////////////////////////////////////////////////////// + public Offerer() { + log.trace("Created by constructor"); } - // written by tasks - public byte[] tradeWalletPubKey; - public Coin payoutAmount; - public String payoutAddressString; - public List connectedOutputsForAllInputs; - public List outputs; - public byte[] signature; - public FiatAccount fiatAccount; - public String accountId; - public PublicKey p2pSigPublicKey; - public PublicKey p2pEncryptPubKey; + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + } + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter/Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + @Nullable + public byte[] getTradeWalletPubKey() { + return tradeWalletPubKey; + } + + public void setTradeWalletPubKey(byte[] tradeWalletPubKey) { + this.tradeWalletPubKey = tradeWalletPubKey; + } + + @Nullable + public Coin getPayoutAmount() { + return payoutAmount; + } + + public void setPayoutAmount(Coin payoutAmount) { + this.payoutAmount = payoutAmount; + } + + @Nullable + public String getPayoutAddressString() { + return payoutAddressString; + } + + public void setPayoutAddressString(String payoutAddressString) { + this.payoutAddressString = payoutAddressString; + } + + @Nullable + public List getConnectedOutputsForAllInputs() { + return connectedOutputsForAllInputs; + } + + public void setConnectedOutputsForAllInputs(List connectedOutputsForAllInputs) { + this.connectedOutputsForAllInputs = connectedOutputsForAllInputs; + } + + @Nullable + public List getOutputs() { + return outputs; + } + + public void setOutputs(List outputs) { + this.outputs = outputs; + } + + @Nullable + public byte[] getSignature() { + return signature; + } + + public void setSignature(byte[] signature) { + this.signature = signature; + } + + @Nullable + public FiatAccount getFiatAccount() { + return fiatAccount; + } + + public void setFiatAccount(FiatAccount fiatAccount) { + this.fiatAccount = fiatAccount; + } + + @Nullable + public String getAccountId() { + return accountId; + } + + public void setAccountId(String accountId) { + this.accountId = accountId; + } + + @Nullable + public PublicKey getP2pSigPublicKey() { + return p2pSigPublicKey; + } + + public void setP2pSigPublicKey(PublicKey p2pSigPublicKey) { + this.p2pSigPublicKey = p2pSigPublicKey; + } + + @Nullable + public PublicKey getP2pEncryptPubKey() { + return p2pEncryptPubKey; + } + + public void setP2pEncryptPubKey(PublicKey p2pEncryptPubKey) { + this.p2pEncryptPubKey = p2pEncryptPubKey; + } + + + @Override + public String toString() { + return "Offerer{" + + "tradeWalletPubKey=" + Arrays.toString(tradeWalletPubKey) + + ", payoutAmount=" + payoutAmount + + ", payoutAddressString='" + payoutAddressString + '\'' + + ", connectedOutputsForAllInputs=" + connectedOutputsForAllInputs + + ", outputs=" + outputs + + ", signature=" + Arrays.toString(signature) + + ", fiatAccount=" + fiatAccount + + ", accountId='" + accountId + '\'' + + ", p2pSigPublicKey=" + p2pSigPublicKey + + ", p2pEncryptPubKey=" + p2pEncryptPubKey + + '}'; + } } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/Taker.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/Taker.java index b691685ba9..20b252813a 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/Taker.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/Taker.java @@ -18,39 +18,147 @@ package io.bitsquare.trade.protocol.trade.taker.models; import io.bitsquare.btc.AddressEntry; +import io.bitsquare.btc.WalletService; import io.bitsquare.fiat.FiatAccount; +import io.bitsquare.offer.Offer; +import io.bitsquare.user.User; import org.bitcoinj.core.Coin; import org.bitcoinj.core.Transaction; import org.bitcoinj.core.TransactionOutput; import org.bitcoinj.crypto.DeterministicKey; +import java.io.IOException; +import java.io.ObjectInputStream; import java.io.Serializable; import java.security.PublicKey; import java.util.List; +import javax.annotation.Nullable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + public class Taker implements Serializable { // That object is saved to disc. We need to take care of changes to not break deserialization. private static final long serialVersionUID = 1L; + transient private static final Logger log = LoggerFactory.getLogger(Taker.class); + + // Transient/Immutable + transient private Offer offer; + transient private WalletService walletService; + transient private User user; + + // Mutable + private List connectedOutputsForAllInputs; + private Coin payoutAmount; + private Transaction preparedDepositTx; + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Constructor, initialization + /////////////////////////////////////////////////////////////////////////////////////////// public Taker() { + log.trace("Created by constructor"); } - public FiatAccount fiatAccount; - public String accountId; - public PublicKey p2pSigPubKey; - public PublicKey p2pEncryptPublicKey; - public byte[] registrationPubKey; // TODO not read yet, missing impl. - transient public DeterministicKey registrationKeyPair; - public AddressEntry addressEntry; - public byte[] tradeWalletPubKey; + private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + } - // written by tasks - public List connectedOutputsForAllInputs; - public List outputs; - public Coin payoutAmount; - public Transaction preparedDepositTx; + // We need to wait until backend services are ready to set the required dependencies + public void onAllServicesInitialized(Offer offer, + WalletService walletService, + User user) { + log.trace("onBackendReady"); + this.offer = offer; + this.walletService = walletService; + this.user = user; + } + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter only + /////////////////////////////////////////////////////////////////////////////////////////// + + public FiatAccount getFiatAccount() { + return user.getFiatAccount(offer.getBankAccountId()); + } + + public DeterministicKey getRegistrationKeyPair() { + return walletService.getRegistrationAddressEntry().getKeyPair(); + } + + public String getAccountId() { + return user.getAccountId(); + } + + public PublicKey getP2pSigPubKey() { + return user.getP2PSigPubKey(); + } + + public PublicKey getP2pEncryptPublicKey() { + return user.getP2PEncryptPubKey(); + } + + public byte[] getRegistrationPubKey() { + return walletService.getRegistrationAddressEntry().getPubKey(); + } + + public AddressEntry getAddressEntry() { + return walletService.getAddressEntry(offer.getId()); + } + + public byte[] getTradeWalletPubKey() { + return getAddressEntry().getPubKey(); + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter/Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + @Nullable + public List getConnectedOutputsForAllInputs() { + return connectedOutputsForAllInputs; + } + + public void setConnectedOutputsForAllInputs(List connectedOutputsForAllInputs) { + this.connectedOutputsForAllInputs = connectedOutputsForAllInputs; + } + + @Nullable + public Coin getPayoutAmount() { + return payoutAmount; + } + + public void setPayoutAmount(Coin payoutAmount) { + this.payoutAmount = payoutAmount; + } + + @Nullable + public Transaction getPreparedDepositTx() { + return preparedDepositTx; + } + + public void setPreparedDepositTx(Transaction preparedDepositTx) { + this.preparedDepositTx = preparedDepositTx; + } + + @Override + public String toString() { + return "Taker{" + + "offer=" + offer + + ", walletService=" + walletService + + ", user=" + user + + ", connectedOutputsForAllInputs=" + connectedOutputsForAllInputs + + ", payoutAmount=" + payoutAmount + + ", preparedDepositTx=" + preparedDepositTx + + '}'; + } } diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerProcessModel.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerProcessModel.java new file mode 100644 index 0000000000..e990d2c1c2 --- /dev/null +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerProcessModel.java @@ -0,0 +1,130 @@ +/* + * 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 . + */ + +package io.bitsquare.trade.protocol.trade.taker.models; + +import io.bitsquare.arbitration.ArbitrationRepository; +import io.bitsquare.btc.BlockChainService; +import io.bitsquare.btc.TradeWalletService; +import io.bitsquare.btc.WalletService; +import io.bitsquare.crypto.SignatureService; +import io.bitsquare.offer.Offer; +import io.bitsquare.p2p.MessageService; +import io.bitsquare.trade.protocol.trade.ProcessModel; +import io.bitsquare.user.User; + +import org.bitcoinj.core.Transaction; + +import java.io.IOException; +import java.io.Serializable; + +import javax.annotation.Nullable; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Fully serializable, no transient fields + *

+ * Holds all data which are needed between tasks. All relevant data for the trade itself are stored in Trade. + */ +public class TakerProcessModel extends ProcessModel implements Serializable { + // That object is saved to disc. We need to take care of changes to not break deserialization. + private static final long serialVersionUID = 1L; + + transient private static final Logger log = LoggerFactory.getLogger(TakerProcessModel.class); + + // Immutable + public final Taker taker; + public final Offerer offerer; + + // Mutable + private Transaction takeOfferFeeTx; + private Transaction payoutTx; + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Constructor, initialization + /////////////////////////////////////////////////////////////////////////////////////////// + + public TakerProcessModel() { + log.trace("Created by constructor"); + taker = new Taker(); + offerer = new Offerer(); + } + + private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException { + in.defaultReadObject(); + log.trace("Created from serialized form."); + } + + @Override + public void onAllServicesInitialized(Offer offer, + MessageService messageService, + WalletService walletService, + TradeWalletService tradeWalletService, + BlockChainService blockChainService, + SignatureService signatureService, + ArbitrationRepository arbitrationRepository, + User user) { + log.trace("onAllServicesInitialized"); + super.onAllServicesInitialized(offer, + messageService, + walletService, + tradeWalletService, + blockChainService, + signatureService, + arbitrationRepository, + user); + + taker.onAllServicesInitialized(offer, walletService, user); + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + // Getter/Setter for Mutable objects + /////////////////////////////////////////////////////////////////////////////////////////// + + @Nullable + public Transaction getPayoutTx() { + return payoutTx; + } + + public void setPayoutTx(Transaction payoutTx) { + this.payoutTx = payoutTx; + } + + @Nullable + public Transaction getTakeOfferFeeTx() { + return takeOfferFeeTx; + } + + public void setTakeOfferFeeTx(Transaction takeOfferFeeTx) { + this.takeOfferFeeTx = takeOfferFeeTx; + } + + + @Override + public String toString() { + return "TakerProcessModel{" + + "taker=" + taker + + ", offerer=" + offerer + + ", takeOfferFeeTx=" + takeOfferFeeTx + + ", payoutTx=" + payoutTx + + '}'; + } +} diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerTradeProcessModel.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerTradeProcessModel.java deleted file mode 100644 index a21d1ae13c..0000000000 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerTradeProcessModel.java +++ /dev/null @@ -1,109 +0,0 @@ -/* - * 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 . - */ - -package io.bitsquare.trade.protocol.trade.taker.models; - -import io.bitsquare.arbitration.ArbitrationRepository; -import io.bitsquare.btc.BlockChainService; -import io.bitsquare.btc.TradeWalletService; -import io.bitsquare.btc.WalletService; -import io.bitsquare.crypto.SignatureService; -import io.bitsquare.offer.Offer; -import io.bitsquare.p2p.MailboxService; -import io.bitsquare.p2p.MessageService; -import io.bitsquare.trade.protocol.trade.TradeProcessModel; -import io.bitsquare.user.User; - -import org.bitcoinj.core.Transaction; - -import java.io.Serializable; - -import javax.annotation.Nullable; - -import org.jetbrains.annotations.NotNull; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -/** - * Holds all data which are needed between tasks. All relevant data for the trade itself are stored in Trade. - */ -public class TakerTradeProcessModel extends TradeProcessModel implements Serializable { - // That object is saved to disc. We need to take care of changes to not break deserialization. - private static final long serialVersionUID = 1L; - - transient private static final Logger log = LoggerFactory.getLogger(TakerTradeProcessModel.class); - - public final Taker taker = new Taker(); - public final Offerer offerer = new Offerer(); - - // written by tasks - @Nullable private Transaction takeOfferFeeTx; - @Nullable private Transaction payoutTx; - - public TakerTradeProcessModel(){ - } - - public void init(@NotNull Offer offer, - @NotNull MessageService messageService, - @NotNull MailboxService mailboxService, - @NotNull WalletService walletService, - @NotNull TradeWalletService tradeWalletService, - @NotNull BlockChainService blockChainService, - @NotNull SignatureService signatureService, - @NotNull ArbitrationRepository arbitrationRepository, - @NotNull User user) { - - super.init(offer, - messageService, - mailboxService, - walletService, - tradeWalletService, - blockChainService, - signatureService, - arbitrationRepository, - user); - - taker.registrationPubKey = walletService.getRegistrationAddressEntry().getPubKey(); - taker.registrationKeyPair = walletService.getRegistrationAddressEntry().getKeyPair(); - taker.addressEntry = walletService.getAddressEntry(id); - taker.fiatAccount = user.getFiatAccount(offer.getBankAccountId()); - taker.accountId = user.getAccountId(); - taker.p2pSigPubKey = user.getP2PSigPubKey(); - taker.p2pEncryptPublicKey = user.getP2PEncryptPubKey(); - taker.tradeWalletPubKey = taker.addressEntry.getPubKey(); - } - - public void setPayoutTx(@NotNull Transaction payoutTx) { - this.payoutTx = payoutTx; - } - - public void setTakeOfferFeeTx(@NotNull Transaction takeOfferFeeTx) { - this.takeOfferFeeTx = takeOfferFeeTx; - } - - @Nullable - public Transaction getTakeOfferFeeTx() { - return takeOfferFeeTx; - } - - @Nullable - public Transaction getPayoutTx() { - return payoutTx; - } - -} diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/BroadcastTakeOfferFeeTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/BroadcastTakeOfferFeeTx.java index a5dabca49d..ef8272b4d3 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/BroadcastTakeOfferFeeTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/BroadcastTakeOfferFeeTx.java @@ -39,7 +39,7 @@ public class BroadcastTakeOfferFeeTx extends TakerTradeTask { @Override protected void doRun() { try { - takerTradeProcessModel.tradeWalletService.broadcastTakeOfferFeeTx(takerTradeProcessModel.getTakeOfferFeeTx(), + takerTradeProcessModel.getTradeWalletService().broadcastTakeOfferFeeTx(takerTradeProcessModel.getTakeOfferFeeTx(), new FutureCallback() { @Override public void onSuccess(Transaction transaction) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/CreateAndSignContract.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/CreateAndSignContract.java index a71719d3f8..0db9b491a7 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/CreateAndSignContract.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/CreateAndSignContract.java @@ -35,18 +35,19 @@ public class CreateAndSignContract extends TakerTradeTask { @Override protected void doRun() { try { + assert takerTradeProcessModel.getTakeOfferFeeTx() != null; Contract contract = new Contract( - takerTradeProcessModel.offer, + takerTradeProcessModel.getOffer(), model.getTradeAmount(), takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString(), - takerTradeProcessModel.offerer.accountId, - takerTradeProcessModel.taker.accountId, - takerTradeProcessModel.offerer.fiatAccount, - takerTradeProcessModel.taker.fiatAccount, - takerTradeProcessModel.offer.getP2PSigPubKey(), - takerTradeProcessModel.taker.p2pSigPubKey); + takerTradeProcessModel.offerer.getAccountId(), + takerTradeProcessModel.taker.getAccountId(), + takerTradeProcessModel.offerer.getFiatAccount(), + takerTradeProcessModel.taker.getFiatAccount(), + takerTradeProcessModel.getOffer().getP2PSigPubKey(), + takerTradeProcessModel.taker.getP2pSigPubKey()); String contractAsJson = Utilities.objectToJson(contract); - String signature = takerTradeProcessModel.signatureService.signMessage(takerTradeProcessModel.taker.registrationKeyPair, contractAsJson); + String signature = takerTradeProcessModel.getSignatureService().signMessage(takerTradeProcessModel.taker.getRegistrationKeyPair(), contractAsJson); model.setContract(contract); model.setContractAsJson(contractAsJson); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/CreateTakeOfferFeeTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/CreateTakeOfferFeeTx.java index baeeaf4431..061445d61a 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/CreateTakeOfferFeeTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/CreateTakeOfferFeeTx.java @@ -35,7 +35,8 @@ public class CreateTakeOfferFeeTx extends TakerTradeTask { @Override protected void doRun() { try { - Transaction createTakeOfferFeeTx = takerTradeProcessModel.tradeWalletService.createTakeOfferFeeTx(takerTradeProcessModel.taker.addressEntry); + Transaction createTakeOfferFeeTx = takerTradeProcessModel.getTradeWalletService().createTakeOfferFeeTx(takerTradeProcessModel.taker + .getAddressEntry()); takerTradeProcessModel.setTakeOfferFeeTx(createTakeOfferFeeTx); takerTrade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_TX_CREATED); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessDepositTxPublishedMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessDepositTxPublishedMessage.java index decfb66e93..8e6e7045e7 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessDepositTxPublishedMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessDepositTxPublishedMessage.java @@ -37,9 +37,10 @@ public class ProcessDepositTxPublishedMessage extends TakerTradeTask { @Override protected void doRun() { try { - checkTradeId(takerTradeProcessModel.id, takerTradeProcessModel.getTradeMessage()); - DepositTxPublishedMessage message = (DepositTxPublishedMessage) takerTradeProcessModel.getTradeMessage(); + checkTradeId(takerTradeProcessModel.getId(), message); + checkNotNull(message); + takerTrade.setDepositTx(checkNotNull(message.depositTx)); takerTrade.setProcessState(TakerTrade.TakerProcessState.DEPOSIT_PUBLISHED); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessFiatTransferStartedMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessFiatTransferStartedMessage.java index e77869e74d..3ee2341f2d 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessFiatTransferStartedMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessFiatTransferStartedMessage.java @@ -37,13 +37,14 @@ public class ProcessFiatTransferStartedMessage extends TakerTradeTask { @Override protected void doRun() { try { - checkTradeId(takerTradeProcessModel.id, takerTradeProcessModel.getTradeMessage()); FiatTransferStartedMessage message = (FiatTransferStartedMessage) takerTradeProcessModel.getTradeMessage(); + checkTradeId(takerTradeProcessModel.getId(), message); + checkNotNull(message); - takerTradeProcessModel.offerer.signature = checkNotNull(message.offererSignature); - takerTradeProcessModel.offerer.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.offererPayoutAmount)); - takerTradeProcessModel.taker.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.takerPayoutAmount)); - takerTradeProcessModel.offerer.payoutAddressString = nonEmptyStringOf(message.offererPayoutAddress); + takerTradeProcessModel.offerer.setSignature(checkNotNull(message.offererSignature)); + takerTradeProcessModel.offerer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.offererPayoutAmount))); + takerTradeProcessModel.taker.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.takerPayoutAmount))); + takerTradeProcessModel.offerer.setPayoutAddressString(nonEmptyStringOf(message.offererPayoutAddress)); takerTrade.setProcessState(TakerTrade.TakerProcessState.FIAT_PAYMENT_STARTED); complete(); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessRequestTakerDepositPaymentMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessRequestTakerDepositPaymentMessage.java index db78dcd798..7536367ce0 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessRequestTakerDepositPaymentMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessRequestTakerDepositPaymentMessage.java @@ -37,17 +37,18 @@ public class ProcessRequestTakerDepositPaymentMessage extends TakerTradeTask { @Override protected void doRun() { try { - checkTradeId(takerTradeProcessModel.id, takerTradeProcessModel.getTradeMessage()); RequestTakerDepositPaymentMessage message = (RequestTakerDepositPaymentMessage) takerTradeProcessModel.getTradeMessage(); + checkTradeId(takerTradeProcessModel.getId(), message); + checkNotNull(message); - takerTradeProcessModel.offerer.connectedOutputsForAllInputs = checkNotNull(message.offererConnectedOutputsForAllInputs); + takerTradeProcessModel.offerer.setConnectedOutputsForAllInputs(checkNotNull(message.offererConnectedOutputsForAllInputs)); checkArgument(message.offererConnectedOutputsForAllInputs.size() > 0); - takerTradeProcessModel.offerer.outputs = checkNotNull(message.offererOutputs); - takerTradeProcessModel.offerer.tradeWalletPubKey = checkNotNull(message.offererTradeWalletPubKey); - takerTradeProcessModel.offerer.p2pSigPublicKey = checkNotNull(message.offererP2PSigPublicKey); - takerTradeProcessModel.offerer.p2pEncryptPubKey = checkNotNull(message.offererP2PEncryptPublicKey); - takerTradeProcessModel.offerer.fiatAccount = checkNotNull(message.offererFiatAccount); - takerTradeProcessModel.offerer.accountId = nonEmptyStringOf(message.offererAccountId); + takerTradeProcessModel.offerer.setOutputs(checkNotNull(message.offererOutputs)); + takerTradeProcessModel.offerer.setTradeWalletPubKey(checkNotNull(message.offererTradeWalletPubKey)); + takerTradeProcessModel.offerer.setP2pSigPublicKey(checkNotNull(message.offererP2PSigPublicKey)); + takerTradeProcessModel.offerer.setP2pEncryptPubKey(checkNotNull(message.offererP2PEncryptPublicKey)); + takerTradeProcessModel.offerer.setFiatAccount(checkNotNull(message.offererFiatAccount)); + takerTradeProcessModel.offerer.setAccountId(nonEmptyStringOf(message.offererAccountId)); complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendPayoutTxToOfferer.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendPayoutTxToOfferer.java index 6acc78bf5c..f2f5fdb670 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendPayoutTxToOfferer.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendPayoutTxToOfferer.java @@ -35,11 +35,11 @@ public class SendPayoutTxToOfferer extends TakerTradeTask { @Override protected void doRun() { try { - PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(takerTradeProcessModel.id, takerTradeProcessModel.getPayoutTx()); - takerTradeProcessModel.messageService.sendMessage(takerTrade.getTradingPeer(), + PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(takerTradeProcessModel.getId(), takerTradeProcessModel.getPayoutTx()); + takerTradeProcessModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage, - takerTradeProcessModel.offerer.p2pSigPublicKey, - takerTradeProcessModel.offerer.p2pEncryptPubKey, + takerTradeProcessModel.offerer.getP2pSigPublicKey(), + takerTradeProcessModel.offerer.getP2pEncryptPubKey(), new SendMessageListener() { @Override public void handleResult() { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendRequestDepositTxInputsMessage.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendRequestDepositTxInputsMessage.java index 8d3490a107..933d2897c8 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendRequestDepositTxInputsMessage.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendRequestDepositTxInputsMessage.java @@ -39,13 +39,14 @@ public class SendRequestDepositTxInputsMessage extends TakerTradeTask { @Override protected void doRun() { try { + assert takerTradeProcessModel.getTakeOfferFeeTx() != null; RequestDepositTxInputsMessage msg = new RequestDepositTxInputsMessage( - takerTradeProcessModel.id, + takerTradeProcessModel.getId(), takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString(), takerTrade.getTradeAmount(), - takerTradeProcessModel.taker.tradeWalletPubKey); + takerTradeProcessModel.taker.getTradeWalletPubKey()); - takerTradeProcessModel.messageService.sendMessage(takerTrade.getTradingPeer(), msg, new SendMessageListener() { + takerTradeProcessModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), msg, new SendMessageListener() { @Override public void handleResult() { log.trace("Sending TakeOfferFeePayedMessage succeeded."); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendSignedTakerDepositTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendSignedTakerDepositTx.java index ac079fe1d7..3a9574862d 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendSignedTakerDepositTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendSignedTakerDepositTx.java @@ -36,20 +36,19 @@ public class SendSignedTakerDepositTx extends TakerTradeTask { protected void doRun() { try { RequestOffererPublishDepositTxMessage tradeMessage = new RequestOffererPublishDepositTxMessage( - takerTradeProcessModel.id, - takerTradeProcessModel.taker.fiatAccount, - takerTradeProcessModel.taker.accountId, - takerTradeProcessModel.taker.p2pSigPubKey, - takerTradeProcessModel.taker.p2pEncryptPublicKey, + takerTradeProcessModel.getId(), + takerTradeProcessModel.taker.getFiatAccount(), + takerTradeProcessModel.taker.getAccountId(), + takerTradeProcessModel.taker.getP2pSigPubKey(), + takerTradeProcessModel.taker.getP2pEncryptPublicKey(), takerTrade.getContractAsJson(), takerTrade.getTakerContractSignature(), - takerTradeProcessModel.taker.addressEntry.getAddressString(), - takerTradeProcessModel.taker.preparedDepositTx, - takerTradeProcessModel.taker.connectedOutputsForAllInputs, - takerTradeProcessModel.taker.outputs + takerTradeProcessModel.taker.getAddressEntry().getAddressString(), + takerTradeProcessModel.taker.getPreparedDepositTx(), + takerTradeProcessModel.taker.getConnectedOutputsForAllInputs() ); - takerTradeProcessModel.messageService.sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { + takerTradeProcessModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { @Override public void handleResult() { complete(); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SignAndPublishPayoutTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SignAndPublishPayoutTx.java index 012dfa47cd..6418fac008 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SignAndPublishPayoutTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SignAndPublishPayoutTx.java @@ -39,16 +39,16 @@ public class SignAndPublishPayoutTx extends TakerTradeTask { @Override protected void doRun() { try { - takerTradeProcessModel.tradeWalletService.takerSignsAndPublishPayoutTx( + takerTradeProcessModel.getTradeWalletService().takerSignsAndPublishPayoutTx( takerTrade.getDepositTx(), - takerTradeProcessModel.offerer.signature, - takerTradeProcessModel.offerer.payoutAmount, - takerTradeProcessModel.taker.payoutAmount, - takerTradeProcessModel.offerer.payoutAddressString, - takerTradeProcessModel.taker.addressEntry, - takerTradeProcessModel.offerer.tradeWalletPubKey, - takerTradeProcessModel.taker.tradeWalletPubKey, - takerTradeProcessModel.arbitratorPubKey, + takerTradeProcessModel.offerer.getSignature(), + takerTradeProcessModel.offerer.getPayoutAmount(), + takerTradeProcessModel.taker.getPayoutAmount(), + takerTradeProcessModel.offerer.getPayoutAddressString(), + takerTradeProcessModel.taker.getAddressEntry(), + takerTradeProcessModel.offerer.getTradeWalletPubKey(), + takerTradeProcessModel.taker.getTradeWalletPubKey(), + takerTradeProcessModel.getArbitratorPubKey(), new FutureCallback() { @Override public void onSuccess(Transaction transaction) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerCommitDepositTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerCommitDepositTx.java index d65db29a2b..37222f9399 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerCommitDepositTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerCommitDepositTx.java @@ -36,7 +36,7 @@ public class TakerCommitDepositTx extends TakerTradeTask { protected void doRun() { try { // To access tx confidence we need to add that tx into our wallet. - Transaction depositTx = takerTradeProcessModel.tradeWalletService.commitsDepositTx(takerTrade.getDepositTx()); + Transaction depositTx = takerTradeProcessModel.getTradeWalletService().commitsDepositTx(takerTrade.getDepositTx()); takerTrade.setDepositTx(depositTx); diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerCreatesAndSignsDepositTx.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerCreatesAndSignsDepositTx.java index dfd87708db..21a9a4c3f0 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerCreatesAndSignsDepositTx.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerCreatesAndSignsDepositTx.java @@ -37,23 +37,23 @@ public class TakerCreatesAndSignsDepositTx extends TakerTradeTask { @Override protected void doRun() { try { + assert takerTrade.getTradeAmount() != null; Coin takerInputAmount = takerTrade.getTradeAmount().add(takerTrade.getSecurityDeposit()).add(FeePolicy.TX_FEE); Coin msOutputAmount = takerInputAmount.add(takerTrade.getSecurityDeposit()); - TradeWalletService.Result result = takerTradeProcessModel.tradeWalletService.takerCreatesAndSignsDepositTx( + TradeWalletService.Result result = takerTradeProcessModel.getTradeWalletService().takerCreatesAndSignsDepositTx( takerInputAmount, msOutputAmount, - takerTradeProcessModel.offerer.connectedOutputsForAllInputs, - takerTradeProcessModel.offerer.outputs, - takerTradeProcessModel.taker.addressEntry, - takerTradeProcessModel.offerer.tradeWalletPubKey, - takerTradeProcessModel.taker.tradeWalletPubKey, - takerTradeProcessModel.arbitratorPubKey); + takerTradeProcessModel.offerer.getConnectedOutputsForAllInputs(), + takerTradeProcessModel.offerer.getOutputs(), + takerTradeProcessModel.taker.getAddressEntry(), + takerTradeProcessModel.offerer.getTradeWalletPubKey(), + takerTradeProcessModel.taker.getTradeWalletPubKey(), + takerTradeProcessModel.getArbitratorPubKey()); - takerTradeProcessModel.taker.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs(); - takerTradeProcessModel.taker.outputs = result.getOutputs(); - takerTradeProcessModel.taker.preparedDepositTx = result.getDepositTx(); + takerTradeProcessModel.taker.setConnectedOutputsForAllInputs(result.getConnectedOutputsForAllInputs()); + takerTradeProcessModel.taker.setPreparedDepositTx(result.getDepositTx()); complete(); } catch (Throwable t) { diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerTradeTask.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerTradeTask.java index cc5589263a..60479de946 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerTradeTask.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerTradeTask.java @@ -23,17 +23,17 @@ import io.bitsquare.btc.exceptions.WalletException; import io.bitsquare.common.taskrunner.Task; import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.trade.TakerTrade; -import io.bitsquare.trade.protocol.trade.taker.models.TakerTradeProcessModel; +import io.bitsquare.trade.protocol.trade.taker.models.TakerProcessModel; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class TakerTradeTask extends Task { +class TakerTradeTask extends Task { private static final Logger log = LoggerFactory.getLogger(TakerTradeTask.class); - protected final TakerTradeProcessModel takerTradeProcessModel; + protected final TakerProcessModel takerTradeProcessModel; protected final TakerTrade takerTrade; - public TakerTradeTask(TaskRunner taskHandler, TakerTrade model) { + TakerTradeTask(TaskRunner taskHandler, TakerTrade model) { super(taskHandler, model); takerTrade = model; diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/VerifyOfferFeePayment.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/VerifyOfferFeePayment.java index b3a2fdec89..bca5147272 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/VerifyOfferFeePayment.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/VerifyOfferFeePayment.java @@ -34,7 +34,7 @@ public class VerifyOfferFeePayment extends TakerTradeTask { protected void doRun() { try { //TODO impl. missing - int numOfPeersSeenTx = takerTradeProcessModel.walletService.getNumOfPeersSeenTx(takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString()); + int numOfPeersSeenTx = takerTradeProcessModel.getWalletService().getNumOfPeersSeenTx(takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString()); /* if (numOfPeersSeenTx > 2) { resultHandler.handleResult(); }*/ diff --git a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/VerifyOffererAccount.java b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/VerifyOffererAccount.java index 021c84578a..b65c95b2c3 100644 --- a/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/VerifyOffererAccount.java +++ b/core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/VerifyOffererAccount.java @@ -33,9 +33,10 @@ public class VerifyOffererAccount extends TakerTradeTask { @Override protected void doRun() { try { - if (takerTradeProcessModel.blockChainService.verifyAccountRegistration()) { - if (takerTradeProcessModel.blockChainService.isAccountBlackListed(takerTradeProcessModel.offerer.accountId, takerTradeProcessModel.offerer - .fiatAccount)) { + if (takerTradeProcessModel.getBlockChainService().verifyAccountRegistration()) { + if (takerTradeProcessModel.getBlockChainService().isAccountBlackListed(takerTradeProcessModel.offerer.getAccountId(), takerTradeProcessModel + .offerer + .getFiatAccount())) { failed("Taker is blacklisted."); } else { diff --git a/core/src/main/java/io/bitsquare/util/Validator.java b/core/src/main/java/io/bitsquare/util/Validator.java index 35d56abec9..f061afbe09 100644 --- a/core/src/main/java/io/bitsquare/util/Validator.java +++ b/core/src/main/java/io/bitsquare/util/Validator.java @@ -54,6 +54,4 @@ public class Validator { public static void checkTradeId(String tradeId, TradeMessage tradeMessage) { checkArgument(tradeId.equals(tradeMessage.tradeId)); } - - }