Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-07-29 17:58:56 -04:00
Code Issues Projects Releases Packages Wiki Activity

renamed Offer and Taker Trade models

Browse source
This commit is contained in:
Manfred Karrer 2015-04-02 13:17:21 +02:00
parent 8fdcab213b
commit 28861ca2de
67 changed files with 476 additions and 476 deletions
Download patch file Download diff file Expand all files Collapse all files

3
core/src/main/java/io/bitsquare/app/BitsquareEnvironment.java
View file

@ -141,7 +141,8 @@ public class BitsquareEnvironment extends StandardEnvironment {
setProperty(Storage.DIR_KEY, Paths.get(appDataDir, "db").toString()); setProperty(Storage.DIR_KEY, Paths.get(appDataDir, "db").toString());
setProperty(MainView.TITLE_KEY, appName); setProperty(MainView.TITLE_KEY, appName);
}}); }
});
} }

4
core/src/main/java/io/bitsquare/gui/bitsquare.css
View file

@ -472,7 +472,6 @@ textfield */
-fx-background-radius: 3px, 3px, 2px, 1px; -fx-background-radius: 3px, 3px, 2px, 1px;
} }
/* Pending trades */ /* Pending trades */
#trade-wizard-item-background-disabled { #trade-wizard-item-background-disabled {
-fx-body-color: linear-gradient(to bottom, #f4f4f4, #F0F0F0); -fx-body-color: linear-gradient(to bottom, #f4f4f4, #F0F0F0);
@ -497,7 +496,7 @@ textfield */
-fx-background-radius: 3px, 3px, 2px, 1px; -fx-background-radius: 3px, 3px, 2px, 1px;
} }
#trade-wizard-item-background-completed{ #trade-wizard-item-background-completed {
-fx-body-color: linear-gradient(to bottom, #f4f4f4, #E1E9E1); -fx-body-color: linear-gradient(to bottom, #f4f4f4, #E1E9E1);
-fx-outer-border: linear-gradient(to bottom, #99ba9c, #619865); -fx-outer-border: linear-gradient(to bottom, #99ba9c, #619865);
-fx-background-color: -fx-shadow-highlight-color, -fx-background-color: -fx-shadow-highlight-color,
@ -508,7 +507,6 @@ textfield */
-fx-background-radius: 3px, 3px, 2px, 1px; -fx-background-radius: 3px, 3px, 2px, 1px;
} }
/* TitledGroupBg */ /* TitledGroupBg */
#titled-group-bg-label { #titled-group-bg-label {
-fx-font-weight: bold; -fx-font-weight: bold;

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

@ -34,25 +34,25 @@ import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererCreatesDepos
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererProcessPayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererProcessPayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererProcessRequestDepositTxInputsMessage; import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererProcessRequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererProcessRequestPublishDepositTxMessage; import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererProcessRequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererSendsRequestSellerDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererSendsFiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererSendsDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererSendsDepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererSendsFiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererSendsRequestSellerDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererSignsAndPublishDepositTx; import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererSignsAndPublishDepositTx;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererVerifiesAndSignsContract; import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererVerifiesAndSignsContract;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakeOfferFeePayment; import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerSendsRequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakerAccount; import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerSendsRequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.seller.taker.SellerAsTakerProtocol; import io.bitsquare.trade.protocol.trade.seller.taker.SellerAsTakerProtocol;
import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerCommitDepositTx;
import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerCreatesAndSignContract; import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerCreatesAndSignContract;
import io.bitsquare.trade.protocol.trade.shared.taker.tasks.CreateTakeOfferFeeTx; import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerCreatesAndSignsDepositTx;
import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerProcessDepositTxPublishedMessage; import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerProcessDepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerProcessFiatTransferStartedMessage; import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerProcessFiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerProcessRequestSellerDepositPaymentMessage; import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerProcessRequestSellerDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerSendsPayoutTxPublishedMessage; import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerSendsPayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerSendsRequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerSendsRequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerSignsAndPublishPayoutTx; import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerSignsAndPublishPayoutTx;
import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerCommitDepositTx; import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakeOfferFeePayment;
import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerCreatesAndSignsDepositTx; import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakerAccount;
import io.bitsquare.trade.protocol.trade.shared.taker.tasks.CreateTakeOfferFeeTx;
import io.bitsquare.trade.protocol.trade.shared.taker.tasks.VerifyOfferFeePayment; import io.bitsquare.trade.protocol.trade.shared.taker.tasks.VerifyOfferFeePayment;
import io.bitsquare.trade.protocol.trade.shared.taker.tasks.VerifyOffererAccount; import io.bitsquare.trade.protocol.trade.shared.taker.tasks.VerifyOffererAccount;

3
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/TradeSubView.java
View file

