Changed state handling

This commit is contained in:
Manfred Karrer 2015-04-14 02:37:49 +02:00
parent 95e23dc8a9
commit b9fe4660a3
54 changed files with 798 additions and 817 deletions

View file

@ -37,7 +37,7 @@ public class FiatAccount implements Serializable {
public static final long WEEK_IN_BLOCKS = DAY_IN_BLOCKS * 7; public static final long WEEK_IN_BLOCKS = DAY_IN_BLOCKS * 7;
public enum Type { public enum Type {
IRC("", "", 2), IRC("", "", 4),
SEPA("IBAN", "BIC", WEEK_IN_BLOCKS), SEPA("IBAN", "BIC", WEEK_IN_BLOCKS),
WIRE("primary ID", "secondary ID", WEEK_IN_BLOCKS), WIRE("primary ID", "secondary ID", WEEK_IN_BLOCKS),
INTERNATIONAL("primary ID", "secondary ID", 2 * WEEK_IN_BLOCKS), INTERNATIONAL("primary ID", "secondary ID", 2 * WEEK_IN_BLOCKS),

View file

@ -253,6 +253,10 @@ public class BootstrappedPeerBuilder {
private void bootstrap() { private void bootstrap() {
log.trace("start bootstrap"); log.trace("start bootstrap");
// We don't wait until bootstrap is done for speeding up startup process
// settableFuture.set(peerDHT);
FutureBootstrap futureBootstrap = peer.bootstrap().peerAddress(getBootstrapAddress()).start(); FutureBootstrap futureBootstrap = peer.bootstrap().peerAddress(getBootstrapAddress()).start();
futureBootstrap.addListener(new BaseFutureListener<BaseFuture>() { futureBootstrap.addListener(new BaseFutureListener<BaseFuture>() {
@Override @Override

View file

@ -17,10 +17,12 @@
package io.bitsquare.trade; package io.bitsquare.trade;
import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.offer.Offer; import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.trade.BuyerAsOffererProtocol; import io.bitsquare.trade.protocol.trade.BuyerAsOffererProtocol;
import io.bitsquare.trade.protocol.trade.BuyerProtocol; import io.bitsquare.trade.protocol.trade.OffererProtocol;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
@ -31,7 +33,7 @@ import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class BuyerAsOffererTrade extends OffererTrade implements BuyerTrade, Serializable { public class BuyerAsOffererTrade extends BuyerTrade implements OffererTrade, Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -66,9 +68,8 @@ public class BuyerAsOffererTrade extends OffererTrade implements BuyerTrade, Ser
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override @Override
public void onFiatPaymentStarted() { public void handleTakeOfferRequest(TradeMessage message, Peer taker) {
assert tradeProtocol instanceof BuyerProtocol; ((OffererProtocol) tradeProtocol).handleTakeOfferRequest(message, taker);
((BuyerProtocol) tradeProtocol).onFiatPaymentStarted();
} }
@Override @Override

View file

@ -21,7 +21,7 @@ import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.offer.Offer; import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.trade.BuyerAsTakerProtocol; import io.bitsquare.trade.protocol.trade.BuyerAsTakerProtocol;
import io.bitsquare.trade.protocol.trade.BuyerProtocol; import io.bitsquare.trade.protocol.trade.TakerProtocol;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
@ -32,7 +32,7 @@ import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class BuyerAsTakerTrade extends TakerTrade implements BuyerTrade, Serializable { public class BuyerAsTakerTrade extends BuyerTrade implements TakerTrade, Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -67,9 +67,9 @@ public class BuyerAsTakerTrade extends TakerTrade implements BuyerTrade, Seriali
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override @Override
public void onFiatPaymentStarted() { public void takeAvailableOffer() {
assert tradeProtocol instanceof BuyerProtocol; assert tradeProtocol instanceof TakerProtocol;
((BuyerProtocol) tradeProtocol).onFiatPaymentStarted(); ((TakerProtocol) tradeProtocol).takeAvailableOffer();
} }
@Override @Override

View file

@ -17,6 +17,94 @@
package io.bitsquare.trade; package io.bitsquare.trade;
public interface BuyerTrade { import io.bitsquare.p2p.Peer;
void onFiatPaymentStarted(); import io.bitsquare.storage.Storage;
import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.trade.BuyerProtocol;
import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.TradeState;
import org.bitcoinj.core.Coin;
import java.io.Serializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class BuyerTrade extends Trade implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(BuyerAsOffererTrade.class);
public BuyerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, Storage<? extends TradableList> storage) {
super(offer, tradeAmount, tradingPeer, storage);
log.trace("Created by constructor");
}
public BuyerTrade(Offer offer, Storage<? extends TradableList> storage) {
super(offer, storage);
log.trace("Created by constructor");
}
@Override
protected void initStates() {
processState = BuyerTradeState.ProcessState.UNDEFINED;
lifeCycleState = Trade.LifeCycleState.PREPARATION;
initStateProperties();
}
public void onFiatPaymentStarted() {
assert tradeProtocol instanceof BuyerProtocol;
((BuyerProtocol) tradeProtocol).onFiatPaymentStarted();
}
///////////////////////////////////////////////////////////////////////////////////////////
// Setter for Mutable objects
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setProcessState(TradeState.ProcessState processState) {
super.setProcessState(processState);
/* switch ((BuyerTradeState.ProcessState) processState) {
case EXCEPTION:
disposeProtocol();
setLifeCycleState(Trade.LifeCycleState.FAILED);
break;
}*/
}
@Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) {
super.setLifeCycleState(lifeCycleState);
switch (lifeCycleState) {
case FAILED:
disposeProtocol();
break;
case COMPLETED:
disposeProtocol();
break;
}
}
@Override
public void setThrowable(Throwable throwable) {
super.setThrowable(throwable);
// setProcessState(BuyerTradeState.ProcessState.EXCEPTION);
}
///////////////////////////////////////////////////////////////////////////////////////////
// Protected
///////////////////////////////////////////////////////////////////////////////////////////
@Override
protected void handleConfidenceResult() {
if (((BuyerTradeState.ProcessState) processState).ordinal() < BuyerTradeState.ProcessState.DEPOSIT_CONFIRMED.ordinal())
setProcessState(BuyerTradeState.ProcessState.DEPOSIT_CONFIRMED);
}
} }

View file

@ -18,86 +18,8 @@
package io.bitsquare.trade; package io.bitsquare.trade;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.trade.OffererProtocol;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.states.OffererTradeState;
import io.bitsquare.trade.states.TradeState;
import java.io.Serializable; public interface OffererTrade {
void handleTakeOfferRequest(TradeMessage message, Peer taker);
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class OffererTrade extends Trade implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(BuyerAsOffererTrade.class);
public OffererTrade(Offer offer, Storage<? extends TradableList> storage) {
super(offer, storage);
log.trace("Created by constructor");
}
@Override
protected void initStates() {
processState = OffererTradeState.ProcessState.UNDEFINED;
lifeCycleState = Trade.LifeCycleState.PREPARATION;
initStateProperties();
}
public void handleTakeOfferRequest(TradeMessage message, Peer taker) {
((OffererProtocol) tradeProtocol).handleTakeOfferRequest(message, taker);
}
///////////////////////////////////////////////////////////////////////////////////////////
// Setter for Mutable objects
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setProcessState(TradeState.ProcessState processState) {
super.setProcessState(processState);
switch ((OffererTradeState.ProcessState) processState) {
case EXCEPTION:
disposeProtocol();
setLifeCycleState(Trade.LifeCycleState.FAILED);
break;
}
}
@Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) {
super.setLifeCycleState(lifeCycleState);
switch (lifeCycleState) {
case FAILED:
disposeProtocol();
break;
case COMPLETED:
disposeProtocol();
break;
}
}
@Override
public void setThrowable(Throwable throwable) {
super.setThrowable(throwable);
setProcessState(OffererTradeState.ProcessState.EXCEPTION);
}
///////////////////////////////////////////////////////////////////////////////////////////
// Protected
///////////////////////////////////////////////////////////////////////////////////////////
@Override
protected void handleConfidenceResult() {
if (((OffererTradeState.ProcessState) processState).ordinal() < OffererTradeState.ProcessState.DEPOSIT_CONFIRMED.ordinal())
setProcessState(OffererTradeState.ProcessState.DEPOSIT_CONFIRMED);
}
} }

View file

@ -17,10 +17,12 @@
package io.bitsquare.trade; package io.bitsquare.trade;
import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.offer.Offer; import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.trade.OffererProtocol;
import io.bitsquare.trade.protocol.trade.SellerAsOffererProtocol; import io.bitsquare.trade.protocol.trade.SellerAsOffererProtocol;
import io.bitsquare.trade.protocol.trade.SellerProtocol; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import java.io.IOException; import java.io.IOException;
import java.io.ObjectInputStream; import java.io.ObjectInputStream;
@ -29,7 +31,7 @@ import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SellerAsOffererTrade extends OffererTrade implements SellerTrade, Serializable { public class SellerAsOffererTrade extends SellerTrade implements OffererTrade, Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -64,8 +66,7 @@ public class SellerAsOffererTrade extends OffererTrade implements SellerTrade, S
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override @Override
public void onFiatPaymentReceived() { public void handleTakeOfferRequest(TradeMessage message, Peer taker) {
assert tradeProtocol instanceof SellerProtocol; ((OffererProtocol) tradeProtocol).handleTakeOfferRequest(message, taker);
((SellerProtocol) tradeProtocol).onFiatPaymentReceived();
} }
} }

View file

@ -21,8 +21,7 @@ import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage; import io.bitsquare.storage.Storage;
import io.bitsquare.trade.offer.Offer; import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.trade.SellerAsTakerProtocol; import io.bitsquare.trade.protocol.trade.SellerAsTakerProtocol;
import io.bitsquare.trade.protocol.trade.SellerProtocol; import io.bitsquare.trade.protocol.trade.TakerProtocol;
import io.bitsquare.trade.states.TakerTradeState;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
@ -32,11 +31,11 @@ import java.io.Serializable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SellerAsTakerTrade extends TakerTrade implements SellerTrade, Serializable { public class SellerAsTakerTrade extends SellerTrade implements TakerTrade, Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization. // That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(TakerTradeState.class); transient private static final Logger log = LoggerFactory.getLogger(SellerAsTakerTrade.class);
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@ -67,8 +66,8 @@ public class SellerAsTakerTrade extends TakerTrade implements SellerTrade, Seria
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override @Override
public void onFiatPaymentReceived() { public void takeAvailableOffer() {
assert tradeProtocol instanceof SellerProtocol; assert tradeProtocol instanceof TakerProtocol;
((SellerProtocol) tradeProtocol).onFiatPaymentReceived(); ((TakerProtocol) tradeProtocol).takeAvailableOffer();
} }
} }

View file

@ -17,6 +17,93 @@
package io.bitsquare.trade; package io.bitsquare.trade;
public interface SellerTrade { import io.bitsquare.p2p.Peer;
void onFiatPaymentReceived(); import io.bitsquare.storage.Storage;
import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.trade.SellerProtocol;
import io.bitsquare.trade.states.SellerTradeState;
import io.bitsquare.trade.states.TradeState;
import org.bitcoinj.core.Coin;
import java.io.Serializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class SellerTrade extends Trade implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(BuyerAsTakerTrade.class);
public SellerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, Storage<? extends TradableList> storage) {
super(offer, tradeAmount, tradingPeer, storage);
log.trace("Created by constructor");
}
public SellerTrade(Offer offer, Storage<? extends TradableList> storage) {
super(offer, storage);
log.trace("Created by constructor");
}
@Override
protected void initStates() {
processState = SellerTradeState.ProcessState.UNDEFINED;
lifeCycleState = Trade.LifeCycleState.PENDING;
initStateProperties();
}
public void onFiatPaymentReceived() {
assert tradeProtocol instanceof SellerProtocol;
((SellerProtocol) tradeProtocol).onFiatPaymentReceived();
}
///////////////////////////////////////////////////////////////////////////////////////////
// Setter for Mutable objects
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setProcessState(TradeState.ProcessState processState) {
super.setProcessState(processState);
/* switch ((SellerTradeState.ProcessState) processState) {
case EXCEPTION:
disposeProtocol();
setLifeCycleState(Trade.LifeCycleState.FAILED);
break;
}*/
}
@Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) {
super.setLifeCycleState(lifeCycleState);
switch (lifeCycleState) {
case FAILED:
disposeProtocol();
break;
case COMPLETED:
disposeProtocol();
break;
}
}
@Override
public void setThrowable(Throwable throwable) {
super.setThrowable(throwable);
// setProcessState(SellerTradeState.ProcessState.EXCEPTION);
}
///////////////////////////////////////////////////////////////////////////////////////////
// Protected
///////////////////////////////////////////////////////////////////////////////////////////
@Override
protected void handleConfidenceResult() {
if (((SellerTradeState.ProcessState) processState).ordinal() < SellerTradeState.ProcessState.DEPOSIT_CONFIRMED.ordinal())
setProcessState(SellerTradeState.ProcessState.DEPOSIT_CONFIRMED);
}
} }

View file

@ -17,89 +17,6 @@
package io.bitsquare.trade; package io.bitsquare.trade;
import io.bitsquare.p2p.Peer; public interface TakerTrade {
import io.bitsquare.storage.Storage; void takeAvailableOffer();
import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.trade.TakerProtocol;
import io.bitsquare.trade.states.TakerTradeState;
import io.bitsquare.trade.states.TradeState;
import org.bitcoinj.core.Coin;
import java.io.Serializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class TakerTrade extends Trade implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(BuyerAsTakerTrade.class);
public TakerTrade(Offer offer, Coin tradeAmount, Peer tradingPeer, Storage<? extends TradableList> storage) {
super(offer, tradeAmount, tradingPeer, storage);
log.trace("Created by constructor");
}
@Override
protected void initStates() {
processState = TakerTradeState.ProcessState.UNDEFINED;
lifeCycleState = Trade.LifeCycleState.PENDING;
initStateProperties();
}
public void takeAvailableOffer() {
assert tradeProtocol instanceof TakerProtocol;
((TakerProtocol) tradeProtocol).takeAvailableOffer();
}
///////////////////////////////////////////////////////////////////////////////////////////
// Setter for Mutable objects
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setProcessState(TradeState.ProcessState processState) {
super.setProcessState(processState);
switch ((TakerTradeState.ProcessState) processState) {
case EXCEPTION:
disposeProtocol();
setLifeCycleState(Trade.LifeCycleState.FAILED);
break;
}
}
@Override
public void setLifeCycleState(Trade.LifeCycleState lifeCycleState) {
super.setLifeCycleState(lifeCycleState);
switch (lifeCycleState) {
case FAILED:
disposeProtocol();
break;
case COMPLETED:
disposeProtocol();
break;
}
}
@Override
public void setThrowable(Throwable throwable) {
super.setThrowable(throwable);
setProcessState(TakerTradeState.ProcessState.EXCEPTION);
}
///////////////////////////////////////////////////////////////////////////////////////////
// Protected
///////////////////////////////////////////////////////////////////////////////////////////
@Override
protected void handleConfidenceResult() {
if (((TakerTradeState.ProcessState) processState).ordinal() < TakerTradeState.ProcessState.DEPOSIT_CONFIRMED.ordinal())
setProcessState(TakerTradeState.ProcessState.DEPOSIT_CONFIRMED);
}
} }

View file

@ -42,11 +42,10 @@ import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.offer.OpenOffer; import io.bitsquare.trade.offer.OpenOffer;
import io.bitsquare.trade.offer.OpenOfferManager; import io.bitsquare.trade.offer.OpenOfferManager;
import io.bitsquare.trade.protocol.availability.OfferAvailabilityModel; import io.bitsquare.trade.protocol.availability.OfferAvailabilityModel;
import io.bitsquare.trade.protocol.availability.OfferAvailabilityProtocol; import io.bitsquare.trade.protocol.trade.messages.DepositTxInputsRequest;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.messages.PayDepositRequest;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.states.OffererTradeState; import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.user.User; import io.bitsquare.user.User;
import org.bitcoinj.core.AddressFormatException; import org.bitcoinj.core.AddressFormatException;
@ -60,9 +59,7 @@ import java.io.File;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Date; import java.util.Date;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Optional; import java.util.Optional;
import javax.inject.Inject; import javax.inject.Inject;
@ -89,11 +86,10 @@ public class TradeManager {
private final WalletService walletService; private final WalletService walletService;
private final TradeWalletService tradeWalletService; private final TradeWalletService tradeWalletService;
private final CryptoService<MailboxMessage> cryptoService; private final CryptoService<MailboxMessage> cryptoService;
private OpenOfferManager openOfferManager; private final OpenOfferManager openOfferManager;
private ClosedTradableManager closedTradableManager; private final ClosedTradableManager closedTradableManager;
private final ArbitrationRepository arbitrationRepository; private final ArbitrationRepository arbitrationRepository;
private final Map<String, OfferAvailabilityProtocol> checkOfferAvailabilityProtocolMap = new HashMap<>();
private final Storage<TradableList<Trade>> pendingTradesStorage; private final Storage<TradableList<Trade>> pendingTradesStorage;
private final TradableList<Trade> pendingTrades; private final TradableList<Trade> pendingTrades;
@ -162,8 +158,8 @@ public class TradeManager {
Message message = messageWithPubKey.getMessage(); Message message = messageWithPubKey.getMessage();
// Those 2 messages are initial request form the taker. // Those 2 messages are initial request form the taker.
// RequestPayDepositMessage is used also in case of SellerAsTaker but there it is handled in the protocol as it is not an initial request // RequestPayDepositMessage is used also in case of SellerAsTaker but there it is handled in the protocol as it is not an initial request
if (message instanceof RequestDepositTxInputsMessage || if (message instanceof DepositTxInputsRequest ||
(message instanceof RequestPayDepositMessage && ((RequestPayDepositMessage) message).isInitialRequest)) (message instanceof PayDepositRequest && ((PayDepositRequest) message).isInitialRequest))
handleInitialTakeOfferRequest((TradeMessage) message, sender); handleInitialTakeOfferRequest((TradeMessage) message, sender);
} }
}); });
@ -183,7 +179,7 @@ public class TradeManager {
Offer offer = openOfferOptional.get().getOffer(); Offer offer = openOfferOptional.get().getOffer();
openOfferManager.reserveOpenOffer(openOfferOptional.get()); openOfferManager.reserveOpenOffer(openOfferOptional.get());
OffererTrade trade; Trade trade;
if (offer.getDirection() == Offer.Direction.BUY) if (offer.getDirection() == Offer.Direction.BUY)
trade = new BuyerAsOffererTrade(offer, pendingTradesStorage); trade = new BuyerAsOffererTrade(offer, pendingTradesStorage);
else else
@ -192,7 +188,7 @@ public class TradeManager {
trade.setStorage(pendingTradesStorage); trade.setStorage(pendingTradesStorage);
pendingTrades.add(trade); pendingTrades.add(trade);
initTrade(trade); initTrade(trade);
trade.handleTakeOfferRequest(message, sender); ((OffererTrade) trade).handleTakeOfferRequest(message, sender);
setupDepositPublishedListener(trade); setupDepositPublishedListener(trade);
} }
else { else {
@ -203,11 +199,23 @@ public class TradeManager {
} }
} }
private void initTrade(Trade trade) {
trade.init(messageService,
walletService,
addressService,
tradeWalletService,
blockChainService,
cryptoService,
arbitrationRepository,
user,
keyRing);
}
// Only after published we consider the openOffer as closed and the trade as completely initialized // Only after published we consider the openOffer as closed and the trade as completely initialized
private void setupDepositPublishedListener(Trade trade) { private void setupDepositPublishedListener(Trade trade) {
trade.processStateProperty().addListener((ov, oldValue, newValue) -> { trade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("setupDepositPublishedListener state = " + newValue); log.debug("setupDepositPublishedListener state = " + newValue);
if (newValue == OffererTradeState.ProcessState.DEPOSIT_PUBLISHED) { if (newValue == BuyerTradeState.ProcessState.DEPOSIT_PUBLISHED) {
openOfferManager.closeOpenOffer(trade.getOffer()); openOfferManager.closeOpenOffer(trade.getOffer());
trade.setTakeOfferDate(new Date()); trade.setTakeOfferDate(new Date());
} }
@ -270,112 +278,33 @@ public class TradeManager {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public void onOfferRemovedFromRemoteOfferBook(Offer offer) { public void onOfferRemovedFromRemoteOfferBook(Offer offer) {
disposeCheckOfferAvailabilityRequest(offer); offer.cancelAvailabilityRequest();
} }
/* private void handlePlaceOfferResult(Transaction transaction, Offer offer, TransactionResultHandler resultHandler) {
Trade trade;
if (offer.getDirection() == Offer.Direction.BUY)
trade = new BuyerAsOffererTrade(offer, openOfferTradesStorage);
else
trade = new SellerAsOffererTrade(offer, openOfferTradesStorage);
openOfferTrades.add(trade);
initTrade(trade);
setupDepositPublishedListener(trade);
resultHandler.handleResult(transaction);
}*/
/* private void setupDepositPublishedListener(Trade trade) {
trade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("setupDepositPublishedListener state = " + newValue);
if (newValue == OffererTradeState.ProcessState.DEPOSIT_PUBLISHED) {
removeOpenOffer(trade.getOffer(),
() -> log.debug("remove offer was successful"),
log::error,
false);
trade.setTakeOfferDate(new Date());
pendingTrades.add(trade);
trade.setStorage(pendingTradesStorage);
}
});
}*/
/* public void onCancelOpenOffer(Offer offer, ResultHandler resultHandler, ErrorMessageHandler errorMessageHandler) {
removeOpenOffer(offer, resultHandler, errorMessageHandler, true);
}
*/
/* private void removeOpenOffer(Offer offer,
ResultHandler resultHandler,
ErrorMessageHandler errorMessageHandler,
boolean isCancelRequest) {
offerBookService.removeOffer(offer,
() -> {
offer.setState(Offer.State.REMOVED);
Optional<Trade> offererTradeOptional = openOfferTrades.stream().filter(e -> e.getId().equals(offer.getId())).findAny();
if (offererTradeOptional.isPresent()) {
Trade trade = offererTradeOptional.get();
openOfferTrades.remove(trade);
if (isCancelRequest) {
if (trade instanceof OffererTrade)
trade.setLifeCycleState(OffererTradeState.LifeCycleState.OFFER_CANCELED);
closedTrades.add(trade);
trade.disposeProtocol();
}
}
disposeCheckOfferAvailabilityRequest(offer);
resultHandler.handleResult();
},
(message, throwable) -> errorMessageHandler.handleErrorMessage(message));
}*/
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Take offer // Take offer
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public void checkOfferAvailability(Offer offer) { public void onCheckOfferAvailability(Offer offer) {
if (!checkOfferAvailabilityProtocolMap.containsKey(offer.getId())) { offer.checkOfferAvailability(getOfferAvailabilityModel(offer));
OfferAvailabilityModel model = new OfferAvailabilityModel(
offer,
keyRing.getPubKeyRing(),
messageService,
addressService);
OfferAvailabilityProtocol protocol = new OfferAvailabilityProtocol(model,
() -> disposeCheckOfferAvailabilityRequest(offer),
(errorMessage) -> disposeCheckOfferAvailabilityRequest(offer));
checkOfferAvailabilityProtocolMap.put(offer.getId(), protocol);
protocol.checkOfferAvailability();
}
else {
log.error("That should never happen: onCheckOfferAvailability already called for offer with ID:" + offer.getId());
}
} }
// When closing take offer view, we are not interested in the onCheckOfferAvailability result anymore, so remove from the map // When closing take offer view, we are not interested in the onCheckOfferAvailability result anymore, so remove from the map
public void cancelCheckOfferAvailabilityRequest(Offer offer) { public void onCancelAvailabilityRequest(Offer offer) {
disposeCheckOfferAvailabilityRequest(offer); offer.cancelAvailabilityRequest();
} }
// First we check if offer is still available then we create the trade with the protocol // First we check if offer is still available then we create the trade with the protocol
public void requestTakeOffer(Coin amount, Offer offer, TakeOfferResultHandler takeOfferResultHandler) { public void onTakeOffer(Coin amount, Offer offer, TakeOfferResultHandler takeOfferResultHandler) {
OfferAvailabilityModel model = new OfferAvailabilityModel(offer, keyRing.getPubKeyRing(), messageService, addressService); final OfferAvailabilityModel model = getOfferAvailabilityModel(offer);
OfferAvailabilityProtocol availabilityProtocol = new OfferAvailabilityProtocol(model, offer.checkOfferAvailability(model, () -> {
() -> createTrade(amount, offer, model, takeOfferResultHandler), if (offer.getState() == Offer.State.AVAILABLE)
(errorMessage) -> disposeCheckOfferAvailabilityRequest(offer)); createTrade(amount, offer, model, takeOfferResultHandler);
checkOfferAvailabilityProtocolMap.put(offer.getId(), availabilityProtocol); });
availabilityProtocol.checkOfferAvailability();
} }
private void createTrade(Coin amount, Offer offer, OfferAvailabilityModel model, TakeOfferResultHandler private void createTrade(Coin amount, Offer offer, OfferAvailabilityModel model, TakeOfferResultHandler takeOfferResultHandler) {
takeOfferResultHandler) {
disposeCheckOfferAvailabilityRequest(offer);
if (offer.getState() == Offer.State.AVAILABLE) {
Trade trade; Trade trade;
if (offer.getDirection() == Offer.Direction.BUY) if (offer.getDirection() == Offer.Direction.BUY)
trade = new SellerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage); trade = new SellerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
@ -385,10 +314,16 @@ public class TradeManager {
trade.setTakeOfferDate(new Date()); trade.setTakeOfferDate(new Date());
initTrade(trade); initTrade(trade);
pendingTrades.add(trade); pendingTrades.add(trade);
if (trade instanceof TakerTrade)
((TakerTrade) trade).takeAvailableOffer(); ((TakerTrade) trade).takeAvailableOffer();
takeOfferResultHandler.handleResult(trade); takeOfferResultHandler.handleResult(trade);
} }
private OfferAvailabilityModel getOfferAvailabilityModel(Offer offer) {
return new OfferAvailabilityModel(
offer,
keyRing.getPubKeyRing(),
messageService,
addressService);
} }
@ -431,57 +366,17 @@ public class TradeManager {
} }
///////////////////////////////////////////////////////////////////////////////////////////
// Called from Offerbook when offer gets removed from DHT
///////////////////////////////////////////////////////////////////////////////////////////
/* public void onOfferRemovedFromRemoteOfferBook(Offer offer) {
disposeCheckOfferAvailabilityRequest(offer);
}
*/
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Getters // Getters
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
/* public ObservableList<Trade> getOpenOfferTrades() {
return openOfferTrades.getObservableList();
}*/
public ObservableList<Trade> getPendingTrades() { public ObservableList<Trade> getPendingTrades() {
return pendingTrades.getObservableList(); return pendingTrades.getObservableList();
} }
/* public ObservableList<Trade> getClosedTrades() {
return closedTrades.getObservableList();
}
*/
///////////////////////////////////////////////////////////////////////////////////////////
// Misc
///////////////////////////////////////////////////////////////////////////////////////////
private void disposeCheckOfferAvailabilityRequest(Offer offer) {
if (checkOfferAvailabilityProtocolMap.containsKey(offer.getId())) {
OfferAvailabilityProtocol protocol = checkOfferAvailabilityProtocolMap.get(offer.getId());
protocol.cancel();
checkOfferAvailabilityProtocolMap.remove(offer.getId());
}
}
private void initTrade(Trade trade) {
trade.init(messageService,
walletService,
addressService,
tradeWalletService,
blockChainService,
cryptoService,
arbitrationRepository,
user,
keyRing);
}
public boolean isMyOffer(Offer offer) { public boolean isMyOffer(Offer offer) {
return offer.isMyOffer(keyRing); return offer.isMyOffer(keyRing);
} }
} }

View file

@ -18,10 +18,13 @@
package io.bitsquare.trade.offer; package io.bitsquare.trade.offer;
import io.bitsquare.btc.Restrictions; import io.bitsquare.btc.Restrictions;
import io.bitsquare.common.handlers.ResultHandler;
import io.bitsquare.crypto.KeyRing; import io.bitsquare.crypto.KeyRing;
import io.bitsquare.crypto.PubKeyRing; import io.bitsquare.crypto.PubKeyRing;
import io.bitsquare.fiat.FiatAccount; import io.bitsquare.fiat.FiatAccount;
import io.bitsquare.locale.Country; import io.bitsquare.locale.Country;
import io.bitsquare.trade.protocol.availability.OfferAvailabilityModel;
import io.bitsquare.trade.protocol.availability.OfferAvailabilityProtocol;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.bitcoinj.utils.ExchangeRate; import org.bitcoinj.utils.ExchangeRate;
@ -46,8 +49,7 @@ import static com.google.common.base.Preconditions.*;
public class Offer implements Serializable { public class Offer implements Serializable {
// That object is sent over the wire, so we need to take care of version compatibility. // That object is sent over the wire, so we need to take care of version compatibility.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private transient static final Logger log = LoggerFactory.getLogger(Offer.class); transient private static final Logger log = LoggerFactory.getLogger(Offer.class);
public enum Direction {BUY, SELL} public enum Direction {BUY, SELL}
@ -88,6 +90,7 @@ public class Offer implements Serializable {
// Those state properties are transient and only used at runtime! // Those state properties are transient and only used at runtime!
// don't access directly as it might be null; use getStateProperty() which creates an object if not instantiated // don't access directly as it might be null; use getStateProperty() which creates an object if not instantiated
transient private ObjectProperty<State> stateProperty = new SimpleObjectProperty<>(state); transient private ObjectProperty<State> stateProperty = new SimpleObjectProperty<>(state);
transient private OfferAvailabilityProtocol availabilityProtocol;
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@ -180,6 +183,33 @@ public class Offer implements Serializable {
} }
///////////////////////////////////////////////////////////////////////////////////////////
// Availability
///////////////////////////////////////////////////////////////////////////////////////////
public void checkOfferAvailability(OfferAvailabilityModel model) {
availabilityProtocol = new OfferAvailabilityProtocol(model,
() -> cancelAvailabilityRequest(),
(errorMessage) -> cancelAvailabilityRequest());
availabilityProtocol.checkOfferAvailability();
}
public void checkOfferAvailability(OfferAvailabilityModel model, ResultHandler resultHandler) {
availabilityProtocol = new OfferAvailabilityProtocol(model,
() -> {
cancelAvailabilityRequest();
resultHandler.handleResult();
},
(errorMessage) -> availabilityProtocol.cancel());
availabilityProtocol.checkOfferAvailability();
}
public void cancelAvailabilityRequest() {
availabilityProtocol.cancel();
}
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Setters // Setters
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////

View file

@ -112,12 +112,12 @@ public class OfferAvailabilityProtocol {
if (message instanceof OfferMessage) { if (message instanceof OfferMessage) {
nonEmptyStringOf(((OfferMessage) message).offerId); nonEmptyStringOf(((OfferMessage) message).offerId);
if (message instanceof OfferAvailabilityResponse && model.offer.getId().equals(((OfferMessage) message).offerId)) if (message instanceof OfferAvailabilityResponse && model.offer.getId().equals(((OfferMessage) message).offerId))
handleDecryptedMessage((OfferAvailabilityResponse) message); handle((OfferAvailabilityResponse) message);
} }
} }
private void handleDecryptedMessage(OfferAvailabilityResponse message) { private void handle(OfferAvailabilityResponse message) {
stopTimeout(); stopTimeout();
model.setMessage(message); model.setMessage(message);

View file

@ -21,17 +21,17 @@ import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.BuyerAsOffererTrade; import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.messages.RequestFinalizePayoutTxMessage; import io.bitsquare.trade.protocol.trade.messages.FinalizePayoutTxRequest;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.CreateDepositTxInputs; import io.bitsquare.trade.protocol.trade.tasks.buyer.CreateDepositTxInputs;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessDepositTxInputsRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestFinalizePayoutTxMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessFinalizePayoutTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessPublishDepositTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendDepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendFiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendFiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayDepositRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayoutTxFinalizedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayoutTxFinalizedMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendRequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndFinalizePayoutTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndFinalizePayoutTx;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndPublishDepositTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndPublishDepositTx;
import io.bitsquare.trade.protocol.trade.tasks.buyer.VerifyAndSignContract; import io.bitsquare.trade.protocol.trade.tasks.buyer.VerifyAndSignContract;
@ -39,6 +39,8 @@ import io.bitsquare.trade.protocol.trade.tasks.offerer.VerifyTakeOfferFeePayment
import io.bitsquare.trade.protocol.trade.tasks.offerer.VerifyTakerAccount; import io.bitsquare.trade.protocol.trade.tasks.offerer.VerifyTakerAccount;
import io.bitsquare.trade.protocol.trade.tasks.shared.CommitPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.shared.CommitPayoutTx;
import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener; import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener;
import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.TradeState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -60,6 +62,23 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
log.debug("New OffererProtocol " + this); log.debug("New OffererProtocol " + this);
this.buyerAsOffererTrade = trade; this.buyerAsOffererTrade = trade;
// If we are after the timelock state we need to setup the listener again
TradeState.ProcessState state = trade.processStateProperty().get();
if (state == BuyerTradeState.ProcessState.PAYOUT_TX_COMMITTED ||
state == BuyerTradeState.ProcessState.PAYOUT_TX_SENT ||
state == BuyerTradeState.ProcessState.PAYOUT_BROAD_CASTED) {
TradeTaskRunner taskRunner = new TradeTaskRunner(trade,
() -> {
log.debug("taskRunner completed");
// we are done!
processModel.onComplete();
},
this::handleTaskRunnerFault);
taskRunner.addTasks(SetupPayoutTxLockTimeReachedListener.class);
taskRunner.run();
}
} }
@ -79,9 +98,9 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
() -> log.debug("taskRunner at handleRequestDepositTxInputsMessage completed"), () -> log.debug("taskRunner at handleRequestDepositTxInputsMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
ProcessRequestDepositTxInputsMessage.class, ProcessDepositTxInputsRequest.class,
CreateDepositTxInputs.class, CreateDepositTxInputs.class,
SendRequestPayDepositMessage.class SendPayDepositRequest.class
); );
taskRunner.run(); taskRunner.run();
startTimeout(); startTimeout();
@ -94,8 +113,8 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
// Find first the actual peer address, as it might have changed in the meantime // Find first the actual peer address, as it might have changed in the meantime
findPeerAddress(processModel.tradingPeer.getPubKeyRing(), findPeerAddress(processModel.tradingPeer.getPubKeyRing(),
() -> { () -> {
if (message instanceof RequestFinalizePayoutTxMessage) { if (message instanceof FinalizePayoutTxRequest) {
handle((RequestFinalizePayoutTxMessage) message); handle((FinalizePayoutTxRequest) message);
} }
}, },
(errorMessage -> { (errorMessage -> {
@ -108,7 +127,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
// Incoming message handling // Incoming message handling
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestPublishDepositTxMessage tradeMessage) { private void handle(PublishDepositTxRequest tradeMessage) {
stopTimeout(); stopTimeout();
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
@ -116,7 +135,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"), () -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
ProcessRequestPublishDepositTxMessage.class, ProcessPublishDepositTxRequest.class,
VerifyTakerAccount.class, VerifyTakerAccount.class,
VerifyAndSignContract.class, VerifyAndSignContract.class,
SignAndPublishDepositTx.class, SignAndPublishDepositTx.class,
@ -133,6 +152,8 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
// User clicked the "bank transfer started" button // User clicked the "bank transfer started" button
@Override @Override
public void onFiatPaymentStarted() { public void onFiatPaymentStarted() {
buyerAsOffererTrade.setProcessState(BuyerTradeState.ProcessState.FIAT_PAYMENT_STARTED);
TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsOffererTrade, TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsOffererTrade,
() -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"), () -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
@ -148,7 +169,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
// Incoming message handling // Incoming message handling
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestFinalizePayoutTxMessage tradeMessage) { private void handle(FinalizePayoutTxRequest tradeMessage) {
log.debug("handle RequestFinalizePayoutTxMessage called"); log.debug("handle RequestFinalizePayoutTxMessage called");
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
@ -161,7 +182,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
ProcessRequestFinalizePayoutTxMessage.class, ProcessFinalizePayoutTxRequest.class,
SignAndFinalizePayoutTx.class, SignAndFinalizePayoutTx.class,
CommitPayoutTx.class, CommitPayoutTx.class,
SendPayoutTxFinalizedMessage.class, SendPayoutTxFinalizedMessage.class,
@ -177,11 +198,11 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
@Override @Override
protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) { protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) {
if (tradeMessage instanceof RequestPublishDepositTxMessage) { if (tradeMessage instanceof PublishDepositTxRequest) {
handle((RequestPublishDepositTxMessage) tradeMessage); handle((PublishDepositTxRequest) tradeMessage);
} }
else if (tradeMessage instanceof RequestFinalizePayoutTxMessage) { else if (tradeMessage instanceof FinalizePayoutTxRequest) {
handle((RequestFinalizePayoutTxMessage) tradeMessage); handle((FinalizePayoutTxRequest) tradeMessage);
} }
else { else {
log.error("Incoming decrypted tradeMessage not supported. " + tradeMessage); log.error("Incoming decrypted tradeMessage not supported. " + tradeMessage);

View file

@ -21,16 +21,16 @@ import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.BuyerAsTakerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.messages.RequestFinalizePayoutTxMessage; import io.bitsquare.trade.protocol.trade.messages.FinalizePayoutTxRequest;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.CreateDepositTxInputs; import io.bitsquare.trade.protocol.trade.tasks.buyer.CreateDepositTxInputs;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestFinalizePayoutTxMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessFinalizePayoutTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessPublishDepositTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendDepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendFiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendFiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayDepositRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayoutTxFinalizedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayoutTxFinalizedMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendRequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndFinalizePayoutTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndFinalizePayoutTx;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndPublishDepositTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndPublishDepositTx;
import io.bitsquare.trade.protocol.trade.tasks.buyer.VerifyAndSignContract; import io.bitsquare.trade.protocol.trade.tasks.buyer.VerifyAndSignContract;
@ -41,6 +41,8 @@ import io.bitsquare.trade.protocol.trade.tasks.taker.BroadcastTakeOfferFeeTx;
import io.bitsquare.trade.protocol.trade.tasks.taker.CreateTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.tasks.taker.CreateTakeOfferFeeTx;
import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOfferFeePayment; import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOfferFeePayment;
import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOffererAccount; import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOffererAccount;
import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.TradeState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -62,6 +64,23 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
this.buyerAsTakerTrade = trade; this.buyerAsTakerTrade = trade;
processModel.tradingPeer.setPubKeyRing(trade.getOffer().getPubKeyRing()); processModel.tradingPeer.setPubKeyRing(trade.getOffer().getPubKeyRing());
// If we are after the timelock state we need to setup the listener again
TradeState.ProcessState state = trade.processStateProperty().get();
if (state == BuyerTradeState.ProcessState.PAYOUT_TX_COMMITTED ||
state == BuyerTradeState.ProcessState.PAYOUT_TX_SENT ||
state == BuyerTradeState.ProcessState.PAYOUT_BROAD_CASTED) {
TradeTaskRunner taskRunner = new TradeTaskRunner(trade,
() -> {
log.debug("taskRunner completed");
// we are done!
processModel.onComplete();
},
this::handleTaskRunnerFault);
taskRunner.addTasks(SetupPayoutTxLockTimeReachedListener.class);
taskRunner.run();
}
} }
@ -76,8 +95,8 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
// Find first the actual peer address, as it might have changed in the meantime // Find first the actual peer address, as it might have changed in the meantime
findPeerAddress(trade.getOffer().getPubKeyRing(), findPeerAddress(trade.getOffer().getPubKeyRing(),
() -> { () -> {
if (message instanceof RequestFinalizePayoutTxMessage) { if (message instanceof FinalizePayoutTxRequest) {
handle((RequestFinalizePayoutTxMessage) message); handle((FinalizePayoutTxRequest) message);
} }
}, },
(errorMessage -> { (errorMessage -> {
@ -95,7 +114,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
CreateTakeOfferFeeTx.class, CreateTakeOfferFeeTx.class,
BroadcastTakeOfferFeeTx.class, BroadcastTakeOfferFeeTx.class,
CreateDepositTxInputs.class, CreateDepositTxInputs.class,
SendRequestPayDepositMessage.class SendPayDepositRequest.class
); );
taskRunner.run(); taskRunner.run();
startTimeout(); startTimeout();
@ -106,7 +125,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
// Incoming message handling // Incoming message handling
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestPublishDepositTxMessage tradeMessage) { private void handle(PublishDepositTxRequest tradeMessage) {
stopTimeout(); stopTimeout();
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
@ -114,7 +133,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"), () -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
ProcessRequestPublishDepositTxMessage.class, ProcessPublishDepositTxRequest.class,
VerifyOffererAccount.class, VerifyOffererAccount.class,
VerifyAndSignContract.class, VerifyAndSignContract.class,
SignAndPublishDepositTx.class, SignAndPublishDepositTx.class,
@ -131,6 +150,9 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
// User clicked the "bank transfer started" button // User clicked the "bank transfer started" button
@Override @Override
public void onFiatPaymentStarted() { public void onFiatPaymentStarted() {
buyerAsTakerTrade.setProcessState(BuyerTradeState.ProcessState.FIAT_PAYMENT_STARTED);
TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsTakerTrade, TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsTakerTrade,
() -> log.debug("taskRunner at onFiatPaymentStarted completed"), () -> log.debug("taskRunner at onFiatPaymentStarted completed"),
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
@ -147,7 +169,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
// Incoming message handling // Incoming message handling
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestFinalizePayoutTxMessage tradeMessage) { private void handle(FinalizePayoutTxRequest tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsTakerTrade, TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsTakerTrade,
@ -159,7 +181,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
ProcessRequestFinalizePayoutTxMessage.class, ProcessFinalizePayoutTxRequest.class,
SignAndFinalizePayoutTx.class, SignAndFinalizePayoutTx.class,
CommitPayoutTx.class, CommitPayoutTx.class,
SendPayoutTxFinalizedMessage.class, SendPayoutTxFinalizedMessage.class,
@ -174,11 +196,11 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
@Override @Override
protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) { protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) {
if (tradeMessage instanceof RequestPublishDepositTxMessage) { if (tradeMessage instanceof PublishDepositTxRequest) {
handle((RequestPublishDepositTxMessage) tradeMessage); handle((PublishDepositTxRequest) tradeMessage);
} }
else if (tradeMessage instanceof RequestFinalizePayoutTxMessage) { else if (tradeMessage instanceof FinalizePayoutTxRequest) {
handle((RequestFinalizePayoutTxMessage) tradeMessage); handle((FinalizePayoutTxRequest) tradeMessage);
} }
else { else {
log.error("Incoming message not supported. " + tradeMessage); log.error("Incoming message not supported. " + tradeMessage);

View file

@ -32,13 +32,15 @@ import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignContract;
import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignDepositTx; import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignDepositTx;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessDepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessFiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessFiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayDepositRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayoutTxFinalizedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayoutTxFinalizedMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessRequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.SendFinalizePayoutTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestFinalizePayoutTxMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.SendPublishDepositTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.SignPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.seller.SignPayoutTx;
import io.bitsquare.trade.protocol.trade.tasks.shared.CommitPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.shared.CommitPayoutTx;
import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener; import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener;
import io.bitsquare.trade.states.SellerTradeState;
import io.bitsquare.trade.states.TradeState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -58,6 +60,23 @@ public class SellerAsOffererProtocol extends TradeProtocol implements SellerProt
log.debug("New OffererProtocol " + this); log.debug("New OffererProtocol " + this);
this.sellerAsOffererTrade = trade; this.sellerAsOffererTrade = trade;
// If we are after the timelock state we need to setup the listener again
TradeState.ProcessState state = trade.processStateProperty().get();
if (state == SellerTradeState.ProcessState.PAYOUT_TX_RECEIVED ||
state == SellerTradeState.ProcessState.PAYOUT_TX_COMMITTED ||
state == SellerTradeState.ProcessState.PAYOUT_BROAD_CASTED) {
TradeTaskRunner taskRunner = new TradeTaskRunner(trade,
() -> {
log.debug("taskRunner completed");
// we are done!
processModel.onComplete();
},
this::handleTaskRunnerFault);
taskRunner.addTasks(SetupPayoutTxLockTimeReachedListener.class);
taskRunner.run();
}
} }
@ -75,11 +94,11 @@ public class SellerAsOffererProtocol extends TradeProtocol implements SellerProt
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
ProcessRequestPayDepositMessage.class, ProcessPayDepositRequest.class,
VerifyTakerAccount.class, VerifyTakerAccount.class,
CreateAndSignContract.class, CreateAndSignContract.class,
CreateAndSignDepositTx.class, CreateAndSignDepositTx.class,
SendRequestPublishDepositTxMessage.class SendPublishDepositTxRequest.class
); );
taskRunner.run(); taskRunner.run();
startTimeout(); startTimeout();
@ -153,6 +172,8 @@ public class SellerAsOffererProtocol extends TradeProtocol implements SellerProt
// User clicked the "bank transfer received" button, so we release the funds for pay out // User clicked the "bank transfer received" button, so we release the funds for pay out
@Override @Override
public void onFiatPaymentReceived() { public void onFiatPaymentReceived() {
sellerAsOffererTrade.setProcessState(SellerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT);
TradeTaskRunner taskRunner = new TradeTaskRunner(sellerAsOffererTrade, TradeTaskRunner taskRunner = new TradeTaskRunner(sellerAsOffererTrade,
() -> { () -> {
log.debug("taskRunner at handleFiatReceivedUIEvent completed"); log.debug("taskRunner at handleFiatReceivedUIEvent completed");
@ -165,7 +186,7 @@ public class SellerAsOffererProtocol extends TradeProtocol implements SellerProt
taskRunner.addTasks( taskRunner.addTasks(
VerifyTakeOfferFeePayment.class, VerifyTakeOfferFeePayment.class,
SignPayoutTx.class, SignPayoutTx.class,
SendRequestFinalizePayoutTxMessage.class SendFinalizePayoutTxRequest.class
); );
taskRunner.run(); taskRunner.run();
} }

View file

@ -20,22 +20,23 @@ package io.bitsquare.trade.protocol.trade;
import io.bitsquare.p2p.Message; import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.SellerAsTakerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.SellerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.messages.PayDepositRequest;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxFinalizedMessage; import io.bitsquare.trade.protocol.trade.messages.PayoutTxFinalizedMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.CommitDepositTx; import io.bitsquare.trade.protocol.trade.tasks.seller.CommitDepositTx;
import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignContract; import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignContract;
import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignDepositTx; import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignDepositTx;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessDepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessFiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessFiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayDepositRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayoutTxFinalizedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayoutTxFinalizedMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessRequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.SendDepositTxInputsRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.SendFinalizePayoutTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestFinalizePayoutTxMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.SendPublishDepositTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.SignPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.seller.SignPayoutTx;
import io.bitsquare.trade.protocol.trade.tasks.shared.CommitPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.shared.CommitPayoutTx;
import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener; import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener;
@ -43,6 +44,8 @@ import io.bitsquare.trade.protocol.trade.tasks.taker.BroadcastTakeOfferFeeTx;
import io.bitsquare.trade.protocol.trade.tasks.taker.CreateTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.tasks.taker.CreateTakeOfferFeeTx;
import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOfferFeePayment; import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOfferFeePayment;
import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOffererAccount; import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOffererAccount;
import io.bitsquare.trade.states.SellerTradeState;
import io.bitsquare.trade.states.TradeState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -64,6 +67,25 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
this.sellerAsTakerTrade = trade; this.sellerAsTakerTrade = trade;
processModel.tradingPeer.setPubKeyRing(trade.getOffer().getPubKeyRing()); processModel.tradingPeer.setPubKeyRing(trade.getOffer().getPubKeyRing());
// If we are after the timelock state we need to setup the listener again
if (trade instanceof SellerTrade) {
TradeState.ProcessState state = trade.processStateProperty().get();
if (state == SellerTradeState.ProcessState.PAYOUT_TX_RECEIVED ||
state == SellerTradeState.ProcessState.PAYOUT_TX_COMMITTED ||
state == SellerTradeState.ProcessState.PAYOUT_BROAD_CASTED) {
TradeTaskRunner taskRunner = new TradeTaskRunner(trade,
() -> {
log.debug("taskRunner completed");
// we are done!
processModel.onComplete();
},
this::handleTaskRunnerFault);
taskRunner.addTasks(SetupPayoutTxLockTimeReachedListener.class);
taskRunner.run();
}
}
} }
@ -104,7 +126,7 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
taskRunner.addTasks( taskRunner.addTasks(
CreateTakeOfferFeeTx.class, CreateTakeOfferFeeTx.class,
BroadcastTakeOfferFeeTx.class, BroadcastTakeOfferFeeTx.class,
SendRequestDepositTxInputsMessage.class SendDepositTxInputsRequest.class
); );
taskRunner.run(); taskRunner.run();
startTimeout(); startTimeout();
@ -115,7 +137,7 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
// Incoming message handling // Incoming message handling
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestPayDepositMessage tradeMessage) { private void handle(PayDepositRequest tradeMessage) {
log.debug("handle RequestPayDepositMessage"); log.debug("handle RequestPayDepositMessage");
stopTimeout(); stopTimeout();
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
@ -125,11 +147,11 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
this::handleTaskRunnerFault); this::handleTaskRunnerFault);
taskRunner.addTasks( taskRunner.addTasks(
ProcessRequestPayDepositMessage.class, ProcessPayDepositRequest.class,
VerifyOffererAccount.class, VerifyOffererAccount.class,
CreateAndSignContract.class, CreateAndSignContract.class,
CreateAndSignDepositTx.class, CreateAndSignDepositTx.class,
SendRequestPublishDepositTxMessage.class SendPublishDepositTxRequest.class
); );
taskRunner.run(); taskRunner.run();
startTimeout(); startTimeout();
@ -174,6 +196,8 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
// User clicked the "bank transfer received" button, so we release the funds for pay out // User clicked the "bank transfer received" button, so we release the funds for pay out
@Override @Override
public void onFiatPaymentReceived() { public void onFiatPaymentReceived() {
sellerAsTakerTrade.setProcessState(SellerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT);
TradeTaskRunner taskRunner = new TradeTaskRunner(sellerAsTakerTrade, TradeTaskRunner taskRunner = new TradeTaskRunner(sellerAsTakerTrade,
() -> { () -> {
log.debug("taskRunner at onFiatPaymentReceived completed"); log.debug("taskRunner at onFiatPaymentReceived completed");
@ -186,7 +210,7 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
taskRunner.addTasks( taskRunner.addTasks(
VerifyOfferFeePayment.class, VerifyOfferFeePayment.class,
SignPayoutTx.class, SignPayoutTx.class,
SendRequestFinalizePayoutTxMessage.class SendFinalizePayoutTxRequest.class
); );
taskRunner.run(); taskRunner.run();
} }
@ -214,8 +238,8 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
@Override @Override
protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) { protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) {
if (tradeMessage instanceof RequestPayDepositMessage) { if (tradeMessage instanceof PayDepositRequest) {
handle((RequestPayDepositMessage) tradeMessage); handle((PayDepositRequest) tradeMessage);
} }
else if (tradeMessage instanceof DepositTxPublishedMessage) { else if (tradeMessage instanceof DepositTxPublishedMessage) {
handle((DepositTxPublishedMessage) tradeMessage); handle((DepositTxPublishedMessage) tradeMessage);

View file

@ -25,13 +25,13 @@ import io.bitsquare.p2p.DecryptedMessageHandler;
import io.bitsquare.p2p.Message; import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.Peer; import io.bitsquare.p2p.Peer;
import io.bitsquare.p2p.listener.GetPeerAddressListener; import io.bitsquare.p2p.listener.GetPeerAddressListener;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.BuyerTrade;
import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.SellerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage; import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener; import io.bitsquare.trade.protocol.trade.tasks.shared.SetupPayoutTxLockTimeReachedListener;
import io.bitsquare.trade.states.OffererTradeState; import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.TakerTradeState; import io.bitsquare.trade.states.SellerTradeState;
import org.bitcoinj.utils.Threading; import org.bitcoinj.utils.Threading;
@ -122,10 +122,10 @@ public abstract class TradeProtocol {
this.trade = trade; this.trade = trade;
boolean needPayoutTxBroadcast = false; boolean needPayoutTxBroadcast = false;
if (trade instanceof TakerTrade) if (trade instanceof SellerTrade)
needPayoutTxBroadcast = trade.processStateProperty().get() == TakerTradeState.ProcessState.PAYOUT_FINALIZED; needPayoutTxBroadcast = trade.processStateProperty().get() == SellerTradeState.ProcessState.PAYOUT_TX_COMMITTED;
else if (trade instanceof OffererTrade) else if (trade instanceof BuyerTrade)
needPayoutTxBroadcast = trade.processStateProperty().get() == OffererTradeState.ProcessState.PAYOUT_FINALIZED; needPayoutTxBroadcast = trade.processStateProperty().get() == BuyerTradeState.ProcessState.PAYOUT_TX_COMMITTED;
if (needPayoutTxBroadcast) { if (needPayoutTxBroadcast) {
TradeTaskRunner taskRunner = new TradeTaskRunner(trade, TradeTaskRunner taskRunner = new TradeTaskRunner(trade,
@ -150,10 +150,10 @@ public abstract class TradeProtocol {
public void run() { public void run() {
Threading.USER_THREAD.execute(() -> { Threading.USER_THREAD.execute(() -> {
log.debug("Timeout reached"); log.debug("Timeout reached");
if (trade instanceof TakerTrade) /* if (trade instanceof SellerTrade)
trade.setProcessState(TakerTradeState.ProcessState.TIMEOUT); trade.setProcessState(SellerTradeState.ProcessState.TIMEOUT);
else if (trade instanceof OffererTrade) else if (trade instanceof BuyerTrade)
trade.setProcessState(OffererTradeState.ProcessState.TIMEOUT); trade.setProcessState(BuyerTradeState.ProcessState.TIMEOUT);*/
}); });
} }
}; };

View file

@ -26,7 +26,7 @@ import java.io.Serializable;
import javax.annotation.concurrent.Immutable; import javax.annotation.concurrent.Immutable;
@Immutable @Immutable
public class RequestDepositTxInputsMessage extends TradeMessage implements Serializable { public class DepositTxInputsRequest extends TradeMessage implements Serializable {
// That object is sent over the wire, so we need to take care of version compatibility. // That object is sent over the wire, so we need to take care of version compatibility.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -35,7 +35,7 @@ public class RequestDepositTxInputsMessage extends TradeMessage implements Seria
public final String sellerOfferFeeTxId; public final String sellerOfferFeeTxId;
public final byte[] sellerTradeWalletPubKey; public final byte[] sellerTradeWalletPubKey;
public RequestDepositTxInputsMessage(String tradeId, PubKeyRing sellerPubKeyRing, String sellerOfferFeeTxId, Coin tradeAmount, byte[] public DepositTxInputsRequest(String tradeId, PubKeyRing sellerPubKeyRing, String sellerOfferFeeTxId, Coin tradeAmount, byte[]
sellerTradeWalletPubKey) { sellerTradeWalletPubKey) {
super(tradeId); super(tradeId);
this.sellerPubKeyRing = sellerPubKeyRing; this.sellerPubKeyRing = sellerPubKeyRing;

View file

@ -24,7 +24,7 @@ import java.io.Serializable;
import javax.annotation.concurrent.Immutable; import javax.annotation.concurrent.Immutable;
@Immutable @Immutable
public class RequestFinalizePayoutTxMessage extends TradeMessage implements MailboxMessage, Serializable { public class FinalizePayoutTxRequest extends TradeMessage implements MailboxMessage, Serializable {
// That object is sent over the wire, so we need to take care of version compatibility. // That object is sent over the wire, so we need to take care of version compatibility.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -32,7 +32,7 @@ public class RequestFinalizePayoutTxMessage extends TradeMessage implements Mail
public final String sellerPayoutAddress; public final String sellerPayoutAddress;
public final long lockTime; public final long lockTime;
public RequestFinalizePayoutTxMessage(String tradeId, public FinalizePayoutTxRequest(String tradeId,
byte[] sellerSignature, byte[] sellerSignature,
String sellerPayoutAddress, String sellerPayoutAddress,
long lockTime) { long lockTime) {

View file

@ -30,7 +30,7 @@ import java.util.List;
import javax.annotation.concurrent.Immutable; import javax.annotation.concurrent.Immutable;
@Immutable @Immutable
public class RequestPayDepositMessage extends TradeMessage implements Serializable { public class PayDepositRequest extends TradeMessage implements Serializable {
// That object is sent over the wire, so we need to take care of version compatibility. // That object is sent over the wire, so we need to take care of version compatibility.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -43,7 +43,7 @@ public class RequestPayDepositMessage extends TradeMessage implements Serializab
public final String buyerAccountId; public final String buyerAccountId;
public final Coin tradeAmount; public final Coin tradeAmount;
public RequestPayDepositMessage(String tradeId, public PayDepositRequest(String tradeId,
Coin tradeAmount, Coin tradeAmount,
boolean isInitialRequest, boolean isInitialRequest,
List<TransactionOutput> buyerConnectedOutputsForAllInputs, List<TransactionOutput> buyerConnectedOutputsForAllInputs,

View file

@ -29,7 +29,7 @@ import java.util.List;
import javax.annotation.concurrent.Immutable; import javax.annotation.concurrent.Immutable;
@Immutable @Immutable
public class RequestPublishDepositTxMessage extends TradeMessage implements Serializable { public class PublishDepositTxRequest extends TradeMessage implements Serializable {
// That object is sent over the wire, so we need to take care of version compatibility. // That object is sent over the wire, so we need to take care of version compatibility.
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -42,7 +42,7 @@ public class RequestPublishDepositTxMessage extends TradeMessage implements Seri
public final List<TransactionOutput> sellerConnectedOutputsForAllInputs; public final List<TransactionOutput> sellerConnectedOutputsForAllInputs;
public final byte[] sellerTradeWalletPubKey; public final byte[] sellerTradeWalletPubKey;
public RequestPublishDepositTxMessage(String tradeId, public PublishDepositTxRequest(String tradeId,
FiatAccount sellerFiatAccount, FiatAccount sellerFiatAccount,
String sellerAccountId, String sellerAccountId,
byte[] sellerTradeWalletPubKey, byte[] sellerTradeWalletPubKey,

View file

@ -20,7 +20,7 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxInputsRequest;
import io.bitsquare.trade.states.StateUtil; import io.bitsquare.trade.states.StateUtil;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -29,17 +29,17 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class ProcessRequestDepositTxInputsMessage extends TradeTask { public class ProcessDepositTxInputsRequest extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(ProcessRequestDepositTxInputsMessage.class); private static final Logger log = LoggerFactory.getLogger(ProcessDepositTxInputsRequest.class);
public ProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) { public ProcessDepositTxInputsRequest(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
RequestDepositTxInputsMessage message = (RequestDepositTxInputsMessage) processModel.getTradeMessage(); DepositTxInputsRequest message = (DepositTxInputsRequest) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message); checkTradeId(processModel.getId(), message);
checkNotNull(message); checkNotNull(message);

View file

@ -20,7 +20,8 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestFinalizePayoutTxMessage; import io.bitsquare.trade.protocol.trade.messages.FinalizePayoutTxRequest;
import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.StateUtil; import io.bitsquare.trade.states.StateUtil;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -29,17 +30,17 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class ProcessRequestFinalizePayoutTxMessage extends TradeTask { public class ProcessFinalizePayoutTxRequest extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(ProcessRequestFinalizePayoutTxMessage.class); private static final Logger log = LoggerFactory.getLogger(ProcessFinalizePayoutTxRequest.class);
public ProcessRequestFinalizePayoutTxMessage(TaskRunner taskHandler, Trade trade) { public ProcessFinalizePayoutTxRequest(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
RequestFinalizePayoutTxMessage message = (RequestFinalizePayoutTxMessage) processModel.getTradeMessage(); FinalizePayoutTxRequest message = (FinalizePayoutTxRequest) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message); checkTradeId(processModel.getId(), message);
checkNotNull(message); checkNotNull(message);
@ -47,6 +48,8 @@ public class ProcessRequestFinalizePayoutTxMessage extends TradeTask {
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.sellerPayoutAddress)); processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.sellerPayoutAddress));
trade.setLockTime(nonNegativeLongOf(message.lockTime)); trade.setLockTime(nonNegativeLongOf(message.lockTime));
trade.setProcessState(BuyerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT_MSG_RECEIVED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();

View file

@ -20,7 +20,7 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest;
import io.bitsquare.trade.states.StateUtil; import io.bitsquare.trade.states.StateUtil;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -29,17 +29,17 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*; import static com.google.common.base.Preconditions.*;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class ProcessRequestPublishDepositTxMessage extends TradeTask { public class ProcessPublishDepositTxRequest extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(ProcessRequestPublishDepositTxMessage.class); private static final Logger log = LoggerFactory.getLogger(ProcessPublishDepositTxRequest.class);
public ProcessRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) { public ProcessPublishDepositTxRequest(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
RequestPublishDepositTxMessage message = (RequestPublishDepositTxMessage) processModel.getTradeMessage(); PublishDepositTxRequest message = (PublishDepositTxRequest) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message); checkTradeId(processModel.getId(), message);
checkNotNull(message); checkNotNull(message);

View file

@ -22,6 +22,7 @@ import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.StateUtil; import io.bitsquare.trade.states.StateUtil;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -48,6 +49,8 @@ public class SendDepositTxPublishedMessage extends TradeTask {
public void handleResult() { public void handleResult() {
log.trace("DepositTxPublishedMessage successfully arrived at peer"); log.trace("DepositTxPublishedMessage successfully arrived at peer");
trade.setProcessState(BuyerTradeState.ProcessState.DEPOSIT_PUBLISHED_MSG_SENT);
complete(); complete();
} }

View file

@ -19,14 +19,11 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.states.OffererTradeState; import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.StateUtil; import io.bitsquare.trade.states.StateUtil;
import io.bitsquare.trade.states.TakerTradeState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -54,10 +51,7 @@ public class SendFiatTransferStartedMessage extends TradeTask {
public void handleResult() { public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded."); log.trace("Sending FiatTransferStartedMessage succeeded.");
if (trade instanceof OffererTrade) trade.setProcessState(BuyerTradeState.ProcessState.FIAT_PAYMENT_STARTED_MSG_SENT);
trade.setProcessState(OffererTradeState.ProcessState.FIAT_PAYMENT_STARTED);
if (trade instanceof TakerTrade)
trade.setProcessState(TakerTradeState.ProcessState.FIAT_PAYMENT_STARTED);
complete(); complete();
} }

View file

@ -22,16 +22,16 @@ import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.BuyerAsTakerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.messages.PayDepositRequest;
import io.bitsquare.trade.states.StateUtil; import io.bitsquare.trade.states.StateUtil;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SendRequestPayDepositMessage extends TradeTask { public class SendPayDepositRequest extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(SendRequestPayDepositMessage.class); private static final Logger log = LoggerFactory.getLogger(SendPayDepositRequest.class);
public SendRequestPayDepositMessage(TaskRunner taskHandler, Trade trade) { public SendPayDepositRequest(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade); super(taskHandler, trade);
} }
@ -39,7 +39,7 @@ public class SendRequestPayDepositMessage extends TradeTask {
protected void doRun() { protected void doRun() {
try { try {
boolean isInitialRequest = trade instanceof BuyerAsTakerTrade; boolean isInitialRequest = trade instanceof BuyerAsTakerTrade;
RequestPayDepositMessage tradeMessage = new RequestPayDepositMessage( PayDepositRequest tradeMessage = new PayDepositRequest(
processModel.getId(), processModel.getId(),
trade.getTradeAmount(), trade.getTradeAmount(),
isInitialRequest, isInitialRequest,

View file

@ -22,6 +22,7 @@ import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxFinalizedMessage; import io.bitsquare.trade.protocol.trade.messages.PayoutTxFinalizedMessage;
import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.StateUtil; import io.bitsquare.trade.states.StateUtil;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -47,6 +48,8 @@ public class SendPayoutTxFinalizedMessage extends TradeTask {
public void handleResult() { public void handleResult() {
log.trace("PayoutTxFinalizedMessage successfully arrived at peer"); log.trace("PayoutTxFinalizedMessage successfully arrived at peer");
trade.setProcessState(BuyerTradeState.ProcessState.PAYOUT_TX_SENT);
complete(); complete();
} }

View file

@ -18,12 +18,8 @@
package io.bitsquare.trade.protocol.trade.tasks.buyer; package io.bitsquare.trade.protocol.trade.tasks.buyer;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.OffererTradeState;
import io.bitsquare.trade.states.TakerTradeState;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -60,10 +56,6 @@ public class SignAndFinalizePayoutTx extends TradeTask {
); );
trade.setPayoutTx(transaction); trade.setPayoutTx(transaction);
if (trade instanceof TakerTrade)
trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_FINALIZED);
else if (trade instanceof OffererTrade)
trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_FINALIZED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {

View file

@ -19,12 +19,10 @@ package io.bitsquare.trade.protocol.trade.tasks.buyer;
import io.bitsquare.btc.FeePolicy; import io.bitsquare.btc.FeePolicy;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.BuyerTrade;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.OffererTradeState; import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.TakerTradeState;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -67,11 +65,7 @@ public class SignAndPublishDepositTx extends TradeTask {
trade.setDepositTx(transaction); trade.setDepositTx(transaction);
trade.setLifeCycleState(Trade.LifeCycleState.PENDING); trade.setLifeCycleState(Trade.LifeCycleState.PENDING);
if (trade instanceof TakerTrade) trade.setProcessState(BuyerTradeState.ProcessState.DEPOSIT_PUBLISHED);
trade.setProcessState(TakerTradeState.ProcessState.DEPOSIT_PUBLISHED);
else if (trade instanceof OffererTrade)
trade.setProcessState(OffererTradeState.ProcessState.DEPOSIT_PUBLISHED);
trade.setTakeOfferDate(new Date()); trade.setTakeOfferDate(new Date());
complete(); complete();
@ -91,7 +85,7 @@ public class SignAndPublishDepositTx extends TradeTask {
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
if (trade instanceof OffererTrade) if (trade instanceof BuyerTrade)
trade.setLifeCycleState(Trade.LifeCycleState.PREPARATION); trade.setLifeCycleState(Trade.LifeCycleState.PREPARATION);
failed(t); failed(t);

View file

@ -18,13 +18,10 @@
package io.bitsquare.trade.protocol.trade.tasks.seller; package io.bitsquare.trade.protocol.trade.tasks.seller;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.states.OffererTradeState; import io.bitsquare.trade.states.SellerTradeState;
import io.bitsquare.trade.states.TakerTradeState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -48,10 +45,7 @@ public class ProcessDepositTxPublishedMessage extends TradeTask {
trade.setDepositTx(checkNotNull(message.depositTx)); trade.setDepositTx(checkNotNull(message.depositTx));
if (trade instanceof OffererTrade) trade.setProcessState(SellerTradeState.ProcessState.DEPOSIT_PUBLISHED_MSG_RECEIVED);
trade.setProcessState(OffererTradeState.ProcessState.DEPOSIT_PUBLISHED);
else if (trade instanceof TakerTrade)
trade.setProcessState(TakerTradeState.ProcessState.DEPOSIT_PUBLISHED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {

View file

@ -18,13 +18,10 @@
package io.bitsquare.trade.protocol.trade.tasks.seller; package io.bitsquare.trade.protocol.trade.tasks.seller;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.states.OffererTradeState; import io.bitsquare.trade.states.SellerTradeState;
import io.bitsquare.trade.states.TakerTradeState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -48,10 +45,7 @@ public class ProcessFiatTransferStartedMessage extends TradeTask {
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress)); processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (trade instanceof OffererTrade) trade.setProcessState(SellerTradeState.ProcessState.FIAT_PAYMENT_STARTED_MSG_RECEIVED);
trade.setProcessState(OffererTradeState.ProcessState.FIAT_PAYMENT_STARTED);
else if (trade instanceof TakerTrade)
trade.setProcessState(TakerTradeState.ProcessState.FIAT_PAYMENT_STARTED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {

View file

@ -20,7 +20,7 @@ package io.bitsquare.trade.protocol.trade.tasks.seller;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.messages.PayDepositRequest;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -28,17 +28,17 @@ import org.slf4j.LoggerFactory;
import static com.google.common.base.Preconditions.*; import static com.google.common.base.Preconditions.*;
import static io.bitsquare.util.Validator.*; import static io.bitsquare.util.Validator.*;
public class ProcessRequestPayDepositMessage extends TradeTask { public class ProcessPayDepositRequest extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(ProcessRequestPayDepositMessage.class); private static final Logger log = LoggerFactory.getLogger(ProcessPayDepositRequest.class);
public ProcessRequestPayDepositMessage(TaskRunner taskHandler, Trade trade) { public ProcessPayDepositRequest(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
RequestPayDepositMessage message = (RequestPayDepositMessage) processModel.getTradeMessage(); PayDepositRequest message = (PayDepositRequest) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message); checkTradeId(processModel.getId(), message);
checkNotNull(message); checkNotNull(message);

View file

@ -18,13 +18,10 @@
package io.bitsquare.trade.protocol.trade.tasks.seller; package io.bitsquare.trade.protocol.trade.tasks.seller;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxFinalizedMessage; import io.bitsquare.trade.protocol.trade.messages.PayoutTxFinalizedMessage;
import io.bitsquare.trade.states.OffererTradeState; import io.bitsquare.trade.states.SellerTradeState;
import io.bitsquare.trade.states.TakerTradeState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -48,10 +45,7 @@ public class ProcessPayoutTxFinalizedMessage extends TradeTask {
trade.setPayoutTx(checkNotNull(message.payoutTx)); trade.setPayoutTx(checkNotNull(message.payoutTx));
if (trade instanceof OffererTrade) trade.setProcessState(SellerTradeState.ProcessState.PAYOUT_TX_RECEIVED);
trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_FINALIZED);
else if (trade instanceof TakerTrade)
trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_FINALIZED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {

View file

@ -21,7 +21,7 @@ import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.messages.DepositTxInputsRequest;
import io.bitsquare.trade.states.StateUtil; import io.bitsquare.trade.states.StateUtil;
import org.bitcoinj.utils.Threading; import org.bitcoinj.utils.Threading;
@ -29,10 +29,10 @@ import org.bitcoinj.utils.Threading;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SendRequestDepositTxInputsMessage extends TradeTask { public class SendDepositTxInputsRequest extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(SendRequestDepositTxInputsMessage.class); private static final Logger log = LoggerFactory.getLogger(SendDepositTxInputsRequest.class);
public SendRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) { public SendDepositTxInputsRequest(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade); super(taskHandler, trade);
} }
@ -42,7 +42,7 @@ public class SendRequestDepositTxInputsMessage extends TradeTask {
protected void doRun() { protected void doRun() {
try { try {
assert processModel.getTakeOfferFeeTx() != null; assert processModel.getTakeOfferFeeTx() != null;
RequestDepositTxInputsMessage message = new RequestDepositTxInputsMessage( DepositTxInputsRequest message = new DepositTxInputsRequest(
processModel.getId(), processModel.getId(),
processModel.getPubKeyRing(), processModel.getPubKeyRing(),
processModel.getTakeOfferFeeTx().getHashAsString(), processModel.getTakeOfferFeeTx().getHashAsString(),
@ -67,7 +67,7 @@ public class SendRequestDepositTxInputsMessage extends TradeTask {
// We try to repeat once and if that fails as well we persist the state for a later retry. // We try to repeat once and if that fails as well we persist the state for a later retry.
if (retryCounter == 0) { if (retryCounter == 0) {
retryCounter++; retryCounter++;
Threading.USER_THREAD.execute(SendRequestDepositTxInputsMessage.this::doRun); Threading.USER_THREAD.execute(SendDepositTxInputsRequest.this::doRun);
} }
else { else {
appendToErrorMessage("Sending TakeOfferFeePayedMessage to offerer failed. Maybe the network connection was " + appendToErrorMessage("Sending TakeOfferFeePayedMessage to offerer failed. Maybe the network connection was " +

View file

@ -19,29 +19,26 @@ package io.bitsquare.trade.protocol.trade.tasks.seller;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestFinalizePayoutTxMessage; import io.bitsquare.trade.protocol.trade.messages.FinalizePayoutTxRequest;
import io.bitsquare.trade.states.OffererTradeState; import io.bitsquare.trade.states.SellerTradeState;
import io.bitsquare.trade.states.StateUtil; import io.bitsquare.trade.states.StateUtil;
import io.bitsquare.trade.states.TakerTradeState;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SendRequestFinalizePayoutTxMessage extends TradeTask { public class SendFinalizePayoutTxRequest extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(SendRequestFinalizePayoutTxMessage.class); private static final Logger log = LoggerFactory.getLogger(SendFinalizePayoutTxRequest.class);
public SendRequestFinalizePayoutTxMessage(TaskRunner taskHandler, Trade trade) { public SendFinalizePayoutTxRequest(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
RequestFinalizePayoutTxMessage message = new RequestFinalizePayoutTxMessage( FinalizePayoutTxRequest message = new FinalizePayoutTxRequest(
processModel.getId(), processModel.getId(),
processModel.getPayoutTxSignature(), processModel.getPayoutTxSignature(),
processModel.getAddressEntry().getAddressString(), processModel.getAddressEntry().getAddressString(),
@ -57,10 +54,7 @@ public class SendRequestFinalizePayoutTxMessage extends TradeTask {
public void handleResult() { public void handleResult() {
log.trace("PayoutTxPublishedMessage successfully arrived at peer"); log.trace("PayoutTxPublishedMessage successfully arrived at peer");
if (trade instanceof TakerTrade) trade.setProcessState(SellerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT_MSG_SENT);
trade.setProcessState(TakerTradeState.ProcessState.REQUEST_PAYOUT_FINALIZE_MSG_SENT);
else if (trade instanceof OffererTrade)
trade.setProcessState(OffererTradeState.ProcessState.REQUEST_PAYOUT_FINALIZE_MSG_SENT);
complete(); complete();
} }

View file

@ -21,23 +21,23 @@ import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener; import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest;
import io.bitsquare.trade.states.StateUtil; import io.bitsquare.trade.states.StateUtil;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class SendRequestPublishDepositTxMessage extends TradeTask { public class SendPublishDepositTxRequest extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(SendRequestPublishDepositTxMessage.class); private static final Logger log = LoggerFactory.getLogger(SendPublishDepositTxRequest.class);
public SendRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) { public SendPublishDepositTxRequest(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
RequestPublishDepositTxMessage tradeMessage = new RequestPublishDepositTxMessage( PublishDepositTxRequest tradeMessage = new PublishDepositTxRequest(
processModel.getId(), processModel.getId(),
processModel.getFiatAccount(), processModel.getFiatAccount(),
processModel.getAccountId(), processModel.getAccountId(),

View file

@ -18,8 +18,12 @@
package io.bitsquare.trade.protocol.trade.tasks.shared; package io.bitsquare.trade.protocol.trade.tasks.shared;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.BuyerTrade;
import io.bitsquare.trade.SellerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.SellerTradeState;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -40,6 +44,11 @@ public class CommitPayoutTx extends TradeTask {
trade.setPayoutTx(transaction); trade.setPayoutTx(transaction);
if (trade instanceof BuyerTrade)
trade.setProcessState(BuyerTradeState.ProcessState.PAYOUT_TX_COMMITTED);
else if (trade instanceof SellerTrade)
trade.setProcessState(SellerTradeState.ProcessState.PAYOUT_TX_COMMITTED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();

View file

@ -18,12 +18,12 @@
package io.bitsquare.trade.protocol.trade.tasks.shared; package io.bitsquare.trade.protocol.trade.tasks.shared;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.BuyerTrade;
import io.bitsquare.trade.TakerTrade; import io.bitsquare.trade.SellerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.OffererTradeState; import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.TakerTradeState; import io.bitsquare.trade.states.SellerTradeState;
import org.bitcoinj.core.StoredBlock; import org.bitcoinj.core.StoredBlock;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -79,10 +79,11 @@ public class SetupPayoutTxLockTimeReachedListener extends TradeTask {
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
log.debug("BroadcastTx succeeded. Transaction:" + transaction); log.debug("BroadcastTx succeeded. Transaction:" + transaction);
if (trade instanceof TakerTrade) if (trade instanceof BuyerTrade)
trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_BROAD_CASTED); trade.setProcessState(BuyerTradeState.ProcessState.PAYOUT_BROAD_CASTED);
else if (trade instanceof OffererTrade) else if (trade instanceof SellerTrade)
trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_BROAD_CASTED); trade.setProcessState(SellerTradeState.ProcessState.PAYOUT_BROAD_CASTED);
complete(); complete();
} }
@ -91,11 +92,11 @@ public class SetupPayoutTxLockTimeReachedListener extends TradeTask {
public void onFailure(@NotNull Throwable t) { public void onFailure(@NotNull Throwable t) {
t.printStackTrace(); t.printStackTrace();
trade.setThrowable(t); trade.setThrowable(t);
/*
if (trade instanceof TakerTrade) if (trade instanceof TakerTrade)
trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_BROAD_CASTED_FAILED); trade.setProcessState(TakerTradeState.ProcessState.PAYOUT_BROAD_CASTED_FAILED);
else if (trade instanceof OffererTrade) else if (trade instanceof OffererTrade)
trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_BROAD_CASTED_FAILED); trade.setProcessState(OffererTradeState.ProcessState.PAYOUT_BROAD_CASTED_FAILED);*/
failed(t); failed(t);

View file

@ -18,10 +18,8 @@
package io.bitsquare.trade.protocol.trade.tasks.taker; package io.bitsquare.trade.protocol.trade.tasks.taker;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.TakerTradeState;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -48,8 +46,9 @@ public class BroadcastTakeOfferFeeTx extends TradeTask {
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString()); log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString());
if (trade instanceof TakerTrade) /* if (trade instanceof SellerTrade)
trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISHED); trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);*/
complete(); complete();
} }
@ -59,8 +58,8 @@ public class BroadcastTakeOfferFeeTx extends TradeTask {
appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again."); appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again.");
trade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (trade instanceof TakerTrade) /* if (trade instanceof SellerTrade)
trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED); trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);*/
failed(t); failed(t);
} }

View file

@ -18,10 +18,8 @@
package io.bitsquare.trade.protocol.trade.tasks.taker; package io.bitsquare.trade.protocol.trade.tasks.taker;
import io.bitsquare.common.taskrunner.TaskRunner; import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask; import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.TakerTradeState;
import org.bitcoinj.core.Transaction; import org.bitcoinj.core.Transaction;
@ -43,8 +41,8 @@ public class CreateTakeOfferFeeTx extends TradeTask {
processModel.setTakeOfferFeeTx(createTakeOfferFeeTx); processModel.setTakeOfferFeeTx(createTakeOfferFeeTx);
processModel.setTakeOfferFeeTxId(createTakeOfferFeeTx.getHashAsString()); processModel.setTakeOfferFeeTxId(createTakeOfferFeeTx.getHashAsString());
if (trade instanceof TakerTrade) /*if (trade instanceof SellerTrade)
trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_TX_CREATED); trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_TX_CREATED);*/
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {

View file

@ -20,24 +20,24 @@ package io.bitsquare.trade.states;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class OffererTradeState { public class BuyerTradeState {
private static final Logger log = LoggerFactory.getLogger(OffererTradeState.class); private static final Logger log = LoggerFactory.getLogger(BuyerTradeState.class);
public enum ProcessState implements TradeState.ProcessState { public enum ProcessState implements TradeState.ProcessState {
UNDEFINED, UNDEFINED,
DEPOSIT_PUBLISHED, DEPOSIT_PUBLISHED,
DEPOSIT_PUBLISHED_MSG_SENT,
DEPOSIT_CONFIRMED, DEPOSIT_CONFIRMED,
FIAT_PAYMENT_STARTED, FIAT_PAYMENT_STARTED,
FIAT_PAYMENT_STARTED_MSG_SENT,
REQUEST_PAYOUT_FINALIZE_MSG_SENT, // seller only FIAT_PAYMENT_RECEIPT_MSG_RECEIVED,
PAYOUT_FINALIZED,
PAYOUT_BROAD_CASTED, PAYOUT_TX_COMMITTED,
PAYOUT_BROAD_CASTED_FAILED, PAYOUT_TX_SENT,
MESSAGE_SENDING_FAILED, PAYOUT_BROAD_CASTED
TIMEOUT,
EXCEPTION
} }
} }

View file

@ -20,28 +20,23 @@ package io.bitsquare.trade.states;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerTradeState { public class SellerTradeState {
private static final Logger log = LoggerFactory.getLogger(TakerTradeState.class); private static final Logger log = LoggerFactory.getLogger(SellerTradeState.class);
public enum ProcessState implements TradeState.ProcessState { public enum ProcessState implements TradeState.ProcessState {
UNDEFINED, UNDEFINED,
TAKE_OFFER_FEE_TX_CREATED,
TAKE_OFFER_FEE_PUBLISHED,
TAKE_OFFER_FEE_PUBLISH_FAILED,
DEPOSIT_PUBLISHED, DEPOSIT_PUBLISHED_MSG_RECEIVED,
DEPOSIT_CONFIRMED, DEPOSIT_CONFIRMED,
FIAT_PAYMENT_STARTED, FIAT_PAYMENT_STARTED_MSG_RECEIVED,
REQUEST_PAYOUT_FINALIZE_MSG_SENT, // seller only FIAT_PAYMENT_RECEIPT,
PAYOUT_FINALIZED, FIAT_PAYMENT_RECEIPT_MSG_SENT,
PAYOUT_BROAD_CASTED, PAYOUT_TX_RECEIVED,
PAYOUT_BROAD_CASTED_FAILED, PAYOUT_TX_COMMITTED,
MESSAGE_SENDING_FAILED, PAYOUT_BROAD_CASTED
TIMEOUT,
EXCEPTION
} }
} }

View file

@ -17,8 +17,7 @@
package io.bitsquare.trade.states; package io.bitsquare.trade.states;
import io.bitsquare.trade.OffererTrade; import io.bitsquare.trade.BuyerTrade;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -28,14 +27,14 @@ public class StateUtil {
private static final Logger log = LoggerFactory.getLogger(StateUtil.class); private static final Logger log = LoggerFactory.getLogger(StateUtil.class);
public static void setSendFailedState(Trade trade) { public static void setSendFailedState(Trade trade) {
if (trade instanceof OffererTrade) /* if (trade instanceof BuyerTrade)
trade.setProcessState(OffererTradeState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(BuyerTradeState.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerTrade) else if (trade instanceof SellerTrade)
trade.setProcessState(TakerTradeState.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(SellerTradeState.ProcessState.MESSAGE_SENDING_FAILED);*/
} }
public static void setOfferOpenState(Trade trade) { public static void setOfferOpenState(Trade trade) {
if (trade instanceof OffererTrade) if (trade instanceof BuyerTrade)
trade.setLifeCycleState(Trade.LifeCycleState.PREPARATION); trade.setLifeCycleState(Trade.LifeCycleState.PREPARATION);
} }
} }

View file

@ -31,12 +31,12 @@ import io.bitsquare.trade.protocol.placeoffer.tasks.ValidateOffer;
import io.bitsquare.trade.protocol.trade.BuyerAsOffererProtocol; import io.bitsquare.trade.protocol.trade.BuyerAsOffererProtocol;
import io.bitsquare.trade.protocol.trade.SellerAsTakerProtocol; import io.bitsquare.trade.protocol.trade.SellerAsTakerProtocol;
import io.bitsquare.trade.protocol.trade.tasks.buyer.CreateDepositTxInputs; import io.bitsquare.trade.protocol.trade.tasks.buyer.CreateDepositTxInputs;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessDepositTxInputsRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessPublishDepositTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendDepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendFiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendFiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayDepositRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayoutTxFinalizedMessage; import io.bitsquare.trade.protocol.trade.tasks.buyer.SendPayoutTxFinalizedMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SendRequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndFinalizePayoutTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndFinalizePayoutTx;
import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndPublishDepositTx; import io.bitsquare.trade.protocol.trade.tasks.buyer.SignAndPublishDepositTx;
import io.bitsquare.trade.protocol.trade.tasks.offerer.VerifyTakeOfferFeePayment; import io.bitsquare.trade.protocol.trade.tasks.offerer.VerifyTakeOfferFeePayment;
@ -45,9 +45,9 @@ import io.bitsquare.trade.protocol.trade.tasks.seller.CommitDepositTx;
import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignDepositTx; import io.bitsquare.trade.protocol.trade.tasks.seller.CreateAndSignDepositTx;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessDepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessFiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessFiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayDepositRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayoutTxFinalizedMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessPayoutTxFinalizedMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.ProcessRequestPayDepositMessage; import io.bitsquare.trade.protocol.trade.tasks.seller.SendDepositTxInputsRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.SignPayoutTx; import io.bitsquare.trade.protocol.trade.tasks.seller.SignPayoutTx;
import io.bitsquare.trade.protocol.trade.tasks.taker.CreateTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.tasks.taker.CreateTakeOfferFeeTx;
import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOfferFeePayment; import io.bitsquare.trade.protocol.trade.tasks.taker.VerifyOfferFeePayment;
@ -98,11 +98,11 @@ public class DebugView extends InitializableView {
/*---- Protocol ----*/ /*---- Protocol ----*/
BuyerAsOffererProtocol.class, BuyerAsOffererProtocol.class,
ProcessRequestDepositTxInputsMessage.class, ProcessDepositTxInputsRequest.class,
CreateDepositTxInputs.class, CreateDepositTxInputs.class,
SendRequestPayDepositMessage.class, SendPayDepositRequest.class,
ProcessRequestPublishDepositTxMessage.class, ProcessPublishDepositTxRequest.class,
VerifyTakerAccount.class, VerifyTakerAccount.class,
SignAndPublishDepositTx.class, SignAndPublishDepositTx.class,
SendDepositTxPublishedMessage.class, SendDepositTxPublishedMessage.class,
@ -118,9 +118,9 @@ public class DebugView extends InitializableView {
/*---- Protocol ----*/ /*---- Protocol ----*/
SellerAsTakerProtocol.class, SellerAsTakerProtocol.class,
CreateTakeOfferFeeTx.class, CreateTakeOfferFeeTx.class,
SendRequestDepositTxInputsMessage.class, SendDepositTxInputsRequest.class,
ProcessRequestPayDepositMessage.class, ProcessPayDepositRequest.class,
VerifyOffererAccount.class, VerifyOffererAccount.class,
CreateAndSignDepositTx.class, CreateAndSignDepositTx.class,

View file

@ -93,7 +93,7 @@ class TakeOfferDataModel implements Activatable, DataModel {
@Override @Override
public void deactivate() { public void deactivate() {
btcCode.unbind(); btcCode.unbind();
tradeManager.cancelCheckOfferAvailabilityRequest(offer); tradeManager.onCancelAvailabilityRequest(offer);
} }
void initWithData(Coin amount, Offer offer) { void initWithData(Coin amount, Offer offer) {
@ -121,11 +121,11 @@ class TakeOfferDataModel implements Activatable, DataModel {
}); });
updateBalance(walletService.getBalanceForAddress(addressEntry.getAddress())); updateBalance(walletService.getBalanceForAddress(addressEntry.getAddress()));
tradeManager.checkOfferAvailability(offer); tradeManager.onCheckOfferAvailability(offer);
} }
void takeOffer(TakeOfferResultHandler handler) { void onTakeOffer(TakeOfferResultHandler handler) {
tradeManager.requestTakeOffer(amountAsCoin.get(), offer, handler::handleResult); tradeManager.onTakeOffer(amountAsCoin.get(), offer, handler::handleResult);
} }
void calculateVolume() { void calculateVolume() {

View file

@ -158,7 +158,7 @@ public class TakeOfferView extends ActivatableViewAndModel<AnchorPane, TakeOffer
@FXML @FXML
void onTakeOffer() { void onTakeOffer() {
model.takeOffer(); model.onTakeOffer();
} }
@FXML @FXML

View file

@ -28,7 +28,8 @@ import io.bitsquare.locale.CurrencyUtil;
import io.bitsquare.trade.BuyerAsTakerTrade; import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.SellerAsTakerTrade; import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.offer.Offer; import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.states.TakerTradeState; import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.SellerTradeState;
import org.bitcoinj.core.Address; import org.bitcoinj.core.Address;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
@ -220,13 +221,13 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
evaluateState(); evaluateState();
} }
void takeOffer() { void onTakeOffer() {
takeOfferRequested = true; takeOfferRequested = true;
applyTakeOfferRequestResult(false); applyTakeOfferRequestResult(false);
isTakeOfferSpinnerVisible.set(true); isTakeOfferSpinnerVisible.set(true);
dataModel.takeOffer((trade) -> { dataModel.onTakeOffer((trade) -> {
trade.processStateProperty().addListener((ov, oldValue, newValue) -> { trade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("trade state = " + newValue); log.debug("trade state = " + newValue);
@ -234,19 +235,24 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
if (trade.getErrorMessage() != null) if (trade.getErrorMessage() != null)
msg = "\nError message: " + trade.getErrorMessage(); msg = "\nError message: " + trade.getErrorMessage();
if (trade instanceof BuyerAsTakerTrade) { if (trade instanceof SellerAsTakerTrade) {
switch ((TakerTradeState.ProcessState) newValue) { switch ((SellerTradeState.ProcessState) newValue) {
case TAKE_OFFER_FEE_TX_CREATED: case UNDEFINED:
break; break;
case DEPOSIT_PUBLISHED: case DEPOSIT_PUBLISHED_MSG_RECEIVED:
case DEPOSIT_CONFIRMED:
assert trade.getDepositTx() != null; assert trade.getDepositTx() != null;
transactionId.set(trade.getDepositTx().getHashAsString()); transactionId.set(trade.getDepositTx().getHashAsString());
applyTakeOfferRequestResult(true); applyTakeOfferRequestResult(true);
break; break;
case FIAT_PAYMENT_STARTED: case DEPOSIT_CONFIRMED:
case FIAT_PAYMENT_STARTED_MSG_RECEIVED:
case FIAT_PAYMENT_RECEIPT:
case FIAT_PAYMENT_RECEIPT_MSG_SENT:
case PAYOUT_TX_RECEIVED:
case PAYOUT_TX_COMMITTED:
case PAYOUT_BROAD_CASTED:
break; break;
case TAKE_OFFER_FEE_PUBLISH_FAILED: /* case TAKE_OFFER_FEE_PUBLISH_FAILED:
errorMessage.set("An error occurred when paying the trade fee." + msg); errorMessage.set("An error occurred when paying the trade fee." + msg);
takeOfferRequested = false; takeOfferRequested = false;
break; break;
@ -258,25 +264,31 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
case EXCEPTION: case EXCEPTION:
errorMessage.set(msg); errorMessage.set(msg);
takeOfferRequested = false; takeOfferRequested = false;
break; break;*/
default: default:
log.warn("Unhandled trade state: " + newValue); log.warn("Unhandled trade state: " + newValue);
break; break;
} }
} }
else if (trade instanceof SellerAsTakerTrade) { else if (trade instanceof BuyerAsTakerTrade) {
switch ((TakerTradeState.ProcessState) newValue) { switch ((BuyerTradeState.ProcessState) newValue) {
case TAKE_OFFER_FEE_TX_CREATED: case UNDEFINED:
break; break;
case DEPOSIT_PUBLISHED: case DEPOSIT_PUBLISHED:
case DEPOSIT_CONFIRMED:
assert trade.getDepositTx() != null; assert trade.getDepositTx() != null;
transactionId.set(trade.getDepositTx().getHashAsString()); transactionId.set(trade.getDepositTx().getHashAsString());
applyTakeOfferRequestResult(true); applyTakeOfferRequestResult(true);
break; break;
case DEPOSIT_PUBLISHED_MSG_SENT:
case DEPOSIT_CONFIRMED:
case FIAT_PAYMENT_STARTED: case FIAT_PAYMENT_STARTED:
case FIAT_PAYMENT_STARTED_MSG_SENT:
case FIAT_PAYMENT_RECEIPT_MSG_RECEIVED:
case PAYOUT_TX_COMMITTED:
case PAYOUT_TX_SENT:
case PAYOUT_BROAD_CASTED:
break; break;
case TAKE_OFFER_FEE_PUBLISH_FAILED: /* case TAKE_OFFER_FEE_PUBLISH_FAILED:
errorMessage.set("An error occurred when paying the trade fee." + msg); errorMessage.set("An error occurred when paying the trade fee." + msg);
takeOfferRequested = false; takeOfferRequested = false;
break; break;
@ -293,7 +305,7 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
case EXCEPTION: case EXCEPTION:
errorMessage.set(msg); errorMessage.set(msg);
takeOfferRequested = false; takeOfferRequested = false;
break; break;*/
default: default:
log.warn("Unhandled trade state: " + newValue); log.warn("Unhandled trade state: " + newValue);
break; break;

View file

@ -17,7 +17,6 @@
package io.bitsquare.gui.main.portfolio.pendingtrades; package io.bitsquare.gui.main.portfolio.pendingtrades;
import io.bitsquare.gui.components.Popups;
import io.bitsquare.gui.main.portfolio.pendingtrades.steps.CompletedView; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.CompletedView;
import io.bitsquare.gui.main.portfolio.pendingtrades.steps.StartFiatView; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.StartFiatView;
import io.bitsquare.gui.main.portfolio.pendingtrades.steps.TradeWizardItem; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.TradeWizardItem;
@ -26,6 +25,8 @@ import io.bitsquare.gui.main.portfolio.pendingtrades.steps.WaitPayoutLockTimeVie
import io.bitsquare.gui.main.portfolio.pendingtrades.steps.WaitTxInBlockchainView; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.WaitTxInBlockchainView;
import io.bitsquare.locale.BSResources; import io.bitsquare.locale.BSResources;
import javafx.beans.value.ChangeListener;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -38,6 +39,7 @@ public class BuyerSubView extends TradeSubView {
private TradeWizardItem payoutUnlock; private TradeWizardItem payoutUnlock;
private TradeWizardItem completed; private TradeWizardItem completed;
private final ChangeListener<PendingTradesViewModel.BuyerState> stateChangeListener;
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Constructor, Initialisation // Constructor, Initialisation
@ -45,6 +47,20 @@ public class BuyerSubView extends TradeSubView {
public BuyerSubView(PendingTradesViewModel model) { public BuyerSubView(PendingTradesViewModel model) {
super(model); super(model);
stateChangeListener = (ov, oldValue, newValue) -> applyState(newValue);
}
@Override
public void activate() {
super.activate();
model.getBuyerState().addListener(stateChangeListener);
applyState(model.getBuyerState().get());
}
@Override
public void deactivate() {
super.deactivate();
model.getBuyerState().removeListener(stateChangeListener);
} }
@Override @Override
@ -63,9 +79,8 @@ public class BuyerSubView extends TradeSubView {
// State // State
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override protected void applyState(PendingTradesViewModel.BuyerState state) {
protected void applyState(PendingTradesViewModel.ViewState viewState) { log.debug("applyState " + state);
log.debug("applyState " + viewState);
waitTxInBlockchain.setDisabled(); waitTxInBlockchain.setDisabled();
startFiat.setDisabled(); startFiat.setDisabled();
@ -76,10 +91,8 @@ public class BuyerSubView extends TradeSubView {
if (tradeStepDetailsView != null) if (tradeStepDetailsView != null)
tradeStepDetailsView.deactivate(); tradeStepDetailsView.deactivate();
switch (viewState) { switch (state) {
case UNDEFINED: case WAIT_FOR_BLOCKCHAIN_CONFIRMATION:
break;
case BUYER_WAIT_TX_CONF:
showItem(waitTxInBlockchain); showItem(waitTxInBlockchain);
((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. You need to wait for at least " + ((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. You need to wait for at least " +
@ -88,11 +101,11 @@ public class BuyerSubView extends TradeSubView {
" be sure that the deposit funding has not been double spent. For higher trade volumes we" + " be sure that the deposit funding has not been double spent. For higher trade volumes we" +
" recommend to wait up to 6 confirmations.");*/ " recommend to wait up to 6 confirmations.");*/
break; break;
case BUYER_START_PAYMENT: case REQUEST_START_FIAT_PAYMENT:
waitTxInBlockchain.setCompleted(); waitTxInBlockchain.setCompleted();
showItem(startFiat); showItem(startFiat);
break; break;
case BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED: case WAIT_FOR_FIAT_PAYMENT_RECEIPT:
waitTxInBlockchain.setCompleted(); waitTxInBlockchain.setCompleted();
startFiat.setCompleted(); startFiat.setCompleted();
showItem(waitFiatReceived); showItem(waitFiatReceived);
@ -104,7 +117,7 @@ public class BuyerSubView extends TradeSubView {
"the Bitcoin sellers payment account, the payout transaction will be published.", "the Bitcoin sellers payment account, the payout transaction will be published.",
model.getCurrencyCode()));*/ model.getCurrencyCode()));*/
break; break;
case BUYER_PAYOUT_FINALIZED: case WAIT_FOR_UNLOCK_PAYOUT:
waitTxInBlockchain.setCompleted(); waitTxInBlockchain.setCompleted();
startFiat.setCompleted(); startFiat.setCompleted();
waitFiatReceived.setCompleted(); waitFiatReceived.setCompleted();
@ -113,7 +126,7 @@ public class BuyerSubView extends TradeSubView {
((WaitPayoutLockTimeView) tradeStepDetailsView).setInfoLabelText("The payout transaction is signed and finalized by both parties." + ((WaitPayoutLockTimeView) tradeStepDetailsView).setInfoLabelText("The payout transaction is signed and finalized by both parties." +
"\nFor reducing bank charge back risks you need to wait until the payout gets unlocked to transfer your Bitcoin."); "\nFor reducing bank charge back risks you need to wait until the payout gets unlocked to transfer your Bitcoin.");
break; break;
case BUYER_COMPLETED: case REQUEST_WITHDRAWAL:
waitTxInBlockchain.setCompleted(); waitTxInBlockchain.setCompleted();
startFiat.setCompleted(); startFiat.setCompleted();
waitFiatReceived.setCompleted(); waitFiatReceived.setCompleted();
@ -131,7 +144,7 @@ public class BuyerSubView extends TradeSubView {
"You can review the details to that trade any time in the closed trades screen."); "You can review the details to that trade any time in the closed trades screen.");
completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount()); completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount());
break; break;
case MESSAGE_SENDING_FAILED: /*case MESSAGE_SENDING_FAILED:
Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage()); Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage());
break; break;
case EXCEPTION: case EXCEPTION:
@ -139,9 +152,9 @@ public class BuyerSubView extends TradeSubView {
Popups.openExceptionPopup(model.getTradeException()); Popups.openExceptionPopup(model.getTradeException());
else else
Popups.openErrorPopup("An error occurred", model.getErrorMessage()); Popups.openErrorPopup("An error occurred", model.getErrorMessage());
break; break;*/
default: default:
log.warn("unhandled viewState " + viewState); log.warn("unhandled buyerState " + state);
break; break;
} }

View file

@ -24,8 +24,8 @@ import io.bitsquare.gui.util.BSFormatter;
import io.bitsquare.gui.util.validation.BtcAddressValidator; import io.bitsquare.gui.util.validation.BtcAddressValidator;
import io.bitsquare.locale.BSResources; import io.bitsquare.locale.BSResources;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.states.OffererTradeState; import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.TakerTradeState; import io.bitsquare.trade.states.SellerTradeState;
import org.bitcoinj.core.BlockChainListener; import org.bitcoinj.core.BlockChainListener;
import org.bitcoinj.core.Coin; import org.bitcoinj.core.Coin;
@ -53,16 +53,16 @@ import org.slf4j.LoggerFactory;
public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTradesDataModel> implements ViewModel { public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTradesDataModel> implements ViewModel {
private static final Logger log = LoggerFactory.getLogger(PendingTradesViewModel.class); private static final Logger log = LoggerFactory.getLogger(PendingTradesViewModel.class);
enum ViewState { /* enum ViewState {
UNDEFINED, UNDEFINED,
SELLER_WAIT_TX_CONF, WAIT_FOR_BLOCKCHAIN_CONFIRMATION,
SELLER_WAIT_PAYMENT_STARTED, WAIT_FOR_FIAT_PAYMENT_STARTED,
SELLER_CONFIRM_RECEIVE_PAYMENT, REQUEST_CONFIRM_FIAT_PAYMENT_RECEIVED,
SELLER_REQUEST_PAYOUT_FINALIZE_MSG_SENT, SELLER_REQUEST_PAYOUT_FINALIZE_MSG_SENT,
SELLER_PAYOUT_FINALIZED, SELLER_PAYOUT_FINALIZED,
SELLER_COMPLETED, SELLER_COMPLETED,
BUYER_WAIT_TX_CONF, WAIT_FOR_BLOCKCHAIN_CONFIRMATION,
BUYER_START_PAYMENT, BUYER_START_PAYMENT,
BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED, BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED,
BUYER_PAYOUT_FINALIZED, BUYER_PAYOUT_FINALIZED,
@ -71,13 +71,36 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
MESSAGE_SENDING_FAILED, MESSAGE_SENDING_FAILED,
TIMEOUT, TIMEOUT,
EXCEPTION EXCEPTION
}*/
interface State {
}
enum BuyerState implements State {
WAIT_FOR_BLOCKCHAIN_CONFIRMATION,
REQUEST_START_FIAT_PAYMENT,
WAIT_FOR_FIAT_PAYMENT_RECEIPT,
WAIT_FOR_UNLOCK_PAYOUT,
REQUEST_WITHDRAWAL
}
enum SellerState implements State {
WAIT_FOR_BLOCKCHAIN_CONFIRMATION,
WAIT_FOR_FIAT_PAYMENT_STARTED,
REQUEST_CONFIRM_FIAT_PAYMENT_RECEIVED,
WAIT_FOR_PAYOUT_TX,
WAIT_FOR_UNLOCK_PAYOUT,
REQUEST_WITHDRAWAL
} }
private final BSFormatter formatter; private final BSFormatter formatter;
private final InvalidationListener sellerStateListener; private final InvalidationListener sellerStateListener;
private final InvalidationListener buyerStateListener; private final InvalidationListener buyerStateListener;
private final BtcAddressValidator btcAddressValidator; private final BtcAddressValidator btcAddressValidator;
private final ObjectProperty<ViewState> viewState = new SimpleObjectProperty<>(ViewState.UNDEFINED);
private final ObjectProperty<BuyerState> buyerState = new SimpleObjectProperty<>(BuyerState.WAIT_FOR_BLOCKCHAIN_CONFIRMATION);
private final ObjectProperty<SellerState> sellerState = new SimpleObjectProperty<>(SellerState.WAIT_FOR_BLOCKCHAIN_CONFIRMATION);
private final StringProperty txId = new SimpleStringProperty(); private final StringProperty txId = new SimpleStringProperty();
private final BooleanProperty withdrawalButtonDisable = new SimpleBooleanProperty(true); private final BooleanProperty withdrawalButtonDisable = new SimpleBooleanProperty(true);
@ -93,8 +116,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
this.formatter = formatter; this.formatter = formatter;
this.btcAddressValidator = btcAddressValidator; this.btcAddressValidator = btcAddressValidator;
this.sellerStateListener = (ov) -> updateSellerState(); this.sellerStateListener = (ov) -> applySellerState();
this.buyerStateListener = (ov) -> updateBuyerState(); this.buyerStateListener = (ov) -> applyBuyerState();
} }
@Override @Override
@ -105,8 +128,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
dataModel.getBuyerProcessState().addListener(buyerStateListener); dataModel.getBuyerProcessState().addListener(buyerStateListener);
if (dataModel.getTrade() != null) { if (dataModel.getTrade() != null) {
updateSellerState(); applySellerState();
updateBuyerState(); applyBuyerState();
} }
} }
@ -130,8 +153,12 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
// Getters // Getters
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
ReadOnlyObjectProperty<ViewState> getViewState() { ReadOnlyObjectProperty<BuyerState> getBuyerState() {
return viewState; return buyerState;
}
ReadOnlyObjectProperty<SellerState> getSellerState() {
return sellerState;
} }
public ReadOnlyStringProperty getTxId() { public ReadOnlyStringProperty getTxId() {
@ -304,97 +331,58 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
// States // States
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private void updateSellerState() { private void applySellerState() {
if (dataModel.getSellerProcessState().get() instanceof TakerTradeState.ProcessState) { if (dataModel.getSellerProcessState().get() instanceof SellerTradeState.ProcessState) {
TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.getSellerProcessState().get(); SellerTradeState.ProcessState processState = (SellerTradeState.ProcessState) dataModel.getSellerProcessState().get();
log.debug("updateSellerState (TakerTradeState) " + processState); log.debug("updateSellerState (SellerTradeState) " + processState);
if (processState != null) { if (processState != null) {
switch (processState) { switch (processState) {
case UNDEFINED: case UNDEFINED:
case TAKE_OFFER_FEE_TX_CREATED:
case TAKE_OFFER_FEE_PUBLISHED: case DEPOSIT_PUBLISHED_MSG_RECEIVED:
break; sellerState.set(SellerState.WAIT_FOR_BLOCKCHAIN_CONFIRMATION);
case TAKE_OFFER_FEE_PUBLISH_FAILED:
viewState.set(ViewState.EXCEPTION);
break; break;
case DEPOSIT_PUBLISHED:
viewState.set(ViewState.SELLER_WAIT_TX_CONF);
break;
case DEPOSIT_CONFIRMED: case DEPOSIT_CONFIRMED:
viewState.set(ViewState.SELLER_WAIT_PAYMENT_STARTED); sellerState.set(SellerState.WAIT_FOR_FIAT_PAYMENT_STARTED);
break; break;
case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.SELLER_CONFIRM_RECEIVE_PAYMENT); case FIAT_PAYMENT_STARTED_MSG_RECEIVED:
sellerState.set(SellerState.REQUEST_CONFIRM_FIAT_PAYMENT_RECEIVED);
break; break;
case REQUEST_PAYOUT_FINALIZE_MSG_SENT:
viewState.set(ViewState.SELLER_REQUEST_PAYOUT_FINALIZE_MSG_SENT); case FIAT_PAYMENT_RECEIPT:
break; break;
case PAYOUT_FINALIZED: case FIAT_PAYMENT_RECEIPT_MSG_SENT:
viewState.set(ViewState.SELLER_PAYOUT_FINALIZED); sellerState.set(SellerState.WAIT_FOR_PAYOUT_TX);
break; break;
case PAYOUT_TX_RECEIVED:
break;
case PAYOUT_TX_COMMITTED:
sellerState.set(SellerState.WAIT_FOR_UNLOCK_PAYOUT);
break;
case PAYOUT_BROAD_CASTED: case PAYOUT_BROAD_CASTED:
viewState.set(ViewState.SELLER_COMPLETED); sellerState.set(SellerState.REQUEST_WITHDRAWAL);
break; break;
case PAYOUT_BROAD_CASTED_FAILED:
viewState.set(ViewState.EXCEPTION);
/* case PAYOUT_BROAD_CASTED_FAILED:
// sellerState.set(SellerState.EXCEPTION);
break; break;
case MESSAGE_SENDING_FAILED: case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED); //sellerState.set(SellerState.MESSAGE_SENDING_FAILED);
break; break;
case EXCEPTION: case EXCEPTION:
viewState.set(ViewState.EXCEPTION); // sellerState.set(SellerState.EXCEPTION);
break; break;*/
default:
log.warn("unhandled processState " + processState);
break;
}
}
}
else if (dataModel.getSellerProcessState().get() instanceof OffererTradeState.ProcessState) {
OffererTradeState.ProcessState processState = (OffererTradeState.ProcessState) dataModel.getSellerProcessState().get();
log.debug("updateSellerState (OffererTradeState) " + processState);
if (processState != null) {
switch (processState) {
case UNDEFINED:
break;
case DEPOSIT_PUBLISHED:
viewState.set(ViewState.SELLER_WAIT_TX_CONF);
break;
case DEPOSIT_CONFIRMED:
viewState.set(ViewState.SELLER_WAIT_PAYMENT_STARTED);
break;
case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.SELLER_CONFIRM_RECEIVE_PAYMENT);
break;
case REQUEST_PAYOUT_FINALIZE_MSG_SENT:
viewState.set(ViewState.SELLER_REQUEST_PAYOUT_FINALIZE_MSG_SENT);
break;
case PAYOUT_FINALIZED:
viewState.set(ViewState.SELLER_PAYOUT_FINALIZED);
break;
case PAYOUT_BROAD_CASTED:
viewState.set(ViewState.SELLER_COMPLETED);
break;
case PAYOUT_BROAD_CASTED_FAILED:
viewState.set(ViewState.EXCEPTION);
break;
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
default: default:
log.warn("unhandled processState " + processState); log.warn("unhandled processState " + processState);
@ -407,94 +395,59 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
} }
} }
private void updateBuyerState() { private void applyBuyerState() {
if (dataModel.getBuyerProcessState().get() instanceof TakerTradeState.ProcessState) { if (dataModel.getBuyerProcessState().get() instanceof BuyerTradeState.ProcessState) {
TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.getBuyerProcessState().get(); BuyerTradeState.ProcessState processState = (BuyerTradeState.ProcessState) dataModel.getBuyerProcessState().get();
log.debug("updateBuyerState (TakerTradeState)" + processState); log.debug("updateBuyerState (BuyerTradeState) " + processState);
if (processState != null) {
switch (processState) {
case UNDEFINED:
case TAKE_OFFER_FEE_TX_CREATED:
case TAKE_OFFER_FEE_PUBLISHED:
break;
case TAKE_OFFER_FEE_PUBLISH_FAILED:
viewState.set(ViewState.EXCEPTION);
break;
case DEPOSIT_PUBLISHED:
viewState.set(ViewState.BUYER_WAIT_TX_CONF);
break;
case DEPOSIT_CONFIRMED:
viewState.set(ViewState.BUYER_START_PAYMENT);
break;
case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED);
break;
case PAYOUT_FINALIZED:
viewState.set(ViewState.BUYER_PAYOUT_FINALIZED);
break;
case PAYOUT_BROAD_CASTED:
viewState.set(ViewState.BUYER_COMPLETED);
break;
case PAYOUT_BROAD_CASTED_FAILED:
viewState.set(ViewState.EXCEPTION);
break;
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case TIMEOUT:
viewState.set(ViewState.TIMEOUT);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
default:
log.warn("unhandled viewState " + processState);
break;
}
}
}
else if (dataModel.getBuyerProcessState().get() instanceof OffererTradeState.ProcessState) {
OffererTradeState.ProcessState processState = (OffererTradeState.ProcessState) dataModel.getBuyerProcessState().get();
log.debug("updateBuyerState (OffererTradeState) " + processState);
if (processState != null) { if (processState != null) {
switch (processState) { switch (processState) {
case UNDEFINED: case UNDEFINED:
break; break;
case DEPOSIT_PUBLISHED: case DEPOSIT_PUBLISHED:
viewState.set(ViewState.BUYER_WAIT_TX_CONF); case DEPOSIT_PUBLISHED_MSG_SENT:
buyerState.set(BuyerState.WAIT_FOR_BLOCKCHAIN_CONFIRMATION);
break; break;
case DEPOSIT_CONFIRMED: case DEPOSIT_CONFIRMED:
viewState.set(ViewState.BUYER_START_PAYMENT); buyerState.set(BuyerState.REQUEST_START_FIAT_PAYMENT);
break; break;
case FIAT_PAYMENT_STARTED: case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED); break;
case FIAT_PAYMENT_STARTED_MSG_SENT:
buyerState.set(BuyerState.WAIT_FOR_FIAT_PAYMENT_RECEIPT);
break; break;
case PAYOUT_FINALIZED:
viewState.set(ViewState.BUYER_PAYOUT_FINALIZED); case FIAT_PAYMENT_RECEIPT_MSG_RECEIVED:
case PAYOUT_TX_COMMITTED:
break; break;
case PAYOUT_TX_SENT:
buyerState.set(BuyerState.WAIT_FOR_UNLOCK_PAYOUT);
break;
case PAYOUT_BROAD_CASTED: case PAYOUT_BROAD_CASTED:
viewState.set(ViewState.BUYER_COMPLETED); buyerState.set(BuyerState.REQUEST_WITHDRAWAL);
break; break;
case PAYOUT_BROAD_CASTED_FAILED:
viewState.set(ViewState.EXCEPTION);
/* case PAYOUT_BROAD_CASTED_FAILED:
// buyerState.set(BuyerState.EXCEPTION);
break; break;
case MESSAGE_SENDING_FAILED: case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED); // buyerState.set(BuyerState.MESSAGE_SENDING_FAILED);
break; break;
case EXCEPTION: case EXCEPTION:
viewState.set(ViewState.EXCEPTION); // buyerState.set(BuyerState.EXCEPTION);
break; break;
*/
default: default:
log.warn("unhandled viewState " + processState); log.warn("unhandled viewState " + processState);
break; break;

View file

@ -17,7 +17,6 @@
package io.bitsquare.gui.main.portfolio.pendingtrades; package io.bitsquare.gui.main.portfolio.pendingtrades;
import io.bitsquare.gui.components.Popups;
import io.bitsquare.gui.main.portfolio.pendingtrades.steps.CompletedView; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.CompletedView;
import io.bitsquare.gui.main.portfolio.pendingtrades.steps.ConfirmFiatReceivedView; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.ConfirmFiatReceivedView;
import io.bitsquare.gui.main.portfolio.pendingtrades.steps.TradeWizardItem; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.TradeWizardItem;
@ -26,6 +25,8 @@ import io.bitsquare.gui.main.portfolio.pendingtrades.steps.WaitPayoutLockTimeVie
import io.bitsquare.gui.main.portfolio.pendingtrades.steps.WaitTxInBlockchainView; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.WaitTxInBlockchainView;
import io.bitsquare.locale.BSResources; import io.bitsquare.locale.BSResources;
import javafx.beans.value.ChangeListener;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -38,6 +39,7 @@ public class SellerSubView extends TradeSubView {
private TradeWizardItem payoutUnlock; private TradeWizardItem payoutUnlock;
private TradeWizardItem completed; private TradeWizardItem completed;
private final ChangeListener<PendingTradesViewModel.SellerState> stateChangeListener;
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// Constructor, Initialisation // Constructor, Initialisation
@ -45,6 +47,20 @@ public class SellerSubView extends TradeSubView {
public SellerSubView(PendingTradesViewModel model) { public SellerSubView(PendingTradesViewModel model) {
super(model); super(model);
stateChangeListener = (ov, oldValue, newValue) -> applyState(newValue);
}
@Override
public void activate() {
super.activate();
model.getSellerState().addListener(stateChangeListener);
applyState(model.getSellerState().get());
}
@Override
public void deactivate() {
super.deactivate();
model.getSellerState().removeListener(stateChangeListener);
} }
@Override @Override
@ -63,8 +79,7 @@ public class SellerSubView extends TradeSubView {
// State // State
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@Override protected void applyState(PendingTradesViewModel.SellerState viewState) {
protected void applyState(PendingTradesViewModel.ViewState viewState) {
log.debug("applyState " + viewState); log.debug("applyState " + viewState);
waitTxInBlockchain.setDisabled(); waitTxInBlockchain.setDisabled();
@ -77,9 +92,7 @@ public class SellerSubView extends TradeSubView {
tradeStepDetailsView.deactivate(); tradeStepDetailsView.deactivate();
switch (viewState) { switch (viewState) {
case UNDEFINED: case WAIT_FOR_BLOCKCHAIN_CONFIRMATION:
break;
case SELLER_WAIT_TX_CONF:
showItem(waitTxInBlockchain); showItem(waitTxInBlockchain);
((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. " + ((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. " +
@ -91,7 +104,7 @@ public class SellerSubView extends TradeSubView {
"For higher trade volumes it is recommended to wait up to 6 confirmations.", "For higher trade volumes it is recommended to wait up to 6 confirmations.",
model.getCurrencyCode()));*/ model.getCurrencyCode()));*/
break; break;
case SELLER_WAIT_PAYMENT_STARTED: case WAIT_FOR_FIAT_PAYMENT_STARTED:
waitTxInBlockchain.setCompleted(); waitTxInBlockchain.setCompleted();
showItem(waitFiatStarted); showItem(waitFiatStarted);
@ -104,7 +117,7 @@ public class SellerSubView extends TradeSubView {
"the {0} payment has been started.", "the {0} payment has been started.",
model.getCurrencyCode()));*/ model.getCurrencyCode()));*/
break; break;
case SELLER_CONFIRM_RECEIVE_PAYMENT: case REQUEST_CONFIRM_FIAT_PAYMENT_RECEIVED:
waitTxInBlockchain.setCompleted(); waitTxInBlockchain.setCompleted();
waitFiatStarted.setCompleted(); waitFiatStarted.setCompleted();
showItem(confirmFiatReceived); showItem(confirmFiatReceived);
@ -119,7 +132,7 @@ public class SellerSubView extends TradeSubView {
model.getCurrencyCode()));*/ model.getCurrencyCode()));*/
break; break;
case SELLER_REQUEST_PAYOUT_FINALIZE_MSG_SENT: case WAIT_FOR_PAYOUT_TX:
waitTxInBlockchain.setCompleted(); waitTxInBlockchain.setCompleted();
waitFiatStarted.setCompleted(); waitFiatStarted.setCompleted();
confirmFiatReceived.setCompleted(); confirmFiatReceived.setCompleted();
@ -132,7 +145,7 @@ public class SellerSubView extends TradeSubView {
((WaitPayoutFinalizedView) tradeStepDetailsView).setInfoLabelText("We requested the trading peer to sign and finalize the payout transaction." + ((WaitPayoutFinalizedView) tradeStepDetailsView).setInfoLabelText("We requested the trading peer to sign and finalize the payout transaction." +
"\nIt might be that the other peer is offline, so we need to wait until he finalize the transaction when he goes online again."); "\nIt might be that the other peer is offline, so we need to wait until he finalize the transaction when he goes online again.");
break; break;
case SELLER_PAYOUT_FINALIZED: case WAIT_FOR_UNLOCK_PAYOUT:
waitTxInBlockchain.setCompleted(); waitTxInBlockchain.setCompleted();
waitFiatStarted.setCompleted(); waitFiatStarted.setCompleted();
confirmFiatReceived.setCompleted(); confirmFiatReceived.setCompleted();
@ -141,7 +154,7 @@ public class SellerSubView extends TradeSubView {
((WaitPayoutLockTimeView) tradeStepDetailsView).setInfoLabelText("The payout transaction is signed and finalized by both parties." + ((WaitPayoutLockTimeView) tradeStepDetailsView).setInfoLabelText("The payout transaction is signed and finalized by both parties." +
"\nFor reducing bank charge back risks you need to wait until the payout gets unlocked to transfer your Bitcoin."); "\nFor reducing bank charge back risks you need to wait until the payout gets unlocked to transfer your Bitcoin.");
break; break;
case SELLER_COMPLETED: case REQUEST_WITHDRAWAL:
waitTxInBlockchain.setCompleted(); waitTxInBlockchain.setCompleted();
waitFiatStarted.setCompleted(); waitFiatStarted.setCompleted();
confirmFiatReceived.setCompleted(); confirmFiatReceived.setCompleted();
@ -160,7 +173,7 @@ public class SellerSubView extends TradeSubView {
completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount()); completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount());
break; break;
case MESSAGE_SENDING_FAILED: /* case MESSAGE_SENDING_FAILED:
Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage()); Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage());
break; break;
case EXCEPTION: case EXCEPTION:
@ -168,7 +181,7 @@ public class SellerSubView extends TradeSubView {
Popups.openExceptionPopup(model.getTradeException()); Popups.openExceptionPopup(model.getTradeException());
else else
Popups.openErrorPopup("An error occurred", model.getErrorMessage()); Popups.openErrorPopup("An error occurred", model.getErrorMessage());
break; break;*/
default: default:
log.warn("unhandled viewState " + viewState); log.warn("unhandled viewState " + viewState);
break; break;

View file

@ -21,7 +21,6 @@ import io.bitsquare.gui.main.portfolio.pendingtrades.steps.TradeStepDetailsView;
import io.bitsquare.gui.main.portfolio.pendingtrades.steps.TradeWizardItem; import io.bitsquare.gui.main.portfolio.pendingtrades.steps.TradeWizardItem;
import io.bitsquare.gui.util.Layout; import io.bitsquare.gui.util.Layout;
import javafx.beans.value.ChangeListener;
import javafx.scene.layout.*; import javafx.scene.layout.*;
import org.slf4j.Logger; import org.slf4j.Logger;
@ -31,7 +30,6 @@ public abstract class TradeSubView extends HBox {
private static final Logger log = LoggerFactory.getLogger(TradeSubView.class); private static final Logger log = LoggerFactory.getLogger(TradeSubView.class);
protected final PendingTradesViewModel model; protected final PendingTradesViewModel model;
protected final ChangeListener<PendingTradesViewModel.ViewState> offererStateChangeListener;
protected VBox leftVBox; protected VBox leftVBox;
protected AnchorPane contentPane; protected AnchorPane contentPane;
protected TradeStepDetailsView tradeStepDetailsView; protected TradeStepDetailsView tradeStepDetailsView;
@ -47,17 +45,12 @@ public abstract class TradeSubView extends HBox {
setSpacing(Layout.PADDING_WINDOW); setSpacing(Layout.PADDING_WINDOW);
buildViews(); buildViews();
offererStateChangeListener = (ov, oldValue, newValue) -> applyState(newValue);
} }
public void activate() { public void activate() {
model.getViewState().addListener(offererStateChangeListener);
applyState(model.getViewState().get());
} }
public void deactivate() { public void deactivate() {
model.getViewState().removeListener(offererStateChangeListener);
if (tradeStepDetailsView != null) if (tradeStepDetailsView != null)
tradeStepDetailsView.deactivate(); tradeStepDetailsView.deactivate();
} }
@ -67,8 +60,6 @@ public abstract class TradeSubView extends HBox {
// Misc // Misc
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
protected abstract void applyState(PendingTradesViewModel.ViewState state);
private void buildViews() { private void buildViews() {
addLeftBox(); addLeftBox();
addContentPane(); addContentPane();

View file

@ -105,7 +105,6 @@ public class StartFiatView extends TradeStepDetailsView {
private void onPaymentStarted(ActionEvent actionEvent) { private void onPaymentStarted(ActionEvent actionEvent) {
log.debug("onPaymentStarted"); log.debug("onPaymentStarted");
model.fiatPaymentStarted();
paymentStartedButton.setDisable(true); paymentStartedButton.setDisable(true);
statusProgressIndicator.setVisible(true); statusProgressIndicator.setVisible(true);
statusProgressIndicator.setProgress(-1); statusProgressIndicator.setProgress(-1);
@ -113,6 +112,8 @@ public class StartFiatView extends TradeStepDetailsView {
root = statusProgressIndicator.getScene().getRoot(); root = statusProgressIndicator.getScene().getRoot();
// We deactivate mouse interaction to avoid that user leaves screen // We deactivate mouse interaction to avoid that user leaves screen
root.setMouseTransparent(true); root.setMouseTransparent(true);
model.fiatPaymentStarted();
} }