Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-04-20 15:55:54 -04:00
Code Issues Packages Projects Releases 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
Show Stats 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.LoggerFactory;
public class SharedTaskModel {
private static final Logger log = LoggerFactory.getLogger(SharedTaskModel.class);
public class Model {
private static final Logger log = LoggerFactory.getLogger(Model.class);
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.LoggerFactory;
public abstract class Task<T extends SharedTaskModel> {
public abstract class Task<T extends Model> {
private static final Logger log = LoggerFactory.getLogger(Task.class);
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.LoggerFactory;
public class TaskRunner<T extends SharedTaskModel> {
public class TaskRunner<T extends Model> {
private static final Logger log = LoggerFactory.getLogger(TaskRunner.class);
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.CreateOfferFeeTx;
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.CreateOffererDepositTxInputs;
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.VerifyTakeOfferFeePayment;
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.CreateTakeOfferFeeTx;
import io.bitsquare.trade.protocol.trade.taker.tasks.ProcessDepositTxPublishedMessage;
@ -100,7 +100,7 @@ public class DebugView extends InitializableView {
/*---- Protocol ----*/
OffererAsBuyerProtocol.class,
OffererProtocol.class,
ProcessRequestDepositTxInputsMessage.class,
CreateOffererDepositTxInputs.class,
RequestTakerDepositPayment.class,
@ -120,7 +120,7 @@ public class DebugView extends InitializableView {
/*---- Protocol ----*/
TakerAsSellerProtocol.class,
TakerProtocol.class,
CreateTakeOfferFeeTx.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";
case FAILED:
return "Failed";
case OPEN_OFFER:
case OFFER_OPEN:
case PENDING:
throw new RuntimeException("That must not happen. We got a pending state but we are in the closed trades list.");
}

28
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.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.TransactionConfidence;
@ -51,7 +53,8 @@ public class OffererTrade extends Trade implements Serializable {
///////////////////////////////////////////////////////////////////////////////////////////
public enum OffererLifeCycleState implements LifeCycleState {
OPEN_OFFER,
OFFER_OPEN,
OFFER_RESERVED,
OFFER_CANCELED,
PENDING,
COMPLETED,
@ -75,6 +78,7 @@ public class OffererTrade extends Trade implements Serializable {
private Peer tradingPeer;
private OffererProcessState processState;
private OffererLifeCycleState lifeCycleState;
private OffererTradeProcessModel offererTradeProcessModel;
transient private ObjectProperty<OffererProcessState> processStateProperty = new SimpleObjectProperty<>();
transient private ObjectProperty<OffererLifeCycleState> lifeCycleStateProperty = new SimpleObjectProperty<>();
@ -84,8 +88,12 @@ public class OffererTrade extends Trade implements Serializable {
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public OffererTrade(Offer offer) {
super(offer);
public OffererTrade(Offer offer, OffererTradeProcessModel offererTradeProcessModel, Storage storage) {
super(offer, storage);
this.offererTradeProcessModel = offererTradeProcessModel;
protocol = new OffererProtocol(this);
setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
}
// Serialized object does not create our transient objects
@ -94,11 +102,15 @@ public class OffererTrade extends Trade implements Serializable {
processStateProperty = new SimpleObjectProperty<>(processState);
lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState);
protocol = new OffererProtocol(this);
}
public void onFiatPaymentStarted() {
((OffererAsBuyerProtocol) protocol).onFiatPaymentStarted();
((OffererProtocol) protocol).onFiatPaymentStarted();
}
public OffererTradeProcessModel getOffererTradeProcessModel() {
return offererTradeProcessModel;
}
@ -140,7 +152,7 @@ public class OffererTrade extends Trade implements Serializable {
public void setTradingPeer(Peer tradingPeer) {
this.tradingPeer = tradingPeer;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Getters
@ -170,7 +182,7 @@ public class OffererTrade extends Trade implements Serializable {
public Peer getTradingPeer() {
return tradingPeer;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Private

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

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

@ -18,10 +18,13 @@
package io.bitsquare.trade;
import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.common.taskrunner.Model;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.protocol.trade.taker.models.TakerTradeProcessModel;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction;
@ -39,27 +42,28 @@ import org.slf4j.Logger;
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.
*/
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.
private static final long serialVersionUID = 1L;
transient protected static final Logger log = LoggerFactory.getLogger(Trade.class);
public interface ProcessState {
}
public interface LifeCycleState {
}
transient protected Protocol protocol;
protected MailboxMessage mailboxMessage;
protected final Offer offer;
protected final Date date;
protected Protocol protocol;
protected Contract contract;
protected String contractAsJson;
protected String takerContractSignature;
@ -73,17 +77,24 @@ abstract public class Trade implements Serializable {
transient protected ObjectProperty<Coin> tradeAmountProperty = new SimpleObjectProperty<>();
transient protected ObjectProperty<Fiat> tradeVolumeProperty = new SimpleObjectProperty<>();
transient private Storage<TakerTradeProcessModel> storage;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public Trade(Offer offer) {
public Trade(Offer offer, Storage storage) {
this.offer = offer;
this.storage = storage;
date = new Date();
}
///////////////////////////////////////////////////////////////////////////////////////////
// API
///////////////////////////////////////////////////////////////////////////////////////////
// The deserialized tx has not actual confidence data, so we need to get the fresh one from the wallet.
public void updateTxFromWallet(TradeWalletService tradeWalletService) {
if (depositTx != null)
@ -95,17 +106,26 @@ abstract public class Trade implements Serializable {
setConfidenceListener();
}
///////////////////////////////////////////////////////////////////////////////////////////
// Protocol
///////////////////////////////////////////////////////////////////////////////////////////
public void setProtocol(Protocol protocol) {
this.protocol = protocol;
public void reActivate() {
if (mailboxMessage != null)
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() {
if (protocol != null) {
protocol.cleanup();
@ -119,6 +139,9 @@ abstract public class Trade implements Serializable {
protocol.setMailboxMessage(mailboxMessage);
}
public void setStorage(Storage storage) {
this.storage = storage;
}
///////////////////////////////////////////////////////////////////////////////////////////
// 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 java.io.File;
import java.io.Serializable;
import java.util.ArrayList;
@ -45,8 +44,8 @@ public class TradeList<T> extends ArrayList<T> implements Serializable {
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public TradeList(File storageDir, String fileName) {
this.storage = new Storage<>(storageDir);
public TradeList(Storage<TradeList> storage, String fileName) {
this.storage = storage;
TradeList persisted = storage.initAndGetPersisted(this, fileName);
if (persisted != null) {

98
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.MessageService;
import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.handlers.TakeOfferResultHandler;
import io.bitsquare.trade.handlers.TransactionResultHandler;
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.PlaceOfferProtocol;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.offerer.OffererAsBuyerProtocol;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import io.bitsquare.trade.protocol.trade.taker.TakerAsSellerProtocol;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererTradeProcessModel;
import io.bitsquare.trade.protocol.trade.taker.models.TakerTradeProcessModel;
import io.bitsquare.user.AccountSettings;
import io.bitsquare.user.User;
@ -85,6 +84,7 @@ public class TradeManager {
private final AddressService addressService;
private final BlockChainService blockChainService;
private final WalletService walletService;
private final Storage pendingTradesStorage;
private TradeWalletService tradeWalletService;
private final SignatureService signatureService;
private final EncryptionService<MailboxMessage> encryptionService;
@ -124,9 +124,11 @@ public class TradeManager {
this.arbitrationRepository = arbitrationRepository;
this.storageDir = storageDir;
this.openOfferTrades = new TradeList<>(storageDir, "OpenOfferTrades");
this.pendingTrades = new TradeList<>(storageDir, "PendingTrades");
this.closedTrades = new TradeList<>(storageDir, "ClosedTrades");
pendingTradesStorage = new Storage(storageDir);
this.openOfferTrades = new TradeList<>(pendingTradesStorage, "OpenOfferTrades");
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
Thread shutDownHookThread = new Thread(TradeManager.this::shutDown, "TradeManager:ShutDownHook");
@ -162,25 +164,16 @@ public class TradeManager {
() -> log.debug("Successful removed open offer from DHT"),
(message, throwable) -> log.error("Remove open offer from DHT failed. " + message));
OffererAsBuyerProtocol protocol = createOffererAsBuyerProtocol(offererTrade);
offererTrade.setProtocol(protocol);
offererTrade.reActivate();
}
for (Trade trade : pendingTrades) {
// We continue an interrupted trade.
// TODO if the peer has changed its IP address, we need to make another findPeer request. At the moment we use the peer stored in trade to
// continue the trade, but that might fail.
if (trade instanceof OffererTrade) {
OffererTrade offererTrade = (OffererTrade) trade;
OffererAsBuyerProtocol protocol = createOffererAsBuyerProtocol(offererTrade);
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);
}
trade.reActivate();
trade.updateTxFromWallet(tradeWalletService);
trade.setStorage(pendingTradesStorage);
}
mailboxService.getAllMessages(user.getP2PSigPubKey(),
@ -224,12 +217,21 @@ public class TradeManager {
PlaceOfferProtocol placeOfferProtocol = new PlaceOfferProtocol(
model,
(transaction) -> {
OffererTrade offererTrade = new OffererTrade(offer);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OPEN_OFFER);
OffererTradeProcessModel processModel = createOffererTradeProcessModel(offer);
OffererTrade offererTrade = new OffererTrade(offer, processModel, pendingTradesStorage);
openOfferTrades.add(offererTrade);
OffererAsBuyerProtocol protocol = createOffererAsBuyerProtocol(offererTrade);
offererTrade.setProtocol(protocol);
offererTrade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("offererTrade state = " + newValue);
if (newValue == OffererTrade.OffererProcessState.DEPOSIT_PUBLISHED) {
removeOpenOffer(offererTrade.getOffer(),
() -> log.debug("remove offer was successful"),
(message) -> log.error(message),
false);
pendingTrades.add(offererTrade);
}
});
resultHandler.handleResult(transaction);
},
(message) -> errorMessageHandler.handleErrorMessage(message)
@ -404,37 +406,27 @@ public class TradeManager {
///////////////////////////////////////////////////////////////////////////////////////////
private TakerTrade takeAvailableOffer(Coin amount, Offer offer, Peer peer) {
TakerTrade takerTrade = new TakerTrade(offer, amount, peer);
takerTrade.setLifeCycleState(TakerTrade.TakerLifeCycleState.PENDING);
TakerTradeProcessModel takerTradeProcessModel = createTakerProcessModel(offer);
TakerTrade takerTrade = new TakerTrade(offer, amount, peer, takerTradeProcessModel, pendingTradesStorage);
pendingTrades.add(takerTrade);
TakerAsSellerProtocol sellerTakesOfferProtocol = createTakerAsSellerProtocol(takerTrade);
takerTrade.setProtocol(sellerTakesOfferProtocol);
sellerTakesOfferProtocol.takeAvailableOffer();
return takerTrade;
}
private TakerAsSellerProtocol createTakerAsSellerProtocol(TakerTrade takerTrade) {
TakerAsSellerModel model = new TakerAsSellerModel(
takerTrade,
private TakerTradeProcessModel createTakerProcessModel(Offer offer) {
return new TakerTradeProcessModel(
offer,
messageService,
mailboxService,
walletService,
blockChainService,
signatureService,
arbitrationRepository,
user,
storageDir);
return new TakerAsSellerProtocol(model);
user);
}
private OffererAsBuyerProtocol createOffererAsBuyerProtocol(OffererTrade offererTrade) {
OffererAsBuyerModel model = new OffererAsBuyerModel(
offererTrade,
private OffererTradeProcessModel createOffererTradeProcessModel(Offer offer) {
return new OffererTradeProcessModel(offer,
messageService,
mailboxService,
walletService,
@ -443,26 +435,6 @@ public class TradeManager {
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;
import io.bitsquare.common.taskrunner.SharedTaskModel;
import io.bitsquare.common.taskrunner.Model;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.AddressService;
import io.bitsquare.p2p.MessageService;
@ -27,7 +27,7 @@ import io.bitsquare.trade.protocol.trade.messages.OfferMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CheckOfferAvailabilityModel extends SharedTaskModel {
public class CheckOfferAvailabilityModel extends Model {
private static final Logger log = LoggerFactory.getLogger(CheckOfferAvailabilityModel.class);
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;
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.OfferBookService;
@ -27,7 +27,7 @@ import org.bitcoinj.core.Transaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PlaceOfferModel extends SharedTaskModel {
public class PlaceOfferModel extends Model {
private static final Logger log = LoggerFactory.getLogger(PlaceOfferModel.class);
public final Offer offer;

20
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.TradeWalletService;
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.offer.Offer;
import io.bitsquare.p2p.MailboxMessage;
@ -34,11 +34,11 @@ import java.io.Serializable;
import org.slf4j.Logger;
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.
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;
// provided
@ -59,13 +59,13 @@ public class SharedTradeModel extends SharedTaskModel implements Serializable {
// data written/read by tasks
transient private TradeMessage tradeMessage;
protected SharedTradeModel(Offer offer,
MessageService messageService,
MailboxService mailboxService,
WalletService walletService,
BlockChainService blockChainService,
SignatureService signatureService,
ArbitrationRepository arbitrationRepository) {
protected TradeProcessModel(Offer offer,
MessageService messageService,
MailboxService mailboxService,
WalletService walletService,
BlockChainService blockChainService,
SignatureService signatureService,
ArbitrationRepository arbitrationRepository) {
this.offer = offer;
this.messageService = messageService;
this.mailboxService = mailboxService;

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.RequestOffererPublishDepositTxMessage;
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.CreateOffererDepositTxInputs;
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.VerifyTakerAccount;
import javafx.application.Platform;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.*;
public class OffererAsBuyerProtocol implements Protocol {
private static final Logger log = LoggerFactory.getLogger(OffererAsBuyerProtocol.class);
public class OffererProtocol implements Protocol {
private static final Logger log = LoggerFactory.getLogger(OffererProtocol.class);
private final OffererAsBuyerModel model;
private final MessageHandler messageHandler;
private final OffererTrade offererTrade;
private final OffererTradeProcessModel offererTradeProcessModel;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public OffererAsBuyerProtocol(OffererAsBuyerModel model) {
public OffererProtocol(OffererTrade model) {
log.debug("New BuyerAsOffererProtocol " + this);
this.model = model;
this.offererTrade = model;
offererTradeProcessModel = offererTrade.getOffererTradeProcessModel();
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) {
log.debug("setMailboxMessage " + mailboxMessage);
// Might be called twice, so check that its only processed once
if (model.mailboxMessage == null) {
model.mailboxMessage = mailboxMessage;
if (offererTradeProcessModel.mailboxMessage == null) {
offererTradeProcessModel.mailboxMessage = mailboxMessage;
if (mailboxMessage instanceof PayoutTxPublishedMessage) {
handlePayoutTxPublishedMessage((PayoutTxPublishedMessage) mailboxMessage);
}
@ -90,10 +89,7 @@ public class OffererAsBuyerProtocol implements Protocol {
public void cleanup() {
log.debug("cleanup " + this);
// tradeMessageService and transactionConfidence use CopyOnWriteArrayList as listeners, but be safe and delay remove a bit.
Platform.runLater(() -> {
model.messageService.removeMessageHandler(messageHandler);
});
offererTradeProcessModel.messageService.removeMessageHandler(messageHandler);
}
///////////////////////////////////////////////////////////////////////////////////////////
@ -103,13 +99,15 @@ public class OffererAsBuyerProtocol implements Protocol {
// OpenOffer requests
private void handleRequestIsOfferAvailableMessage(RequestIsOfferAvailableMessage tradeMessage, Peer sender) {
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
boolean isOfferOpen = model.trade.lifeCycleStateProperty().get() == OffererTrade.OffererLifeCycleState.OPEN_OFFER;
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(model.id, isOfferOpen);
model.messageService.sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
boolean isOfferOpen = offererTrade.lifeCycleStateProperty().get() == OffererTrade.OffererLifeCycleState.OFFER_OPEN;
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(offererTradeProcessModel.id, isOfferOpen);
offererTradeProcessModel.messageService.sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@Override
public void handleResult() {
// Offerer does not do anything at that moment. Peer might only watch the offer and does not start a trade.
@ -128,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) {
checkTradeId(model.id, tradeMessage);
model.setTradeMessage(tradeMessage);
model.trade.setTradingPeer(taker);
checkTradeId(offererTradeProcessModel.id, tradeMessage);
offererTradeProcessModel.setTradeMessage(tradeMessage);
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"),
(errorMessage) -> handleTaskRunnerFault(errorMessage));
taskRunner.addTasks(
@ -146,9 +145,9 @@ public class OffererAsBuyerProtocol implements Protocol {
}
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"),
(errorMessage) -> handleTaskRunnerFault(errorMessage));
taskRunner.addTasks(
@ -168,7 +167,7 @@ public class OffererAsBuyerProtocol implements Protocol {
// User clicked the "bank transfer started" button
public void onFiatPaymentStarted() {
TaskRunner<OffererAsBuyerModel> taskRunner = new TaskRunner<>(model,
TaskRunner<OffererTrade> taskRunner = new TaskRunner<>(offererTrade,
() -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"),
(errorMessage) -> handleTaskRunnerFault(errorMessage));
taskRunner.addTasks(
@ -185,13 +184,13 @@ public class OffererAsBuyerProtocol implements Protocol {
///////////////////////////////////////////////////////////////////////////////////////////
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");
// we are done!
model.onComplete();
offererTradeProcessModel.onComplete();
},
(errorMessage) -> handleTaskRunnerFault(errorMessage));
@ -210,7 +209,7 @@ public class OffererAsBuyerProtocol implements Protocol {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(model.id)) {
if (tradeMessage.tradeId.equals(offererTrade.getId())) {
if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
handleRequestIsOfferAvailableMessage((RequestIsOfferAvailableMessage) tradeMessage, sender);
}

34
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.WalletService;
import io.bitsquare.crypto.SignatureService;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.MailboxService;
import io.bitsquare.p2p.MessageService;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.SharedTradeModel;
import io.bitsquare.trade.protocol.trade.TradeProcessModel;
import io.bitsquare.user.User;
import java.io.File;
@ -34,14 +34,13 @@ import java.io.Serializable;
import org.slf4j.Logger;
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.
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 public final OffererTrade trade;
transient private Storage<OffererTradeProcessModel> storage;
public final Taker taker;
public final Offerer offerer;
@ -49,16 +48,16 @@ public class OffererAsBuyerModel extends SharedTradeModel implements Serializabl
// written by tasks
private String takeOfferFeeTxId;
public OffererAsBuyerModel(OffererTrade trade,
MessageService messageService,
MailboxService mailboxService,
WalletService walletService,
BlockChainService blockChainService,
SignatureService signatureService,
ArbitrationRepository arbitrationRepository,
User user,
File storageDir) {
super(trade.getOffer(),
public OffererTradeProcessModel(Offer offer,
MessageService messageService,
MailboxService mailboxService,
WalletService walletService,
BlockChainService blockChainService,
SignatureService signatureService,
ArbitrationRepository arbitrationRepository,
User user,
File storageDir) {
super(offer,
messageService,
mailboxService,
walletService,
@ -66,10 +65,9 @@ public class OffererAsBuyerModel extends SharedTradeModel implements Serializabl
signatureService,
arbitrationRepository);
this.trade = trade;
this.storage = new Storage<>(storageDir);
OffererAsBuyerModel persisted = storage.initAndGetPersisted(this, getFileName());
OffererTradeProcessModel persisted = storage.initAndGetPersisted(this, getFileName());
if (persisted != null) {
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;
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.OffererAsBuyerModel;
import org.bitcoinj.core.Coin;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CreateAndSignPayoutTx extends Task<OffererAsBuyerModel> {
public class CreateAndSignPayoutTx extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateAndSignPayoutTx.class);
public CreateAndSignPayoutTx(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public CreateAndSignPayoutTx(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
try {
OffererTrade offererTrade = model.trade;
Coin securityDeposit = offererTrade.getSecurityDeposit();
Coin offererPayoutAmount = offererTrade.getTradeAmount().add(securityDeposit);
@SuppressWarnings("UnnecessaryLocalVariable") Coin takerPayoutAmount = securityDeposit;
byte[] offererPayoutTxSignature = model.tradeWalletService.offererCreatesAndSignsPayoutTx(
byte[] offererPayoutTxSignature = offererTradeProcessModel.tradeWalletService.offererCreatesAndSignsPayoutTx(
offererTrade.getDepositTx(),
offererPayoutAmount,
takerPayoutAmount,
model.offerer.addressEntry,
model.taker.payoutAddressString,
model.offerer.tradeWalletPubKey,
model.taker.tradeWalletPubKey,
model.arbitratorPubKey);
offererTradeProcessModel.offerer.addressEntry,
offererTradeProcessModel.taker.payoutAddressString,
offererTradeProcessModel.offerer.tradeWalletPubKey,
offererTradeProcessModel.taker.tradeWalletPubKey,
offererTradeProcessModel.arbitratorPubKey);
model.offerer.payoutTxSignature = offererPayoutTxSignature;
model.offerer.payoutAmount = offererPayoutAmount;
model.taker.payoutAmount = takerPayoutAmount;
offererTradeProcessModel.offerer.payoutTxSignature = offererPayoutTxSignature;
offererTradeProcessModel.offerer.payoutAmount = offererPayoutAmount;
offererTradeProcessModel.taker.payoutAmount = takerPayoutAmount;
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(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.TradeWalletService;
import io.bitsquare.common.taskrunner.Task;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CreateOffererDepositTxInputs extends Task<OffererAsBuyerModel> {
public class CreateOffererDepositTxInputs extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateOffererDepositTxInputs.class);
public CreateOffererDepositTxInputs(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public CreateOffererDepositTxInputs(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
try {
log.debug("model.trade.id" + model.trade.getId());
Coin offererInputAmount = model.trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
TradeWalletService.Result result = model.tradeWalletService.createOffererDepositTxInputs(offererInputAmount,
model.offerer.addressEntry);
log.debug("offererTrade.id" + offererTrade.getId());
Coin offererInputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
TradeWalletService.Result result = offererTradeProcessModel.tradeWalletService.createOffererDepositTxInputs(offererInputAmount,
offererTradeProcessModel.offerer.addressEntry);
model.offerer.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs();
model.offerer.outputs = result.getOutputs();
offererTradeProcessModel.offerer.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs();
offererTradeProcessModel.offerer.outputs = result.getOutputs();
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -29,25 +27,25 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public ProcessPayoutTxPublishedMessage(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public ProcessPayoutTxPublishedMessage(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
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();
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -29,27 +27,27 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public ProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public ProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
try {
checkTradeId(model.id, model.getTradeMessage());
OffererTrade offererTrade = model.trade;
RequestDepositTxInputsMessage requestDepositTxInputsMessage = (RequestDepositTxInputsMessage) model.getTradeMessage();
checkTradeId(offererTradeProcessModel.id, offererTradeProcessModel.getTradeMessage());
RequestDepositTxInputsMessage requestDepositTxInputsMessage = (RequestDepositTxInputsMessage) offererTradeProcessModel.getTradeMessage();
offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(requestDepositTxInputsMessage.tradeAmount)));
model.setTakeOfferFeeTxId(nonEmptyStringOf(requestDepositTxInputsMessage.takeOfferFeeTxId));
model.taker.tradeWalletPubKey = checkNotNull(requestDepositTxInputsMessage.takerTradeWalletPubKey);
offererTradeProcessModel.setTakeOfferFeeTxId(nonEmptyStringOf(requestDepositTxInputsMessage.takeOfferFeeTxId));
offererTradeProcessModel.taker.tradeWalletPubKey = checkNotNull(requestDepositTxInputsMessage.takerTradeWalletPubKey);
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
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;
import io.bitsquare.common.taskrunner.Task;
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.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -28,33 +27,34 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*;
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);
public ProcessRequestOffererPublishDepositTxMessage(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public ProcessRequestOffererPublishDepositTxMessage(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
try {
checkTradeId(model.id, model.getTradeMessage());
RequestOffererPublishDepositTxMessage message = (RequestOffererPublishDepositTxMessage) model.getTradeMessage();
checkTradeId(offererTradeProcessModel.id, offererTradeProcessModel.getTradeMessage());
RequestOffererPublishDepositTxMessage message = (RequestOffererPublishDepositTxMessage) offererTradeProcessModel.getTradeMessage();
model.taker.fiatAccount = checkNotNull(message.takerFiatAccount);
model.taker.accountId = nonEmptyStringOf(message.takerAccountId);
model.taker.p2pSigPublicKey = checkNotNull(message.takerP2PSigPublicKey);
model.taker.p2pEncryptPubKey = checkNotNull(message.takerP2PEncryptPublicKey);
model.taker.contractAsJson = nonEmptyStringOf(message.takerContractAsJson);
model.taker.contractSignature = nonEmptyStringOf(message.takerContractSignature);
model.taker.payoutAddressString = nonEmptyStringOf(message.takerPayoutAddressString);
model.taker.preparedDepositTx = checkNotNull(message.takersPreparedDepositTx);
model.taker.connectedOutputsForAllInputs = checkNotNull(message.takerConnectedOutputsForAllInputs);
offererTradeProcessModel.taker.fiatAccount = checkNotNull(message.takerFiatAccount);
offererTradeProcessModel.taker.accountId = nonEmptyStringOf(message.takerAccountId);
offererTradeProcessModel.taker.p2pSigPublicKey = checkNotNull(message.takerP2PSigPublicKey);
offererTradeProcessModel.taker.p2pEncryptPubKey = checkNotNull(message.takerP2PEncryptPublicKey);
offererTradeProcessModel.taker.contractAsJson = nonEmptyStringOf(message.takerContractAsJson);
offererTradeProcessModel.taker.contractSignature = nonEmptyStringOf(message.takerContractSignature);
offererTradeProcessModel.taker.payoutAddressString = nonEmptyStringOf(message.takerPayoutAddressString);
offererTradeProcessModel.taker.preparedDepositTx = checkNotNull(message.takersPreparedDepositTx);
offererTradeProcessModel.taker.connectedOutputsForAllInputs = checkNotNull(message.takerConnectedOutputsForAllInputs);
checkArgument(message.takerConnectedOutputsForAllInputs.size() > 0);
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestTakerDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class RequestTakerDepositPayment extends Task<OffererAsBuyerModel> {
public class RequestTakerDepositPayment extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(RequestTakerDepositPayment.class);
public RequestTakerDepositPayment(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public RequestTakerDepositPayment(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
try {
RequestTakerDepositPaymentMessage tradeMessage = new RequestTakerDepositPaymentMessage(
model.id,
model.offerer.connectedOutputsForAllInputs,
model.offerer.outputs,
model.offerer.tradeWalletPubKey,
model.offerer.p2pSigPubKey,
model.offerer.p2pEncryptPubKey,
model.offerer.fiatAccount,
model.offerer.accountId);
offererTradeProcessModel.id,
offererTradeProcessModel.offerer.connectedOutputsForAllInputs,
offererTradeProcessModel.offerer.outputs,
offererTradeProcessModel.offerer.tradeWalletPubKey,
offererTradeProcessModel.offerer.p2pSigPubKey,
offererTradeProcessModel.offerer.p2pEncryptPubKey,
offererTradeProcessModel.offerer.fiatAccount,
offererTradeProcessModel.offerer.accountId);
model.messageService.sendMessage(model.trade.getTradingPeer(), tradeMessage, new SendMessageListener() {
offererTradeProcessModel.messageService.sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer");
@ -57,13 +55,15 @@ public class RequestTakerDepositPayment extends Task<OffererAsBuyerModel> {
@Override
public void handleFault() {
appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed");
model.trade.setErrorMessage(errorMessage);
model.trade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED);
offererTrade.setErrorMessage(errorMessage);
offererTrade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed();
}
});
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SendBankTransferStartedMessage extends Task<OffererAsBuyerModel> {
public class SendBankTransferStartedMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(SendBankTransferStartedMessage.class);
public SendBankTransferStartedMessage(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public SendBankTransferStartedMessage(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
try {
FiatTransferStartedMessage tradeMessage = new FiatTransferStartedMessage(model.id,
model.offerer.payoutTxSignature,
model.offerer.payoutAmount,
model.taker.payoutAmount,
model.offerer.addressEntry.getAddressString());
FiatTransferStartedMessage tradeMessage = new FiatTransferStartedMessage(offererTradeProcessModel.id,
offererTradeProcessModel.offerer.payoutTxSignature,
offererTradeProcessModel.offerer.payoutAmount,
offererTradeProcessModel.taker.payoutAmount,
offererTradeProcessModel.offerer.addressEntry.getAddressString());
model.messageService.sendMessage(model.trade.getTradingPeer(), tradeMessage,
model.taker.p2pSigPublicKey,
model.taker.p2pEncryptPubKey,
offererTradeProcessModel.messageService.sendMessage(offererTrade.getTradingPeer(), tradeMessage,
offererTradeProcessModel.taker.p2pSigPublicKey,
offererTradeProcessModel.taker.p2pEncryptPubKey,
new SendMessageListener() {
@Override
public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded.");
model.trade.setProcessState(OffererTrade.OffererProcessState.FIAT_PAYMENT_STARTED);
offererTrade.setProcessState(OffererTrade.OffererProcessState.FIAT_PAYMENT_STARTED);
complete();
}
@Override
public void handleFault() {
appendToErrorMessage("Sending FiatTransferStartedMessage failed");
model.trade.setErrorMessage(errorMessage);
model.trade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED);
offererTrade.setErrorMessage(errorMessage);
offererTrade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SendDepositTxToTaker extends Task<OffererAsBuyerModel> {
public class SendDepositTxToTaker extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(SendDepositTxToTaker.class);
public SendDepositTxToTaker(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public SendDepositTxToTaker(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
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
public void handleResult() {
log.trace("DepositTxPublishedMessage successfully arrived at peer");
@ -49,13 +47,13 @@ public class SendDepositTxToTaker extends Task<OffererAsBuyerModel> {
@Override
public void handleFault() {
appendToErrorMessage("Sending DepositTxPublishedMessage failed");
model.trade.setErrorMessage(errorMessage);
model.trade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED);
offererTrade.setErrorMessage(errorMessage);
offererTrade.setProcessState(OffererTrade.OffererProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(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;
import io.bitsquare.btc.FeePolicy;
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.OffererAsBuyerModel;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction;
@ -33,45 +31,48 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SignAndPublishDepositTx extends Task<OffererAsBuyerModel> {
public class SignAndPublishDepositTx extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(SignAndPublishDepositTx.class);
public SignAndPublishDepositTx(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public SignAndPublishDepositTx(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
try {
Coin offererInputAmount = model.trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
model.tradeWalletService.offererSignsAndPublishDepositTx(
model.taker.preparedDepositTx,
model.offerer.connectedOutputsForAllInputs,
model.taker.connectedOutputsForAllInputs,
model.offerer.outputs,
Coin offererInputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
offererTradeProcessModel.tradeWalletService.offererSignsAndPublishDepositTx(
offererTradeProcessModel.taker.preparedDepositTx,
offererTradeProcessModel.offerer.connectedOutputsForAllInputs,
offererTradeProcessModel.taker.connectedOutputsForAllInputs,
offererTradeProcessModel.offerer.outputs,
offererInputAmount,
model.offerer.tradeWalletPubKey,
model.taker.tradeWalletPubKey,
model.arbitratorPubKey,
offererTradeProcessModel.offerer.tradeWalletPubKey,
offererTradeProcessModel.taker.tradeWalletPubKey,
offererTradeProcessModel.arbitratorPubKey,
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {
log.trace("offererSignAndPublishTx succeeded " + transaction);
model.trade.setDepositTx(transaction);
model.trade.setProcessState(OffererTrade.OffererProcessState.DEPOSIT_PUBLISHED);
offererTrade.setDepositTx(transaction);
offererTrade.setProcessState(OffererTrade.OffererProcessState.DEPOSIT_PUBLISHED);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.PENDING);
complete();
}
@Override
public void onFailure(@NotNull Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
failed(t);
}
});
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Contract;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import io.bitsquare.util.Utilities;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class VerifyAndSignContract extends Task<OffererAsBuyerModel> {
public class VerifyAndSignContract extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyAndSignContract.class);
public VerifyAndSignContract(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public VerifyAndSignContract(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
try {
OffererTrade offererTrade = model.trade;
Contract contract = new Contract(
model.offer,
offererTradeProcessModel.offer,
offererTrade.getTradeAmount(),
model.getTakeOfferFeeTxId(),
model.offerer.accountId,
model.taker.accountId,
model.offerer.fiatAccount,
model.taker.fiatAccount,
model.offerer.p2pSigPubKey,
model.taker.p2pSigPublicKey);
offererTradeProcessModel.getTakeOfferFeeTxId(),
offererTradeProcessModel.offerer.accountId,
offererTradeProcessModel.taker.accountId,
offererTradeProcessModel.offerer.fiatAccount,
offererTradeProcessModel.taker.fiatAccount,
offererTradeProcessModel.offerer.p2pSigPubKey,
offererTradeProcessModel.taker.p2pSigPublicKey);
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.setContractAsJson(contractAsJson);
offererTrade.setOffererContractSignature(signature);
offererTrade.setTakerContractSignature(model.taker.contractSignature);
offererTrade.setTakerContractSignature(offererTradeProcessModel.taker.contractSignature);
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
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;
import io.bitsquare.common.taskrunner.Task;
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.LoggerFactory;
public class VerifyTakeOfferFeePayment extends Task<OffererAsBuyerModel> {
public class VerifyTakeOfferFeePayment extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyTakeOfferFeePayment.class);
public VerifyTakeOfferFeePayment(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public VerifyTakeOfferFeePayment(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
try {
//TODO mocked yet, need a confidence listeners
int numOfPeersSeenTx = model.walletService.getNumOfPeersSeenTx(model.getTakeOfferFeeTxId());
int numOfPeersSeenTx = offererTradeProcessModel.walletService.getNumOfPeersSeenTx(offererTradeProcessModel.getTakeOfferFeeTxId());
/* if (numOfPeersSeenTx > 2) {
resultHandler.handleResult();
}*/
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
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.LoggerFactory;
public class VerifyTakerAccount extends Task<OffererAsBuyerModel> {
public class VerifyTakerAccount extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyTakerAccount.class);
public VerifyTakerAccount(TaskRunner taskHandler, OffererAsBuyerModel model) {
super(taskHandler, model);
public VerifyTakerAccount(TaskRunner taskHandler, OffererTrade offererTradeProcessModel) {
super(taskHandler, offererTradeProcessModel);
}
@Override
protected void doRun() {
try {
//TODO mocked yet
if (model.blockChainService.verifyAccountRegistration()) {
if (model.blockChainService.isAccountBlackListed(model.taker.accountId, model.taker.fiatAccount)) {
if (offererTradeProcessModel.blockChainService.verifyAccountRegistration()) {
if (offererTradeProcessModel.blockChainService.isAccountBlackListed(offererTradeProcessModel.taker.accountId, offererTradeProcessModel.taker
.fiatAccount)) {
log.error("Taker is blacklisted");
failed("Taker is blacklisted");
}
@ -46,9 +46,11 @@ public class VerifyTakerAccount extends Task<OffererAsBuyerModel> {
}
else {
failed("Account registration validation for peer failed.");
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
}
} catch (Throwable t) {
model.trade.setThrowable(t);
offererTrade.setThrowable(t);
offererTrade.setLifeCycleState(OffererTrade.OffererLifeCycleState.OFFER_OPEN);
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.RequestTakerDepositPaymentMessage;
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.CreateAndSignContract;
import io.bitsquare.trade.protocol.trade.taker.tasks.CreateTakeOfferFeeTx;
@ -49,10 +49,11 @@ import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.nonEmptyStringOf;
public class TakerAsSellerProtocol implements Protocol {
private static final Logger log = LoggerFactory.getLogger(TakerAsSellerProtocol.class);
public class TakerProtocol implements Protocol {
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;
@ -60,11 +61,13 @@ public class TakerAsSellerProtocol implements Protocol {
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public TakerAsSellerProtocol(TakerAsSellerModel model) {
public TakerProtocol(TakerTrade takerTrade) {
log.debug("New SellerAsTakerProtocol " + this);
this.model = model;
this.takerTrade = takerTrade;
takerTradeProcessModel = takerTrade.getTakerTradeProcessModel();
messageHandler = this::handleMessage;
model.messageService.addMessageHandler(messageHandler);
takerTradeProcessModel.messageService.addMessageHandler(messageHandler);
}
@ -74,14 +77,14 @@ public class TakerAsSellerProtocol implements Protocol {
public void cleanup() {
log.debug("cleanup " + this);
model.messageService.removeMessageHandler(messageHandler);
takerTradeProcessModel.messageService.removeMessageHandler(messageHandler);
}
public void setMailboxMessage(MailboxMessage mailboxMessage) {
log.debug("setMailboxMessage " + mailboxMessage);
// Might be called twice, so check that its only processed once
if (model.mailboxMessage == null) {
model.mailboxMessage = mailboxMessage;
if (takerTradeProcessModel.mailboxMessage == null) {
takerTradeProcessModel.mailboxMessage = mailboxMessage;
if (mailboxMessage instanceof FiatTransferStartedMessage) {
handleFiatTransferStartedMessage((FiatTransferStartedMessage) mailboxMessage);
}
@ -92,7 +95,7 @@ public class TakerAsSellerProtocol implements Protocol {
}
public void takeAvailableOffer() {
TaskRunner<TakerAsSellerModel> taskRunner = new TaskRunner<>(model,
TaskRunner<TakerTrade> taskRunner = new TaskRunner<>(takerTrade,
() -> {
log.debug("taskRunner at takeAvailableOffer completed");
},
@ -112,9 +115,9 @@ public class TakerAsSellerProtocol implements Protocol {
///////////////////////////////////////////////////////////////////////////////////////////
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");
},
@ -131,9 +134,9 @@ public class TakerAsSellerProtocol implements Protocol {
}
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");
},
@ -147,9 +150,9 @@ public class TakerAsSellerProtocol implements Protocol {
}
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");
},
@ -166,14 +169,14 @@ public class TakerAsSellerProtocol implements Protocol {
// User clicked the "bank transfer received" button, so we release the funds for pay out
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");
// we are done!
model.onComplete();
takerTradeProcessModel.onComplete();
},
(errorMessage) -> handleTaskRunnerFault(errorMessage));
@ -195,7 +198,7 @@ public class TakerAsSellerProtocol implements Protocol {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(model.id)) {
if (tradeMessage.tradeId.equals(takerTradeProcessModel.id)) {
if (tradeMessage instanceof RequestTakerDepositPaymentMessage) {
handleRequestTakerDepositPaymentMessage((RequestTakerDepositPaymentMessage) tradeMessage);
}

50
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.WalletService;
import io.bitsquare.crypto.SignatureService;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.MailboxService;
import io.bitsquare.p2p.MessageService;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.SharedTradeModel;
import io.bitsquare.trade.protocol.trade.TradeProcessModel;
import io.bitsquare.user.User;
import org.bitcoinj.core.Transaction;
import java.io.File;
import java.io.Serializable;
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.
*/
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.
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;
transient public final TakerTrade trade;
public final Taker taker;
public final Offerer offerer;
public final Taker taker = new Taker();
public final Offerer offerer = new Offerer();
// written by tasks
private Transaction takeOfferFeeTx;
private Transaction payoutTx;
public TakerAsSellerModel(TakerTrade trade,
MessageService messageService,
MailboxService mailboxService,
WalletService walletService,
BlockChainService blockChainService,
SignatureService signatureService,
ArbitrationRepository arbitrationRepository,
User user,
File storageDir) {
super(trade.getOffer(),
public TakerTradeProcessModel(Offer offer,
MessageService messageService,
MailboxService mailboxService,
WalletService walletService,
BlockChainService blockChainService,
SignatureService signatureService,
ArbitrationRepository arbitrationRepository,
User user) {
super(offer,
messageService,
mailboxService,
walletService,
@ -72,10 +66,8 @@ public class TakerAsSellerModel extends SharedTradeModel implements Serializable
signatureService,
arbitrationRepository);
this.trade = trade;
this.storage = new Storage<>(storageDir);
TakerAsSellerModel persisted = storage.initAndGetPersisted(this, getFileName());
/*TakerProcessModel persisted = storage.initAndGetPersisted(this, getFileName());
if (persisted != null) {
log.debug("Model reconstructed from persisted model.");
@ -88,7 +80,7 @@ public class TakerAsSellerModel extends SharedTradeModel implements Serializable
else {
taker = new Taker();
offerer = new Offerer();
}
}*/
taker.registrationPubKey = walletService.getRegistrationAddressEntry().getPubKey();
taker.registrationKeyPair = walletService.getRegistrationAddressEntry().getKeyPair();
@ -101,7 +93,7 @@ public class TakerAsSellerModel extends SharedTradeModel implements Serializable
}
// Get called form taskRunner after each completed task
@Override
/* @Override
public void persist() {
storage.save();
}
@ -110,7 +102,7 @@ public class TakerAsSellerModel extends SharedTradeModel implements Serializable
public void onComplete() {
// Just in case of successful completion we delete our persisted object
storage.remove(getFileName());
}
}*/
public Transaction getTakeOfferFeeTx() {
return takeOfferFeeTx;
@ -128,8 +120,8 @@ public class TakerAsSellerModel extends SharedTradeModel implements Serializable
this.payoutTx = payoutTx;
}
private String getFileName() {
/*private String getFileName() {
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;
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.TakerAsSellerModel;
import org.bitcoinj.core.Transaction;
@ -31,23 +29,23 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class BroadcastTakeOfferFeeTx extends Task<TakerAsSellerModel> {
public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(BroadcastTakeOfferFeeTx.class);
public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, TakerAsSellerModel model) {
public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@Override
protected void doRun() {
try {
model.tradeWalletService.broadcastTakeOfferFeeTx(model.getTakeOfferFeeTx(),
takerTradeProcessModel.tradeWalletService.broadcastTakeOfferFeeTx(takerTradeProcessModel.getTakeOfferFeeTx(),
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {
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();
}
@ -55,14 +53,14 @@ public class BroadcastTakeOfferFeeTx extends Task<TakerAsSellerModel> {
@Override
public void onFailure(@NotNull Throwable t) {
appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again.");
model.trade.setErrorMessage(errorMessage);
model.trade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
takerTrade.setErrorMessage(errorMessage);
takerTrade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
failed(t);
}
});
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Contract;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.util.Utilities;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CreateAndSignContract extends Task<TakerAsSellerModel> {
public class CreateAndSignContract extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateAndSignContract.class);
public CreateAndSignContract(TaskRunner taskHandler, TakerAsSellerModel model) {
public CreateAndSignContract(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@Override
protected void doRun() {
try {
Trade trade = model.trade;
Contract contract = new Contract(
model.offer,
trade.getTradeAmount(),
model.getTakeOfferFeeTx().getHashAsString(),
model.offerer.accountId,
model.taker.accountId,
model.offerer.fiatAccount,
model.taker.fiatAccount,
model.offer.getP2PSigPubKey(),
model.taker.p2pSigPubKey);
takerTradeProcessModel.offer,
model.getTradeAmount(),
takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString(),
takerTradeProcessModel.offerer.accountId,
takerTradeProcessModel.taker.accountId,
takerTradeProcessModel.offerer.fiatAccount,
takerTradeProcessModel.taker.fiatAccount,
takerTradeProcessModel.offer.getP2PSigPubKey(),
takerTradeProcessModel.taker.p2pSigPubKey);
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);
trade.setContractAsJson(contractAsJson);
trade.setTakerContractSignature(signature);
model.setContract(contract);
model.setContractAsJson(contractAsJson);
model.setTakerContractSignature(signature);
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
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.TakerAsSellerModel;
import org.bitcoinj.core.Transaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CreateTakeOfferFeeTx extends Task<TakerAsSellerModel> {
public class CreateTakeOfferFeeTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateTakeOfferFeeTx.class);
public CreateTakeOfferFeeTx(TaskRunner taskHandler, TakerAsSellerModel model) {
public CreateTakeOfferFeeTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@Override
protected void doRun() {
try {
Transaction createTakeOfferFeeTx = model.tradeWalletService.createTakeOfferFeeTx(model.taker.addressEntry);
Transaction createTakeOfferFeeTx = takerTradeProcessModel.tradeWalletService.createTakeOfferFeeTx(takerTradeProcessModel.taker.addressEntry);
model.setTakeOfferFeeTx(createTakeOfferFeeTx);
model.trade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_TX_CREATED);
takerTradeProcessModel.setTakeOfferFeeTx(createTakeOfferFeeTx);
takerTrade.setProcessState(TakerTrade.TakerProcessState.TAKE_OFFER_FEE_TX_CREATED);
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -29,25 +27,25 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public ProcessDepositTxPublishedMessage(TaskRunner taskHandler, TakerAsSellerModel model) {
public ProcessDepositTxPublishedMessage(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@Override
protected void doRun() {
try {
checkTradeId(model.id, model.getTradeMessage());
checkTradeId(takerTradeProcessModel.id, takerTradeProcessModel.getTradeMessage());
DepositTxPublishedMessage message = (DepositTxPublishedMessage) model.getTradeMessage();
model.trade.setDepositTx(checkNotNull(message.depositTx));
model.trade.setProcessState(TakerTrade.TakerProcessState.DEPOSIT_PUBLISHED);
DepositTxPublishedMessage message = (DepositTxPublishedMessage) takerTradeProcessModel.getTradeMessage();
takerTrade.setDepositTx(checkNotNull(message.depositTx));
takerTrade.setProcessState(TakerTrade.TakerProcessState.DEPOSIT_PUBLISHED);
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -29,28 +27,28 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull;
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);
public ProcessFiatTransferStartedMessage(TaskRunner taskHandler, TakerAsSellerModel model) {
public ProcessFiatTransferStartedMessage(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@Override
protected void doRun() {
try {
checkTradeId(model.id, model.getTradeMessage());
FiatTransferStartedMessage message = (FiatTransferStartedMessage) model.getTradeMessage();
checkTradeId(takerTradeProcessModel.id, takerTradeProcessModel.getTradeMessage());
FiatTransferStartedMessage message = (FiatTransferStartedMessage) takerTradeProcessModel.getTradeMessage();
model.offerer.signature = checkNotNull(message.offererSignature);
model.offerer.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.offererPayoutAmount));
model.taker.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.takerPayoutAmount));
model.offerer.payoutAddressString = nonEmptyStringOf(message.offererPayoutAddress);
model.trade.setProcessState(TakerTrade.TakerProcessState.FIAT_PAYMENT_STARTED);
takerTradeProcessModel.offerer.signature = checkNotNull(message.offererSignature);
takerTradeProcessModel.offerer.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.offererPayoutAmount));
takerTradeProcessModel.taker.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.takerPayoutAmount));
takerTradeProcessModel.offerer.payoutAddressString = nonEmptyStringOf(message.offererPayoutAddress);
takerTrade.setProcessState(TakerTrade.TakerProcessState.FIAT_PAYMENT_STARTED);
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
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.taker.models.TakerAsSellerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -28,31 +27,31 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*;
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);
public ProcessRequestTakerDepositPaymentMessage(TaskRunner taskHandler, TakerAsSellerModel model) {
public ProcessRequestTakerDepositPaymentMessage(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@Override
protected void doRun() {
try {
checkTradeId(model.id, model.getTradeMessage());
RequestTakerDepositPaymentMessage message = (RequestTakerDepositPaymentMessage) model.getTradeMessage();
checkTradeId(takerTradeProcessModel.id, takerTradeProcessModel.getTradeMessage());
RequestTakerDepositPaymentMessage message = (RequestTakerDepositPaymentMessage) takerTradeProcessModel.getTradeMessage();
model.offerer.connectedOutputsForAllInputs = checkNotNull(message.offererConnectedOutputsForAllInputs);
takerTradeProcessModel.offerer.connectedOutputsForAllInputs = checkNotNull(message.offererConnectedOutputsForAllInputs);
checkArgument(message.offererConnectedOutputsForAllInputs.size() > 0);
model.offerer.outputs = checkNotNull(message.offererOutputs);
model.offerer.tradeWalletPubKey = checkNotNull(message.offererTradeWalletPubKey);
model.offerer.p2pSigPublicKey = checkNotNull(message.offererP2PSigPublicKey);
model.offerer.p2pEncryptPubKey = checkNotNull(message.offererP2PEncryptPublicKey);
model.offerer.fiatAccount = checkNotNull(message.offererFiatAccount);
model.offerer.accountId = nonEmptyStringOf(message.offererAccountId);
takerTradeProcessModel.offerer.outputs = checkNotNull(message.offererOutputs);
takerTradeProcessModel.offerer.tradeWalletPubKey = checkNotNull(message.offererTradeWalletPubKey);
takerTradeProcessModel.offerer.p2pSigPublicKey = checkNotNull(message.offererP2PSigPublicKey);
takerTradeProcessModel.offerer.p2pEncryptPubKey = checkNotNull(message.offererP2PEncryptPublicKey);
takerTradeProcessModel.offerer.fiatAccount = checkNotNull(message.offererFiatAccount);
takerTradeProcessModel.offerer.accountId = nonEmptyStringOf(message.offererAccountId);
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SendPayoutTxToOfferer extends Task<TakerAsSellerModel> {
public class SendPayoutTxToOfferer extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(SendPayoutTxToOfferer.class);
public SendPayoutTxToOfferer(TaskRunner taskHandler, TakerAsSellerModel model) {
public SendPayoutTxToOfferer(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@Override
protected void doRun() {
try {
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(model.id, model.getPayoutTx());
model.messageService.sendMessage(model.trade.getTradingPeer(),
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(takerTradeProcessModel.id, takerTradeProcessModel.getPayoutTx());
takerTradeProcessModel.messageService.sendMessage(takerTrade.getTradingPeer(),
tradeMessage,
model.offerer.p2pSigPublicKey,
model.offerer.p2pEncryptPubKey,
takerTradeProcessModel.offerer.p2pSigPublicKey,
takerTradeProcessModel.offerer.p2pEncryptPubKey,
new SendMessageListener() {
@Override
public void handleResult() {
@ -52,13 +50,13 @@ public class SendPayoutTxToOfferer extends Task<TakerAsSellerModel> {
@Override
public void handleFault() {
appendToErrorMessage("Sending PayoutTxPublishedMessage failed");
model.trade.setErrorMessage(errorMessage);
model.trade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED);
takerTrade.setErrorMessage(errorMessage);
takerTrade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import javafx.application.Platform;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SendRequestDepositTxInputsMessage extends Task<TakerAsSellerModel> {
public class SendRequestDepositTxInputsMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(SendRequestDepositTxInputsMessage.class);
public SendRequestDepositTxInputsMessage(TaskRunner taskHandler, TakerAsSellerModel model) {
public SendRequestDepositTxInputsMessage(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@ -42,12 +40,12 @@ public class SendRequestDepositTxInputsMessage extends Task<TakerAsSellerModel>
protected void doRun() {
try {
RequestDepositTxInputsMessage msg = new RequestDepositTxInputsMessage(
model.id,
model.getTakeOfferFeeTx().getHashAsString(),
model.trade.getTradeAmount(),
model.taker.tradeWalletPubKey);
takerTradeProcessModel.id,
takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString(),
takerTrade.getTradeAmount(),
takerTradeProcessModel.taker.tradeWalletPubKey);
model.messageService.sendMessage(model.trade.getTradingPeer(), msg, new SendMessageListener() {
takerTradeProcessModel.messageService.sendMessage(takerTrade.getTradingPeer(), msg, new SendMessageListener() {
@Override
public void handleResult() {
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 " +
"or cancel that trade.");
model.trade.setErrorMessage(errorMessage);
model.trade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED);
takerTrade.setErrorMessage(errorMessage);
takerTrade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED);
failed();
}
}
});
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.taker.models.TakerAsSellerModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SendSignedTakerDepositTx extends Task<TakerAsSellerModel> {
public class SendSignedTakerDepositTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(SendSignedTakerDepositTx.class);
public SendSignedTakerDepositTx(TaskRunner taskHandler, TakerAsSellerModel model) {
public SendSignedTakerDepositTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@ -38,20 +36,20 @@ public class SendSignedTakerDepositTx extends Task<TakerAsSellerModel> {
protected void doRun() {
try {
RequestOffererPublishDepositTxMessage tradeMessage = new RequestOffererPublishDepositTxMessage(
model.id,
model.taker.fiatAccount,
model.taker.accountId,
model.taker.p2pSigPubKey,
model.taker.p2pEncryptPublicKey,
model.trade.getContractAsJson(),
model.trade.getTakerContractSignature(),
model.taker.addressEntry.getAddressString(),
model.taker.preparedDepositTx,
model.taker.connectedOutputsForAllInputs,
model.taker.outputs
takerTradeProcessModel.id,
takerTradeProcessModel.taker.fiatAccount,
takerTradeProcessModel.taker.accountId,
takerTradeProcessModel.taker.p2pSigPubKey,
takerTradeProcessModel.taker.p2pEncryptPublicKey,
takerTrade.getContractAsJson(),
takerTrade.getTakerContractSignature(),
takerTradeProcessModel.taker.addressEntry.getAddressString(),
takerTradeProcessModel.taker.preparedDepositTx,
takerTradeProcessModel.taker.connectedOutputsForAllInputs,
takerTradeProcessModel.taker.outputs
);
model.messageService.sendMessage(model.trade.getTradingPeer(), tradeMessage, new SendMessageListener() {
takerTradeProcessModel.messageService.sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
complete();
@ -60,14 +58,14 @@ public class SendSignedTakerDepositTx extends Task<TakerAsSellerModel> {
@Override
public void handleFault() {
appendToErrorMessage("Sending RequestOffererDepositPublicationMessage failed");
model.trade.setErrorMessage(errorMessage);
model.trade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED);
takerTrade.setErrorMessage(errorMessage);
takerTrade.setProcessState(TakerTrade.TakerProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
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.TakerAsSellerModel;
import org.bitcoinj.core.Transaction;
@ -31,43 +29,43 @@ import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SignAndPublishPayoutTx extends Task<TakerAsSellerModel> {
public class SignAndPublishPayoutTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(SignAndPublishPayoutTx.class);
public SignAndPublishPayoutTx(TaskRunner taskHandler, TakerAsSellerModel model) {
public SignAndPublishPayoutTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@Override
protected void doRun() {
try {
model.tradeWalletService.takerSignsAndPublishPayoutTx(
model.trade.getDepositTx(),
model.offerer.signature,
model.offerer.payoutAmount,
model.taker.payoutAmount,
model.offerer.payoutAddressString,
model.taker.addressEntry,
model.offerer.tradeWalletPubKey,
model.taker.tradeWalletPubKey,
model.arbitratorPubKey,
takerTradeProcessModel.tradeWalletService.takerSignsAndPublishPayoutTx(
takerTrade.getDepositTx(),
takerTradeProcessModel.offerer.signature,
takerTradeProcessModel.offerer.payoutAmount,
takerTradeProcessModel.taker.payoutAmount,
takerTradeProcessModel.offerer.payoutAddressString,
takerTradeProcessModel.taker.addressEntry,
takerTradeProcessModel.offerer.tradeWalletPubKey,
takerTradeProcessModel.taker.tradeWalletPubKey,
takerTradeProcessModel.arbitratorPubKey,
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {
model.setPayoutTx(transaction);
model.trade.setProcessState(TakerTrade.TakerProcessState.PAYOUT_PUBLISHED);
takerTradeProcessModel.setPayoutTx(transaction);
takerTrade.setProcessState(TakerTrade.TakerProcessState.PAYOUT_PUBLISHED);
complete();
}
@Override
public void onFailure(@NotNull Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(t);
failed(t);
}
});
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerCommitDepositTx extends Task<TakerAsSellerModel> {
public class TakerCommitDepositTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCommitDepositTx.class);
public TakerCommitDepositTx(TaskRunner taskHandler, TakerAsSellerModel model) {
public TakerCommitDepositTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@ -37,13 +36,13 @@ public class TakerCommitDepositTx extends Task<TakerAsSellerModel> {
protected void doRun() {
try {
// 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();
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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.TradeWalletService;
import io.bitsquare.common.taskrunner.Task;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignsDepositTx extends Task<TakerAsSellerModel> {
public class TakerCreatesAndSignsDepositTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsDepositTx.class);
public TakerCreatesAndSignsDepositTx(TaskRunner taskHandler, TakerAsSellerModel model) {
public TakerCreatesAndSignsDepositTx(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@Override
protected void doRun() {
try {
Coin takerInputAmount = model.trade.getTradeAmount().add(model.trade.getSecurityDeposit()).add(FeePolicy.TX_FEE);
Coin msOutputAmount = takerInputAmount.add(model.trade.getSecurityDeposit());
Coin takerInputAmount = takerTrade.getTradeAmount().add(takerTrade.getSecurityDeposit()).add(FeePolicy.TX_FEE);
Coin msOutputAmount = takerInputAmount.add(takerTrade.getSecurityDeposit());
TradeWalletService.Result result = model.tradeWalletService.takerCreatesAndSignsDepositTx(
TradeWalletService.Result result = takerTradeProcessModel.tradeWalletService.takerCreatesAndSignsDepositTx(
takerInputAmount,
msOutputAmount,
model.offerer.connectedOutputsForAllInputs,
model.offerer.outputs,
model.taker.addressEntry,
model.offerer.tradeWalletPubKey,
model.taker.tradeWalletPubKey,
model.arbitratorPubKey);
takerTradeProcessModel.offerer.connectedOutputsForAllInputs,
takerTradeProcessModel.offerer.outputs,
takerTradeProcessModel.taker.addressEntry,
takerTradeProcessModel.offerer.tradeWalletPubKey,
takerTradeProcessModel.taker.tradeWalletPubKey,
takerTradeProcessModel.arbitratorPubKey);
model.taker.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs();
model.taker.outputs = result.getOutputs();
model.taker.preparedDepositTx = result.getDepositTx();
takerTradeProcessModel.taker.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs();
takerTradeProcessModel.taker.outputs = result.getOutputs();
takerTradeProcessModel.taker.preparedDepositTx = result.getDepositTx();
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
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.LoggerFactory;
public class VerifyOfferFeePayment extends Task<TakerAsSellerModel> {
public class VerifyOfferFeePayment extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyOfferFeePayment.class);
public VerifyOfferFeePayment(TaskRunner taskHandler, TakerAsSellerModel model) {
public VerifyOfferFeePayment(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@ -35,13 +34,13 @@ public class VerifyOfferFeePayment extends Task<TakerAsSellerModel> {
protected void doRun() {
try {
//TODO impl. missing
int numOfPeersSeenTx = model.walletService.getNumOfPeersSeenTx(model.getTakeOfferFeeTx().getHashAsString());
int numOfPeersSeenTx = takerTradeProcessModel.walletService.getNumOfPeersSeenTx(takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString());
/* if (numOfPeersSeenTx > 2) {
resultHandler.handleResult();
}*/
complete();
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(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;
import io.bitsquare.common.taskrunner.Task;
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.LoggerFactory;
public class VerifyOffererAccount extends Task<TakerAsSellerModel> {
public class VerifyOffererAccount extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyOffererAccount.class);
public VerifyOffererAccount(TaskRunner taskHandler, TakerAsSellerModel model) {
public VerifyOffererAccount(TaskRunner taskHandler, TakerTrade model) {
super(taskHandler, model);
}
@Override
protected void doRun() {
try {
if (model.blockChainService.verifyAccountRegistration()) {
if (model.blockChainService.isAccountBlackListed(model.offerer.accountId, model.offerer.fiatAccount)) {
if (takerTradeProcessModel.blockChainService.verifyAccountRegistration()) {
if (takerTradeProcessModel.blockChainService.isAccountBlackListed(takerTradeProcessModel.offerer.accountId, takerTradeProcessModel.offerer.fiatAccount)) {
failed("Taker is blacklisted.");
}
else {
@ -46,7 +45,7 @@ public class VerifyOffererAccount extends Task<TakerAsSellerModel> {
failed("Account registration validation for peer faultHandler.onFault.");
}
} catch (Throwable t) {
model.trade.setThrowable(t);
takerTrade.setThrowable(t);
failed(t);
}
}