Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-12-15 15:59:10 -05:00
Code Issues Projects Releases Packages Wiki Activity

Changed state handling

Browse source
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
Download patch file Download diff file Expand all files Collapse all files

2
core/src/main/java/io/bitsquare/fiat/FiatAccount.java
View file

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

4
core/src/main/java/io/bitsquare/p2p/tomp2p/BootstrappedPeerBuilder.java
View file

@ -253,6 +253,10 @@ public class BootstrappedPeerBuilder {
private void 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.addListener(new BaseFutureListener<BaseFuture>() {
@Override

11
core/src/main/java/io/bitsquare/trade/BuyerAsOffererTrade.java
View file

@ -17,10 +17,12 @@
package io.bitsquare.trade;
import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.offer.Offer;
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;
@ -31,7 +33,7 @@ import java.io.Serializable;
import org.slf4j.Logger;
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.
private static final long serialVersionUID = 1L;
@ -66,9 +68,8 @@ public class BuyerAsOffererTrade extends OffererTrade implements BuyerTrade, Ser
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void onFiatPaymentStarted() {
assert tradeProtocol instanceof BuyerProtocol;
((BuyerProtocol) tradeProtocol).onFiatPaymentStarted();
public void handleTakeOfferRequest(TradeMessage message, Peer taker) {
((OffererProtocol) tradeProtocol).handleTakeOfferRequest(message, taker);
}
@Override

10
core/src/main/java/io/bitsquare/trade/BuyerAsTakerTrade.java
View file

@ -21,7 +21,7 @@ import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.offer.Offer;
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;
@ -32,7 +32,7 @@ import java.io.Serializable;
import org.slf4j.Logger;
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.
private static final long serialVersionUID = 1L;
@ -67,9 +67,9 @@ public class BuyerAsTakerTrade extends TakerTrade implements BuyerTrade, Seriali
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void onFiatPaymentStarted() {
assert tradeProtocol instanceof BuyerProtocol;
((BuyerProtocol) tradeProtocol).onFiatPaymentStarted();
public void takeAvailableOffer() {
assert tradeProtocol instanceof TakerProtocol;
((TakerProtocol) tradeProtocol).takeAvailableOffer();
}
@Override

92
core/src/main/java/io/bitsquare/trade/BuyerTrade.java
View file

@ -17,6 +17,94 @@
package io.bitsquare.trade;
public interface BuyerTrade {
void onFiatPaymentStarted();
import io.bitsquare.p2p.Peer;
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);
}
}

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

@ -18,86 +18,8 @@
package io.bitsquare.trade;
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.states.OffererTradeState;
import io.bitsquare.trade.states.TradeState;
import java.io.Serializable;
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);
}
public interface OffererTrade {
void handleTakeOfferRequest(TradeMessage message, Peer taker);
}

11
core/src/main/java/io/bitsquare/trade/SellerAsOffererTrade.java
View file

@ -17,10 +17,12 @@
package io.bitsquare.trade;
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.SellerAsOffererProtocol;
import io.bitsquare.trade.protocol.trade.SellerProtocol;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import java.io.IOException;
import java.io.ObjectInputStream;
@ -29,7 +31,7 @@ import java.io.Serializable;
import org.slf4j.Logger;
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.
private static final long serialVersionUID = 1L;
@ -64,8 +66,7 @@ public class SellerAsOffererTrade extends OffererTrade implements SellerTrade, S
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public void onFiatPaymentReceived() {
assert tradeProtocol instanceof SellerProtocol;
((SellerProtocol) tradeProtocol).onFiatPaymentReceived();
public void handleTakeOfferRequest(TradeMessage message, Peer taker) {
((OffererProtocol) tradeProtocol).handleTakeOfferRequest(message, taker);
}
}

13
core/src/main/java/io/bitsquare/trade/SellerAsTakerTrade.java
View file

@ -21,8 +21,7 @@ import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.protocol.trade.SellerAsTakerProtocol;
import io.bitsquare.trade.protocol.trade.SellerProtocol;
import io.bitsquare.trade.states.TakerTradeState;
import io.bitsquare.trade.protocol.trade.TakerProtocol;
import org.bitcoinj.core.Coin;
@ -32,11 +31,11 @@ import java.io.Serializable;
import org.slf4j.Logger;
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.
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
public void onFiatPaymentReceived() {
assert tradeProtocol instanceof SellerProtocol;
((SellerProtocol) tradeProtocol).onFiatPaymentReceived();
public void takeAvailableOffer() {
assert tradeProtocol instanceof TakerProtocol;
((TakerProtocol) tradeProtocol).takeAvailableOffer();
}
}

91
core/src/main/java/io/bitsquare/trade/SellerTrade.java
View file

@ -17,6 +17,93 @@
package io.bitsquare.trade;
public interface SellerTrade {
void onFiatPaymentReceived();
import io.bitsquare.p2p.Peer;
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);
}
}

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

