Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-07-31 02:39:08 -04:00
Code Issues Projects Releases Packages Wiki Activity

Move process model inside trade

Browse source
This commit is contained in:
Manfred Karrer 2015-03-26 23:25:29 +01:00
parent ece3639e5f
commit 4a2cb8dc7e
45 changed files with 615 additions and 546 deletions
Download patch file Download diff file Expand all files Collapse all files

4
core/src/main/java/io/bitsquare/common/taskrunner/SharedTaskModel.java → core/src/main/java/io/bitsquare/common/taskrunner/Model.java
View file

@ -20,8 +20,8 @@ package io.bitsquare.common.taskrunner;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SharedTaskModel { public class Model {
private static final Logger log = LoggerFactory.getLogger(SharedTaskModel.class); private static final Logger log = LoggerFactory.getLogger(Model.class);
public void persist() { public void persist() {
} }

2
core/src/main/java/io/bitsquare/common/taskrunner/Task.java
View file

@ -24,7 +24,7 @@ import io.bitsquare.btc.exceptions.WalletException;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public abstract class Task<T extends SharedTaskModel> { public abstract class Task<T extends Model> {
private static final Logger log = LoggerFactory.getLogger(Task.class); private static final Logger log = LoggerFactory.getLogger(Task.class);
public static Class<? extends Task> taskToInterceptBeforeRun; public static Class<? extends Task> taskToInterceptBeforeRun;

2
core/src/main/java/io/bitsquare/common/taskrunner/TaskRunner.java
View file

@ -27,7 +27,7 @@ import java.util.concurrent.LinkedBlockingQueue;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TaskRunner<T extends SharedTaskModel> { public class TaskRunner<T extends Model> {
private static final Logger log = LoggerFactory.getLogger(TaskRunner.class); private static final Logger log = LoggerFactory.getLogger(TaskRunner.class);
private final Queue<Class> tasks = new LinkedBlockingQueue<>(); private final Queue<Class> tasks = new LinkedBlockingQueue<>();

8
core/src/main/java/io/bitsquare/gui/main/debug/DebugView.java
View file

@ -28,7 +28,7 @@ import io.bitsquare.trade.protocol.placeoffer.tasks.AddOfferToRemoteOfferBook;
import io.bitsquare.trade.protocol.placeoffer.tasks.BroadcastCreateOfferFeeTx; import io.bitsquare.trade.protocol.placeoffer.tasks.BroadcastCreateOfferFeeTx;
import io.bitsquare.trade.protocol.placeoffer.tasks.CreateOfferFeeTx; import io.bitsquare.trade.protocol.placeoffer.tasks.CreateOfferFeeTx;
import io.bitsquare.trade.protocol.placeoffer.tasks.ValidateOffer; import io.bitsquare.trade.protocol.placeoffer.tasks.ValidateOffer;
import io.bitsquare.trade.protocol.trade.offerer.OffererAsBuyerProtocol; import io.bitsquare.trade.protocol.trade.offerer.OffererProtocol;
import io.bitsquare.trade.protocol.trade.offerer.tasks.CreateAndSignPayoutTx; 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.CreateOffererDepositTxInputs;
import io.bitsquare.trade.protocol.trade.offerer.tasks.ProcessPayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.offerer.tasks.ProcessPayoutTxPublishedMessage;
@ -41,7 +41,7 @@ import io.bitsquare.trade.protocol.trade.offerer.tasks.SignAndPublishDepositTx;
import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyAndSignContract; import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyAndSignContract;
import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyTakeOfferFeePayment; import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyTakeOfferFeePayment;
import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyTakerAccount; import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyTakerAccount;
import io.bitsquare.trade.protocol.trade.taker.TakerAsSellerProtocol; import io.bitsquare.trade.protocol.trade.taker.TakerProtocol;
import io.bitsquare.trade.protocol.trade.taker.tasks.CreateAndSignContract; import io.bitsquare.trade.protocol.trade.taker.tasks.CreateAndSignContract;
import io.bitsquare.trade.protocol.trade.taker.tasks.CreateTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.taker.tasks.CreateTakeOfferFeeTx;
import io.bitsquare.trade.protocol.trade.taker.tasks.ProcessDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.taker.tasks.ProcessDepositTxPublishedMessage;
@ -100,7 +100,7 @@ public class DebugView extends InitializableView {
/*---- Protocol ----*/ /*---- Protocol ----*/
OffererAsBuyerProtocol.class, OffererProtocol.class,
ProcessRequestDepositTxInputsMessage.class, ProcessRequestDepositTxInputsMessage.class,
CreateOffererDepositTxInputs.class, CreateOffererDepositTxInputs.class,
RequestTakerDepositPayment.class, RequestTakerDepositPayment.class,
@ -120,7 +120,7 @@ public class DebugView extends InitializableView {
/*---- Protocol ----*/ /*---- Protocol ----*/
TakerAsSellerProtocol.class, TakerProtocol.class,
CreateTakeOfferFeeTx.class, CreateTakeOfferFeeTx.class,
SendRequestDepositTxInputsMessage.class, SendRequestDepositTxInputsMessage.class,

2
core/src/main/java/io/bitsquare/gui/main/portfolio/closed/ClosedTradesViewModel.java
View file

@ -89,7 +89,7 @@ class ClosedTradesViewModel extends ActivatableWithDataModel<ClosedTradesDataMod
return "Completed"; return "Completed";
case FAILED: case FAILED:
return "Failed"; return "Failed";
case OPEN_OFFER: case OFFER_OPEN:
case PENDING: case PENDING:
throw new RuntimeException("That must not happen. We got a pending state but we are in the closed trades list."); throw new RuntimeException("That must not happen. We got a pending state but we are in the closed trades list.");
} }

24
core/src/main/java/io/bitsquare/trade/OffererTrade.java
View file

@ -19,7 +19,9 @@ package io.bitsquare.trade;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.protocol.trade.offerer.OffererAsBuyerProtocol; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.trade.offerer.OffererProtocol;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererTradeProcessModel;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.bitcoinj.core.TransactionConfidence; import org.bitcoinj.core.TransactionConfidence;
@ -51,7 +53,8 @@ public class OffererTrade extends Trade implements Serializable {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public enum OffererLifeCycleState implements LifeCycleState { public enum OffererLifeCycleState implements LifeCycleState {
OPEN_OFFER, OFFER_OPEN,
OFFER_RESERVED,
OFFER_CANCELED, OFFER_CANCELED,
PENDING, PENDING,
COMPLETED, COMPLETED,
@ -75,6 +78,7 @@ public class OffererTrade extends Trade implements Serializable {
private Peer tradingPeer; private Peer tradingPeer;
private OffererProcessState processState; private OffererProcessState processState;
private OffererLifeCycleState lifeCycleState; private OffererLifeCycleState lifeCycleState;
private OffererTradeProcessModel offererTradeProcessModel;
transient private ObjectProperty<OffererProcessState> processStateProperty = new SimpleObjectProperty<>(); transient private ObjectProperty<OffererProcessState> processStateProperty = new SimpleObjectProperty<>();
transient private ObjectProperty<OffererLifeCycleState> lifeCycleStateProperty = new SimpleObjectProperty<>(); transient private ObjectProperty<OffererLifeCycleState> lifeCycleStateProperty = new SimpleObjectProperty<>();
@ -84,8 +88,12 @@ public class OffererTrade extends Trade implements Serializable {
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public OffererTrade(Offer offer) { public OffererTrade(Offer offer, OffererTradeProcessModel offererTradeProcessModel, Storage storage) {
super(offer); super(offer, storage);
this.offererTradeProcessModel = offererTradeProcessModel;
protocol = new OffererProtocol(this);
setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
} }
// Serialized object does not create our transient objects // Serialized object does not create our transient objects
@ -94,11 +102,15 @@ public class OffererTrade extends Trade implements Serializable {
processStateProperty = new SimpleObjectProperty<>(processState); processStateProperty = new SimpleObjectProperty<>(processState);
lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState); lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState);
protocol = new OffererProtocol(this);
} }
public void onFiatPaymentStarted() { public void onFiatPaymentStarted() {
((OffererAsBuyerProtocol) protocol).onFiatPaymentStarted(); ((OffererProtocol) protocol).onFiatPaymentStarted();
}
public OffererTradeProcessModel getOffererTradeProcessModel() {
return offererTradeProcessModel;
} }

25
core/src/main/java/io/bitsquare/trade/TakerTrade.java
View file

@ -19,7 +19,9 @@ package io.bitsquare.trade;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.protocol.trade.taker.TakerAsSellerProtocol; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.trade.taker.TakerProtocol;
import io.bitsquare.trade.protocol.trade.taker.models.TakerTradeProcessModel;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.bitcoinj.core.TransactionConfidence; import org.bitcoinj.core.TransactionConfidence;
@ -45,6 +47,11 @@ public class TakerTrade extends Trade implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(TakerTrade.class); transient private static final Logger log = LoggerFactory.getLogger(TakerTrade.class);
public TakerTradeProcessModel getTakerTradeProcessModel() {
return takerTradeProcessModel;
}
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Enum // Enum
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@ -72,9 +79,9 @@ public class TakerTrade extends Trade implements Serializable {
EXCEPTION EXCEPTION
} }
private final Coin tradeAmount; private final Coin tradeAmount;
private final Peer tradingPeer; private final Peer tradingPeer;
private final TakerTradeProcessModel takerTradeProcessModel;
private TakerProcessState processState; private TakerProcessState processState;
private TakerLifeCycleState lifeCycleState; private TakerLifeCycleState lifeCycleState;
@ -87,14 +94,19 @@ public class TakerTrade extends Trade implements Serializable {
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public TakerTrade(Offer offer, Coin tradeAmount, Peer peer) { public TakerTrade(Offer offer, Coin tradeAmount, Peer peer, TakerTradeProcessModel takerTradeProcessModel, Storage storage) {
super(offer); super(offer, storage);
this.tradeAmount = tradeAmount; this.tradeAmount = tradeAmount;
this.tradingPeer = peer; this.tradingPeer = peer;
this.takerTradeProcessModel = takerTradeProcessModel;
protocol = new TakerProtocol(this);
setLifeCycleState(TakerTrade.TakerLifeCycleState.PENDING);
tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount); tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount);
tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume()); // cannot be set before offer is set tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume()); // cannot be set before offer is set
((TakerProtocol) protocol).takeAvailableOffer();
} }
// Serialized object does not create our transient objects // Serialized object does not create our transient objects
@ -105,10 +117,12 @@ public class TakerTrade extends Trade implements Serializable {
lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState); lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState);
tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount); tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount);
tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume()); tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume());
protocol = new TakerProtocol(this);
} }
public void onFiatPaymentReceived() { public void onFiatPaymentReceived() {
((TakerAsSellerProtocol) protocol).onFiatPaymentReceived(); ((TakerProtocol) protocol).onFiatPaymentReceived();
} }
@ -146,6 +160,7 @@ public class TakerTrade extends Trade implements Serializable {
public ReadOnlyObjectProperty<TakerProcessState> processStateProperty() { public ReadOnlyObjectProperty<TakerProcessState> processStateProperty() {
return processStateProperty; return processStateProperty;
} }
@Override @Override
public ReadOnlyObjectProperty<TakerLifeCycleState> lifeCycleStateProperty() { public ReadOnlyObjectProperty<TakerLifeCycleState> lifeCycleStateProperty() {
return lifeCycleStateProperty; return lifeCycleStateProperty;

43
core/src/main/java/io/bitsquare/trade/Trade.java
View file

@ -18,10 +18,13 @@
package io.bitsquare.trade; package io.bitsquare.trade;
import io.bitsquare.btc.TradeWalletService; import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.common.taskrunner.Model;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.MailboxMessage; import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.Protocol; import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.protocol.trade.taker.models.TakerTradeProcessModel;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -42,24 +45,25 @@ import org.slf4j.LoggerFactory;
* Holds all data which are relevant to the trade, but not those which are only needed in the trade process as shared data between tasks. Those data are * Holds all data which are relevant to the trade, but not those which are only needed in the trade process as shared data between tasks. Those data are
* stored in the task model. * stored in the task model.
*/ */
abstract public class Trade implements Serializable { 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. // 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 long serialVersionUID = 1L;
transient protected static final Logger log = LoggerFactory.getLogger(Trade.class); transient protected static final Logger log = LoggerFactory.getLogger(Trade.class);
public interface ProcessState { public interface ProcessState {
} }
public interface LifeCycleState { public interface LifeCycleState {
} }
transient protected Protocol protocol;
protected MailboxMessage mailboxMessage; protected MailboxMessage mailboxMessage;
protected final Offer offer; protected final Offer offer;
protected final Date date; protected final Date date;
protected Protocol protocol;
protected Contract contract; protected Contract contract;
protected String contractAsJson; protected String contractAsJson;
protected String takerContractSignature; protected String takerContractSignature;
@ -73,17 +77,24 @@ abstract public class Trade implements Serializable {
transient protected ObjectProperty<Coin> tradeAmountProperty = new SimpleObjectProperty<>(); transient protected ObjectProperty<Coin> tradeAmountProperty = new SimpleObjectProperty<>();
transient protected ObjectProperty<Fiat> tradeVolumeProperty = new SimpleObjectProperty<>(); transient protected ObjectProperty<Fiat> tradeVolumeProperty = new SimpleObjectProperty<>();
transient private Storage<TakerTradeProcessModel> storage;
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public Trade(Offer offer) { public Trade(Offer offer, Storage storage) {
this.offer = offer; this.offer = offer;
this.storage = storage;
date = new Date(); date = new Date();
} }
///////////////////////////////////////////////////////////////////////////////////////////
// API
///////////////////////////////////////////////////////////////////////////////////////////
// The deserialized tx has not actual confidence data, so we need to get the fresh one from the wallet. // The deserialized tx has not actual confidence data, so we need to get the fresh one from the wallet.
public void updateTxFromWallet(TradeWalletService tradeWalletService) { public void updateTxFromWallet(TradeWalletService tradeWalletService) {
if (depositTx != null) if (depositTx != null)
@ -95,17 +106,26 @@ abstract public class Trade implements Serializable {
setConfidenceListener(); setConfidenceListener();
} }
/////////////////////////////////////////////////////////////////////////////////////////// public void reActivate() {
// Protocol
///////////////////////////////////////////////////////////////////////////////////////////
public void setProtocol(Protocol protocol) {
this.protocol = protocol;
if (mailboxMessage != null) if (mailboxMessage != null)
protocol.setMailboxMessage(mailboxMessage); protocol.setMailboxMessage(mailboxMessage);
} }
// Get called from taskRunner after each completed task
@Override
public void persist() {
storage.save();
}
@Override
public void onComplete() {
storage.save();
}
///////////////////////////////////////////////////////////////////////////////////////////
// Protocol
///////////////////////////////////////////////////////////////////////////////////////////
public void disposeProtocol() { public void disposeProtocol() {
if (protocol != null) { if (protocol != null) {
protocol.cleanup(); protocol.cleanup();
@ -119,6 +139,9 @@ abstract public class Trade implements Serializable {
protocol.setMailboxMessage(mailboxMessage); protocol.setMailboxMessage(mailboxMessage);
} }
public void setStorage(Storage storage) {
this.storage = storage;
}
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Setters // Setters

5
core/src/main/java/io/bitsquare/trade/TradeList.java
View file

@ -19,7 +19,6 @@ package io.bitsquare.trade;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import java.io.File;
import java.io.Serializable; import java.io.Serializable;
import java.util.ArrayList; import java.util.ArrayList;
@ -45,8 +44,8 @@ public class TradeList<T> extends ArrayList<T> implements Serializable {
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public TradeList(File storageDir, String fileName) { public TradeList(Storage<TradeList> storage, String fileName) {
this.storage = new Storage<>(storageDir); this.storage = storage;
TradeList persisted = storage.initAndGetPersisted(this, fileName); TradeList persisted = storage.initAndGetPersisted(this, fileName);
if (persisted != null) { if (persisted != null) {

114
core/src/main/java/io/bitsquare/trade/TradeManager.java
View file

@ -36,6 +36,7 @@ import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.MailboxService; import io.bitsquare.p2p.MailboxService;
import io.bitsquare.p2p.MessageService; import io.bitsquare.p2p.MessageService;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.handlers.TakeOfferResultHandler; import io.bitsquare.trade.handlers.TakeOfferResultHandler;
import io.bitsquare.trade.handlers.TransactionResultHandler; import io.bitsquare.trade.handlers.TransactionResultHandler;
import io.bitsquare.trade.protocol.availability.CheckOfferAvailabilityModel; import io.bitsquare.trade.protocol.availability.CheckOfferAvailabilityModel;
@ -43,10 +44,8 @@ import io.bitsquare.trade.protocol.availability.CheckOfferAvailabilityProtocol;
import io.bitsquare.trade.protocol.placeoffer.PlaceOfferModel; import io.bitsquare.trade.protocol.placeoffer.PlaceOfferModel;
import io.bitsquare.trade.protocol.placeoffer.PlaceOfferProtocol; import io.bitsquare.trade.protocol.placeoffer.PlaceOfferProtocol;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.offerer.OffererAsBuyerProtocol; import io.bitsquare.trade.protocol.trade.offerer.models.OffererTradeProcessModel;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel; import io.bitsquare.trade.protocol.trade.taker.models.TakerTradeProcessModel;
import io.bitsquare.trade.protocol.trade.taker.TakerAsSellerProtocol;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import io.bitsquare.user.AccountSettings; import io.bitsquare.user.AccountSettings;
import io.bitsquare.user.User; import io.bitsquare.user.User;
@ -85,6 +84,7 @@ public class TradeManager {
private final AddressService addressService; private final AddressService addressService;
private final BlockChainService blockChainService; private final BlockChainService blockChainService;
private final WalletService walletService; private final WalletService walletService;
private final Storage pendingTradesStorage;
private TradeWalletService tradeWalletService; private TradeWalletService tradeWalletService;
private final SignatureService signatureService; private final SignatureService signatureService;
private final EncryptionService<MailboxMessage> encryptionService; private final EncryptionService<MailboxMessage> encryptionService;
@ -124,9 +124,11 @@ public class TradeManager {
this.arbitrationRepository = arbitrationRepository; this.arbitrationRepository = arbitrationRepository;
this.storageDir = storageDir; this.storageDir = storageDir;
this.openOfferTrades = new TradeList<>(storageDir, "OpenOfferTrades"); pendingTradesStorage = new Storage(storageDir);
this.pendingTrades = new TradeList<>(storageDir, "PendingTrades"); this.openOfferTrades = new TradeList<>(pendingTradesStorage, "OpenOfferTrades");
this.closedTrades = new TradeList<>(storageDir, "ClosedTrades"); this.pendingTrades = new TradeList<>(new Storage(storageDir), "PendingTrades");
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 // In case the app did get killed the shutDown from the modules is not called, so we use a shutdown hook
Thread shutDownHookThread = new Thread(TradeManager.this::shutDown, "TradeManager:ShutDownHook"); Thread shutDownHookThread = new Thread(TradeManager.this::shutDown, "TradeManager:ShutDownHook");
@ -162,25 +164,16 @@ public class TradeManager {
() -> log.debug("Successful removed open offer from DHT"), () -> log.debug("Successful removed open offer from DHT"),
(message, throwable) -> log.error("Remove open offer from DHT failed. " + message)); (message, throwable) -> log.error("Remove open offer from DHT failed. " + message));
OffererAsBuyerProtocol protocol = createOffererAsBuyerProtocol(offererTrade); offererTrade.reActivate();
offererTrade.setProtocol(protocol);
} }
for (Trade trade : pendingTrades) { for (Trade trade : pendingTrades) {
// We continue an interrupted trade. // 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 // 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. // continue the trade, but that might fail.
if (trade instanceof OffererTrade) { trade.reActivate();
OffererTrade offererTrade = (OffererTrade) trade; trade.updateTxFromWallet(tradeWalletService);
OffererAsBuyerProtocol protocol = createOffererAsBuyerProtocol(offererTrade); trade.setStorage(pendingTradesStorage);
offererTrade.setProtocol(protocol);
offererTrade.updateTxFromWallet(tradeWalletService);
}
else if (trade instanceof TakerTrade) {
TakerTrade takerTrade = (TakerTrade) trade;
TakerAsSellerProtocol sellerTakesOfferProtocol = createTakerAsSellerProtocol(takerTrade);
takerTrade.setProtocol(sellerTakesOfferProtocol);
takerTrade.updateTxFromWallet(tradeWalletService);
}
} }
mailboxService.getAllMessages(user.getP2PSigPubKey(), mailboxService.getAllMessages(user.getP2PSigPubKey(),
@ -224,12 +217,21 @@ public class TradeManager {
PlaceOfferProtocol placeOfferProtocol = new PlaceOfferProtocol( PlaceOfferProtocol placeOfferProtocol = new PlaceOfferProtocol(
model, model,
(transaction) -> { (transaction) -> {
OffererTrade offererTrade = new OffererTrade(offer); OffererTradeProcessModel processModel = createOffererTradeProcessModel(offer);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OPEN_OFFER); OffererTrade offererTrade = new OffererTrade(offer, processModel, pendingTradesStorage);
openOfferTrades.add(offererTrade); openOfferTrades.add(offererTrade);
OffererAsBuyerProtocol protocol = createOffererAsBuyerProtocol(offererTrade); offererTrade.processStateProperty().addListener((ov, oldValue, newValue) -> {
offererTrade.setProtocol(protocol); 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);
}
});
resultHandler.handleResult(transaction); resultHandler.handleResult(transaction);
}, },
(message) -> errorMessageHandler.handleErrorMessage(message) (message) -> errorMessageHandler.handleErrorMessage(message)
@ -404,21 +406,27 @@ public class TradeManager {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private TakerTrade takeAvailableOffer(Coin amount, Offer offer, Peer peer) { private TakerTrade takeAvailableOffer(Coin amount, Offer offer, Peer peer) {
TakerTrade takerTrade = new TakerTrade(offer, amount, peer); TakerTradeProcessModel takerTradeProcessModel = createTakerProcessModel(offer);
takerTrade.setLifeCycleState(TakerTrade.TakerLifeCycleState.PENDING); TakerTrade takerTrade = new TakerTrade(offer, amount, peer, takerTradeProcessModel, pendingTradesStorage);
pendingTrades.add(takerTrade); pendingTrades.add(takerTrade);
TakerAsSellerProtocol sellerTakesOfferProtocol = createTakerAsSellerProtocol(takerTrade);
takerTrade.setProtocol(sellerTakesOfferProtocol);
sellerTakesOfferProtocol.takeAvailableOffer();
return takerTrade; return takerTrade;
} }
private TakerAsSellerProtocol createTakerAsSellerProtocol(TakerTrade takerTrade) { private TakerTradeProcessModel createTakerProcessModel(Offer offer) {
TakerAsSellerModel model = new TakerAsSellerModel( return new TakerTradeProcessModel(
takerTrade, offer,
messageService,
mailboxService,
walletService,
blockChainService,
signatureService,
arbitrationRepository,
user);
}
private OffererTradeProcessModel createOffererTradeProcessModel(Offer offer) {
return new OffererTradeProcessModel(offer,
messageService, messageService,
mailboxService, mailboxService,
walletService, walletService,
@ -427,42 +435,6 @@ public class TradeManager {
arbitrationRepository, arbitrationRepository,
user, user,
storageDir); storageDir);
return new TakerAsSellerProtocol(model);
}
private OffererAsBuyerProtocol createOffererAsBuyerProtocol(OffererTrade offererTrade) {
OffererAsBuyerModel model = new OffererAsBuyerModel(
offererTrade,
messageService,
mailboxService,
walletService,
blockChainService,
signatureService,
arbitrationRepository,
user,
storageDir);
// TODO check, remove listener
offererTrade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("offererTrade state = " + newValue);
switch (newValue) {
case DEPOSIT_PUBLISHED:
removeOpenOffer(offererTrade.getOffer(),
() -> log.debug("remove offer was successful"),
(message) -> log.error(message),
false);
((OffererTrade) model.trade).setLifeCycleState(OffererTrade.OffererLifeCycleState.PENDING);
pendingTrades.add(offererTrade);
break;
default:
break;
}
});
return new OffererAsBuyerProtocol(model);
} }

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

@ -17,7 +17,7 @@
package io.bitsquare.trade.protocol.availability; package io.bitsquare.trade.protocol.availability;
import io.bitsquare.common.taskrunner.SharedTaskModel; import io.bitsquare.common.taskrunner.Model;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.AddressService; import io.bitsquare.p2p.AddressService;
import io.bitsquare.p2p.MessageService; import io.bitsquare.p2p.MessageService;
@ -27,7 +27,7 @@ import io.bitsquare.trade.protocol.trade.messages.OfferMessage;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class CheckOfferAvailabilityModel extends SharedTaskModel { public class CheckOfferAvailabilityModel extends Model {
private static final Logger log = LoggerFactory.getLogger(CheckOfferAvailabilityModel.class); private static final Logger log = LoggerFactory.getLogger(CheckOfferAvailabilityModel.class);
public final Offer offer; public final Offer offer;

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

@ -18,7 +18,7 @@
package io.bitsquare.trade.protocol.placeoffer; package io.bitsquare.trade.protocol.placeoffer;
import io.bitsquare.btc.WalletService; import io.bitsquare.btc.WalletService;
import io.bitsquare.common.taskrunner.SharedTaskModel; import io.bitsquare.common.taskrunner.Model;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.offer.OfferBookService; import io.bitsquare.offer.OfferBookService;
@ -27,7 +27,7 @@ import org.bitcoinj.core.Transaction;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class PlaceOfferModel extends SharedTaskModel { public class PlaceOfferModel extends Model {
private static final Logger log = LoggerFactory.getLogger(PlaceOfferModel.class); private static final Logger log = LoggerFactory.getLogger(PlaceOfferModel.class);
public final Offer offer; public final Offer offer;

8
core/src/main/java/io/bitsquare/trade/protocol/trade/SharedTradeModel.java → core/src/main/java/io/bitsquare/trade/protocol/trade/TradeProcessModel.java
View file

@ -21,7 +21,7 @@ import io.bitsquare.arbitration.ArbitrationRepository;
import io.bitsquare.btc.BlockChainService; import io.bitsquare.btc.BlockChainService;
import io.bitsquare.btc.TradeWalletService; import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.btc.WalletService; import io.bitsquare.btc.WalletService;
import io.bitsquare.common.taskrunner.SharedTaskModel; import io.bitsquare.common.taskrunner.Model;
import io.bitsquare.crypto.SignatureService; import io.bitsquare.crypto.SignatureService;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.MailboxMessage; import io.bitsquare.p2p.MailboxMessage;
@ -34,11 +34,11 @@ import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SharedTradeModel extends SharedTaskModel implements Serializable { public class TradeProcessModel extends Model implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // 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 long serialVersionUID = 1L;
protected static final Logger log = LoggerFactory.getLogger(SharedTradeModel.class); protected static final Logger log = LoggerFactory.getLogger(TradeProcessModel.class);
transient public MailboxMessage mailboxMessage; transient public MailboxMessage mailboxMessage;
// provided // provided
@ -59,7 +59,7 @@ public class SharedTradeModel extends SharedTaskModel implements Serializable {
// data written/read by tasks // data written/read by tasks
transient private TradeMessage tradeMessage; transient private TradeMessage tradeMessage;
protected SharedTradeModel(Offer offer, protected TradeProcessModel(Offer offer,
MessageService messageService, MessageService messageService,
MailboxService mailboxService, MailboxService mailboxService,
WalletService walletService, WalletService walletService,

65
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/OffererAsBuyerProtocol.java → core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/OffererProtocol.java
View file

@ -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.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel; import io.bitsquare.trade.protocol.trade.offerer.models.OffererTradeProcessModel;
import io.bitsquare.trade.protocol.trade.offerer.tasks.CreateAndSignPayoutTx; 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.CreateOffererDepositTxInputs;
import io.bitsquare.trade.protocol.trade.offerer.tasks.ProcessPayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.offerer.tasks.ProcessPayoutTxPublishedMessage;
@ -45,30 +45,29 @@ import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyAndSignContract;
import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyTakeOfferFeePayment; import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyTakeOfferFeePayment;
import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyTakerAccount; import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyTakerAccount;
import javafx.application.Platform;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class OffererAsBuyerProtocol implements Protocol { public class OffererProtocol implements Protocol {
private static final Logger log = LoggerFactory.getLogger(OffererAsBuyerProtocol.class); private static final Logger log = LoggerFactory.getLogger(OffererProtocol.class);
private final OffererAsBuyerModel model;
private final MessageHandler messageHandler; private final MessageHandler messageHandler;
private final OffererTrade offererTrade;
private final OffererTradeProcessModel offererTradeProcessModel;
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public OffererAsBuyerProtocol(OffererAsBuyerModel model) { public OffererProtocol(OffererTrade model) {
log.debug("New BuyerAsOffererProtocol " + this); log.debug("New BuyerAsOffererProtocol " + this);
this.model = model; this.offererTrade = model;
offererTradeProcessModel = offererTrade.getOffererTradeProcessModel();
messageHandler = this::handleMessage; messageHandler = this::handleMessage;
model.messageService.addMessageHandler(messageHandler); offererTradeProcessModel.messageService.addMessageHandler(messageHandler);
} }
@ -79,8 +78,8 @@ public class OffererAsBuyerProtocol implements Protocol {
public void setMailboxMessage(MailboxMessage mailboxMessage) { public void setMailboxMessage(MailboxMessage mailboxMessage) {
log.debug("setMailboxMessage " + mailboxMessage); log.debug("setMailboxMessage " + mailboxMessage);
// Might be called twice, so check that its only processed once // Might be called twice, so check that its only processed once
if (model.mailboxMessage == null) { if (offererTradeProcessModel.mailboxMessage == null) {
model.mailboxMessage = mailboxMessage; offererTradeProcessModel.mailboxMessage = mailboxMessage;
if (mailboxMessage instanceof PayoutTxPublishedMessage) { if (mailboxMessage instanceof PayoutTxPublishedMessage) {
handlePayoutTxPublishedMessage((PayoutTxPublishedMessage) mailboxMessage); handlePayoutTxPublishedMessage((PayoutTxPublishedMessage) mailboxMessage);
} }
@ -90,10 +89,7 @@ public class OffererAsBuyerProtocol implements Protocol {
public void cleanup() { public void cleanup() {
log.debug("cleanup " + this); log.debug("cleanup " + this);
// tradeMessageService and transactionConfidence use CopyOnWriteArrayList as listeners, but be safe and delay remove a bit. offererTradeProcessModel.messageService.removeMessageHandler(messageHandler);
Platform.runLater(() -> {
model.messageService.removeMessageHandler(messageHandler);
});
} }
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@ -103,13 +99,15 @@ public class OffererAsBuyerProtocol implements Protocol {
// OpenOffer requests // OpenOffer requests
private void handleRequestIsOfferAvailableMessage(RequestIsOfferAvailableMessage tradeMessage, Peer sender) { private void handleRequestIsOfferAvailableMessage(RequestIsOfferAvailableMessage tradeMessage, Peer sender) {
try { try {
checkTradeId(model.id, tradeMessage); checkTradeId(offererTradeProcessModel.id, tradeMessage);
// We don't store anything in the model as we might be in a trade process and receive that request from another peer who wants to take the offer // 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 // at the same time
boolean isOfferOpen = model.trade.lifeCycleStateProperty().get() == OffererTrade.OffererLifeCycleState.OPEN_OFFER; boolean isOfferOpen = offererTrade.lifeCycleStateProperty().get() == OffererTrade.OffererLifeCycleState.OFFER_OPEN;
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(model.id, isOfferOpen); ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(offererTradeProcessModel.id, isOfferOpen);
model.messageService.sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() { offererTradeProcessModel.messageService.sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
// Offerer does not do anything at that moment. Peer might only watch the offer and does not start a trade. // Offerer does not do anything at that moment. Peer might only watch the offer and does not start a trade.
@ -128,13 +126,14 @@ public class OffererAsBuyerProtocol implements Protocol {
} }
} }
// Trade started // 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) { private void handleRequestDepositTxInputsMessage(RequestDepositTxInputsMessage tradeMessage, Peer taker) {
checkTradeId(model.id, tradeMessage); checkTradeId(offererTradeProcessModel.id, tradeMessage);
model.setTradeMessage(tradeMessage); offererTradeProcessModel.setTradeMessage(tradeMessage);
model.trade.setTradingPeer(taker); offererTrade.setTradingPeer(taker);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_RESERVED);
TaskRunner<OffererAsBuyerModel> taskRunner = new TaskRunner<>(model, TaskRunner<OffererTrade> taskRunner = new TaskRunner<>(offererTrade,
() -> log.debug("taskRunner at handleTakeOfferFeePayedMessage completed"), () -> log.debug("taskRunner at handleTakeOfferFeePayedMessage completed"),
(errorMessage) -> handleTaskRunnerFault(errorMessage)); (errorMessage) -> handleTaskRunnerFault(errorMessage));
taskRunner.addTasks( taskRunner.addTasks(
@ -146,9 +145,9 @@ public class OffererAsBuyerProtocol implements Protocol {
} }
private void handleRequestOffererPublishDepositTxMessage(RequestOffererPublishDepositTxMessage tradeMessage) { private void handleRequestOffererPublishDepositTxMessage(RequestOffererPublishDepositTxMessage tradeMessage) {
model.setTradeMessage(tradeMessage); offererTradeProcessModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsBuyerModel> taskRunner = new TaskRunner<>(model, TaskRunner<OffererTrade> taskRunner = new TaskRunner<>(offererTrade,
() -> log.debug("taskRunner at handleRequestOffererPublishDepositTxMessage completed"), () -> log.debug("taskRunner at handleRequestOffererPublishDepositTxMessage completed"),
(errorMessage) -> handleTaskRunnerFault(errorMessage)); (errorMessage) -> handleTaskRunnerFault(errorMessage));
taskRunner.addTasks( taskRunner.addTasks(
@ -168,7 +167,7 @@ public class OffererAsBuyerProtocol implements Protocol {
// User clicked the "bank transfer started" button // User clicked the "bank transfer started" button
public void onFiatPaymentStarted() { public void onFiatPaymentStarted() {
TaskRunner<OffererAsBuyerModel> taskRunner = new TaskRunner<>(model, TaskRunner<OffererTrade> taskRunner = new TaskRunner<>(offererTrade,
() -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"), () -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"),
(errorMessage) -> handleTaskRunnerFault(errorMessage)); (errorMessage) -> handleTaskRunnerFault(errorMessage));
taskRunner.addTasks( taskRunner.addTasks(
@ -185,13 +184,13 @@ public class OffererAsBuyerProtocol implements Protocol {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private void handlePayoutTxPublishedMessage(PayoutTxPublishedMessage tradeMessage) { private void handlePayoutTxPublishedMessage(PayoutTxPublishedMessage tradeMessage) {
model.setTradeMessage(tradeMessage); offererTradeProcessModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsBuyerModel> taskRunner = new TaskRunner<>(model, TaskRunner<OffererTrade> taskRunner = new TaskRunner<>(offererTrade,
() -> { () -> {
log.debug("taskRunner at handlePayoutTxPublishedMessage completed"); log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
// we are done! // we are done!
model.onComplete(); offererTradeProcessModel.onComplete();
}, },
(errorMessage) -> handleTaskRunnerFault(errorMessage)); (errorMessage) -> handleTaskRunnerFault(errorMessage));
@ -210,7 +209,7 @@ public class OffererAsBuyerProtocol implements Protocol {
TradeMessage tradeMessage = (TradeMessage) message; TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId); nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(model.id)) { if (tradeMessage.tradeId.equals(offererTrade.getId())) {
if (tradeMessage instanceof RequestIsOfferAvailableMessage) { if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
handleRequestIsOfferAvailableMessage((RequestIsOfferAvailableMessage) tradeMessage, sender); handleRequestIsOfferAvailableMessage((RequestIsOfferAvailableMessage) tradeMessage, sender);
} }

18
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererAsBuyerModel.java → core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererTradeProcessModel.java
View file

@ -21,11 +21,11 @@ import io.bitsquare.arbitration.ArbitrationRepository;
import io.bitsquare.btc.BlockChainService; import io.bitsquare.btc.BlockChainService;
import io.bitsquare.btc.WalletService; import io.bitsquare.btc.WalletService;
import io.bitsquare.crypto.SignatureService; import io.bitsquare.crypto.SignatureService;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.MailboxService; import io.bitsquare.p2p.MailboxService;
import io.bitsquare.p2p.MessageService; import io.bitsquare.p2p.MessageService;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.protocol.trade.TradeProcessModel;
import io.bitsquare.trade.protocol.trade.SharedTradeModel;
import io.bitsquare.user.User; import io.bitsquare.user.User;
import java.io.File; import java.io.File;
@ -34,14 +34,13 @@ import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererAsBuyerModel extends SharedTradeModel implements Serializable { public class OffererTradeProcessModel extends TradeProcessModel implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // 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 long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(OffererAsBuyerModel.class); transient private static final Logger log = LoggerFactory.getLogger(OffererTradeProcessModel.class);
transient private Storage<OffererAsBuyerModel> storage; transient private Storage<OffererTradeProcessModel> storage;
transient public final OffererTrade trade;
public final Taker taker; public final Taker taker;
public final Offerer offerer; public final Offerer offerer;
@ -49,7 +48,7 @@ public class OffererAsBuyerModel extends SharedTradeModel implements Serializabl
// written by tasks // written by tasks
private String takeOfferFeeTxId; private String takeOfferFeeTxId;
public OffererAsBuyerModel(OffererTrade trade, public OffererTradeProcessModel(Offer offer,
MessageService messageService, MessageService messageService,
MailboxService mailboxService, MailboxService mailboxService,
WalletService walletService, WalletService walletService,
@ -58,7 +57,7 @@ public class OffererAsBuyerModel extends SharedTradeModel implements Serializabl
ArbitrationRepository arbitrationRepository, ArbitrationRepository arbitrationRepository,
User user, User user,
File storageDir) { File storageDir) {
super(trade.getOffer(), super(offer,
messageService, messageService,
mailboxService, mailboxService,
walletService, walletService,
@ -66,10 +65,9 @@ public class OffererAsBuyerModel extends SharedTradeModel implements Serializabl
signatureService, signatureService,
arbitrationRepository); arbitrationRepository);
this.trade = trade;
this.storage = new Storage<>(storageDir); this.storage = new Storage<>(storageDir);
OffererAsBuyerModel persisted = storage.initAndGetPersisted(this, getFileName()); OffererTradeProcessModel persisted = storage.initAndGetPersisted(this, getFileName());
if (persisted != null) { if (persisted != null) {
log.debug("Model reconstructed form persisted model."); log.debug("Model reconstructed form persisted model.");

29
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateAndSignPayoutTx.java
View file

@ -17,48 +17,45 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class CreateAndSignPayoutTx extends Task<OffererAsBuyerModel> { public class CreateAndSignPayoutTx extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateAndSignPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(CreateAndSignPayoutTx.class);
public CreateAndSignPayoutTx(TaskRunner taskHandler, OffererAsBuyerModel model) { public CreateAndSignPayoutTx(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
OffererTrade offererTrade = model.trade;
Coin securityDeposit = offererTrade.getSecurityDeposit(); Coin securityDeposit = offererTrade.getSecurityDeposit();
Coin offererPayoutAmount = offererTrade.getTradeAmount().add(securityDeposit); Coin offererPayoutAmount = offererTrade.getTradeAmount().add(securityDeposit);
@SuppressWarnings("UnnecessaryLocalVariable") Coin takerPayoutAmount = securityDeposit; @SuppressWarnings("UnnecessaryLocalVariable") Coin takerPayoutAmount = securityDeposit;
byte[] offererPayoutTxSignature = model.tradeWalletService.offererCreatesAndSignsPayoutTx( byte[] offererPayoutTxSignature = offererTradeProcessModel.tradeWalletService.offererCreatesAndSignsPayoutTx(
offererTrade.getDepositTx(), offererTrade.getDepositTx(),
offererPayoutAmount, offererPayoutAmount,
takerPayoutAmount, takerPayoutAmount,
model.offerer.addressEntry, offererTradeProcessModel.offerer.addressEntry,
model.taker.payoutAddressString, offererTradeProcessModel.taker.payoutAddressString,
model.offerer.tradeWalletPubKey, offererTradeProcessModel.offerer.tradeWalletPubKey,
model.taker.tradeWalletPubKey, offererTradeProcessModel.taker.tradeWalletPubKey,
model.arbitratorPubKey); offererTradeProcessModel.arbitratorPubKey);
model.offerer.payoutTxSignature = offererPayoutTxSignature; offererTradeProcessModel.offerer.payoutTxSignature = offererPayoutTxSignature;
model.offerer.payoutAmount = offererPayoutAmount; offererTradeProcessModel.offerer.payoutAmount = offererPayoutAmount;
model.taker.payoutAmount = takerPayoutAmount; offererTradeProcessModel.taker.payoutAmount = takerPayoutAmount;
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

24
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateOffererDepositTxInputs.java
View file

@ -19,36 +19,36 @@ package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.btc.FeePolicy; import io.bitsquare.btc.FeePolicy;
import io.bitsquare.btc.TradeWalletService; import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel; import io.bitsquare.trade.OffererTrade;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class CreateOffererDepositTxInputs extends Task<OffererAsBuyerModel> { public class CreateOffererDepositTxInputs extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateOffererDepositTxInputs.class); private static final Logger log = LoggerFactory.getLogger(CreateOffererDepositTxInputs.class);
public CreateOffererDepositTxInputs(TaskRunner taskHandler, OffererAsBuyerModel model) { public CreateOffererDepositTxInputs(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
log.debug("model.trade.id" + model.trade.getId()); log.debug("offererTrade.id" + offererTrade.getId());
Coin offererInputAmount = model.trade.getSecurityDeposit().add(FeePolicy.TX_FEE); Coin offererInputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
TradeWalletService.Result result = model.tradeWalletService.createOffererDepositTxInputs(offererInputAmount, TradeWalletService.Result result = offererTradeProcessModel.tradeWalletService.createOffererDepositTxInputs(offererInputAmount,
model.offerer.addressEntry); offererTradeProcessModel.offerer.addressEntry);
model.offerer.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs(); offererTradeProcessModel.offerer.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs();
model.offerer.outputs = result.getOutputs(); offererTradeProcessModel.offerer.outputs = result.getOutputs();
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }
} }

46
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/OffererTradeTask.java Normal file
View file

@ -0,0 +1,46 @@
/*
* This file is part of Bitsquare.
*
* Bitsquare is free software: you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or (at
* your option) any later version.
*
* Bitsquare is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
* License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.btc.exceptions.SigningException;
import io.bitsquare.btc.exceptions.TransactionVerificationException;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererTradeTask extends Task<OffererTrade> {
private static final Logger log = LoggerFactory.getLogger(OffererTradeTask.class);
protected final OffererTradeProcessModel offererTradeProcessModel;
protected final OffererTrade offererTrade;
public OffererTradeTask(TaskRunner taskHandler, OffererTrade model) {
super(taskHandler, model);
offererTrade = model;
offererTradeProcessModel = offererTrade.getOffererTradeProcessModel();
}
@Override
protected void doRun() throws WalletException, TransactionVerificationException, SigningException {
}
}

16
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessPayoutTxPublishedMessage.java
View file

@ -17,11 +17,9 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -29,25 +27,25 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.checkTradeId; import static io.bitsquare.util.Validator.checkTradeId;
public class ProcessPayoutTxPublishedMessage extends Task<OffererAsBuyerModel> { public class ProcessPayoutTxPublishedMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(ProcessPayoutTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(ProcessPayoutTxPublishedMessage.class);
public ProcessPayoutTxPublishedMessage(TaskRunner taskHandler, OffererAsBuyerModel model) { public ProcessPayoutTxPublishedMessage(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
checkTradeId(model.id, model.getTradeMessage()); checkTradeId(offererTradeProcessModel.id, offererTradeProcessModel.getTradeMessage());
model.trade.setPayoutTx(checkNotNull(((PayoutTxPublishedMessage) model.getTradeMessage()).payoutTx)); offererTrade.setPayoutTx(checkNotNull(((PayoutTxPublishedMessage) offererTradeProcessModel.getTradeMessage()).payoutTx));
model.trade.setProcessState(OffererTrade.OffererProcessState.PAYOUT_PUBLISHED); offererTrade.setProcessState(OffererTrade.OffererProcessState.PAYOUT_PUBLISHED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

20
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestDepositTxInputsMessage.java
View file

@ -17,11 +17,9 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -29,27 +27,27 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class ProcessRequestDepositTxInputsMessage extends Task<OffererAsBuyerModel> { public class ProcessRequestDepositTxInputsMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(ProcessRequestDepositTxInputsMessage.class); private static final Logger log = LoggerFactory.getLogger(ProcessRequestDepositTxInputsMessage.class);
public ProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, OffererAsBuyerModel model) { public ProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
checkTradeId(model.id, model.getTradeMessage()); checkTradeId(offererTradeProcessModel.id, offererTradeProcessModel.getTradeMessage());
OffererTrade offererTrade = model.trade; RequestDepositTxInputsMessage requestDepositTxInputsMessage = (RequestDepositTxInputsMessage) offererTradeProcessModel.getTradeMessage();
RequestDepositTxInputsMessage requestDepositTxInputsMessage = (RequestDepositTxInputsMessage) model.getTradeMessage();
offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(requestDepositTxInputsMessage.tradeAmount))); offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(requestDepositTxInputsMessage.tradeAmount)));
model.setTakeOfferFeeTxId(nonEmptyStringOf(requestDepositTxInputsMessage.takeOfferFeeTxId)); offererTradeProcessModel.setTakeOfferFeeTxId(nonEmptyStringOf(requestDepositTxInputsMessage.takeOfferFeeTxId));
model.taker.tradeWalletPubKey = checkNotNull(requestDepositTxInputsMessage.takerTradeWalletPubKey); offererTradeProcessModel.taker.tradeWalletPubKey = checkNotNull(requestDepositTxInputsMessage.takerTradeWalletPubKey);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }
} }

34
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestOffererPublishDepositTxMessage.java
View file

@ -17,10 +17,9 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -28,33 +27,34 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*; import static com.google.common.base.Preconditions.*;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class ProcessRequestOffererPublishDepositTxMessage extends Task<OffererAsBuyerModel> { public class ProcessRequestOffererPublishDepositTxMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(ProcessRequestOffererPublishDepositTxMessage.class); private static final Logger log = LoggerFactory.getLogger(ProcessRequestOffererPublishDepositTxMessage.class);
public ProcessRequestOffererPublishDepositTxMessage(TaskRunner taskHandler, OffererAsBuyerModel model) { public ProcessRequestOffererPublishDepositTxMessage(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
checkTradeId(model.id, model.getTradeMessage()); checkTradeId(offererTradeProcessModel.id, offererTradeProcessModel.getTradeMessage());
RequestOffererPublishDepositTxMessage message = (RequestOffererPublishDepositTxMessage) model.getTradeMessage(); RequestOffererPublishDepositTxMessage message = (RequestOffererPublishDepositTxMessage) offererTradeProcessModel.getTradeMessage();
model.taker.fiatAccount = checkNotNull(message.takerFiatAccount); offererTradeProcessModel.taker.fiatAccount = checkNotNull(message.takerFiatAccount);
model.taker.accountId = nonEmptyStringOf(message.takerAccountId); offererTradeProcessModel.taker.accountId = nonEmptyStringOf(message.takerAccountId);
model.taker.p2pSigPublicKey = checkNotNull(message.takerP2PSigPublicKey); offererTradeProcessModel.taker.p2pSigPublicKey = checkNotNull(message.takerP2PSigPublicKey);
model.taker.p2pEncryptPubKey = checkNotNull(message.takerP2PEncryptPublicKey); offererTradeProcessModel.taker.p2pEncryptPubKey = checkNotNull(message.takerP2PEncryptPublicKey);
model.taker.contractAsJson = nonEmptyStringOf(message.takerContractAsJson); offererTradeProcessModel.taker.contractAsJson = nonEmptyStringOf(message.takerContractAsJson);
model.taker.contractSignature = nonEmptyStringOf(message.takerContractSignature); offererTradeProcessModel.taker.contractSignature = nonEmptyStringOf(message.takerContractSignature);
model.taker.payoutAddressString = nonEmptyStringOf(message.takerPayoutAddressString); offererTradeProcessModel.taker.payoutAddressString = nonEmptyStringOf(message.takerPayoutAddressString);
model.taker.preparedDepositTx = checkNotNull(message.takersPreparedDepositTx); offererTradeProcessModel.taker.preparedDepositTx = checkNotNull(message.takersPreparedDepositTx);
model.taker.connectedOutputsForAllInputs = checkNotNull(message.takerConnectedOutputsForAllInputs); offererTradeProcessModel.taker.connectedOutputsForAllInputs = checkNotNull(message.takerConnectedOutputsForAllInputs);
checkArgument(message.takerConnectedOutputsForAllInputs.size() > 0); checkArgument(message.takerConnectedOutputsForAllInputs.size() > 0);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }
} }

34
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/RequestTakerDepositPayment.java
View file

@ -17,37 +17,35 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestTakerDepositPaymentMessage; import io.bitsquare.trade.protocol.trade.messages.RequestTakerDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class RequestTakerDepositPayment extends Task<OffererAsBuyerModel> { public class RequestTakerDepositPayment extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(RequestTakerDepositPayment.class); private static final Logger log = LoggerFactory.getLogger(RequestTakerDepositPayment.class);
public RequestTakerDepositPayment(TaskRunner taskHandler, OffererAsBuyerModel model) { public RequestTakerDepositPayment(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
RequestTakerDepositPaymentMessage tradeMessage = new RequestTakerDepositPaymentMessage( RequestTakerDepositPaymentMessage tradeMessage = new RequestTakerDepositPaymentMessage(
model.id, offererTradeProcessModel.id,
model.offerer.connectedOutputsForAllInputs, offererTradeProcessModel.offerer.connectedOutputsForAllInputs,
model.offerer.outputs, offererTradeProcessModel.offerer.outputs,
model.offerer.tradeWalletPubKey, offererTradeProcessModel.offerer.tradeWalletPubKey,
model.offerer.p2pSigPubKey, offererTradeProcessModel.offerer.p2pSigPubKey,
model.offerer.p2pEncryptPubKey, offererTradeProcessModel.offerer.p2pEncryptPubKey,
model.offerer.fiatAccount, offererTradeProcessModel.offerer.fiatAccount,
model.offerer.accountId); offererTradeProcessModel.offerer.accountId);
model.messageService.sendMessage(model.trade.getTradingPeer(), tradeMessage, new SendMessageListener() { offererTradeProcessModel.messageService.sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer"); log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer");
@ -57,13 +55,15 @@ public class RequestTakerDepositPayment extends Task<OffererAsBuyerModel> {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed"); appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed");
model.trade.setErrorMessage(errorMessage); offererTrade.setErrorMessage(errorMessage);
model.trade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED); offererTrade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }
} }

32
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SendBankTransferStartedMessage.java
View file

@ -17,53 +17,51 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SendBankTransferStartedMessage extends Task<OffererAsBuyerModel> { public class SendBankTransferStartedMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(SendBankTransferStartedMessage.class); private static final Logger log = LoggerFactory.getLogger(SendBankTransferStartedMessage.class);
public SendBankTransferStartedMessage(TaskRunner taskHandler, OffererAsBuyerModel model) { public SendBankTransferStartedMessage(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
FiatTransferStartedMessage tradeMessage = new FiatTransferStartedMessage(model.id, FiatTransferStartedMessage tradeMessage = new FiatTransferStartedMessage(offererTradeProcessModel.id,
model.offerer.payoutTxSignature, offererTradeProcessModel.offerer.payoutTxSignature,
model.offerer.payoutAmount, offererTradeProcessModel.offerer.payoutAmount,
model.taker.payoutAmount, offererTradeProcessModel.taker.payoutAmount,
model.offerer.addressEntry.getAddressString()); offererTradeProcessModel.offerer.addressEntry.getAddressString());
model.messageService.sendMessage(model.trade.getTradingPeer(), tradeMessage, offererTradeProcessModel.messageService.sendMessage(offererTrade.getTradingPeer(), tradeMessage,
model.taker.p2pSigPublicKey, offererTradeProcessModel.taker.p2pSigPublicKey,
model.taker.p2pEncryptPubKey, offererTradeProcessModel.taker.p2pEncryptPubKey,
new SendMessageListener() { new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded."); log.trace("Sending FiatTransferStartedMessage succeeded.");
model.trade.setProcessState(OffererTrade.OffererProcessState.FIAT_PAYMENT_STARTED); offererTrade.setProcessState(OffererTrade.OffererProcessState.FIAT_PAYMENT_STARTED);
complete(); complete();
} }
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending FiatTransferStartedMessage failed"); appendToErrorMessage("Sending FiatTransferStartedMessage failed");
model.trade.setErrorMessage(errorMessage); offererTrade.setErrorMessage(errorMessage);
model.trade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED); offererTrade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

18
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SendDepositTxToTaker.java
View file

@ -17,29 +17,27 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SendDepositTxToTaker extends Task<OffererAsBuyerModel> { public class SendDepositTxToTaker extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(SendDepositTxToTaker.class); private static final Logger log = LoggerFactory.getLogger(SendDepositTxToTaker.class);
public SendDepositTxToTaker(TaskRunner taskHandler, OffererAsBuyerModel model) { public SendDepositTxToTaker(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(model.id, model.trade.getDepositTx()); DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(offererTradeProcessModel.id, offererTrade.getDepositTx());
model.messageService.sendMessage(model.trade.getTradingPeer(), tradeMessage, new SendMessageListener() { offererTradeProcessModel.messageService.sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
log.trace("DepositTxPublishedMessage successfully arrived at peer"); log.trace("DepositTxPublishedMessage successfully arrived at peer");
@ -49,13 +47,13 @@ public class SendDepositTxToTaker extends Task<OffererAsBuyerModel> {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending DepositTxPublishedMessage failed"); appendToErrorMessage("Sending DepositTxPublishedMessage failed");
model.trade.setErrorMessage(errorMessage); offererTrade.setErrorMessage(errorMessage);
model.trade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED); offererTrade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

37
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SignAndPublishDepositTx.java
View file

@ -18,10 +18,8 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.btc.FeePolicy; import io.bitsquare.btc.FeePolicy;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -33,45 +31,48 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SignAndPublishDepositTx extends Task<OffererAsBuyerModel> { public class SignAndPublishDepositTx extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(SignAndPublishDepositTx.class); private static final Logger log = LoggerFactory.getLogger(SignAndPublishDepositTx.class);
public SignAndPublishDepositTx(TaskRunner taskHandler, OffererAsBuyerModel model) { public SignAndPublishDepositTx(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
Coin offererInputAmount = model.trade.getSecurityDeposit().add(FeePolicy.TX_FEE); Coin offererInputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
model.tradeWalletService.offererSignsAndPublishDepositTx( offererTradeProcessModel.tradeWalletService.offererSignsAndPublishDepositTx(
model.taker.preparedDepositTx, offererTradeProcessModel.taker.preparedDepositTx,
model.offerer.connectedOutputsForAllInputs, offererTradeProcessModel.offerer.connectedOutputsForAllInputs,
model.taker.connectedOutputsForAllInputs, offererTradeProcessModel.taker.connectedOutputsForAllInputs,
model.offerer.outputs, offererTradeProcessModel.offerer.outputs,
offererInputAmount, offererInputAmount,
model.offerer.tradeWalletPubKey, offererTradeProcessModel.offerer.tradeWalletPubKey,
model.taker.tradeWalletPubKey, offererTradeProcessModel.taker.tradeWalletPubKey,
model.arbitratorPubKey, offererTradeProcessModel.arbitratorPubKey,
new FutureCallback<Transaction>() { new FutureCallback<Transaction>() {
@Override @Override
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
log.trace("offererSignAndPublishTx succeeded " + transaction); log.trace("offererSignAndPublishTx succeeded " + transaction);
model.trade.setDepositTx(transaction); offererTrade.setDepositTx(transaction);
model.trade.setProcessState(OffererTrade.OffererProcessState.DEPOSIT_PUBLISHED); offererTrade.setProcessState(OffererTrade.OffererProcessState.DEPOSIT_PUBLISHED);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.PENDING);
complete(); complete();
} }
@Override @Override
public void onFailure(@NotNull Throwable t) { public void onFailure(@NotNull Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }
} }

33
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyAndSignContract.java
View file

@ -17,49 +17,46 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Contract; import io.bitsquare.trade.Contract;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import io.bitsquare.util.Utilities; import io.bitsquare.util.Utilities;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class VerifyAndSignContract extends Task<OffererAsBuyerModel> { public class VerifyAndSignContract extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyAndSignContract.class); private static final Logger log = LoggerFactory.getLogger(VerifyAndSignContract.class);
public VerifyAndSignContract(TaskRunner taskHandler, OffererAsBuyerModel model) { public VerifyAndSignContract(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
OffererTrade offererTrade = model.trade;
Contract contract = new Contract( Contract contract = new Contract(
model.offer, offererTradeProcessModel.offer,
offererTrade.getTradeAmount(), offererTrade.getTradeAmount(),
model.getTakeOfferFeeTxId(), offererTradeProcessModel.getTakeOfferFeeTxId(),
model.offerer.accountId, offererTradeProcessModel.offerer.accountId,
model.taker.accountId, offererTradeProcessModel.taker.accountId,
model.offerer.fiatAccount, offererTradeProcessModel.offerer.fiatAccount,
model.taker.fiatAccount, offererTradeProcessModel.taker.fiatAccount,
model.offerer.p2pSigPubKey, offererTradeProcessModel.offerer.p2pSigPubKey,
model.taker.p2pSigPublicKey); offererTradeProcessModel.taker.p2pSigPublicKey);
String contractAsJson = Utilities.objectToJson(contract); String contractAsJson = Utilities.objectToJson(contract);
String signature = model.signatureService.signMessage(model.offerer.registrationKeyPair, contractAsJson); String signature = offererTradeProcessModel.signatureService.signMessage(offererTradeProcessModel.offerer.registrationKeyPair, contractAsJson);
offererTrade.setContract(contract); offererTrade.setContract(contract);
offererTrade.setContractAsJson(contractAsJson); offererTrade.setContractAsJson(contractAsJson);
offererTrade.setOffererContractSignature(signature); offererTrade.setOffererContractSignature(signature);
offererTrade.setTakerContractSignature(model.taker.contractSignature); offererTrade.setTakerContractSignature(offererTradeProcessModel.taker.contractSignature);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }
} }

13
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyTakeOfferFeePayment.java
View file

@ -17,32 +17,31 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel; import io.bitsquare.trade.OffererTrade;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class VerifyTakeOfferFeePayment extends Task<OffererAsBuyerModel> { public class VerifyTakeOfferFeePayment extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyTakeOfferFeePayment.class); private static final Logger log = LoggerFactory.getLogger(VerifyTakeOfferFeePayment.class);
public VerifyTakeOfferFeePayment(TaskRunner taskHandler, OffererAsBuyerModel model) { public VerifyTakeOfferFeePayment(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
//TODO mocked yet, need a confidence listeners //TODO mocked yet, need a confidence listeners
int numOfPeersSeenTx = model.walletService.getNumOfPeersSeenTx(model.getTakeOfferFeeTxId()); int numOfPeersSeenTx = offererTradeProcessModel.walletService.getNumOfPeersSeenTx(offererTradeProcessModel.getTakeOfferFeeTxId());
/* if (numOfPeersSeenTx > 2) { /* if (numOfPeersSeenTx > 2) {
resultHandler.handleResult(); resultHandler.handleResult();
}*/ }*/
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

18
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyTakerAccount.java
View file

@ -17,26 +17,26 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks; package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel; import io.bitsquare.trade.OffererTrade;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class VerifyTakerAccount extends Task<OffererAsBuyerModel> { public class VerifyTakerAccount extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyTakerAccount.class); private static final Logger log = LoggerFactory.getLogger(VerifyTakerAccount.class);
public VerifyTakerAccount(TaskRunner taskHandler, OffererAsBuyerModel model) { public VerifyTakerAccount(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, model); super(taskHandler, offererTradeProcessModel);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
//TODO mocked yet //TODO mocked yet
if (model.blockChainService.verifyAccountRegistration()) { if (offererTradeProcessModel.blockChainService.verifyAccountRegistration()) {
if (model.blockChainService.isAccountBlackListed(model.taker.accountId, model.taker.fiatAccount)) { if (offererTradeProcessModel.blockChainService.isAccountBlackListed(offererTradeProcessModel.taker.accountId, offererTradeProcessModel.taker
.fiatAccount)) {
log.error("Taker is blacklisted"); log.error("Taker is blacklisted");
failed("Taker is blacklisted"); failed("Taker is blacklisted");
} }
@ -46,9 +46,11 @@ public class VerifyTakerAccount extends Task<OffererAsBuyerModel> {
} }
else { else {
failed("Account registration validation for peer failed."); failed("Account registration validation for peer failed.");
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
} }
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }
} }

45
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/TakerAsSellerProtocol.java → core/src/main/java/io/bitsquare/trade/protocol/trade/taker/TakerProtocol.java
View file

@ -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.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestTakerDepositPaymentMessage; import io.bitsquare.trade.protocol.trade.messages.RequestTakerDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel; import io.bitsquare.trade.protocol.trade.taker.models.TakerTradeProcessModel;
import io.bitsquare.trade.protocol.trade.taker.tasks.BroadcastTakeOfferFeeTx; 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.CreateAndSignContract;
import io.bitsquare.trade.protocol.trade.taker.tasks.CreateTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.taker.tasks.CreateTakeOfferFeeTx;
@ -49,10 +49,11 @@ import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.nonEmptyStringOf; import static io.bitsquare.util.Validator.nonEmptyStringOf;
public class TakerAsSellerProtocol implements Protocol { public class TakerProtocol implements Protocol {
private static final Logger log = LoggerFactory.getLogger(TakerAsSellerProtocol.class); private static final Logger log = LoggerFactory.getLogger(TakerProtocol.class);
private final TakerAsSellerModel model; private final TakerTrade takerTrade;
private final TakerTradeProcessModel takerTradeProcessModel;
private final MessageHandler messageHandler; private final MessageHandler messageHandler;
@ -60,11 +61,13 @@ public class TakerAsSellerProtocol implements Protocol {
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public TakerAsSellerProtocol(TakerAsSellerModel model) { public TakerProtocol(TakerTrade takerTrade) {
log.debug("New SellerAsTakerProtocol " + this); log.debug("New SellerAsTakerProtocol " + this);
this.model = model; this.takerTrade = takerTrade;
takerTradeProcessModel = takerTrade.getTakerTradeProcessModel();
messageHandler = this::handleMessage; messageHandler = this::handleMessage;
model.messageService.addMessageHandler(messageHandler); takerTradeProcessModel.messageService.addMessageHandler(messageHandler);
} }
@ -74,14 +77,14 @@ public class TakerAsSellerProtocol implements Protocol {
public void cleanup() { public void cleanup() {
log.debug("cleanup " + this); log.debug("cleanup " + this);
model.messageService.removeMessageHandler(messageHandler); takerTradeProcessModel.messageService.removeMessageHandler(messageHandler);
} }
public void setMailboxMessage(MailboxMessage mailboxMessage) { public void setMailboxMessage(MailboxMessage mailboxMessage) {
log.debug("setMailboxMessage " + mailboxMessage); log.debug("setMailboxMessage " + mailboxMessage);
// Might be called twice, so check that its only processed once // Might be called twice, so check that its only processed once
if (model.mailboxMessage == null) { if (takerTradeProcessModel.mailboxMessage == null) {
model.mailboxMessage = mailboxMessage; takerTradeProcessModel.mailboxMessage = mailboxMessage;
if (mailboxMessage instanceof FiatTransferStartedMessage) { if (mailboxMessage instanceof FiatTransferStartedMessage) {
handleFiatTransferStartedMessage((FiatTransferStartedMessage) mailboxMessage); handleFiatTransferStartedMessage((FiatTransferStartedMessage) mailboxMessage);
} }
@ -92,7 +95,7 @@ public class TakerAsSellerProtocol implements Protocol {
} }
public void takeAvailableOffer() { public void takeAvailableOffer() {
TaskRunner<TakerAsSellerModel> taskRunner = new TaskRunner<>(model, TaskRunner<TakerTrade> taskRunner = new TaskRunner<>(takerTrade,
() -> { () -> {
log.debug("taskRunner at takeAvailableOffer completed"); log.debug("taskRunner at takeAvailableOffer completed");
}, },
@ -112,9 +115,9 @@ public class TakerAsSellerProtocol implements Protocol {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private void handleRequestTakerDepositPaymentMessage(RequestTakerDepositPaymentMessage tradeMessage) { private void handleRequestTakerDepositPaymentMessage(RequestTakerDepositPaymentMessage tradeMessage) {
model.setTradeMessage(tradeMessage); takerTradeProcessModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsSellerModel> taskRunner = new TaskRunner<>(model, TaskRunner<TakerTrade> taskRunner = new TaskRunner<>(takerTrade,
() -> { () -> {
log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"); log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed");
}, },
@ -131,9 +134,9 @@ public class TakerAsSellerProtocol implements Protocol {
} }
private void handleDepositTxPublishedMessage(DepositTxPublishedMessage tradeMessage) { private void handleDepositTxPublishedMessage(DepositTxPublishedMessage tradeMessage) {
model.setTradeMessage(tradeMessage); takerTradeProcessModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsSellerModel> taskRunner = new TaskRunner<>(model, TaskRunner<TakerTrade> taskRunner = new TaskRunner<>(takerTrade,
() -> { () -> {
log.debug("taskRunner at handleDepositTxPublishedMessage completed"); log.debug("taskRunner at handleDepositTxPublishedMessage completed");
}, },
@ -147,9 +150,9 @@ public class TakerAsSellerProtocol implements Protocol {
} }
private void handleFiatTransferStartedMessage(FiatTransferStartedMessage tradeMessage) { private void handleFiatTransferStartedMessage(FiatTransferStartedMessage tradeMessage) {
model.setTradeMessage(tradeMessage); takerTradeProcessModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsSellerModel> taskRunner = new TaskRunner<>(model, TaskRunner<TakerTrade> taskRunner = new TaskRunner<>(takerTrade,
() -> { () -> {
log.debug("taskRunner at handleFiatTransferStartedMessage completed"); log.debug("taskRunner at handleFiatTransferStartedMessage completed");
}, },
@ -166,14 +169,14 @@ public class TakerAsSellerProtocol implements Protocol {
// User clicked the "bank transfer received" button, so we release the funds for pay out // User clicked the "bank transfer received" button, so we release the funds for pay out
public void onFiatPaymentReceived() { public void onFiatPaymentReceived() {
model.trade.setProcessState(TakerTrade.TakerProcessState.FIAT_PAYMENT_RECEIVED); takerTrade.setProcessState(TakerTrade.TakerProcessState.FIAT_PAYMENT_RECEIVED);
TaskRunner<TakerAsSellerModel> taskRunner = new TaskRunner<>(model, TaskRunner<TakerTrade> taskRunner = new TaskRunner<>(takerTrade,
() -> { () -> {
log.debug("taskRunner at handleFiatReceivedUIEvent completed"); log.debug("taskRunner at handleFiatReceivedUIEvent completed");
// we are done! // we are done!
model.onComplete(); takerTradeProcessModel.onComplete();
}, },
(errorMessage) -> handleTaskRunnerFault(errorMessage)); (errorMessage) -> handleTaskRunnerFault(errorMessage));
@ -195,7 +198,7 @@ public class TakerAsSellerProtocol implements Protocol {
TradeMessage tradeMessage = (TradeMessage) message; TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId); nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(model.id)) { if (tradeMessage.tradeId.equals(takerTradeProcessModel.id)) {
if (tradeMessage instanceof RequestTakerDepositPaymentMessage) { if (tradeMessage instanceof RequestTakerDepositPaymentMessage) {
handleRequestTakerDepositPaymentMessage((RequestTakerDepositPaymentMessage) tradeMessage); handleRequestTakerDepositPaymentMessage((RequestTakerDepositPaymentMessage) tradeMessage);
} }

38
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerAsSellerModel.java → core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerTradeProcessModel.java
View file

@ -21,16 +21,14 @@ import io.bitsquare.arbitration.ArbitrationRepository;
import io.bitsquare.btc.BlockChainService; import io.bitsquare.btc.BlockChainService;
import io.bitsquare.btc.WalletService; import io.bitsquare.btc.WalletService;
import io.bitsquare.crypto.SignatureService; import io.bitsquare.crypto.SignatureService;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.MailboxService; import io.bitsquare.p2p.MailboxService;
import io.bitsquare.p2p.MessageService; import io.bitsquare.p2p.MessageService;
import io.bitsquare.storage.Storage; import io.bitsquare.trade.protocol.trade.TradeProcessModel;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.SharedTradeModel;
import io.bitsquare.user.User; import io.bitsquare.user.User;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
import java.io.File;
import java.io.Serializable; import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -39,32 +37,28 @@ import org.slf4j.LoggerFactory;
/** /**
* Holds all data which are needed between tasks. All relevant data for the trade itself are stored in Trade. * Holds all data which are needed between tasks. All relevant data for the trade itself are stored in Trade.
*/ */
public class TakerAsSellerModel extends SharedTradeModel implements Serializable { public class TakerTradeProcessModel extends TradeProcessModel implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // 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 long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(TakerAsSellerModel.class); transient private static final Logger log = LoggerFactory.getLogger(TakerTradeProcessModel.class);
transient private Storage<TakerAsSellerModel> storage; public final Taker taker = new Taker();
transient public final TakerTrade trade; public final Offerer offerer = new Offerer();
public final Taker taker;
public final Offerer offerer;
// written by tasks // written by tasks
private Transaction takeOfferFeeTx; private Transaction takeOfferFeeTx;
private Transaction payoutTx; private Transaction payoutTx;
public TakerAsSellerModel(TakerTrade trade, public TakerTradeProcessModel(Offer offer,
MessageService messageService, MessageService messageService,
MailboxService mailboxService, MailboxService mailboxService,
WalletService walletService, WalletService walletService,
BlockChainService blockChainService, BlockChainService blockChainService,
SignatureService signatureService, SignatureService signatureService,
ArbitrationRepository arbitrationRepository, ArbitrationRepository arbitrationRepository,
User user, User user) {
File storageDir) { super(offer,
super(trade.getOffer(),
messageService, messageService,
mailboxService, mailboxService,
walletService, walletService,
@ -72,10 +66,8 @@ public class TakerAsSellerModel extends SharedTradeModel implements Serializable
signatureService, signatureService,
arbitrationRepository); arbitrationRepository);
this.trade = trade;
this.storage = new Storage<>(storageDir);
TakerAsSellerModel persisted = storage.initAndGetPersisted(this, getFileName()); /*TakerProcessModel persisted = storage.initAndGetPersisted(this, getFileName());
if (persisted != null) { if (persisted != null) {
log.debug("Model reconstructed from persisted model."); log.debug("Model reconstructed from persisted model.");
@ -88,7 +80,7 @@ public class TakerAsSellerModel extends SharedTradeModel implements Serializable
else { else {
taker = new Taker(); taker = new Taker();
offerer = new Offerer(); offerer = new Offerer();
} }*/
taker.registrationPubKey = walletService.getRegistrationAddressEntry().getPubKey(); taker.registrationPubKey = walletService.getRegistrationAddressEntry().getPubKey();
taker.registrationKeyPair = walletService.getRegistrationAddressEntry().getKeyPair(); taker.registrationKeyPair = walletService.getRegistrationAddressEntry().getKeyPair();
@ -101,7 +93,7 @@ public class TakerAsSellerModel extends SharedTradeModel implements Serializable
} }
// Get called form taskRunner after each completed task // Get called form taskRunner after each completed task
@Override /* @Override
public void persist() { public void persist() {
storage.save(); storage.save();
} }
@ -110,7 +102,7 @@ public class TakerAsSellerModel extends SharedTradeModel implements Serializable
public void onComplete() { public void onComplete() {
// Just in case of successful completion we delete our persisted object // Just in case of successful completion we delete our persisted object
storage.remove(getFileName()); storage.remove(getFileName());
} }*/
public Transaction getTakeOfferFeeTx() { public Transaction getTakeOfferFeeTx() {
return takeOfferFeeTx; return takeOfferFeeTx;
@ -128,8 +120,8 @@ public class TakerAsSellerModel extends SharedTradeModel implements Serializable
this.payoutTx = payoutTx; this.payoutTx = payoutTx;
} }
private String getFileName() { /*private String getFileName() {
return getClass().getSimpleName() + "_" + id; return getClass().getSimpleName() + "_" + id;
} }*/
} }

16
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/BroadcastTakeOfferFeeTx.java
View file

@ -17,10 +17,8 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -31,23 +29,23 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class BroadcastTakeOfferFeeTx extends Task<TakerAsSellerModel> { public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(BroadcastTakeOfferFeeTx.class); private static final Logger log = LoggerFactory.getLogger(BroadcastTakeOfferFeeTx.class);
public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, TakerAsSellerModel model) { public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
model.tradeWalletService.broadcastTakeOfferFeeTx(model.getTakeOfferFeeTx(), takerTradeProcessModel.tradeWalletService.broadcastTakeOfferFeeTx(takerTradeProcessModel.getTakeOfferFeeTx(),
new FutureCallback<Transaction>() { new FutureCallback<Transaction>() {
@Override @Override
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString()); log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString());
model.trade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_PUBLISHED); takerTrade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_PUBLISHED);
complete(); complete();
} }
@ -55,14 +53,14 @@ public class BroadcastTakeOfferFeeTx extends Task<TakerAsSellerModel> {
@Override @Override
public void onFailure(@NotNull Throwable t) { public void onFailure(@NotNull Throwable t) {
appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again."); appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again.");
model.trade.setErrorMessage(errorMessage); takerTrade.setErrorMessage(errorMessage);
model.trade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED); takerTrade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
failed(t); failed(t);
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

37
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/CreateAndSignContract.java
View file

@ -17,47 +17,44 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Contract; import io.bitsquare.trade.Contract;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import io.bitsquare.util.Utilities; import io.bitsquare.util.Utilities;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class CreateAndSignContract extends Task<TakerAsSellerModel> { public class CreateAndSignContract extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateAndSignContract.class); private static final Logger log = LoggerFactory.getLogger(CreateAndSignContract.class);
public CreateAndSignContract(TaskRunner taskHandler, TakerAsSellerModel model) { public CreateAndSignContract(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
Trade trade = model.trade;
Contract contract = new Contract( Contract contract = new Contract(
model.offer, takerTradeProcessModel.offer,
trade.getTradeAmount(), model.getTradeAmount(),
model.getTakeOfferFeeTx().getHashAsString(), takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString(),
model.offerer.accountId, takerTradeProcessModel.offerer.accountId,
model.taker.accountId, takerTradeProcessModel.taker.accountId,
model.offerer.fiatAccount, takerTradeProcessModel.offerer.fiatAccount,
model.taker.fiatAccount, takerTradeProcessModel.taker.fiatAccount,
model.offer.getP2PSigPubKey(), takerTradeProcessModel.offer.getP2PSigPubKey(),
model.taker.p2pSigPubKey); takerTradeProcessModel.taker.p2pSigPubKey);
String contractAsJson = Utilities.objectToJson(contract); String contractAsJson = Utilities.objectToJson(contract);
String signature = model.signatureService.signMessage(model.taker.registrationKeyPair, contractAsJson); String signature = takerTradeProcessModel.signatureService.signMessage(takerTradeProcessModel.taker.registrationKeyPair, contractAsJson);
trade.setContract(contract); model.setContract(contract);
trade.setContractAsJson(contractAsJson); model.setContractAsJson(contractAsJson);
trade.setTakerContractSignature(signature); model.setTakerContractSignature(signature);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

14
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/CreateTakeOfferFeeTx.java
View file

@ -17,34 +17,32 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class CreateTakeOfferFeeTx extends Task<TakerAsSellerModel> { public class CreateTakeOfferFeeTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateTakeOfferFeeTx.class); private static final Logger log = LoggerFactory.getLogger(CreateTakeOfferFeeTx.class);
public CreateTakeOfferFeeTx(TaskRunner taskHandler, TakerAsSellerModel model) { public CreateTakeOfferFeeTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
Transaction createTakeOfferFeeTx = model.tradeWalletService.createTakeOfferFeeTx(model.taker.addressEntry); Transaction createTakeOfferFeeTx = takerTradeProcessModel.tradeWalletService.createTakeOfferFeeTx(takerTradeProcessModel.taker.addressEntry);
model.setTakeOfferFeeTx(createTakeOfferFeeTx); takerTradeProcessModel.setTakeOfferFeeTx(createTakeOfferFeeTx);
model.trade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_TX_CREATED); takerTrade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_TX_CREATED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

16
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessDepositTxPublishedMessage.java
View file

@ -17,11 +17,9 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -29,25 +27,25 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.checkTradeId; import static io.bitsquare.util.Validator.checkTradeId;
public class ProcessDepositTxPublishedMessage extends Task<TakerAsSellerModel> { public class ProcessDepositTxPublishedMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(ProcessDepositTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(ProcessDepositTxPublishedMessage.class);
public ProcessDepositTxPublishedMessage(TaskRunner taskHandler, TakerAsSellerModel model) { public ProcessDepositTxPublishedMessage(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
checkTradeId(model.id, model.getTradeMessage()); checkTradeId(takerTradeProcessModel.id, takerTradeProcessModel.getTradeMessage());
DepositTxPublishedMessage message = (DepositTxPublishedMessage) model.getTradeMessage(); DepositTxPublishedMessage message = (DepositTxPublishedMessage) takerTradeProcessModel.getTradeMessage();
model.trade.setDepositTx(checkNotNull(message.depositTx)); takerTrade.setDepositTx(checkNotNull(message.depositTx));
model.trade.setProcessState(TakerTrade.TakerProcessState.DEPOSIT_PUBLISHED); takerTrade.setProcessState(TakerTrade.TakerProcessState.DEPOSIT_PUBLISHED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

22
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessFiatTransferStartedMessage.java
View file

@ -17,11 +17,9 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -29,28 +27,28 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class ProcessFiatTransferStartedMessage extends Task<TakerAsSellerModel> { public class ProcessFiatTransferStartedMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(ProcessFiatTransferStartedMessage.class); private static final Logger log = LoggerFactory.getLogger(ProcessFiatTransferStartedMessage.class);
public ProcessFiatTransferStartedMessage(TaskRunner taskHandler, TakerAsSellerModel model) { public ProcessFiatTransferStartedMessage(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
checkTradeId(model.id, model.getTradeMessage()); checkTradeId(takerTradeProcessModel.id, takerTradeProcessModel.getTradeMessage());
FiatTransferStartedMessage message = (FiatTransferStartedMessage) model.getTradeMessage(); FiatTransferStartedMessage message = (FiatTransferStartedMessage) takerTradeProcessModel.getTradeMessage();
model.offerer.signature = checkNotNull(message.offererSignature); takerTradeProcessModel.offerer.signature = checkNotNull(message.offererSignature);
model.offerer.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.offererPayoutAmount)); takerTradeProcessModel.offerer.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.offererPayoutAmount));
model.taker.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.takerPayoutAmount)); takerTradeProcessModel.taker.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.takerPayoutAmount));
model.offerer.payoutAddressString = nonEmptyStringOf(message.offererPayoutAddress); takerTradeProcessModel.offerer.payoutAddressString = nonEmptyStringOf(message.offererPayoutAddress);
model.trade.setProcessState(TakerTrade.TakerProcessState.FIAT_PAYMENT_STARTED); takerTrade.setProcessState(TakerTrade.TakerProcessState.FIAT_PAYMENT_STARTED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

27
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/ProcessRequestTakerDepositPaymentMessage.java
View file

@ -17,10 +17,9 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestTakerDepositPaymentMessage; import io.bitsquare.trade.protocol.trade.messages.RequestTakerDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -28,31 +27,31 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*; import static com.google.common.base.Preconditions.*;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class ProcessRequestTakerDepositPaymentMessage extends Task<TakerAsSellerModel> { public class ProcessRequestTakerDepositPaymentMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(ProcessRequestTakerDepositPaymentMessage.class); private static final Logger log = LoggerFactory.getLogger(ProcessRequestTakerDepositPaymentMessage.class);
public ProcessRequestTakerDepositPaymentMessage(TaskRunner taskHandler, TakerAsSellerModel model) { public ProcessRequestTakerDepositPaymentMessage(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
checkTradeId(model.id, model.getTradeMessage()); checkTradeId(takerTradeProcessModel.id, takerTradeProcessModel.getTradeMessage());
RequestTakerDepositPaymentMessage message = (RequestTakerDepositPaymentMessage) model.getTradeMessage(); RequestTakerDepositPaymentMessage message = (RequestTakerDepositPaymentMessage) takerTradeProcessModel.getTradeMessage();
model.offerer.connectedOutputsForAllInputs = checkNotNull(message.offererConnectedOutputsForAllInputs); takerTradeProcessModel.offerer.connectedOutputsForAllInputs = checkNotNull(message.offererConnectedOutputsForAllInputs);
checkArgument(message.offererConnectedOutputsForAllInputs.size() > 0); checkArgument(message.offererConnectedOutputsForAllInputs.size() > 0);
model.offerer.outputs = checkNotNull(message.offererOutputs); takerTradeProcessModel.offerer.outputs = checkNotNull(message.offererOutputs);
model.offerer.tradeWalletPubKey = checkNotNull(message.offererTradeWalletPubKey); takerTradeProcessModel.offerer.tradeWalletPubKey = checkNotNull(message.offererTradeWalletPubKey);
model.offerer.p2pSigPublicKey = checkNotNull(message.offererP2PSigPublicKey); takerTradeProcessModel.offerer.p2pSigPublicKey = checkNotNull(message.offererP2PSigPublicKey);
model.offerer.p2pEncryptPubKey = checkNotNull(message.offererP2PEncryptPublicKey); takerTradeProcessModel.offerer.p2pEncryptPubKey = checkNotNull(message.offererP2PEncryptPublicKey);
model.offerer.fiatAccount = checkNotNull(message.offererFiatAccount); takerTradeProcessModel.offerer.fiatAccount = checkNotNull(message.offererFiatAccount);
model.offerer.accountId = nonEmptyStringOf(message.offererAccountId); takerTradeProcessModel.offerer.accountId = nonEmptyStringOf(message.offererAccountId);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

20
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendPayoutTxToOfferer.java
View file

@ -17,31 +17,29 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SendPayoutTxToOfferer extends Task<TakerAsSellerModel> { public class SendPayoutTxToOfferer extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(SendPayoutTxToOfferer.class); private static final Logger log = LoggerFactory.getLogger(SendPayoutTxToOfferer.class);
public SendPayoutTxToOfferer(TaskRunner taskHandler, TakerAsSellerModel model) { public SendPayoutTxToOfferer(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(model.id, model.getPayoutTx()); PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(takerTradeProcessModel.id, takerTradeProcessModel.getPayoutTx());
model.messageService.sendMessage(model.trade.getTradingPeer(), takerTradeProcessModel.messageService.sendMessage(takerTrade.getTradingPeer(),
tradeMessage, tradeMessage,
model.offerer.p2pSigPublicKey, takerTradeProcessModel.offerer.p2pSigPublicKey,
model.offerer.p2pEncryptPubKey, takerTradeProcessModel.offerer.p2pEncryptPubKey,
new SendMessageListener() { new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
@ -52,13 +50,13 @@ public class SendPayoutTxToOfferer extends Task<TakerAsSellerModel> {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending PayoutTxPublishedMessage failed"); appendToErrorMessage("Sending PayoutTxPublishedMessage failed");
model.trade.setErrorMessage(errorMessage); takerTrade.setErrorMessage(errorMessage);
model.trade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED); takerTrade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

22
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendRequestDepositTxInputsMessage.java
View file

@ -17,22 +17,20 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import javafx.application.Platform; import javafx.application.Platform;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SendRequestDepositTxInputsMessage extends Task<TakerAsSellerModel> { public class SendRequestDepositTxInputsMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(SendRequestDepositTxInputsMessage.class); private static final Logger log = LoggerFactory.getLogger(SendRequestDepositTxInputsMessage.class);
public SendRequestDepositTxInputsMessage(TaskRunner taskHandler, TakerAsSellerModel model) { public SendRequestDepositTxInputsMessage(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@ -42,12 +40,12 @@ public class SendRequestDepositTxInputsMessage extends Task<TakerAsSellerModel>
protected void doRun() { protected void doRun() {
try { try {
RequestDepositTxInputsMessage msg = new RequestDepositTxInputsMessage( RequestDepositTxInputsMessage msg = new RequestDepositTxInputsMessage(
model.id, takerTradeProcessModel.id,
model.getTakeOfferFeeTx().getHashAsString(), takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString(),
model.trade.getTradeAmount(), takerTrade.getTradeAmount(),
model.taker.tradeWalletPubKey); takerTradeProcessModel.taker.tradeWalletPubKey);
model.messageService.sendMessage(model.trade.getTradingPeer(), msg, new SendMessageListener() { takerTradeProcessModel.messageService.sendMessage(takerTrade.getTradingPeer(), msg, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
log.trace("Sending TakeOfferFeePayedMessage succeeded."); log.trace("Sending TakeOfferFeePayedMessage succeeded.");
@ -68,15 +66,15 @@ public class SendRequestDepositTxInputsMessage extends Task<TakerAsSellerModel>
"lost or the offerer lost his connection. We persisted the state of the trade, please try again later " + "lost or the offerer lost his connection. We persisted the state of the trade, please try again later " +
"or cancel that trade."); "or cancel that trade.");
model.trade.setErrorMessage(errorMessage); takerTrade.setErrorMessage(errorMessage);
model.trade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED); takerTrade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

36
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SendSignedTakerDepositTx.java
View file

@ -17,20 +17,18 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SendSignedTakerDepositTx extends Task<TakerAsSellerModel> { public class SendSignedTakerDepositTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(SendSignedTakerDepositTx.class); private static final Logger log = LoggerFactory.getLogger(SendSignedTakerDepositTx.class);
public SendSignedTakerDepositTx(TaskRunner taskHandler, TakerAsSellerModel model) { public SendSignedTakerDepositTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@ -38,20 +36,20 @@ public class SendSignedTakerDepositTx extends Task<TakerAsSellerModel> {
protected void doRun() { protected void doRun() {
try { try {
RequestOffererPublishDepositTxMessage tradeMessage = new RequestOffererPublishDepositTxMessage( RequestOffererPublishDepositTxMessage tradeMessage = new RequestOffererPublishDepositTxMessage(
model.id, takerTradeProcessModel.id,
model.taker.fiatAccount, takerTradeProcessModel.taker.fiatAccount,
model.taker.accountId, takerTradeProcessModel.taker.accountId,
model.taker.p2pSigPubKey, takerTradeProcessModel.taker.p2pSigPubKey,
model.taker.p2pEncryptPublicKey, takerTradeProcessModel.taker.p2pEncryptPublicKey,
model.trade.getContractAsJson(), takerTrade.getContractAsJson(),
model.trade.getTakerContractSignature(), takerTrade.getTakerContractSignature(),
model.taker.addressEntry.getAddressString(), takerTradeProcessModel.taker.addressEntry.getAddressString(),
model.taker.preparedDepositTx, takerTradeProcessModel.taker.preparedDepositTx,
model.taker.connectedOutputsForAllInputs, takerTradeProcessModel.taker.connectedOutputsForAllInputs,
model.taker.outputs takerTradeProcessModel.taker.outputs
); );
model.messageService.sendMessage(model.trade.getTradingPeer(), tradeMessage, new SendMessageListener() { takerTradeProcessModel.messageService.sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
complete(); complete();
@ -60,14 +58,14 @@ public class SendSignedTakerDepositTx extends Task<TakerAsSellerModel> {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending RequestOffererDepositPublicationMessage failed"); appendToErrorMessage("Sending RequestOffererDepositPublicationMessage failed");
model.trade.setErrorMessage(errorMessage); takerTrade.setErrorMessage(errorMessage);
model.trade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED); takerTrade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

34
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SignAndPublishPayoutTx.java
View file

@ -17,10 +17,8 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -31,43 +29,43 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SignAndPublishPayoutTx extends Task<TakerAsSellerModel> { public class SignAndPublishPayoutTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(SignAndPublishPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(SignAndPublishPayoutTx.class);
public SignAndPublishPayoutTx(TaskRunner taskHandler, TakerAsSellerModel model) { public SignAndPublishPayoutTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
model.tradeWalletService.takerSignsAndPublishPayoutTx( takerTradeProcessModel.tradeWalletService.takerSignsAndPublishPayoutTx(
model.trade.getDepositTx(), takerTrade.getDepositTx(),
model.offerer.signature, takerTradeProcessModel.offerer.signature,
model.offerer.payoutAmount, takerTradeProcessModel.offerer.payoutAmount,
model.taker.payoutAmount, takerTradeProcessModel.taker.payoutAmount,
model.offerer.payoutAddressString, takerTradeProcessModel.offerer.payoutAddressString,
model.taker.addressEntry, takerTradeProcessModel.taker.addressEntry,
model.offerer.tradeWalletPubKey, takerTradeProcessModel.offerer.tradeWalletPubKey,
model.taker.tradeWalletPubKey, takerTradeProcessModel.taker.tradeWalletPubKey,
model.arbitratorPubKey, takerTradeProcessModel.arbitratorPubKey,
new FutureCallback<Transaction>() { new FutureCallback<Transaction>() {
@Override @Override
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
model.setPayoutTx(transaction); takerTradeProcessModel.setPayoutTx(transaction);
model.trade.setProcessState(TakerTrade.TakerProcessState.PAYOUT_PUBLISHED); takerTrade.setProcessState(TakerTrade.TakerProcessState.PAYOUT_PUBLISHED);
complete(); complete();
} }
@Override @Override
public void onFailure(@NotNull Throwable t) { public void onFailure(@NotNull Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

13
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerCommitDepositTx.java
View file

@ -17,19 +17,18 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel; import io.bitsquare.trade.TakerTrade;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerCommitDepositTx extends Task<TakerAsSellerModel> { public class TakerCommitDepositTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCommitDepositTx.class); private static final Logger log = LoggerFactory.getLogger(TakerCommitDepositTx.class);
public TakerCommitDepositTx(TaskRunner taskHandler, TakerAsSellerModel model) { public TakerCommitDepositTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@ -37,13 +36,13 @@ public class TakerCommitDepositTx extends Task<TakerAsSellerModel> {
protected void doRun() { protected void doRun() {
try { try {
// To access tx confidence we need to add that tx into our wallet. // To access tx confidence we need to add that tx into our wallet.
Transaction depositTx = model.tradeWalletService.commitsDepositTx(model.trade.getDepositTx()); Transaction depositTx = takerTradeProcessModel.tradeWalletService.commitsDepositTx(takerTrade.getDepositTx());
model.trade.setDepositTx(depositTx); takerTrade.setDepositTx(depositTx);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

33
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerCreatesAndSignsDepositTx.java
View file

@ -19,46 +19,45 @@ package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.btc.FeePolicy; import io.bitsquare.btc.FeePolicy;
import io.bitsquare.btc.TradeWalletService; import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel; import io.bitsquare.trade.TakerTrade;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignsDepositTx extends Task<TakerAsSellerModel> { public class TakerCreatesAndSignsDepositTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsDepositTx.class); private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsDepositTx.class);
public TakerCreatesAndSignsDepositTx(TaskRunner taskHandler, TakerAsSellerModel model) { public TakerCreatesAndSignsDepositTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
Coin takerInputAmount = model.trade.getTradeAmount().add(model.trade.getSecurityDeposit()).add(FeePolicy.TX_FEE); Coin takerInputAmount = takerTrade.getTradeAmount().add(takerTrade.getSecurityDeposit()).add(FeePolicy.TX_FEE);
Coin msOutputAmount = takerInputAmount.add(model.trade.getSecurityDeposit()); Coin msOutputAmount = takerInputAmount.add(takerTrade.getSecurityDeposit());
TradeWalletService.Result result = model.tradeWalletService.takerCreatesAndSignsDepositTx( TradeWalletService.Result result = takerTradeProcessModel.tradeWalletService.takerCreatesAndSignsDepositTx(
takerInputAmount, takerInputAmount,
msOutputAmount, msOutputAmount,
model.offerer.connectedOutputsForAllInputs, takerTradeProcessModel.offerer.connectedOutputsForAllInputs,
model.offerer.outputs, takerTradeProcessModel.offerer.outputs,
model.taker.addressEntry, takerTradeProcessModel.taker.addressEntry,
model.offerer.tradeWalletPubKey, takerTradeProcessModel.offerer.tradeWalletPubKey,
model.taker.tradeWalletPubKey, takerTradeProcessModel.taker.tradeWalletPubKey,
model.arbitratorPubKey); takerTradeProcessModel.arbitratorPubKey);
model.taker.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs(); takerTradeProcessModel.taker.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs();
model.taker.outputs = result.getOutputs(); takerTradeProcessModel.taker.outputs = result.getOutputs();
model.taker.preparedDepositTx = result.getDepositTx(); takerTradeProcessModel.taker.preparedDepositTx = result.getDepositTx();
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

46
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerTradeTask.java Normal file
View file

@ -0,0 +1,46 @@
/*
* This file is part of Bitsquare.
*
* Bitsquare is free software: you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or (at
* your option) any later version.
*
* Bitsquare is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
* License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.btc.exceptions.SigningException;
import io.bitsquare.btc.exceptions.TransactionVerificationException;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerTradeTask extends Task<TakerTrade> {
private static final Logger log = LoggerFactory.getLogger(TakerTradeTask.class);
protected final TakerTradeProcessModel takerTradeProcessModel;
protected final TakerTrade takerTrade;
public TakerTradeTask(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
takerTrade = model;
takerTradeProcessModel = takerTrade.getTakerTradeProcessModel();
}
@Override
protected void doRun() throws WalletException, TransactionVerificationException, SigningException {
}
}

11
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/VerifyOfferFeePayment.java
View file

@ -17,17 +17,16 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel; import io.bitsquare.trade.TakerTrade;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class VerifyOfferFeePayment extends Task<TakerAsSellerModel> { public class VerifyOfferFeePayment extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyOfferFeePayment.class); private static final Logger log = LoggerFactory.getLogger(VerifyOfferFeePayment.class);
public VerifyOfferFeePayment(TaskRunner taskHandler, TakerAsSellerModel model) { public VerifyOfferFeePayment(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@ -35,13 +34,13 @@ public class VerifyOfferFeePayment extends Task<TakerAsSellerModel> {
protected void doRun() { protected void doRun() {
try { try {
//TODO impl. missing //TODO impl. missing
int numOfPeersSeenTx = model.walletService.getNumOfPeersSeenTx(model.getTakeOfferFeeTx().getHashAsString()); int numOfPeersSeenTx = takerTradeProcessModel.walletService.getNumOfPeersSeenTx(takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString());
/* if (numOfPeersSeenTx > 2) { /* if (numOfPeersSeenTx > 2) {
resultHandler.handleResult(); resultHandler.handleResult();
}*/ }*/
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }

13
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/VerifyOffererAccount.java
View file

@ -17,25 +17,24 @@
package io.bitsquare.trade.protocol.trade.taker.tasks; package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel; import io.bitsquare.trade.TakerTrade;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class VerifyOffererAccount extends Task<TakerAsSellerModel> { public class VerifyOffererAccount extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyOffererAccount.class); private static final Logger log = LoggerFactory.getLogger(VerifyOffererAccount.class);
public VerifyOffererAccount(TaskRunner taskHandler, TakerAsSellerModel model) { public VerifyOffererAccount(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model); super(taskHandler, model);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
if (model.blockChainService.verifyAccountRegistration()) { if (takerTradeProcessModel.blockChainService.verifyAccountRegistration()) {
if (model.blockChainService.isAccountBlackListed(model.offerer.accountId, model.offerer.fiatAccount)) { if (takerTradeProcessModel.blockChainService.isAccountBlackListed(takerTradeProcessModel.offerer.accountId, takerTradeProcessModel.offerer.fiatAccount)) {
failed("Taker is blacklisted."); failed("Taker is blacklisted.");
} }
else { else {
@ -46,7 +45,7 @@ public class VerifyOffererAccount extends Task<TakerAsSellerModel> {
failed("Account registration validation for peer faultHandler.onFault."); failed("Account registration validation for peer faultHandler.onFault.");
} }
} catch (Throwable t) { } catch (Throwable t) {
model.trade.setThrowable(t); takerTrade.setThrowable(t);
failed(t); failed(t);
} }
} }