@ -56,7 +56,8 @@ public abstract class TradeSubView extends HBox {
applyState(model.viewState.get()); applyState(model.viewState.get());
} }
public void deactivate() { log.debug("deactivate"); public void deactivate() {
log.debug("deactivate");
model.viewState.removeListener(offererStateChangeListener); model.viewState.removeListener(offererStateChangeListener);
if (tradeStepDetailsView != null) if (tradeStepDetailsView != null)

2
core/src/main/java/io/bitsquare/gui/main/trade/createoffer/CreateOfferViewModel.java
View file

@ -118,7 +118,7 @@ class CreateOfferViewModel extends ActivatableWithDataModel<CreateOfferDataModel
// setOfferBookFilter is a one time call // setOfferBookFilter is a one time call
void initWithData(Offer.Direction direction, Coin amount, Fiat price) { void initWithData(Offer.Direction direction, Coin amount, Fiat price) {
dataModel.initWithData( direction, amount, price); dataModel.initWithData(direction, amount, price);
if (dataModel.getDirection() == Offer.Direction.BUY) { if (dataModel.getDirection() == Offer.Direction.BUY) {
directionLabel.set(BSResources.get("shared.buyBitcoin")); directionLabel.set(BSResources.get("shared.buyBitcoin"));

30
core/src/main/java/io/bitsquare/gui/main/trade/takeoffer/TakeOfferViewModel.java
View file

@ -225,28 +225,28 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
isTakeOfferSpinnerVisible.set(true); isTakeOfferSpinnerVisible.set(true);
dataModel.takeOffer((takerTrade) -> { dataModel.takeOffer((trade) -> {
takerTrade.processStateProperty().addListener((ov, oldValue, newValue) -> { trade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("takerTrade state = " + newValue); log.debug("trade state = " + newValue);
String msg = ""; String msg = "";
if (takerTrade.getErrorMessage() != null) if (trade.getErrorMessage() != null)
msg = "\nError message: " + takerTrade.getErrorMessage(); msg = "\nError message: " + trade.getErrorMessage();
if (takerTrade instanceof TakerAsBuyerTrade) { if (trade instanceof TakerAsBuyerTrade) {
switch ((TakerAsBuyerTrade.ProcessState) newValue) { switch ((TakerAsBuyerTrade.ProcessState) newValue) {
case TAKE_OFFER_FEE_TX_CREATED: case TAKE_OFFER_FEE_TX_CREATED:
break; break;
case DEPOSIT_PUBLISHED: case DEPOSIT_PUBLISHED:
case DEPOSIT_CONFIRMED: case DEPOSIT_CONFIRMED:
assert takerTrade.getDepositTx() != null; assert trade.getDepositTx() != null;
transactionId.set(takerTrade.getDepositTx().getHashAsString()); transactionId.set(trade.getDepositTx().getHashAsString());
applyTakeOfferRequestResult(true); applyTakeOfferRequestResult(true);
break; break;
case FIAT_PAYMENT_STARTED: case FIAT_PAYMENT_STARTED:
break; break;
case TAKE_OFFER_FEE_PUBLISH_FAILED: case TAKE_OFFER_FEE_PUBLISH_FAILED:
errorMessage.set("An error occurred when paying the takerTrade fee." + msg); errorMessage.set("An error occurred when paying the trade fee." + msg);
takeOfferRequested = false; takeOfferRequested = false;
break; break;
case MESSAGE_SENDING_FAILED: case MESSAGE_SENDING_FAILED:
@ -261,24 +261,24 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
takeOfferRequested = false; takeOfferRequested = false;
break; break;
default: default:
log.warn("Unhandled takerTrade state: " + newValue); log.warn("Unhandled trade state: " + newValue);
break; break;
} }
} }
else if (takerTrade instanceof TakerAsSellerTrade) { else if (trade instanceof TakerAsSellerTrade) {
switch ((TakerAsSellerTrade.ProcessState) newValue) { switch ((TakerAsSellerTrade.ProcessState) newValue) {
case TAKE_OFFER_FEE_TX_CREATED: case TAKE_OFFER_FEE_TX_CREATED:
break; break;
case DEPOSIT_PUBLISHED: case DEPOSIT_PUBLISHED:
case DEPOSIT_CONFIRMED: case DEPOSIT_CONFIRMED:
assert takerTrade.getDepositTx() != null; assert trade.getDepositTx() != null;
transactionId.set(takerTrade.getDepositTx().getHashAsString()); transactionId.set(trade.getDepositTx().getHashAsString());
applyTakeOfferRequestResult(true); applyTakeOfferRequestResult(true);
break; break;
case FIAT_PAYMENT_STARTED: case FIAT_PAYMENT_STARTED:
break; break;
case TAKE_OFFER_FEE_PUBLISH_FAILED: case TAKE_OFFER_FEE_PUBLISH_FAILED:
errorMessage.set("An error occurred when paying the takerTrade fee." + msg); errorMessage.set("An error occurred when paying the trade fee." + msg);
takeOfferRequested = false; takeOfferRequested = false;
break; break;
case MESSAGE_SENDING_FAILED: case MESSAGE_SENDING_FAILED:
@ -293,7 +293,7 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
takeOfferRequested = false; takeOfferRequested = false;
break; break;
default: default:
log.warn("Unhandled takerTrade state: " + newValue); log.warn("Unhandled trade state: " + newValue);
break; break;
} }
} }

2
core/src/main/java/io/bitsquare/gui/util/Layout.java
View file

@ -20,7 +20,7 @@ package io.bitsquare.gui.util;
public class Layout { public class Layout {
public static final double FIRST_ROW_DISTANCE = 20d; public static final double FIRST_ROW_DISTANCE = 20d;
public static final double GROUP_DISTANCE = 40d; public static final double GROUP_DISTANCE = 40d;
public static final double FIRST_ROW_AND_GROUP_DISTANCE = GROUP_DISTANCE+FIRST_ROW_DISTANCE; public static final double FIRST_ROW_AND_GROUP_DISTANCE = GROUP_DISTANCE + FIRST_ROW_DISTANCE;
public static double PADDING_WINDOW = 20d; public static double PADDING_WINDOW = 20d;
public static double PADDING = 10d; public static double PADDING = 10d;
public static double SPACING_HBOX = 10d; public static double SPACING_HBOX = 10d;

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

@ -150,15 +150,15 @@ public class TradeManager {
// When all services are initialized we create the protocols for our open offers and persisted pendingTrades // When all services are initialized we create the protocols for our open offers and persisted pendingTrades
// OffererAsBuyerProtocol listens for take offer requests, so we need to instantiate it early. // OffererAsBuyerProtocol listens for take offer requests, so we need to instantiate it early.
public void onAllServicesInitialized() { public void onAllServicesInitialized() {
for (Trade offererTrade : openOfferTrades) { for (Trade trade : openOfferTrades) {
Offer offer = offererTrade.getOffer(); Offer offer = trade.getOffer();
// We add own offers to offerbook when we go online again // We add own offers to offerbook when we go online again
offerBookService.addOffer(offer, offerBookService.addOffer(offer,
() -> log.debug("Successful removed open offer from DHT"), () -> log.debug("Successful removed open offer from DHT"),
(message, throwable) -> log.error("Remove open offer from DHT failed. " + message)); (message, throwable) -> log.error("Remove open offer from DHT failed. " + message));
setupDepositPublishedListener(offererTrade); setupDepositPublishedListener(trade);
offererTrade.setStorage(openOfferTradesStorage); trade.setStorage(openOfferTradesStorage);
initTrade(offererTrade); initTrade(trade);
} }
List<Trade> failedTrades = new ArrayList<>(); List<Trade> failedTrades = new ArrayList<>();
@ -228,8 +228,8 @@ public class TradeManager {
log.debug("shutDown"); log.debug("shutDown");
shutDownRequested = true; shutDownRequested = true;
// we remove own offers form offerbook when we go offline // we remove own offers form offerbook when we go offline
for (Trade offererTrade : openOfferTrades) { for (Trade trade : openOfferTrades) {
Offer offer = offererTrade.getOffer(); Offer offer = trade.getOffer();
offerBookService.removeOfferAtShutDown(offer); offerBookService.removeOfferAtShutDown(offer);
} }
} }
@ -276,28 +276,28 @@ public class TradeManager {
} }
private void handlePlaceOfferResult(Transaction transaction, Offer offer, TransactionResultHandler resultHandler) { private void handlePlaceOfferResult(Transaction transaction, Offer offer, TransactionResultHandler resultHandler) {
Trade offererTrade; Trade trade;
if (offer.getDirection() == Offer.Direction.BUY) if (offer.getDirection() == Offer.Direction.BUY)
offererTrade = new OffererAsBuyerTrade(offer, openOfferTradesStorage); trade = new OffererAsBuyerTrade(offer, openOfferTradesStorage);
else else
offererTrade = new OffererAsSellerTrade(offer, openOfferTradesStorage); trade = new OffererAsSellerTrade(offer, openOfferTradesStorage);
openOfferTrades.add(offererTrade); openOfferTrades.add(trade);
initTrade(offererTrade); initTrade(trade);
setupDepositPublishedListener(offererTrade); setupDepositPublishedListener(trade);
resultHandler.handleResult(transaction); resultHandler.handleResult(transaction);
} }
private void setupDepositPublishedListener(Trade offererTrade) { private void setupDepositPublishedListener(Trade trade) {
offererTrade.processStateProperty().addListener((ov, oldValue, newValue) -> { trade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("setupDepositPublishedListener state = " + newValue); log.debug("setupDepositPublishedListener state = " + newValue);
if (newValue == OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED || newValue == OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED) { if (newValue == OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED || newValue == OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED) {
removeOpenOffer(offererTrade.getOffer(), removeOpenOffer(trade.getOffer(),
() -> log.debug("remove offer was successful"), () -> log.debug("remove offer was successful"),
log::error, log::error,
false); false);
pendingTrades.add(offererTrade); pendingTrades.add(trade);
offererTrade.setStorage(pendingTradesStorage); trade.setStorage(pendingTradesStorage);
} }
}); });
} }
@ -315,16 +315,16 @@ public class TradeManager {
offer.setState(Offer.State.REMOVED); offer.setState(Offer.State.REMOVED);
Optional<Trade> offererTradeOptional = openOfferTrades.stream().filter(e -> e.getId().equals(offer.getId())).findAny(); Optional<Trade> offererTradeOptional = openOfferTrades.stream().filter(e -> e.getId().equals(offer.getId())).findAny();
if (offererTradeOptional.isPresent()) { if (offererTradeOptional.isPresent()) {
Trade offererTrade = offererTradeOptional.get(); Trade trade = offererTradeOptional.get();
openOfferTrades.remove(offererTrade); openOfferTrades.remove(trade);
if (isCancelRequest) { if (isCancelRequest) {
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_CANCELED); trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_CANCELED);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_CANCELED); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_CANCELED);
closedTrades.add(offererTrade); closedTrades.add(trade);
offererTrade.disposeProtocol(); trade.disposeProtocol();
} }
} }
@ -377,16 +377,16 @@ public class TradeManager {
takeOfferResultHandler) { takeOfferResultHandler) {
disposeCheckOfferAvailabilityRequest(offer); disposeCheckOfferAvailabilityRequest(offer);
if (offer.getState() == Offer.State.AVAILABLE) { if (offer.getState() == Offer.State.AVAILABLE) {
Trade takerTrade; Trade trade;
if (offer.getDirection() == Offer.Direction.BUY) if (offer.getDirection() == Offer.Direction.BUY)
takerTrade = new TakerAsSellerTrade(offer, amount, model.getPeer(), pendingTradesStorage); trade = new TakerAsSellerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
else else
takerTrade = new TakerAsBuyerTrade(offer, amount, model.getPeer(), pendingTradesStorage); trade = new TakerAsBuyerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
initTrade(takerTrade); initTrade(trade);
pendingTrades.add(takerTrade); pendingTrades.add(trade);
takerTrade.takeAvailableOffer(); trade.takeAvailableOffer();
takeOfferResultHandler.handleResult(takerTrade); takeOfferResultHandler.handleResult(trade);
} }
} }

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

@ -29,21 +29,21 @@ import org.slf4j.LoggerFactory;
public class OffererCommitsPayoutTx extends OffererTradeTask { public class OffererCommitsPayoutTx extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCommitsPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(OffererCommitsPayoutTx.class);
public OffererCommitsPayoutTx(TaskRunner taskHandler, Trade offererTrade) { public OffererCommitsPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
Transaction transaction = processModel.getTradeWalletService().commitTx(offererTrade.getPayoutTx()); Transaction transaction = processModel.getTradeWalletService().commitTx(trade.getPayoutTx());
offererTrade.setPayoutTx(transaction); trade.setPayoutTx(transaction);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -29,20 +29,20 @@ import org.slf4j.LoggerFactory;
public class OffererCreatesAndSignPayoutTx extends OffererTradeTask { public class OffererCreatesAndSignPayoutTx extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignPayoutTx.class);
public OffererCreatesAndSignPayoutTx(TaskRunner taskHandler, Trade offererTrade) { public OffererCreatesAndSignPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
assert offererTrade.getTradeAmount() != null; assert trade.getTradeAmount() != null;
Coin securityDeposit = offererTrade.getSecurityDeposit(); Coin securityDeposit = trade.getSecurityDeposit();
Coin offererPayoutAmount = securityDeposit.add(offererTrade.getTradeAmount()); Coin offererPayoutAmount = securityDeposit.add(trade.getTradeAmount());
Coin takerPayoutAmount = securityDeposit; Coin takerPayoutAmount = securityDeposit;
byte[] offererPayoutTxSignature = processModel.getTradeWalletService().createAndSignPayoutTx( byte[] offererPayoutTxSignature = processModel.getTradeWalletService().createAndSignPayoutTx(
offererTrade.getDepositTx(), trade.getDepositTx(),
offererPayoutAmount, offererPayoutAmount,
takerPayoutAmount, takerPayoutAmount,
processModel.getAddressEntry(), processModel.getAddressEntry(),
@ -58,7 +58,7 @@ public class OffererCreatesAndSignPayoutTx extends OffererTradeTask {
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -33,15 +33,15 @@ import org.slf4j.LoggerFactory;
public class OffererCreatesDepositTxInputs extends OffererTradeTask { public class OffererCreatesDepositTxInputs extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesDepositTxInputs.class); private static final Logger log = LoggerFactory.getLogger(OffererCreatesDepositTxInputs.class);
public OffererCreatesDepositTxInputs(TaskRunner taskHandler, Trade offererTrade) { public OffererCreatesDepositTxInputs(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
log.debug("offererTrade.id" + offererTrade.getId()); log.debug("trade.id" + trade.getId());
Coin inputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE); Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
TradeWalletService.Result result = processModel.getTradeWalletService().createDepositTxInputs(inputAmount, TradeWalletService.Result result = processModel.getTradeWalletService().createDepositTxInputs(inputAmount,
processModel.getAddressEntry()); processModel.getAddressEntry());
@ -51,13 +51,13 @@ public class OffererCreatesDepositTxInputs extends OffererTradeTask {
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade) { if (trade instanceof OffererAsBuyerTrade) {
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
} }
else if (offererTrade instanceof OffererAsSellerTrade) { else if (trade instanceof OffererAsSellerTrade) {
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
} }
failed(t); failed(t);

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

@ -33,8 +33,8 @@ import static io.bitsquare.util.Validator.checkTradeId;
public class OffererProcessPayoutTxPublishedMessage extends OffererTradeTask { public class OffererProcessPayoutTxPublishedMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessPayoutTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessPayoutTxPublishedMessage.class);
public OffererProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -44,17 +44,17 @@ public class OffererProcessPayoutTxPublishedMessage extends OffererTradeTask {
checkTradeId(processModel.getId(), message); checkTradeId(processModel.getId(), message);
checkNotNull(message); checkNotNull(message);
offererTrade.setPayoutTx(checkNotNull(message.payoutTx)); trade.setPayoutTx(checkNotNull(message.payoutTx));
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(OffererAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(OffererAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -33,8 +33,8 @@ import static io.bitsquare.util.Validator.*;
public class OffererProcessRequestDepositTxInputsMessage extends OffererTradeTask { public class OffererProcessRequestDepositTxInputsMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestDepositTxInputsMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestDepositTxInputsMessage.class);
public OffererProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -44,19 +44,19 @@ public class OffererProcessRequestDepositTxInputsMessage extends OffererTradeTas
checkTradeId(processModel.getId(), message); checkTradeId(processModel.getId(), message);
checkNotNull(message); checkNotNull(message);
offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount))); trade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount)));
processModel.setTakeOfferFeeTxId(nonEmptyStringOf(message.takeOfferFeeTxId)); processModel.setTakeOfferFeeTxId(nonEmptyStringOf(message.takeOfferFeeTxId));
processModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.takerTradeWalletPubKey)); processModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.takerTradeWalletPubKey));
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }

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

@ -33,8 +33,8 @@ import static io.bitsquare.util.Validator.*;
public class OffererProcessRequestPublishDepositTxMessage extends OffererTradeTask { public class OffererProcessRequestPublishDepositTxMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestPublishDepositTxMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestPublishDepositTxMessage.class);
public OffererProcessRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererProcessRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -58,12 +58,12 @@ public class OffererProcessRequestPublishDepositTxMessage extends OffererTradeTa
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }

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

@ -31,16 +31,16 @@ import org.slf4j.LoggerFactory;
public class OffererSendsDepositTxPublishedMessage extends OffererTradeTask { public class OffererSendsDepositTxPublishedMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsDepositTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererSendsDepositTxPublishedMessage.class);
public OffererSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(processModel.getId(), offererTrade.getDepositTx()); DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(processModel.getId(), trade.getDepositTx());
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
log.trace("DepositTxPublishedMessage successfully arrived at peer"); log.trace("DepositTxPublishedMessage successfully arrived at peer");
@ -50,19 +50,19 @@ public class OffererSendsDepositTxPublishedMessage extends OffererTradeTask {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending DepositTxPublishedMessage failed"); appendToErrorMessage("Sending DepositTxPublishedMessage failed");
offererTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

26
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererSendsFiatTransferStartedMessage.java
View file

@ -31,8 +31,8 @@ import org.slf4j.LoggerFactory;
public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask { public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsFiatTransferStartedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererSendsFiatTransferStartedMessage.class);
public OffererSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -44,7 +44,7 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
processModel.tradingPeer.getPayoutAmount(), processModel.tradingPeer.getPayoutAmount(),
processModel.getAddressEntry().getAddressString()); processModel.getAddressEntry().getAddressString());
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage,
processModel.tradingPeer.getP2pSigPubKey(), processModel.tradingPeer.getP2pSigPubKey(),
processModel.tradingPeer.getP2pEncryptPubKey(), processModel.tradingPeer.getP2pEncryptPubKey(),
new SendMessageListener() { new SendMessageListener() {
@ -52,11 +52,11 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
public void handleResult() { public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded."); log.trace("Sending FiatTransferStartedMessage succeeded.");
if (offererTrade instanceof OffererAsBuyerTrade) { if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) offererTrade).setProcessState(OffererAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED); ((OffererAsBuyerTrade) trade).setProcessState(OffererAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
} }
else if (offererTrade instanceof OffererAsSellerTrade) { else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) offererTrade).setProcessState(OffererAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED); ((OffererAsSellerTrade) trade).setProcessState(OffererAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
} }
complete(); complete();
@ -65,13 +65,13 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending FiatTransferStartedMessage failed"); appendToErrorMessage("Sending FiatTransferStartedMessage failed");
offererTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (offererTrade instanceof OffererAsBuyerTrade) { if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) offererTrade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); ((OffererAsBuyerTrade) trade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
} }
else if (offererTrade instanceof OffererAsSellerTrade) { else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) offererTrade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); ((OffererAsSellerTrade) trade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
} }
failed(); failed();
@ -79,7 +79,7 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -31,8 +31,8 @@ import org.slf4j.LoggerFactory;
public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTradeTask { public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestSellerDepositPaymentMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestSellerDepositPaymentMessage.class);
public OffererSendsRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererSendsRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -48,7 +48,7 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
processModel.getFiatAccount(), processModel.getFiatAccount(),
processModel.getAccountId()); processModel.getAccountId());
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer"); log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer");
@ -58,14 +58,14 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed"); appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed");
offererTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (offererTrade instanceof OffererAsBuyerTrade) { if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) offererTrade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); ((OffererAsBuyerTrade) trade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsBuyerTrade) offererTrade).setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN); ((OffererAsBuyerTrade) trade).setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
} }
else if (offererTrade instanceof OffererAsSellerTrade) { else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) offererTrade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); ((OffererAsSellerTrade) trade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) offererTrade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); ((OffererAsSellerTrade) trade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
} }
failed(); failed();
@ -73,15 +73,15 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade) { if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) offererTrade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); ((OffererAsBuyerTrade) trade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) offererTrade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); ((OffererAsSellerTrade) trade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
} }
else if (offererTrade instanceof OffererAsSellerTrade) { else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) offererTrade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); ((OffererAsSellerTrade) trade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) offererTrade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); ((OffererAsSellerTrade) trade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
} }
failed(t); failed(t);