@ -17,89 +17,6 @@
package io.bitsquare.trade;
import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
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);
}
public interface TakerTrade {
void takeAvailableOffer();
}

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

@ -42,11 +42,10 @@ import io.bitsquare.trade.offer.Offer;
import io.bitsquare.trade.offer.OpenOffer;
import io.bitsquare.trade.offer.OpenOfferManager;
import io.bitsquare.trade.protocol.availability.OfferAvailabilityModel;
import io.bitsquare.trade.protocol.availability.OfferAvailabilityProtocol;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.messages.DepositTxInputsRequest;
import io.bitsquare.trade.protocol.trade.messages.PayDepositRequest;
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 org.bitcoinj.core.AddressFormatException;
@ -60,9 +59,7 @@ import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import javax.inject.Inject;
@ -89,11 +86,10 @@ public class TradeManager {
private final WalletService walletService;
private final TradeWalletService tradeWalletService;
private final CryptoService<MailboxMessage> cryptoService;
private OpenOfferManager openOfferManager;
private ClosedTradableManager closedTradableManager;
private final OpenOfferManager openOfferManager;
private final ClosedTradableManager closedTradableManager;
private final ArbitrationRepository arbitrationRepository;
private final Map<String, OfferAvailabilityProtocol> checkOfferAvailabilityProtocolMap = new HashMap<>();
private final Storage<TradableList<Trade>> pendingTradesStorage;
private final TradableList<Trade> pendingTrades;
@ -162,8 +158,8 @@ public class TradeManager {
Message message = messageWithPubKey.getMessage();
// 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
if (message instanceof RequestDepositTxInputsMessage ||
(message instanceof RequestPayDepositMessage && ((RequestPayDepositMessage) message).isInitialRequest))
if (message instanceof DepositTxInputsRequest ||
(message instanceof PayDepositRequest && ((PayDepositRequest) message).isInitialRequest))
handleInitialTakeOfferRequest((TradeMessage) message, sender);
}
});
@ -183,7 +179,7 @@ public class TradeManager {
Offer offer = openOfferOptional.get().getOffer();
openOfferManager.reserveOpenOffer(openOfferOptional.get());
OffererTrade trade;
Trade trade;
if (offer.getDirection() == Offer.Direction.BUY)
trade = new BuyerAsOffererTrade(offer, pendingTradesStorage);
else
@ -192,7 +188,7 @@ public class TradeManager {
trade.setStorage(pendingTradesStorage);
pendingTrades.add(trade);
initTrade(trade);
trade.handleTakeOfferRequest(message, sender);
((OffererTrade) trade).handleTakeOfferRequest(message, sender);
setupDepositPublishedListener(trade);
}
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
private void setupDepositPublishedListener(Trade trade) {
trade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("setupDepositPublishedListener state = " + newValue);
if (newValue == OffererTradeState.ProcessState.DEPOSIT_PUBLISHED) {
if (newValue == BuyerTradeState.ProcessState.DEPOSIT_PUBLISHED) {
openOfferManager.closeOpenOffer(trade.getOffer());
trade.setTakeOfferDate(new Date());
}
@ -270,125 +278,52 @@ public class TradeManager {
///////////////////////////////////////////////////////////////////////////////////////////
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
///////////////////////////////////////////////////////////////////////////////////////////
public void checkOfferAvailability(Offer offer) {
if (!checkOfferAvailabilityProtocolMap.containsKey(offer.getId())) {
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());
}
public void onCheckOfferAvailability(Offer offer) {
offer.checkOfferAvailability(getOfferAvailabilityModel(offer));
}
// When closing take offer view, we are not interested in the onCheckOfferAvailability result anymore, so remove from the map
public void cancelCheckOfferAvailabilityRequest(Offer offer) {
disposeCheckOfferAvailabilityRequest(offer);
public void onCancelAvailabilityRequest(Offer offer) {
offer.cancelAvailabilityRequest();
}
// 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) {
OfferAvailabilityModel model = new OfferAvailabilityModel(offer, keyRing.getPubKeyRing(), messageService, addressService);
OfferAvailabilityProtocol availabilityProtocol = new OfferAvailabilityProtocol(model,
() -> createTrade(amount, offer, model, takeOfferResultHandler),
(errorMessage) -> disposeCheckOfferAvailabilityRequest(offer));
checkOfferAvailabilityProtocolMap.put(offer.getId(), availabilityProtocol);
availabilityProtocol.checkOfferAvailability();
public void onTakeOffer(Coin amount, Offer offer, TakeOfferResultHandler takeOfferResultHandler) {
final OfferAvailabilityModel model = getOfferAvailabilityModel(offer);
offer.checkOfferAvailability(model, () -> {
if (offer.getState() == Offer.State.AVAILABLE)
createTrade(amount, offer, model, takeOfferResultHandler);
});
}
private void createTrade(Coin amount, Offer offer, OfferAvailabilityModel model, TakeOfferResultHandler
takeOfferResultHandler) {
disposeCheckOfferAvailabilityRequest(offer);
if (offer.getState() == Offer.State.AVAILABLE) {
Trade trade;
if (offer.getDirection() == Offer.Direction.BUY)
trade = new SellerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
else
trade = new BuyerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
private void createTrade(Coin amount, Offer offer, OfferAvailabilityModel model, TakeOfferResultHandler takeOfferResultHandler) {
Trade trade;
if (offer.getDirection() == Offer.Direction.BUY)
trade = new SellerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
else
trade = new BuyerAsTakerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
trade.setTakeOfferDate(new Date());
initTrade(trade);
pendingTrades.add(trade);
if (trade instanceof TakerTrade)
((TakerTrade) trade).takeAvailableOffer();
takeOfferResultHandler.handleResult(trade);
}
trade.setTakeOfferDate(new Date());
initTrade(trade);
pendingTrades.add(trade);
((TakerTrade) trade).takeAvailableOffer();
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
///////////////////////////////////////////////////////////////////////////////////////////
/* public ObservableList<Trade> getOpenOfferTrades() {
return openOfferTrades.getObservableList();
}*/
public ObservableList<Trade> getPendingTrades() {
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) {
return offer.isMyOffer(keyRing);
}
}

36
core/src/main/java/io/bitsquare/trade/offer/Offer.java
View file

@ -18,10 +18,13 @@
package io.bitsquare.trade.offer;
import io.bitsquare.btc.Restrictions;
import io.bitsquare.common.handlers.ResultHandler;
import io.bitsquare.crypto.KeyRing;
import io.bitsquare.crypto.PubKeyRing;
import io.bitsquare.fiat.FiatAccount;
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.utils.ExchangeRate;
@ -46,8 +49,7 @@ import static com.google.common.base.Preconditions.*;
public class Offer implements Serializable {
// That object is sent over the wire, so we need to take care of version compatibility.
private static final long serialVersionUID = 1L;
private transient static final Logger log = LoggerFactory.getLogger(Offer.class);
transient private static final Logger log = LoggerFactory.getLogger(Offer.class);
public enum Direction {BUY, SELL}
@ -88,6 +90,7 @@ public class Offer implements Serializable {
// 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
transient private ObjectProperty<State> stateProperty = new SimpleObjectProperty<>(state);
transient private OfferAvailabilityProtocol availabilityProtocol;
///////////////////////////////////////////////////////////////////////////////////////////
@ -163,7 +166,7 @@ public class Offer implements Serializable {
public boolean isMyOffer(KeyRing keyRing) {
return getPubKeyRing().getHashString().equals(keyRing.getPubKeyRing().getHashString());
}
public Fiat getVolumeByAmount(Coin amount) {
if (fiatPrice != 0 && amount != null && !amount.isZero())
return new ExchangeRate(Fiat.valueOf(currencyCode, fiatPrice)).coinToFiat(amount);
@ -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
///////////////////////////////////////////////////////////////////////////////////////////

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

@ -112,12 +112,12 @@ public class OfferAvailabilityProtocol {
if (message instanceof OfferMessage) {
nonEmptyStringOf(((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();
model.setMessage(message);

57
core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsOffererProtocol.java
View file

@ -21,17 +21,17 @@ import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.messages.RequestFinalizePayoutTxMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.messages.FinalizePayoutTxRequest;
import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest;
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.ProcessRequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestFinalizePayoutTxMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessDepositTxInputsRequest;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessFinalizePayoutTxRequest;
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.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.SendRequestPayDepositMessage;
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.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.shared.CommitPayoutTx;
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.LoggerFactory;
@ -60,6 +62,23 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
log.debug("New OffererProtocol " + this);
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"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
ProcessRequestDepositTxInputsMessage.class,
ProcessDepositTxInputsRequest.class,
CreateDepositTxInputs.class,
SendRequestPayDepositMessage.class
SendPayDepositRequest.class
);
taskRunner.run();
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
findPeerAddress(processModel.tradingPeer.getPubKeyRing(),
() -> {
if (message instanceof RequestFinalizePayoutTxMessage) {
handle((RequestFinalizePayoutTxMessage) message);
if (message instanceof FinalizePayoutTxRequest) {
handle((FinalizePayoutTxRequest) message);
}
},
(errorMessage -> {
@ -108,7 +127,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
// Incoming message handling
///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestPublishDepositTxMessage tradeMessage) {
private void handle(PublishDepositTxRequest tradeMessage) {
stopTimeout();
processModel.setTradeMessage(tradeMessage);
@ -116,7 +135,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
ProcessRequestPublishDepositTxMessage.class,
ProcessPublishDepositTxRequest.class,
VerifyTakerAccount.class,
VerifyAndSignContract.class,
SignAndPublishDepositTx.class,
@ -133,6 +152,8 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
// User clicked the "bank transfer started" button
@Override
public void onFiatPaymentStarted() {
buyerAsOffererTrade.setProcessState(BuyerTradeState.ProcessState.FIAT_PAYMENT_STARTED);
TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsOffererTrade,
() -> log.debug("taskRunner at handleBankTransferStartedUIEvent completed"),
this::handleTaskRunnerFault);
@ -148,7 +169,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
// Incoming message handling
///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestFinalizePayoutTxMessage tradeMessage) {
private void handle(FinalizePayoutTxRequest tradeMessage) {
log.debug("handle RequestFinalizePayoutTxMessage called");
processModel.setTradeMessage(tradeMessage);
@ -161,7 +182,7 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
this::handleTaskRunnerFault);
taskRunner.addTasks(
ProcessRequestFinalizePayoutTxMessage.class,
ProcessFinalizePayoutTxRequest.class,
SignAndFinalizePayoutTx.class,
CommitPayoutTx.class,
SendPayoutTxFinalizedMessage.class,
@ -177,11 +198,11 @@ public class BuyerAsOffererProtocol extends TradeProtocol implements BuyerProtoc
@Override
protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) {
if (tradeMessage instanceof RequestPublishDepositTxMessage) {
handle((RequestPublishDepositTxMessage) tradeMessage);
if (tradeMessage instanceof PublishDepositTxRequest) {
handle((PublishDepositTxRequest) tradeMessage);
}
else if (tradeMessage instanceof RequestFinalizePayoutTxMessage) {
handle((RequestFinalizePayoutTxMessage) tradeMessage);
else if (tradeMessage instanceof FinalizePayoutTxRequest) {
handle((FinalizePayoutTxRequest) tradeMessage);
}
else {
log.error("Incoming decrypted tradeMessage not supported. " + tradeMessage);

54
core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsTakerProtocol.java
View file

@ -21,16 +21,16 @@ import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.messages.RequestFinalizePayoutTxMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.messages.FinalizePayoutTxRequest;
import io.bitsquare.trade.protocol.trade.messages.PublishDepositTxRequest;
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.ProcessRequestFinalizePayoutTxMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessRequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.tasks.buyer.ProcessFinalizePayoutTxRequest;
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.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.SendRequestPayDepositMessage;
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.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.VerifyOfferFeePayment;
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.LoggerFactory;
@ -62,6 +64,23 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
this.buyerAsTakerTrade = trade;
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
findPeerAddress(trade.getOffer().getPubKeyRing(),
() -> {
if (message instanceof RequestFinalizePayoutTxMessage) {
handle((RequestFinalizePayoutTxMessage) message);
if (message instanceof FinalizePayoutTxRequest) {
handle((FinalizePayoutTxRequest) message);
}
},
(errorMessage -> {
@ -95,7 +114,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
CreateTakeOfferFeeTx.class,
BroadcastTakeOfferFeeTx.class,
CreateDepositTxInputs.class,
SendRequestPayDepositMessage.class
SendPayDepositRequest.class
);
taskRunner.run();
startTimeout();
@ -106,7 +125,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
// Incoming message handling
///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestPublishDepositTxMessage tradeMessage) {
private void handle(PublishDepositTxRequest tradeMessage) {
stopTimeout();
processModel.setTradeMessage(tradeMessage);
@ -114,7 +133,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
this::handleTaskRunnerFault);
taskRunner.addTasks(
ProcessRequestPublishDepositTxMessage.class,
ProcessPublishDepositTxRequest.class,
VerifyOffererAccount.class,
VerifyAndSignContract.class,
SignAndPublishDepositTx.class,
@ -131,6 +150,9 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
// User clicked the "bank transfer started" button
@Override
public void onFiatPaymentStarted() {
buyerAsTakerTrade.setProcessState(BuyerTradeState.ProcessState.FIAT_PAYMENT_STARTED);
TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsTakerTrade,
() -> log.debug("taskRunner at onFiatPaymentStarted completed"),
this::handleTaskRunnerFault);
@ -147,7 +169,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
// Incoming message handling
///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestFinalizePayoutTxMessage tradeMessage) {
private void handle(FinalizePayoutTxRequest tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TradeTaskRunner taskRunner = new TradeTaskRunner(buyerAsTakerTrade,
@ -159,7 +181,7 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
this::handleTaskRunnerFault);
taskRunner.addTasks(
ProcessRequestFinalizePayoutTxMessage.class,
ProcessFinalizePayoutTxRequest.class,
SignAndFinalizePayoutTx.class,
CommitPayoutTx.class,
SendPayoutTxFinalizedMessage.class,
@ -174,11 +196,11 @@ public class BuyerAsTakerProtocol extends TradeProtocol implements BuyerProtocol
@Override
protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) {
if (tradeMessage instanceof RequestPublishDepositTxMessage) {
handle((RequestPublishDepositTxMessage) tradeMessage);
if (tradeMessage instanceof PublishDepositTxRequest) {
handle((PublishDepositTxRequest) tradeMessage);
}
else if (tradeMessage instanceof RequestFinalizePayoutTxMessage) {
handle((RequestFinalizePayoutTxMessage) tradeMessage);
else if (tradeMessage instanceof FinalizePayoutTxRequest) {
handle((FinalizePayoutTxRequest) tradeMessage);
}
else {
log.error("Incoming message not supported. " + tradeMessage);

33
core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsOffererProtocol.java
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.ProcessDepositTxPublishedMessage;
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.ProcessRequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestFinalizePayoutTxMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendFinalizePayoutTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendPublishDepositTxRequest;
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.SetupPayoutTxLockTimeReachedListener;
import io.bitsquare.trade.states.SellerTradeState;
import io.bitsquare.trade.states.TradeState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -58,6 +60,23 @@ public class SellerAsOffererProtocol extends TradeProtocol implements SellerProt
log.debug("New OffererProtocol " + this);
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);
taskRunner.addTasks(
ProcessRequestPayDepositMessage.class,
ProcessPayDepositRequest.class,
VerifyTakerAccount.class,
CreateAndSignContract.class,
CreateAndSignDepositTx.class,
SendRequestPublishDepositTxMessage.class
SendPublishDepositTxRequest.class
);
taskRunner.run();
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
@Override
public void onFiatPaymentReceived() {
sellerAsOffererTrade.setProcessState(SellerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT);
TradeTaskRunner taskRunner = new TradeTaskRunner(sellerAsOffererTrade,
() -> {
log.debug("taskRunner at handleFiatReceivedUIEvent completed");
@ -165,7 +186,7 @@ public class SellerAsOffererProtocol extends TradeProtocol implements SellerProt
taskRunner.addTasks(
VerifyTakeOfferFeePayment.class,
SignPayoutTx.class,
SendRequestFinalizePayoutTxMessage.class
SendFinalizePayoutTxRequest.class
);
taskRunner.run();
}

48
core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsTakerProtocol.java
View file

@ -20,22 +20,23 @@ package io.bitsquare.trade.protocol.trade;
import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.SellerTrade;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
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.RequestPayDepositMessage;
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.CreateAndSignContract;
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.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.ProcessRequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestFinalizePayoutTxMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendRequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendDepositTxInputsRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendFinalizePayoutTxRequest;
import io.bitsquare.trade.protocol.trade.tasks.seller.SendPublishDepositTxRequest;
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.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.VerifyOfferFeePayment;
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.LoggerFactory;
@ -64,6 +67,25 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
this.sellerAsTakerTrade = trade;
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(
CreateTakeOfferFeeTx.class,
BroadcastTakeOfferFeeTx.class,
SendRequestDepositTxInputsMessage.class
SendDepositTxInputsRequest.class
);
taskRunner.run();
startTimeout();
@ -115,7 +137,7 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
// Incoming message handling
///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestPayDepositMessage tradeMessage) {
private void handle(PayDepositRequest tradeMessage) {
log.debug("handle RequestPayDepositMessage");
stopTimeout();
processModel.setTradeMessage(tradeMessage);
@ -125,11 +147,11 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
this::handleTaskRunnerFault);
taskRunner.addTasks(
ProcessRequestPayDepositMessage.class,
ProcessPayDepositRequest.class,
VerifyOffererAccount.class,
CreateAndSignContract.class,
CreateAndSignDepositTx.class,
SendRequestPublishDepositTxMessage.class
SendPublishDepositTxRequest.class
);
taskRunner.run();
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
@Override
public void onFiatPaymentReceived() {
sellerAsTakerTrade.setProcessState(SellerTradeState.ProcessState.FIAT_PAYMENT_RECEIPT);
TradeTaskRunner taskRunner = new TradeTaskRunner(sellerAsTakerTrade,
() -> {
log.debug("taskRunner at onFiatPaymentReceived completed");
@ -186,7 +210,7 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
taskRunner.addTasks(
VerifyOfferFeePayment.class,
SignPayoutTx.class,
SendRequestFinalizePayoutTxMessage.class
SendFinalizePayoutTxRequest.class
);
taskRunner.run();
}
@ -214,8 +238,8 @@ public class SellerAsTakerProtocol extends TradeProtocol implements SellerProtoc
@Override
protected void doHandleDecryptedMessage(TradeMessage tradeMessage, Peer sender) {
if (tradeMessage instanceof RequestPayDepositMessage) {
handle((RequestPayDepositMessage) tradeMessage);
if (tradeMessage instanceof PayDepositRequest) {
handle((PayDepositRequest) tradeMessage);
}
else if (tradeMessage instanceof DepositTxPublishedMessage) {
handle((DepositTxPublishedMessage) tradeMessage);

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

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

4
core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestDepositTxInputsMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/messages/DepositTxInputsRequest.java
View file

@ -26,7 +26,7 @@ import java.io.Serializable;
import javax.annotation.concurrent.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.
private static final long serialVersionUID = 1L;
@ -35,7 +35,7 @@ public class RequestDepositTxInputsMessage extends TradeMessage implements Seria
public final String sellerOfferFeeTxId;
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) {
super(tradeId);
this.sellerPubKeyRing = sellerPubKeyRing;

10
core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestFinalizePayoutTxMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/messages/FinalizePayoutTxRequest.java
View file

@ -24,7 +24,7 @@ import java.io.Serializable;
import javax.annotation.concurrent.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.
private static final long serialVersionUID = 1L;
@ -32,10 +32,10 @@ public class RequestFinalizePayoutTxMessage extends TradeMessage implements Mail
public final String sellerPayoutAddress;
public final long lockTime;
public RequestFinalizePayoutTxMessage(String tradeId,
byte[] sellerSignature,
String sellerPayoutAddress,
long lockTime) {
public FinalizePayoutTxRequest(String tradeId,
byte[] sellerSignature,
String sellerPayoutAddress,
long lockTime) {
super(tradeId);
this.sellerSignature = sellerSignature;
this.sellerPayoutAddress = sellerPayoutAddress;

20
core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestPayDepositMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/messages/PayDepositRequest.java
View file

@ -30,7 +30,7 @@ import java.util.List;
import javax.annotation.concurrent.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.
private static final long serialVersionUID = 1L;
@ -43,15 +43,15 @@ public class RequestPayDepositMessage extends TradeMessage implements Serializab
public final String buyerAccountId;
public final Coin tradeAmount;
public RequestPayDepositMessage(String tradeId,
Coin tradeAmount,
boolean isInitialRequest,
List<TransactionOutput> buyerConnectedOutputsForAllInputs,
List<TransactionOutput> buyerOutputs,
byte[] buyerTradeWalletPubKey,
PubKeyRing buyerPubKeyRing,
FiatAccount buyerFiatAccount,
String buyerAccountId) {
public PayDepositRequest(String tradeId,
Coin tradeAmount,
boolean isInitialRequest,
List<TransactionOutput> buyerConnectedOutputsForAllInputs,
List<TransactionOutput> buyerOutputs,
byte[] buyerTradeWalletPubKey,
PubKeyRing buyerPubKeyRing,
FiatAccount buyerFiatAccount,
String buyerAccountId) {
super(tradeId);
this.tradeAmount = tradeAmount;
this.isInitialRequest = isInitialRequest;

20
core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestPublishDepositTxMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/messages/PublishDepositTxRequest.java
View file

@ -29,7 +29,7 @@ import java.util.List;
import javax.annotation.concurrent.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.
private static final long serialVersionUID = 1L;
@ -42,15 +42,15 @@ public class RequestPublishDepositTxMessage extends TradeMessage implements Seri
public final List<TransactionOutput> sellerConnectedOutputsForAllInputs;
public final byte[] sellerTradeWalletPubKey;
public RequestPublishDepositTxMessage(String tradeId,
FiatAccount sellerFiatAccount,
String sellerAccountId,
byte[] sellerTradeWalletPubKey,
String sellerContractAsJson,
String sellerContractSignature,
String sellerPayoutAddressString,
Transaction sellersPreparedDepositTx,
List<TransactionOutput> sellerConnectedOutputsForAllInputs) {
public PublishDepositTxRequest(String tradeId,
FiatAccount sellerFiatAccount,
String sellerAccountId,
byte[] sellerTradeWalletPubKey,
String sellerContractAsJson,
String sellerContractSignature,
String sellerPayoutAddressString,
Transaction sellersPreparedDepositTx,
List<TransactionOutput> sellerConnectedOutputsForAllInputs) {
super(tradeId);
this.sellerFiatAccount = sellerFiatAccount;
this.sellerAccountId = sellerAccountId;

10
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestDepositTxInputsMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessDepositTxInputsRequest.java
View file

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

13
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestFinalizePayoutTxMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessFinalizePayoutTxRequest.java
View file

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

10
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessRequestPublishDepositTxMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/ProcessPublishDepositTxRequest.java
View file

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

3
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendDepositTxPublishedMessage.java
View file

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

10
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendFiatTransferStartedMessage.java
View file

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

10
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendRequestPayDepositMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendPayDepositRequest.java
View file

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

3
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SendPayoutTxFinalizedMessage.java
View file

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

8
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SignAndFinalizePayoutTx.java
View file

@ -18,12 +18,8 @@
package io.bitsquare.trade.protocol.trade.tasks.buyer;
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.protocol.trade.TradeTask;
import io.bitsquare.trade.states.OffererTradeState;
import io.bitsquare.trade.states.TakerTradeState;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction;
@ -60,10 +56,6 @@ public class SignAndFinalizePayoutTx extends TradeTask {
);
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();
} catch (Throwable t) {

14
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/buyer/SignAndPublishDepositTx.java
View file

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

10
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessDepositTxPublishedMessage.java
View file

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

10
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessFiatTransferStartedMessage.java
View file

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

10
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessRequestPayDepositMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessPayDepositRequest.java
View file

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

10
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/ProcessPayoutTxFinalizedMessage.java
View file

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

12
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestDepositTxInputsMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendDepositTxInputsRequest.java
View file

@ -21,7 +21,7 @@ import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.p2p.listener.SendMessageListener;
import io.bitsquare.trade.Trade;
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 org.bitcoinj.utils.Threading;
@ -29,10 +29,10 @@ import org.bitcoinj.utils.Threading;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SendRequestDepositTxInputsMessage extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(SendRequestDepositTxInputsMessage.class);
public class SendDepositTxInputsRequest extends TradeTask {
private static final Logger log = LoggerFactory.getLogger(SendDepositTxInputsRequest.class);
public SendRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) {
public SendDepositTxInputsRequest(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@ -42,7 +42,7 @@ public class SendRequestDepositTxInputsMessage extends TradeTask {
protected void doRun() {
try {
assert processModel.getTakeOfferFeeTx() != null;
RequestDepositTxInputsMessage message = new RequestDepositTxInputsMessage(
DepositTxInputsRequest message = new DepositTxInputsRequest(
processModel.getId(),
processModel.getPubKeyRing(),
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.
if (retryCounter == 0) {
retryCounter++;
Threading.USER_THREAD.execute(SendRequestDepositTxInputsMessage.this::doRun);
Threading.USER_THREAD.execute(SendDepositTxInputsRequest.this::doRun);
}
else {
appendToErrorMessage("Sending TakeOfferFeePayedMessage to offerer failed. Maybe the network connection was " +

20
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestFinalizePayoutTxMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendFinalizePayoutTxRequest.java
View file

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

10
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendRequestPublishDepositTxMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/seller/SendPublishDepositTxRequest.java
View file

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

9
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/shared/CommitPayoutTx.java
View file

@ -18,8 +18,12 @@
package io.bitsquare.trade.protocol.trade.tasks.shared;
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.protocol.trade.TradeTask;
import io.bitsquare.trade.states.BuyerTradeState;
import io.bitsquare.trade.states.SellerTradeState;
import org.bitcoinj.core.Transaction;
@ -40,6 +44,11 @@ public class CommitPayoutTx extends TradeTask {
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();
} catch (Throwable t) {
t.printStackTrace();

21
core/src/main/java/io/bitsquare/trade/protocol/trade/tasks/shared/SetupPayoutTxLockTimeReachedListener.java
View file

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

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

@ -18,10 +18,8 @@
package io.bitsquare.trade.protocol.trade.tasks.taker;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.TradeTask;
import io.bitsquare.trade.states.TakerTradeState;
import org.bitcoinj.core.Transaction;
@ -48,8 +46,9 @@ public class BroadcastTakeOfferFeeTx extends TradeTask {
public void onSuccess(Transaction transaction) {
log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString());
if (trade instanceof TakerTrade)
trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
/* if (trade instanceof SellerTrade)
trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISHED);*/
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.");
trade.setErrorMessage(errorMessage);
if (trade instanceof TakerTrade)
trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
/* if (trade instanceof SellerTrade)
trade.setProcessState(TakerTradeState.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);*/
failed(t);
}

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

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

18
core/src/main/java/io/bitsquare/trade/states/OffererTradeState.java → core/src/main/java/io/bitsquare/trade/states/BuyerTradeState.java
View file

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

23
core/src/main/java/io/bitsquare/trade/states/TakerTradeState.java → core/src/main/java/io/bitsquare/trade/states/SellerTradeState.java
View file

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

13
core/src/main/java/io/bitsquare/trade/states/StateUtil.java
View file

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