40
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererSignsAndPublishDepositTx.java
View file

@ -37,14 +37,14 @@ import org.slf4j.LoggerFactory;
public class OffererSignsAndPublishDepositTx extends OffererTradeTask { public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishDepositTx.class); private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishDepositTx.class);
public OffererSignsAndPublishDepositTx(TaskRunner taskHandler, Trade offererTrade) { public OffererSignsAndPublishDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
Coin inputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE); Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
processModel.getTradeWalletService().signAndPublishDepositTx( processModel.getTradeWalletService().signAndPublishDepositTx(
processModel.tradingPeer.getPreparedDepositTx(), processModel.tradingPeer.getPreparedDepositTx(),
@ -60,15 +60,15 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
log.trace("offererSignAndPublishTx succeeded " + transaction); log.trace("offererSignAndPublishTx succeeded " + transaction);
offererTrade.setDepositTx(transaction); trade.setDepositTx(transaction);
if (offererTrade instanceof OffererAsBuyerTrade) { if (trade instanceof OffererAsBuyerTrade) {
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.PENDING); trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.PENDING);
} }
else if (offererTrade instanceof OffererAsSellerTrade) { else if (trade instanceof OffererAsSellerTrade) {
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.PENDING); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.PENDING);
} }
complete(); complete();
@ -77,24 +77,24 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
@Override @Override
public void onFailure(@NotNull Throwable t) { public void onFailure(@NotNull Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }

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

@ -31,8 +31,8 @@ import org.slf4j.LoggerFactory;
public class OffererVerifiesAndSignsContract extends OffererTradeTask { public class OffererVerifiesAndSignsContract extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererVerifiesAndSignsContract.class); private static final Logger log = LoggerFactory.getLogger(OffererVerifiesAndSignsContract.class);
public OffererVerifiesAndSignsContract(TaskRunner taskHandler, Trade offererTrade) { public OffererVerifiesAndSignsContract(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -40,7 +40,7 @@ public class OffererVerifiesAndSignsContract extends OffererTradeTask {
try { try {
Contract contract = new Contract( Contract contract = new Contract(
processModel.getOffer(), processModel.getOffer(),
offererTrade.getTradeAmount(), trade.getTradeAmount(),
processModel.getTakeOfferFeeTxId(), processModel.getTakeOfferFeeTxId(),
processModel.getAccountId(), processModel.getAccountId(),
processModel.tradingPeer.getAccountId(), processModel.tradingPeer.getAccountId(),
@ -52,20 +52,20 @@ public class OffererVerifiesAndSignsContract extends OffererTradeTask {
String signature = processModel.getSignatureService().signMessage(processModel.getRegistrationKeyPair(), String signature = processModel.getSignatureService().signMessage(processModel.getRegistrationKeyPair(),
contractAsJson); contractAsJson);
offererTrade.setContract(contract); trade.setContract(contract);
offererTrade.setContractAsJson(contractAsJson); trade.setContractAsJson(contractAsJson);
offererTrade.setOffererContractSignature(signature); trade.setOffererContractSignature(signature);
offererTrade.setTakerContractSignature(processModel.tradingPeer.getContractSignature()); trade.setTakerContractSignature(processModel.tradingPeer.getContractSignature());
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }

6
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/BuyerAsTakerProtocol.java
View file

@ -60,10 +60,10 @@ public class BuyerAsTakerProtocol implements Protocol {
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public BuyerAsTakerProtocol(TakerAsBuyerTrade takerTrade) { public BuyerAsTakerProtocol(TakerAsBuyerTrade trade) {
log.debug("New SellerAsTakerProtocol " + this); log.debug("New SellerAsTakerProtocol " + this);
this.takerAsBuyerTrade = takerTrade; this.takerAsBuyerTrade = trade;
processModel = takerTrade.getProcessModel(); processModel = trade.getProcessModel();
messageHandler = this::handleMessage; messageHandler = this::handleMessage;
processModel.getMessageService().addMessageHandler(messageHandler); processModel.getMessageService().addMessageHandler(messageHandler);

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

@ -29,21 +29,21 @@ import org.slf4j.LoggerFactory;
public class TakerCommitsPayoutTx extends TakerTradeTask { public class TakerCommitsPayoutTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCommitsPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(TakerCommitsPayoutTx.class);
public TakerCommitsPayoutTx(TaskRunner taskHandler, Trade takerTrade) { public TakerCommitsPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
Transaction transaction = processModel.getTradeWalletService().commitTx(takerTrade.getPayoutTx()); Transaction transaction = processModel.getTradeWalletService().commitTx(trade.getPayoutTx());
takerTrade.setPayoutTx(transaction); trade.setPayoutTx(transaction);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -29,22 +29,22 @@ import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignsPayoutTx extends TakerTradeTask { public class TakerCreatesAndSignsPayoutTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsPayoutTx.class);
public TakerCreatesAndSignsPayoutTx(TaskRunner taskHandler, Trade takerTrade) { public TakerCreatesAndSignsPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
assert takerTrade.getTradeAmount() != null; assert trade.getTradeAmount() != null;
Coin securityDeposit = takerTrade.getSecurityDeposit(); Coin securityDeposit = trade.getSecurityDeposit();
Coin offererPayoutAmount = securityDeposit; Coin offererPayoutAmount = securityDeposit;
Coin takerPayoutAmount = securityDeposit.add(takerTrade.getTradeAmount()); Coin takerPayoutAmount = securityDeposit.add(trade.getTradeAmount());
byte[] takerPayoutTxSignature = processModel.getTradeWalletService().createAndSignPayoutTx( byte[] takerPayoutTxSignature = processModel.getTradeWalletService().createAndSignPayoutTx(
takerTrade.getDepositTx(), trade.getDepositTx(),
takerPayoutAmount, takerPayoutAmount,
offererPayoutAmount, offererPayoutAmount,
processModel.getAddressEntry(), processModel.getAddressEntry(),
@ -60,7 +60,7 @@ public class TakerCreatesAndSignsPayoutTx extends TakerTradeTask {
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -31,15 +31,15 @@ import org.slf4j.LoggerFactory;
public class TakerCreatesDepositTxInputs extends TakerTradeTask { public class TakerCreatesDepositTxInputs extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesDepositTxInputs.class); private static final Logger log = LoggerFactory.getLogger(TakerCreatesDepositTxInputs.class);
public TakerCreatesDepositTxInputs(TaskRunner taskHandler, Trade takerTrade) { public TakerCreatesDepositTxInputs(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
log.debug("takerTrade.id" + takerTrade.getId()); log.debug("trade.id" + trade.getId());
Coin inputAmount = takerTrade.getSecurityDeposit().add(FeePolicy.TX_FEE); Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
TradeWalletService.Result result = processModel.getTradeWalletService().createDepositTxInputs(inputAmount, TradeWalletService.Result result = processModel.getTradeWalletService().createDepositTxInputs(inputAmount,
processModel.getAddressEntry()); processModel.getAddressEntry());
@ -49,7 +49,7 @@ public class TakerCreatesDepositTxInputs extends TakerTradeTask {
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -33,8 +33,8 @@ import static io.bitsquare.util.Validator.checkTradeId;
public class TakerProcessPayoutTxPublishedMessage extends TakerTradeTask { public class TakerProcessPayoutTxPublishedMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerProcessPayoutTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerProcessPayoutTxPublishedMessage.class);
public TakerProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -44,17 +44,17 @@ public class TakerProcessPayoutTxPublishedMessage extends TakerTradeTask {
checkTradeId(processModel.getId(), message); checkTradeId(processModel.getId(), message);
checkNotNull(message); checkNotNull(message);
takerTrade.setPayoutTx(checkNotNull(message.payoutTx)); trade.setPayoutTx(checkNotNull(message.payoutTx));
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(TakerAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -31,8 +31,8 @@ import static io.bitsquare.util.Validator.*;
public class TakerProcessRequestPublishDepositTxFromTakerMessage extends TakerTradeTask { public class TakerProcessRequestPublishDepositTxFromTakerMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerProcessRequestPublishDepositTxFromTakerMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerProcessRequestPublishDepositTxFromTakerMessage.class);
public TakerProcessRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerProcessRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -58,7 +58,7 @@ public class TakerProcessRequestPublishDepositTxFromTakerMessage extends TakerTr
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }

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

@ -31,16 +31,16 @@ import org.slf4j.LoggerFactory;
public class TakerSendsDepositTxPublishedMessage extends TakerTradeTask { public class TakerSendsDepositTxPublishedMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsDepositTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsDepositTxPublishedMessage.class);
public TakerSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(processModel.getId(), takerTrade.getDepositTx()); DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(processModel.getId(), trade.getDepositTx());
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
log.trace("DepositTxPublishedMessage successfully arrived at peer"); log.trace("DepositTxPublishedMessage successfully arrived at peer");
@ -50,19 +50,19 @@ public class TakerSendsDepositTxPublishedMessage extends TakerTradeTask {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending DepositTxPublishedMessage failed"); appendToErrorMessage("Sending DepositTxPublishedMessage failed");
takerTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

26
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsFiatTransferStartedMessage.java
View file

@ -31,8 +31,8 @@ import org.slf4j.LoggerFactory;
public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask { public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsFiatTransferStartedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsFiatTransferStartedMessage.class);
public TakerSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -44,7 +44,7 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
processModel.tradingPeer.getPayoutAmount(), processModel.tradingPeer.getPayoutAmount(),
processModel.getAddressEntry().getAddressString()); processModel.getAddressEntry().getAddressString());
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage, processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage,
processModel.getP2pSigPubKey(), processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPubKey(), processModel.getP2pEncryptPubKey(),
new SendMessageListener() { new SendMessageListener() {
@ -52,11 +52,11 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
public void handleResult() { public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded."); log.trace("Sending FiatTransferStartedMessage succeeded.");
if (takerTrade instanceof TakerAsBuyerTrade) { if (trade instanceof TakerAsBuyerTrade) {
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
} }
else if (takerTrade instanceof TakerAsSellerTrade) { else if (trade instanceof TakerAsSellerTrade) {
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(TakerAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
} }
complete(); complete();
@ -65,13 +65,13 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending FiatTransferStartedMessage failed"); appendToErrorMessage("Sending FiatTransferStartedMessage failed");
takerTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade) { if (trade instanceof TakerAsBuyerTrade) {
((TakerAsBuyerTrade) takerTrade).setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); ((TakerAsBuyerTrade) trade).setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
} }
else if (takerTrade instanceof TakerAsSellerTrade) { else if (trade instanceof TakerAsSellerTrade) {
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
} }
failed(); failed();
@ -79,7 +79,7 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -33,8 +33,8 @@ import org.slf4j.LoggerFactory;
public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask { public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestDepositTxInputsMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestDepositTxInputsMessage.class);
public TakerSendsRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerSendsRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
private int retryCounter = 0; private int retryCounter = 0;
@ -46,10 +46,10 @@ public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask {
RequestDepositTxInputsMessage message = new RequestDepositTxInputsMessage( RequestDepositTxInputsMessage message = new RequestDepositTxInputsMessage(
processModel.getId(), processModel.getId(),
processModel.getTakeOfferFeeTx().getHashAsString(), processModel.getTakeOfferFeeTx().getHashAsString(),
takerTrade.getTradeAmount(), trade.getTradeAmount(),
processModel.getTradeWalletPubKey()); processModel.getTradeWalletPubKey());
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), message, new SendMessageListener() { processModel.getMessageService().sendMessage(trade.getTradingPeer(), message, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
log.trace("Sending TakeOfferFeePayedMessage succeeded."); log.trace("Sending TakeOfferFeePayedMessage succeeded.");
@ -70,12 +70,12 @@ public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask {
"lost or the offerer lost his connection. We persisted the state of the trade, please try again later " + "lost or the offerer lost his connection. We persisted the state of the trade, please try again later " +
"or cancel that trade."); "or cancel that trade.");
takerTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
@ -84,7 +84,7 @@ public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask {
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

26
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsRequestPayDepositMessage.java
View file

@ -31,8 +31,8 @@ import org.slf4j.LoggerFactory;
public class TakerSendsRequestPayDepositMessage extends TakerTradeTask { public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPayDepositMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPayDepositMessage.class);
public TakerSendsRequestPayDepositMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerSendsRequestPayDepositMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -49,7 +49,7 @@ public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
processModel.getFiatAccount(), processModel.getFiatAccount(),
processModel.getAccountId()); processModel.getAccountId());
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), message, new SendMessageListener() { processModel.getMessageService().sendMessage(trade.getTradingPeer(), message, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer"); log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer");
@ -59,24 +59,24 @@ public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed"); appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed");
takerTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
if (takerTrade instanceof TakerAsBuyerTrade) { if (trade instanceof TakerAsBuyerTrade) {
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
} }
else if (takerTrade instanceof TakerAsSellerTrade) { else if (trade instanceof TakerAsSellerTrade) {
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
} }
failed(t); failed(t);

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

@ -31,8 +31,8 @@ import org.slf4j.LoggerFactory;
public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask { public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPublishDepositTxMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPublishDepositTxMessage.class);
public TakerSendsRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerSendsRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -44,14 +44,14 @@ public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask {
processModel.getAccountId(), processModel.getAccountId(),
processModel.getP2pSigPubKey(), processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPublicKey(), processModel.getP2pEncryptPublicKey(),
takerTrade.getContractAsJson(), trade.getContractAsJson(),
takerTrade.getTakerContractSignature(), trade.getTakerContractSignature(),
processModel.getAddressEntry().getAddressString(), processModel.getAddressEntry().getAddressString(),
processModel.getPreparedDepositTx(), processModel.getPreparedDepositTx(),
processModel.getConnectedOutputsForAllInputs() processModel.getConnectedOutputsForAllInputs()
); );
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
complete(); complete();
@ -60,19 +60,19 @@ public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed"); appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed");
takerTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

24
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSignsAndPublishDepositTx.java
View file

@ -37,14 +37,14 @@ import org.slf4j.LoggerFactory;
public class TakerSignsAndPublishDepositTx extends TakerTradeTask { public class TakerSignsAndPublishDepositTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishDepositTx.class); private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishDepositTx.class);
public TakerSignsAndPublishDepositTx(TaskRunner taskHandler, Trade takerTrade) { public TakerSignsAndPublishDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
Coin inputAmount = takerTrade.getSecurityDeposit().add(FeePolicy.TX_FEE); Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
processModel.getTradeWalletService().signAndPublishDepositTx( processModel.getTradeWalletService().signAndPublishDepositTx(
processModel.tradingPeer.getPreparedDepositTx(), processModel.tradingPeer.getPreparedDepositTx(),
@ -60,15 +60,15 @@ public class TakerSignsAndPublishDepositTx extends TakerTradeTask {
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
log.trace("takerSignAndPublishTx succeeded " + transaction); log.trace("takerSignAndPublishTx succeeded " + transaction);
takerTrade.setDepositTx(transaction); trade.setDepositTx(transaction);
if (takerTrade instanceof TakerAsBuyerTrade) { if (trade instanceof TakerAsBuyerTrade) {
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
takerTrade.setLifeCycleState(TakerAsBuyerTrade.LifeCycleState.PENDING); trade.setLifeCycleState(TakerAsBuyerTrade.LifeCycleState.PENDING);
} }
else if (takerTrade instanceof TakerAsSellerTrade) { else if (trade instanceof TakerAsSellerTrade) {
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(TakerAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
takerTrade.setLifeCycleState(TakerAsSellerTrade.LifeCycleState.PENDING); trade.setLifeCycleState(TakerAsSellerTrade.LifeCycleState.PENDING);
} }
complete(); complete();
@ -77,13 +77,13 @@ public class TakerSignsAndPublishDepositTx extends TakerTradeTask {
@Override @Override
public void onFailure(@NotNull Throwable t) { public void onFailure(@NotNull Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -29,8 +29,8 @@ import org.slf4j.LoggerFactory;
public class TakerVerifiesAndSignsContract extends TakerTradeTask { public class TakerVerifiesAndSignsContract extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerVerifiesAndSignsContract.class); private static final Logger log = LoggerFactory.getLogger(TakerVerifiesAndSignsContract.class);
public TakerVerifiesAndSignsContract(TaskRunner taskHandler, Trade takerTrade) { public TakerVerifiesAndSignsContract(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -38,7 +38,7 @@ public class TakerVerifiesAndSignsContract extends TakerTradeTask {
try { try {
Contract contract = new Contract( Contract contract = new Contract(
processModel.getOffer(), processModel.getOffer(),
takerTrade.getTradeAmount(), trade.getTradeAmount(),
processModel.getTakeOfferFeeTx().getHashAsString(), processModel.getTakeOfferFeeTx().getHashAsString(),
processModel.tradingPeer.getAccountId(), processModel.tradingPeer.getAccountId(),
processModel.getAccountId(), processModel.getAccountId(),
@ -50,15 +50,15 @@ public class TakerVerifiesAndSignsContract extends TakerTradeTask {
String signature = processModel.getSignatureService().signMessage(processModel.getRegistrationKeyPair(), String signature = processModel.getSignatureService().signMessage(processModel.getRegistrationKeyPair(),
contractAsJson); contractAsJson);
takerTrade.setContract(contract); trade.setContract(contract);
takerTrade.setContractAsJson(contractAsJson); trade.setContractAsJson(contractAsJson);
takerTrade.setOffererContractSignature(signature); trade.setOffererContractSignature(signature);
takerTrade.setOffererContractSignature(processModel.tradingPeer.getContractSignature()); trade.setOffererContractSignature(processModel.tradingPeer.getContractSignature());
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }

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

@ -28,13 +28,13 @@ import org.slf4j.LoggerFactory;
public class OffererTradeTask extends Task<Trade> { public class OffererTradeTask extends Task<Trade> {
private static final Logger log = LoggerFactory.getLogger(OffererTradeTask.class); private static final Logger log = LoggerFactory.getLogger(OffererTradeTask.class);
protected final ProcessModel processModel; protected final ProcessModel processModel;
protected final Trade offererTrade; protected final Trade trade;
public OffererTradeTask(TaskRunner taskHandler, Trade offererTrade) { public OffererTradeTask(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
this.offererTrade = offererTrade; this.trade = trade;
processModel = offererTrade.getProcessModel(); processModel = trade.getProcessModel();
} }
@Override @Override

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

@ -29,22 +29,22 @@ import org.slf4j.LoggerFactory;
public class OffererCommitDepositTx extends OffererTradeTask { public class OffererCommitDepositTx extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCommitDepositTx.class); private static final Logger log = LoggerFactory.getLogger(OffererCommitDepositTx.class);
public OffererCommitDepositTx(TaskRunner taskHandler, Trade offererTrade) { public OffererCommitDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
// To access tx confidence we need to add that tx into our wallet. // To access tx confidence we need to add that tx into our wallet.
Transaction depositTx = processModel.getTradeWalletService().commitTx(offererTrade.getDepositTx()); Transaction depositTx = processModel.getTradeWalletService().commitTx(trade.getDepositTx());
offererTrade.setDepositTx(depositTx); trade.setDepositTx(depositTx);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

6
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererCreatesAndSignsContract.java
View file

@ -29,8 +29,8 @@ import org.slf4j.LoggerFactory;
public class OffererCreatesAndSignsContract extends OffererTradeTask { public class OffererCreatesAndSignsContract extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsContract.class); private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsContract.class);
public OffererCreatesAndSignsContract(TaskRunner taskHandler, Trade offererTrade) { public OffererCreatesAndSignsContract(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -58,7 +58,7 @@ public class OffererCreatesAndSignsContract extends OffererTradeTask {
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

12
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererCreatesAndSignsDepositTx.java
View file

@ -31,16 +31,16 @@ import org.slf4j.LoggerFactory;
public class OffererCreatesAndSignsDepositTx extends OffererTradeTask { public class OffererCreatesAndSignsDepositTx extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsDepositTx.class); private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsDepositTx.class);
public OffererCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade offererTrade) { public OffererCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
assert offererTrade.getTradeAmount() != null; assert trade.getTradeAmount() != null;
Coin inputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE).add(offererTrade.getTradeAmount()); Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE).add(trade.getTradeAmount());
Coin msOutputAmount = inputAmount.add(offererTrade.getSecurityDeposit()); Coin msOutputAmount = inputAmount.add(trade.getSecurityDeposit());
TradeWalletService.Result result = processModel.getTradeWalletService().createAndSignDepositTx( TradeWalletService.Result result = processModel.getTradeWalletService().createAndSignDepositTx(
inputAmount, inputAmount,
@ -59,7 +59,7 @@ public class OffererCreatesAndSignsDepositTx extends OffererTradeTask {
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -33,8 +33,8 @@ import static io.bitsquare.util.Validator.checkTradeId;
public class OffererProcessDepositTxPublishedMessage extends OffererTradeTask { public class OffererProcessDepositTxPublishedMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessDepositTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessDepositTxPublishedMessage.class);
public OffererProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -44,17 +44,17 @@ public class OffererProcessDepositTxPublishedMessage extends OffererTradeTask {
checkTradeId(processModel.getId(), message); checkTradeId(processModel.getId(), message);
checkNotNull(message); checkNotNull(message);
offererTrade.setDepositTx(checkNotNull(message.depositTx)); trade.setDepositTx(checkNotNull(message.depositTx));
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

14
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererProcessFiatTransferStartedMessage.java
View file

@ -33,8 +33,8 @@ import static io.bitsquare.util.Validator.*;
public class OffererProcessFiatTransferStartedMessage extends OffererTradeTask { public class OffererProcessFiatTransferStartedMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessFiatTransferStartedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessFiatTransferStartedMessage.class);
public OffererProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -49,15 +49,15 @@ public class OffererProcessFiatTransferStartedMessage extends OffererTradeTask {
processModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount))); processModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount)));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress)); processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(OffererAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(OffererAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

8
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererProcessRequestPayDepositFromOffererMessage.java
View file

@ -31,8 +31,8 @@ import static io.bitsquare.util.Validator.*;
public class OffererProcessRequestPayDepositFromOffererMessage extends OffererTradeTask { public class OffererProcessRequestPayDepositFromOffererMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestPayDepositFromOffererMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestPayDepositFromOffererMessage.class);
public OffererProcessRequestPayDepositFromOffererMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererProcessRequestPayDepositFromOffererMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -50,12 +50,12 @@ public class OffererProcessRequestPayDepositFromOffererMessage extends OffererTr
processModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.buyerP2PEncryptPublicKey)); processModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.buyerP2PEncryptPublicKey));
processModel.tradingPeer.setFiatAccount(checkNotNull(message.buyerFiatAccount)); processModel.tradingPeer.setFiatAccount(checkNotNull(message.buyerFiatAccount));
processModel.tradingPeer.setAccountId(nonEmptyStringOf(message.buyerAccountId)); processModel.tradingPeer.setAccountId(nonEmptyStringOf(message.buyerAccountId));
offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount))); trade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount)));
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -31,15 +31,15 @@ import org.slf4j.LoggerFactory;
public class OffererSendsPayoutTxPublishedMessage extends OffererTradeTask { public class OffererSendsPayoutTxPublishedMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsPayoutTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererSendsPayoutTxPublishedMessage.class);
public OffererSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(processModel.getId(), processModel.getPayoutTx()); PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(processModel.getId(), processModel.getPayoutTx());
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), processModel.getMessageService().sendMessage(trade.getTradingPeer(),
tradeMessage, tradeMessage,
processModel.getP2pSigPubKey(), processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPubKey(), processModel.getP2pEncryptPubKey(),
@ -53,19 +53,19 @@ public class OffererSendsPayoutTxPublishedMessage extends OffererTradeTask {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending PayoutTxPublishedMessage failed"); appendToErrorMessage("Sending PayoutTxPublishedMessage failed");
offererTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

22
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererSendsRequestPublishDepositTxFromTakerMessage.java
View file

@ -31,8 +31,8 @@ import org.slf4j.LoggerFactory;
public class OffererSendsRequestPublishDepositTxFromTakerMessage extends OffererTradeTask { public class OffererSendsRequestPublishDepositTxFromTakerMessage extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestPublishDepositTxFromTakerMessage.class); private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestPublishDepositTxFromTakerMessage.class);
public OffererSendsRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade offererTrade) { public OffererSendsRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -45,14 +45,14 @@ public class OffererSendsRequestPublishDepositTxFromTakerMessage extends Offerer
processModel.getTradeWalletPubKey(), processModel.getTradeWalletPubKey(),
processModel.getP2pSigPubKey(), processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPublicKey(), processModel.getP2pEncryptPublicKey(),
offererTrade.getContractAsJson(), trade.getContractAsJson(),
offererTrade.getOffererContractSignature(), trade.getOffererContractSignature(),
processModel.getAddressEntry().getAddressString(), processModel.getAddressEntry().getAddressString(),
processModel.getPreparedDepositTx(), processModel.getPreparedDepositTx(),
processModel.getConnectedOutputsForAllInputs() processModel.getConnectedOutputsForAllInputs()
); );
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() { processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override @Override
public void handleResult() { public void handleResult() {
complete(); complete();
@ -61,19 +61,19 @@ public class OffererSendsRequestPublishDepositTxFromTakerMessage extends Offerer
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed"); appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed");
offererTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -35,15 +35,15 @@ import org.slf4j.LoggerFactory;
public class OffererSignsAndPublishPayoutTx extends OffererTradeTask { public class OffererSignsAndPublishPayoutTx extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishPayoutTx.class);
public OffererSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade offererTrade) { public OffererSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
processModel.getTradeWalletService().signAndPublishPayoutTx( processModel.getTradeWalletService().signAndPublishPayoutTx(
offererTrade.getDepositTx(), trade.getDepositTx(),
processModel.tradingPeer.getSignature(), processModel.tradingPeer.getSignature(),
processModel.tradingPeer.getPayoutAmount(), processModel.tradingPeer.getPayoutAmount(),
processModel.getPayoutAmount(), processModel.getPayoutAmount(),
@ -57,10 +57,10 @@ public class OffererSignsAndPublishPayoutTx extends OffererTradeTask {
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
processModel.setPayoutTx(transaction); processModel.setPayoutTx(transaction);
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(OffererAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(OffererAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
complete(); complete();
} }
@ -68,13 +68,13 @@ public class OffererSignsAndPublishPayoutTx extends OffererTradeTask {
@Override @Override
public void onFailure(@NotNull Throwable t) { public void onFailure(@NotNull Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

6
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/SellerAsTakerProtocol.java
View file

@ -62,10 +62,10 @@ public class SellerAsTakerProtocol implements Protocol {
// Constructor // Constructor
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public SellerAsTakerProtocol(TakerAsSellerTrade takerTrade) { public SellerAsTakerProtocol(TakerAsSellerTrade trade) {
log.debug("New SellerAsTakerProtocol " + this); log.debug("New SellerAsTakerProtocol " + this);
this.takerAsSellerTrade = takerTrade; this.takerAsSellerTrade = trade;
processModel = takerTrade.getProcessModel(); processModel = trade.getProcessModel();
messageHandler = this::handleMessage; messageHandler = this::handleMessage;
processModel.getMessageService().addMessageHandler(messageHandler); processModel.getMessageService().addMessageHandler(messageHandler);

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

@ -29,22 +29,22 @@ import org.slf4j.LoggerFactory;
public class TakerCommitDepositTx extends TakerTradeTask { public class TakerCommitDepositTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCommitDepositTx.class); private static final Logger log = LoggerFactory.getLogger(TakerCommitDepositTx.class);
public TakerCommitDepositTx(TaskRunner taskHandler, Trade takerTrade) { public TakerCommitDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
// To access tx confidence we need to add that tx into our wallet. // To access tx confidence we need to add that tx into our wallet.
Transaction depositTx = processModel.getTradeWalletService().commitTx(takerTrade.getDepositTx()); Transaction depositTx = processModel.getTradeWalletService().commitTx(trade.getDepositTx());
takerTrade.setDepositTx(depositTx); trade.setDepositTx(depositTx);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -29,8 +29,8 @@ import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignContract extends TakerTradeTask { public class TakerCreatesAndSignContract extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignContract.class); private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignContract.class);
public TakerCreatesAndSignContract(TaskRunner taskHandler, Trade takerTrade) { public TakerCreatesAndSignContract(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -57,7 +57,7 @@ public class TakerCreatesAndSignContract extends TakerTradeTask {
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -31,16 +31,16 @@ import org.slf4j.LoggerFactory;
public class TakerCreatesAndSignsDepositTx extends TakerTradeTask { public class TakerCreatesAndSignsDepositTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsDepositTx.class); private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsDepositTx.class);
public TakerCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade takerTrade) { public TakerCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
assert takerTrade.getTradeAmount() != null; assert trade.getTradeAmount() != null;
Coin inputAmount = takerTrade.getSecurityDeposit().add(FeePolicy.TX_FEE).add(takerTrade.getTradeAmount()); Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE).add(trade.getTradeAmount());
Coin msOutputAmount = inputAmount.add(takerTrade.getSecurityDeposit()); Coin msOutputAmount = inputAmount.add(trade.getSecurityDeposit());
TradeWalletService.Result result = processModel.getTradeWalletService().createAndSignDepositTx( TradeWalletService.Result result = processModel.getTradeWalletService().createAndSignDepositTx(
inputAmount, inputAmount,
@ -58,7 +58,7 @@ public class TakerCreatesAndSignsDepositTx extends TakerTradeTask {
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -33,8 +33,8 @@ import static io.bitsquare.util.Validator.checkTradeId;
public class TakerProcessDepositTxPublishedMessage extends TakerTradeTask { public class TakerProcessDepositTxPublishedMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerProcessDepositTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerProcessDepositTxPublishedMessage.class);
public TakerProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -44,17 +44,17 @@ public class TakerProcessDepositTxPublishedMessage extends TakerTradeTask {
checkTradeId(processModel.getId(), message); checkTradeId(processModel.getId(), message);
checkNotNull(message); checkNotNull(message);
takerTrade.setDepositTx(checkNotNull(message.depositTx)); trade.setDepositTx(checkNotNull(message.depositTx));
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED); trade.setProcessState(TakerAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -33,8 +33,8 @@ import static io.bitsquare.util.Validator.*;
public class TakerProcessFiatTransferStartedMessage extends TakerTradeTask { public class TakerProcessFiatTransferStartedMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerProcessFiatTransferStartedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerProcessFiatTransferStartedMessage.class);
public TakerProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -49,15 +49,15 @@ public class TakerProcessFiatTransferStartedMessage extends TakerTradeTask {
processModel.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.sellerPayoutAmount))); processModel.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.sellerPayoutAmount)));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress)); processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED); trade.setProcessState(TakerAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -31,8 +31,8 @@ import static io.bitsquare.util.Validator.*;
public class TakerProcessRequestSellerDepositPaymentMessage extends TakerTradeTask { public class TakerProcessRequestSellerDepositPaymentMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerProcessRequestSellerDepositPaymentMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerProcessRequestSellerDepositPaymentMessage.class);
public TakerProcessRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerProcessRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -54,7 +54,7 @@ public class TakerProcessRequestSellerDepositPaymentMessage extends TakerTradeTa
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

18
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerSendsPayoutTxPublishedMessage.java
View file

@ -31,15 +31,15 @@ import org.slf4j.LoggerFactory;
public class TakerSendsPayoutTxPublishedMessage extends TakerTradeTask { public class TakerSendsPayoutTxPublishedMessage extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSendsPayoutTxPublishedMessage.class); private static final Logger log = LoggerFactory.getLogger(TakerSendsPayoutTxPublishedMessage.class);
public TakerSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade takerTrade) { public TakerSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(processModel.getId(), processModel.getPayoutTx()); PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(processModel.getId(), processModel.getPayoutTx());
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), processModel.getMessageService().sendMessage(trade.getTradingPeer(),
tradeMessage, tradeMessage,
processModel.tradingPeer.getP2pSigPubKey(), processModel.tradingPeer.getP2pSigPubKey(),
processModel.tradingPeer.getP2pEncryptPubKey(), processModel.tradingPeer.getP2pEncryptPubKey(),
@ -53,19 +53,19 @@ public class TakerSendsPayoutTxPublishedMessage extends TakerTradeTask {
@Override @Override
public void handleFault() { public void handleFault() {
appendToErrorMessage("Sending PayoutTxPublishedMessage failed"); appendToErrorMessage("Sending PayoutTxPublishedMessage failed");
takerTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED); trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed(); failed();
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

18
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerSignsAndPublishPayoutTx.java
View file

@ -35,15 +35,15 @@ import org.slf4j.LoggerFactory;
public class TakerSignsAndPublishPayoutTx extends TakerTradeTask { public class TakerSignsAndPublishPayoutTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishPayoutTx.class); private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishPayoutTx.class);
public TakerSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade takerTrade) { public TakerSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
protected void doRun() { protected void doRun() {
try { try {
processModel.getTradeWalletService().signAndPublishPayoutTx( processModel.getTradeWalletService().signAndPublishPayoutTx(
takerTrade.getDepositTx(), trade.getDepositTx(),
processModel.tradingPeer.getSignature(), processModel.tradingPeer.getSignature(),
processModel.tradingPeer.getPayoutAmount(), processModel.tradingPeer.getPayoutAmount(),
processModel.getPayoutAmount(), processModel.getPayoutAmount(),
@ -57,10 +57,10 @@ public class TakerSignsAndPublishPayoutTx extends TakerTradeTask {
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
processModel.setPayoutTx(transaction); processModel.setPayoutTx(transaction);
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.PAYOUT_PUBLISHED); trade.setProcessState(TakerAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
complete(); complete();
} }
@ -68,13 +68,13 @@ public class TakerSignsAndPublishPayoutTx extends TakerTradeTask {
@Override @Override
public void onFailure(@NotNull Throwable t) { public void onFailure(@NotNull Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -27,8 +27,8 @@ import org.slf4j.LoggerFactory;
public class VerifyTakeOfferFeePayment extends OffererTradeTask { public class VerifyTakeOfferFeePayment extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyTakeOfferFeePayment.class); private static final Logger log = LoggerFactory.getLogger(VerifyTakeOfferFeePayment.class);
public VerifyTakeOfferFeePayment(TaskRunner taskHandler, Trade offererTrade) { public VerifyTakeOfferFeePayment(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -43,7 +43,7 @@ public class VerifyTakeOfferFeePayment extends OffererTradeTask {
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -29,8 +29,8 @@ import org.slf4j.LoggerFactory;
public class VerifyTakerAccount extends OffererTradeTask { public class VerifyTakerAccount extends OffererTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyTakerAccount.class); private static final Logger log = LoggerFactory.getLogger(VerifyTakerAccount.class);
public VerifyTakerAccount(TaskRunner taskHandler, Trade offererTrade) { public VerifyTakerAccount(TaskRunner taskHandler, Trade trade) {
super(taskHandler, offererTrade); super(taskHandler, trade);
} }
@Override @Override
@ -52,19 +52,19 @@ public class VerifyTakerAccount extends OffererTradeTask {
else { else {
failed("Account registration validation for peer failed."); failed("Account registration validation for peer failed.");
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
} }
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
offererTrade.setThrowable(t); trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade) if (trade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade) else if (trade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN); trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
failed(t); failed(t);
} }

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

@ -35,8 +35,8 @@ import org.slf4j.LoggerFactory;
public class BroadcastTakeOfferFeeTx extends TakerTradeTask { public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(BroadcastTakeOfferFeeTx.class); private static final Logger log = LoggerFactory.getLogger(BroadcastTakeOfferFeeTx.class);
public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, Trade takerTrade) { public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -48,10 +48,10 @@ public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
public void onSuccess(Transaction transaction) { public void onSuccess(Transaction transaction) {
log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString()); log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString());
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISHED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISHED); trade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
complete(); complete();
} }
@ -59,19 +59,19 @@ public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
public void onFailure(@NotNull Throwable t) { public void onFailure(@NotNull Throwable t) {
t.printStackTrace(); t.printStackTrace();
appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again."); appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again.");
takerTrade.setErrorMessage(errorMessage); trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED); trade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
failed(t); failed(t);
} }
}); });
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -31,8 +31,8 @@ import org.slf4j.LoggerFactory;
public class CreateTakeOfferFeeTx extends TakerTradeTask { public class CreateTakeOfferFeeTx extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(CreateTakeOfferFeeTx.class); private static final Logger log = LoggerFactory.getLogger(CreateTakeOfferFeeTx.class);
public CreateTakeOfferFeeTx(TaskRunner taskHandler, Trade takerTrade) { public CreateTakeOfferFeeTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -42,15 +42,15 @@ public class CreateTakeOfferFeeTx extends TakerTradeTask {
processModel.setTakeOfferFeeTx(createTakeOfferFeeTx); processModel.setTakeOfferFeeTx(createTakeOfferFeeTx);
if (takerTrade instanceof TakerAsBuyerTrade) if (trade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_TX_CREATED); trade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
else if (takerTrade instanceof TakerAsSellerTrade) else if (trade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_TX_CREATED); trade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -27,8 +27,8 @@ import org.slf4j.LoggerFactory;
public class VerifyOfferFeePayment extends TakerTradeTask { public class VerifyOfferFeePayment extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyOfferFeePayment.class); private static final Logger log = LoggerFactory.getLogger(VerifyOfferFeePayment.class);
public VerifyOfferFeePayment(TaskRunner taskHandler, Trade takerTrade) { public VerifyOfferFeePayment(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -42,7 +42,7 @@ public class VerifyOfferFeePayment extends TakerTradeTask {
complete(); complete();
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -27,8 +27,8 @@ import org.slf4j.LoggerFactory;
public class VerifyOffererAccount extends TakerTradeTask { public class VerifyOffererAccount extends TakerTradeTask {
private static final Logger log = LoggerFactory.getLogger(VerifyOffererAccount.class); private static final Logger log = LoggerFactory.getLogger(VerifyOffererAccount.class);
public VerifyOffererAccount(TaskRunner taskHandler, Trade takerTrade) { public VerifyOffererAccount(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
} }
@Override @Override
@ -48,7 +48,7 @@ public class VerifyOffererAccount extends TakerTradeTask {
} }
} catch (Throwable t) { } catch (Throwable t) {
t.printStackTrace(); t.printStackTrace();
takerTrade.setThrowable(t); trade.setThrowable(t);
failed(t); failed(t);
} }
} }

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

@ -28,13 +28,13 @@ import org.slf4j.LoggerFactory;
public class TakerTradeTask extends Task<Trade> { public class TakerTradeTask extends Task<Trade> {
private static final Logger log = LoggerFactory.getLogger(TakerTradeTask.class); private static final Logger log = LoggerFactory.getLogger(TakerTradeTask.class);
protected final ProcessModel processModel; protected final ProcessModel processModel;
protected final Trade takerTrade; protected final Trade trade;
public TakerTradeTask(TaskRunner taskHandler, Trade takerTrade) { public TakerTradeTask(TaskRunner taskHandler, Trade trade) {
super(taskHandler, takerTrade); super(taskHandler, trade);
this.takerTrade = takerTrade; this.trade = trade;
processModel = takerTrade.getProcessModel(); processModel = trade.getProcessModel();
} }
@Override @Override