Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-04-20 23:56:30 -04:00
Code Issues Packages Projects Releases 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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
core/src/main/java/io/bitsquare/app/BitsquareEnvironment.java
View File

@ -127,21 +127,22 @@ public class BitsquareEnvironment extends StandardEnvironment {
private static final long serialVersionUID = -8478089705207326165L;
{
setProperty(APP_DATA_DIR_KEY, appDataDir);
setProperty(APP_DATA_DIR_CLEAN_KEY, DEFAULT_APP_DATA_DIR_CLEAN);
setProperty(APP_DATA_DIR_KEY, appDataDir);
setProperty(APP_DATA_DIR_CLEAN_KEY, DEFAULT_APP_DATA_DIR_CLEAN);
setProperty(APP_NAME_KEY, appName);
setProperty(APP_NAME_KEY, appName);
setProperty(UserAgent.NAME_KEY, appName);
setProperty(UserAgent.VERSION_KEY, BitsquareAppMain.getVersion());
setProperty(UserAgent.NAME_KEY, appName);
setProperty(UserAgent.VERSION_KEY, BitsquareAppMain.getVersion());
setProperty(WalletService.DIR_KEY, appDataDir);
setProperty(WalletService.PREFIX_KEY, appName);
setProperty(WalletService.DIR_KEY, appDataDir);
setProperty(WalletService.PREFIX_KEY, appName);
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);
}
});
}

2
core/src/main/java/io/bitsquare/gui/SystemTray.java
View File

@ -55,7 +55,7 @@ public class SystemTray {
private final MenuItem toggleShowHideItem = new MenuItem(HIDE_WINDOW_LABEL);
public static void create(Stage stage, Runnable onExit) {
systemTray = new SystemTray(stage, onExit);
systemTray = new SystemTray(stage, onExit);
}
public SystemTray(Stage stage, Runnable onExit) {

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

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

2
core/src/main/java/io/bitsquare/gui/main/account/AccountView.java
View File

@ -118,7 +118,7 @@ public class AccountView extends ActivatableView<TabPane, AccountViewModel> {
}
// for IRC demo we deactivate the arbitratorSettingsTab
// arbitratorSettingsTab.setDisable(true);
// arbitratorSettingsTab.setDisable(true);
tab.setContent(view.getRoot());
root.getSelectionModel().select(tab);

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.OffererProcessRequestDepositTxInputsMessage;
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.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.OffererVerifiesAndSignsContract;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakeOfferFeePayment;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakerAccount;
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.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.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.TakerProcessFiatTransferStartedMessage;
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.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.TakerCommitDepositTx;
import io.bitsquare.trade.protocol.trade.seller.taker.tasks.TakerCreatesAndSignsDepositTx;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakeOfferFeePayment;
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.VerifyOffererAccount;

2
core/src/main/java/io/bitsquare/gui/main/portfolio/PortfolioView.java
View File

@ -76,7 +76,7 @@ public class PortfolioView extends ActivatableViewAndModel<TabPane, Activatable>
root.getSelectionModel().selectedItemProperty().addListener(tabChangeListener);
navigation.addListener(navigationListener);
// navigation.navigateTo(MainView.class, PortfolioView.class, PendingTradesView.class);
// navigation.navigateTo(MainView.class, PortfolioView.class, PendingTradesView.class);
/* if (tradeManager.getPendingTrades().size() == 0)
navigation.navigateTo(MainView.class, PortfolioView.class, OffersView.class);

5
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/TradeSubView.java
View File

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

4
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/steps/ConfirmFiatReceivedView.java
View File

@ -54,7 +54,7 @@ public class ConfirmFiatReceivedView extends TradeStepDetailsView {
public void activate() {
super.activate();
model.txId.addListener(txIdChangeListener);
model.txId.addListener(txIdChangeListener);
txIdTextField.setup(model.getWalletService(), model.txId.get());
}
@ -62,7 +62,7 @@ public class ConfirmFiatReceivedView extends TradeStepDetailsView {
public void deactivate() {
super.deactivate();
model.txId.removeListener(txIdChangeListener);
model.txId.removeListener(txIdChangeListener);
txIdTextField.cleanup();
}

2
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/steps/WaitFiatReceivedView.java
View File

@ -36,7 +36,7 @@ public class WaitFiatReceivedView extends TradeStepDetailsView {
private TxIdTextField txIdTextField;
private Label infoLabel;
private InfoDisplay infoDisplay;
private final ChangeListener<String> txIdChangeListener;
private final ChangeListener<String> txIdChangeListener;
///////////////////////////////////////////////////////////////////////////////////////////

2
core/src/main/java/io/bitsquare/gui/main/trade/createoffer/CreateOfferView.fxml
View File

@ -51,7 +51,7 @@
<Insets bottom="10.0" left="10.0" right="10.0" top="20.0"/>
</GridPane.margin>
<ImageView fx:id="imageView" pickOnBounds="true"/>
<Label fx:id="buyLabel" id="direction-icon-label"
<Label fx:id="buyLabel" id="direction-icon-label"
alignment="CENTER">
<padding>
<Insets top="-5.0"/>

4
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
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) {
directionLabel.set(BSResources.get("shared.buyBitcoin"));
@ -427,7 +427,7 @@ class CreateOfferViewModel extends ActivatableWithDataModel<CreateOfferDataModel
return fiatValidator.validate(input);
}
boolean isSeller() {
boolean isSeller() {
return dataModel.getDirection() == Offer.Direction.SELL;
}
}

2
core/src/main/java/io/bitsquare/gui/main/trade/takeoffer/TakeOfferDataModel.java
View File

@ -108,7 +108,7 @@ class TakeOfferDataModel implements Activatable, DataModel {
else {
amountAsCoin.set(offer.getAmount());
}
calculateVolume();
calculateTotalToPay();

8
core/src/main/java/io/bitsquare/gui/main/trade/takeoffer/TakeOfferView.java
View File

@ -293,8 +293,8 @@ public class TakeOfferView extends ActivatableViewAndModel<AnchorPane, TakeOffer
totalToPayTextField.textProperty().bind(model.totalToPay);
addressTextField.amountAsCoinProperty().bind(model.totalToPayAsCoin);
amountDescriptionLabel.textProperty().bind(model.amountDescription);
// Validation
amountTextField.validationResultProperty().bind(model.amountValidationResult);
@ -442,8 +442,8 @@ public class TakeOfferView extends ActivatableViewAndModel<AnchorPane, TakeOffer
BSResources.get("takeOffer.fundsBox.amount"),
model.getAmount());
}
addPayInfoEntry(infoGridPane, i++,
BSResources.get("takeOffer.fundsBox.securityDeposit"),
model.securityDeposit.get());

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);
dataModel.takeOffer((takerTrade) -> {
takerTrade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("takerTrade state = " + newValue);
dataModel.takeOffer((trade) -> {
trade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("trade state = " + newValue);
String msg = "";
if (takerTrade.getErrorMessage() != null)
msg = "\nError message: " + takerTrade.getErrorMessage();
if (trade.getErrorMessage() != null)
msg = "\nError message: " + trade.getErrorMessage();
if (takerTrade instanceof TakerAsBuyerTrade) {
if (trade instanceof TakerAsBuyerTrade) {
switch ((TakerAsBuyerTrade.ProcessState) newValue) {
case TAKE_OFFER_FEE_TX_CREATED:
break;
case DEPOSIT_PUBLISHED:
case DEPOSIT_CONFIRMED:
assert takerTrade.getDepositTx() != null;
transactionId.set(takerTrade.getDepositTx().getHashAsString());
assert trade.getDepositTx() != null;
transactionId.set(trade.getDepositTx().getHashAsString());
applyTakeOfferRequestResult(true);
break;
case FIAT_PAYMENT_STARTED:
break;
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;
break;
case MESSAGE_SENDING_FAILED:
@ -261,24 +261,24 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
takeOfferRequested = false;
break;
default:
log.warn("Unhandled takerTrade state: " + newValue);
log.warn("Unhandled trade state: " + newValue);
break;
}
}
else if (takerTrade instanceof TakerAsSellerTrade) {
else if (trade instanceof TakerAsSellerTrade) {
switch ((TakerAsSellerTrade.ProcessState) newValue) {
case TAKE_OFFER_FEE_TX_CREATED:
break;
case DEPOSIT_PUBLISHED:
case DEPOSIT_CONFIRMED:
assert takerTrade.getDepositTx() != null;
transactionId.set(takerTrade.getDepositTx().getHashAsString());
assert trade.getDepositTx() != null;
transactionId.set(trade.getDepositTx().getHashAsString());
applyTakeOfferRequestResult(true);
break;
case FIAT_PAYMENT_STARTED:
break;
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;
break;
case MESSAGE_SENDING_FAILED:
@ -293,7 +293,7 @@ class TakeOfferViewModel extends ActivatableWithDataModel<TakeOfferDataModel> im
takeOfferRequested = false;
break;
default:
log.warn("Unhandled takerTrade state: " + newValue);
log.warn("Unhandled trade state: " + newValue);
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 static final double FIRST_ROW_DISTANCE = 20d;
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 = 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
// OffererAsBuyerProtocol listens for take offer requests, so we need to instantiate it early.
public void onAllServicesInitialized() {
for (Trade offererTrade : openOfferTrades) {
Offer offer = offererTrade.getOffer();
for (Trade trade : openOfferTrades) {
Offer offer = trade.getOffer();
// We add own offers to offerbook when we go online again
offerBookService.addOffer(offer,
() -> log.debug("Successful removed open offer from DHT"),
(message, throwable) -> log.error("Remove open offer from DHT failed. " + message));
setupDepositPublishedListener(offererTrade);
offererTrade.setStorage(openOfferTradesStorage);
initTrade(offererTrade);
setupDepositPublishedListener(trade);
trade.setStorage(openOfferTradesStorage);
initTrade(trade);
}
List<Trade> failedTrades = new ArrayList<>();
@ -228,8 +228,8 @@ public class TradeManager {
log.debug("shutDown");
shutDownRequested = true;
// we remove own offers form offerbook when we go offline
for (Trade offererTrade : openOfferTrades) {
Offer offer = offererTrade.getOffer();
for (Trade trade : openOfferTrades) {
Offer offer = trade.getOffer();
offerBookService.removeOfferAtShutDown(offer);
}
}
@ -276,28 +276,28 @@ public class TradeManager {
}
private void handlePlaceOfferResult(Transaction transaction, Offer offer, TransactionResultHandler resultHandler) {
Trade offererTrade;
Trade trade;
if (offer.getDirection() == Offer.Direction.BUY)
offererTrade = new OffererAsBuyerTrade(offer, openOfferTradesStorage);
trade = new OffererAsBuyerTrade(offer, openOfferTradesStorage);
else
offererTrade = new OffererAsSellerTrade(offer, openOfferTradesStorage);
trade = new OffererAsSellerTrade(offer, openOfferTradesStorage);
openOfferTrades.add(offererTrade);
initTrade(offererTrade);
setupDepositPublishedListener(offererTrade);
openOfferTrades.add(trade);
initTrade(trade);
setupDepositPublishedListener(trade);
resultHandler.handleResult(transaction);
}
private void setupDepositPublishedListener(Trade offererTrade) {
offererTrade.processStateProperty().addListener((ov, oldValue, newValue) -> {
private void setupDepositPublishedListener(Trade trade) {
trade.processStateProperty().addListener((ov, oldValue, newValue) -> {
log.debug("setupDepositPublishedListener state = " + newValue);
if (newValue == OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED || newValue == OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED) {
removeOpenOffer(offererTrade.getOffer(),
removeOpenOffer(trade.getOffer(),
() -> log.debug("remove offer was successful"),
log::error,
false);
pendingTrades.add(offererTrade);
offererTrade.setStorage(pendingTradesStorage);
pendingTrades.add(trade);
trade.setStorage(pendingTradesStorage);
}
});
}
@ -315,16 +315,16 @@ public class TradeManager {
offer.setState(Offer.State.REMOVED);
Optional<Trade> offererTradeOptional = openOfferTrades.stream().filter(e -> e.getId().equals(offer.getId())).findAny();
if (offererTradeOptional.isPresent()) {
Trade offererTrade = offererTradeOptional.get();
openOfferTrades.remove(offererTrade);
Trade trade = offererTradeOptional.get();
openOfferTrades.remove(trade);
if (isCancelRequest) {
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_CANCELED);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_CANCELED);
closedTrades.add(offererTrade);
offererTrade.disposeProtocol();
if (trade instanceof OffererAsBuyerTrade)
trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_CANCELED);
else if (trade instanceof OffererAsSellerTrade)
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_CANCELED);
closedTrades.add(trade);
trade.disposeProtocol();
}
}
@ -377,16 +377,16 @@ public class TradeManager {
takeOfferResultHandler) {
disposeCheckOfferAvailabilityRequest(offer);
if (offer.getState() == Offer.State.AVAILABLE) {
Trade takerTrade;
Trade trade;
if (offer.getDirection() == Offer.Direction.BUY)
takerTrade = new TakerAsSellerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
trade = new TakerAsSellerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
else
takerTrade = new TakerAsBuyerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
trade = new TakerAsBuyerTrade(offer, amount, model.getPeer(), pendingTradesStorage);
initTrade(takerTrade);
pendingTrades.add(takerTrade);
takerTrade.takeAvailableOffer();
takeOfferResultHandler.handleResult(takerTrade);
initTrade(trade);
pendingTrades.add(trade);
trade.takeAvailableOffer();
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 {
private static final Logger log = LoggerFactory.getLogger(OffererCommitsPayoutTx.class);
public OffererCommitsPayoutTx(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererCommitsPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
Transaction transaction = processModel.getTradeWalletService().commitTx(offererTrade.getPayoutTx());
Transaction transaction = processModel.getTradeWalletService().commitTx(trade.getPayoutTx());
offererTrade.setPayoutTx(transaction);
trade.setPayoutTx(transaction);
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignPayoutTx.class);
public OffererCreatesAndSignPayoutTx(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererCreatesAndSignPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
assert offererTrade.getTradeAmount() != null;
Coin securityDeposit = offererTrade.getSecurityDeposit();
Coin offererPayoutAmount = securityDeposit.add(offererTrade.getTradeAmount());
assert trade.getTradeAmount() != null;
Coin securityDeposit = trade.getSecurityDeposit();
Coin offererPayoutAmount = securityDeposit.add(trade.getTradeAmount());
Coin takerPayoutAmount = securityDeposit;
byte[] offererPayoutTxSignature = processModel.getTradeWalletService().createAndSignPayoutTx(
offererTrade.getDepositTx(),
trade.getDepositTx(),
offererPayoutAmount,
takerPayoutAmount,
processModel.getAddressEntry(),
@ -58,7 +58,7 @@ public class OffererCreatesAndSignPayoutTx extends OffererTradeTask {
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesDepositTxInputs.class);
public OffererCreatesDepositTxInputs(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererCreatesDepositTxInputs(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
log.debug("offererTrade.id" + offererTrade.getId());
Coin inputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
log.debug("trade.id" + trade.getId());
Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
TradeWalletService.Result result = processModel.getTradeWalletService().createDepositTxInputs(inputAmount,
processModel.getAddressEntry());
@ -51,13 +51,13 @@ public class OffererCreatesDepositTxInputs extends OffererTradeTask {
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade) {
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
if (trade instanceof OffererAsBuyerTrade) {
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
}
else if (offererTrade instanceof OffererAsSellerTrade) {
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade) {
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
}
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 {
private static final Logger log = LoggerFactory.getLogger(OffererProcessPayoutTxPublishedMessage.class);
public OffererProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -44,17 +44,17 @@ public class OffererProcessPayoutTxPublishedMessage extends OffererTradeTask {
checkTradeId(processModel.getId(), message);
checkNotNull(message);
offererTrade.setPayoutTx(checkNotNull(message.payoutTx));
trade.setPayoutTx(checkNotNull(message.payoutTx));
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
if (trade instanceof OffererAsBuyerTrade)
trade.setProcessState(OffererAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof OffererAsSellerTrade)
trade.setProcessState(OffererAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestDepositTxInputsMessage.class);
public OffererProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererProcessRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -44,19 +44,19 @@ public class OffererProcessRequestDepositTxInputsMessage extends OffererTradeTas
checkTradeId(processModel.getId(), message);
checkNotNull(message);
offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount)));
trade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount)));
processModel.setTakeOfferFeeTxId(nonEmptyStringOf(message.takeOfferFeeTxId));
processModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.takerTradeWalletPubKey));
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
if (trade instanceof OffererAsBuyerTrade)
trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
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 {
private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestPublishDepositTxMessage.class);
public OffererProcessRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererProcessRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -58,12 +58,12 @@ public class OffererProcessRequestPublishDepositTxMessage extends OffererTradeTa
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
if (trade instanceof OffererAsBuyerTrade)
trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
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 {
private static final Logger log = LoggerFactory.getLogger(OffererSendsDepositTxPublishedMessage.class);
public OffererSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
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
public void handleResult() {
log.trace("DepositTxPublishedMessage successfully arrived at peer");
@ -50,19 +50,19 @@ public class OffererSendsDepositTxPublishedMessage extends OffererTradeTask {
@Override
public void handleFault() {
appendToErrorMessage("Sending DepositTxPublishedMessage failed");
offererTrade.setErrorMessage(errorMessage);
trade.setErrorMessage(errorMessage);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof OffererAsBuyerTrade)
trade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof OffererAsSellerTrade)
trade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererSendsFiatTransferStartedMessage.class);
public OffererSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -44,7 +44,7 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
processModel.tradingPeer.getPayoutAmount(),
processModel.getAddressEntry().getAddressString());
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage,
processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage,
processModel.tradingPeer.getP2pSigPubKey(),
processModel.tradingPeer.getP2pEncryptPubKey(),
new SendMessageListener() {
@ -52,11 +52,11 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded.");
if (offererTrade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) offererTrade).setProcessState(OffererAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
}
else if (offererTrade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) offererTrade).setProcessState(OffererAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
}
complete();
@ -65,13 +65,13 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
@Override
public void handleFault() {
appendToErrorMessage("Sending FiatTransferStartedMessage failed");
offererTrade.setErrorMessage(errorMessage);
trade.setErrorMessage(errorMessage);
if (offererTrade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) offererTrade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
}
else if (offererTrade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) offererTrade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
}
failed();
@ -79,7 +79,7 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
});
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestSellerDepositPaymentMessage.class);
public OffererSendsRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererSendsRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -48,7 +48,7 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
processModel.getFiatAccount(),
processModel.getAccountId());
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer");
@ -58,14 +58,14 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
@Override
public void handleFault() {
appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed");
offererTrade.setErrorMessage(errorMessage);
if (offererTrade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) offererTrade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsBuyerTrade) offererTrade).setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
trade.setErrorMessage(errorMessage);
if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsBuyerTrade) trade).setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
}
else if (offererTrade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) offererTrade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) offererTrade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) trade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
}
failed();
@ -73,15 +73,15 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
});
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) offererTrade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) offererTrade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
if (trade instanceof OffererAsBuyerTrade) {
((OffererAsBuyerTrade) trade).setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) trade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
}
else if (offererTrade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) offererTrade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) offererTrade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade) {
((OffererAsSellerTrade) trade).setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
((OffererAsSellerTrade) trade).setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
}
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 {
private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishDepositTx.class);
public OffererSignsAndPublishDepositTx(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererSignsAndPublishDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
Coin inputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
processModel.getTradeWalletService().signAndPublishDepositTx(
processModel.tradingPeer.getPreparedDepositTx(),
@ -60,15 +60,15 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
public void onSuccess(Transaction transaction) {
log.trace("offererSignAndPublishTx succeeded " + transaction);
offererTrade.setDepositTx(transaction);
trade.setDepositTx(transaction);
if (offererTrade instanceof OffererAsBuyerTrade) {
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.PENDING);
if (trade instanceof OffererAsBuyerTrade) {
trade.setProcessState(OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.PENDING);
}
else if (offererTrade instanceof OffererAsSellerTrade) {
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.PENDING);
else if (trade instanceof OffererAsSellerTrade) {
trade.setProcessState(OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.PENDING);
}
complete();
@ -77,24 +77,24 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
@Override
public void onFailure(@NotNull Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
if (trade instanceof OffererAsBuyerTrade)
trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
failed(t);
}
});
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
if (trade instanceof OffererAsBuyerTrade)
trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
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 {
private static final Logger log = LoggerFactory.getLogger(OffererVerifiesAndSignsContract.class);
public OffererVerifiesAndSignsContract(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererVerifiesAndSignsContract(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -40,7 +40,7 @@ public class OffererVerifiesAndSignsContract extends OffererTradeTask {
try {
Contract contract = new Contract(
processModel.getOffer(),
offererTrade.getTradeAmount(),
trade.getTradeAmount(),
processModel.getTakeOfferFeeTxId(),
processModel.getAccountId(),
processModel.tradingPeer.getAccountId(),
@ -52,20 +52,20 @@ public class OffererVerifiesAndSignsContract extends OffererTradeTask {
String signature = processModel.getSignatureService().signMessage(processModel.getRegistrationKeyPair(),
contractAsJson);
offererTrade.setContract(contract);
offererTrade.setContractAsJson(contractAsJson);
offererTrade.setOffererContractSignature(signature);
offererTrade.setTakerContractSignature(processModel.tradingPeer.getContractSignature());
trade.setContract(contract);
trade.setContractAsJson(contractAsJson);
trade.setOffererContractSignature(signature);
trade.setTakerContractSignature(processModel.tradingPeer.getContractSignature());
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
if (trade instanceof OffererAsBuyerTrade)
trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
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
///////////////////////////////////////////////////////////////////////////////////////////
public BuyerAsTakerProtocol(TakerAsBuyerTrade takerTrade) {
public BuyerAsTakerProtocol(TakerAsBuyerTrade trade) {
log.debug("New SellerAsTakerProtocol " + this);
this.takerAsBuyerTrade = takerTrade;
processModel = takerTrade.getProcessModel();
this.takerAsBuyerTrade = trade;
processModel = trade.getProcessModel();
messageHandler = this::handleMessage;
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 {
private static final Logger log = LoggerFactory.getLogger(TakerCommitsPayoutTx.class);
public TakerCommitsPayoutTx(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerCommitsPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
Transaction transaction = processModel.getTradeWalletService().commitTx(takerTrade.getPayoutTx());
Transaction transaction = processModel.getTradeWalletService().commitTx(trade.getPayoutTx());
takerTrade.setPayoutTx(transaction);
trade.setPayoutTx(transaction);
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsPayoutTx.class);
public TakerCreatesAndSignsPayoutTx(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerCreatesAndSignsPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
assert takerTrade.getTradeAmount() != null;
Coin securityDeposit = takerTrade.getSecurityDeposit();
assert trade.getTradeAmount() != null;
Coin securityDeposit = trade.getSecurityDeposit();
Coin offererPayoutAmount = securityDeposit;
Coin takerPayoutAmount = securityDeposit.add(takerTrade.getTradeAmount());
Coin takerPayoutAmount = securityDeposit.add(trade.getTradeAmount());
byte[] takerPayoutTxSignature = processModel.getTradeWalletService().createAndSignPayoutTx(
takerTrade.getDepositTx(),
trade.getDepositTx(),
takerPayoutAmount,
offererPayoutAmount,
processModel.getAddressEntry(),
@ -60,7 +60,7 @@ public class TakerCreatesAndSignsPayoutTx extends TakerTradeTask {
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesDepositTxInputs.class);
public TakerCreatesDepositTxInputs(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerCreatesDepositTxInputs(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
log.debug("takerTrade.id" + takerTrade.getId());
Coin inputAmount = takerTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
log.debug("trade.id" + trade.getId());
Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
TradeWalletService.Result result = processModel.getTradeWalletService().createDepositTxInputs(inputAmount,
processModel.getAddressEntry());
@ -49,7 +49,7 @@ public class TakerCreatesDepositTxInputs extends TakerTradeTask {
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerProcessPayoutTxPublishedMessage.class);
public TakerProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerProcessPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -44,17 +44,17 @@ public class TakerProcessPayoutTxPublishedMessage extends TakerTradeTask {
checkTradeId(processModel.getId(), message);
checkNotNull(message);
takerTrade.setPayoutTx(checkNotNull(message.payoutTx));
trade.setPayoutTx(checkNotNull(message.payoutTx));
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerProcessRequestPublishDepositTxFromTakerMessage.class);
public TakerProcessRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerProcessRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -58,7 +58,7 @@ public class TakerProcessRequestPublishDepositTxFromTakerMessage extends TakerTr
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerSendsDepositTxPublishedMessage.class);
public TakerSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerSendsDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
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
public void handleResult() {
log.trace("DepositTxPublishedMessage successfully arrived at peer");
@ -50,19 +50,19 @@ public class TakerSendsDepositTxPublishedMessage extends TakerTradeTask {
@Override
public void handleFault() {
appendToErrorMessage("Sending DepositTxPublishedMessage failed");
takerTrade.setErrorMessage(errorMessage);
trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerSendsFiatTransferStartedMessage.class);
public TakerSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerSendsFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -44,7 +44,7 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
processModel.tradingPeer.getPayoutAmount(),
processModel.getAddressEntry().getAddressString());
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage,
processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage,
processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPubKey(),
new SendMessageListener() {
@ -52,11 +52,11 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
public void handleResult() {
log.trace("Sending FiatTransferStartedMessage succeeded.");
if (takerTrade instanceof TakerAsBuyerTrade) {
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
if (trade instanceof TakerAsBuyerTrade) {
trade.setProcessState(TakerAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
}
else if (takerTrade instanceof TakerAsSellerTrade) {
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
else if (trade instanceof TakerAsSellerTrade) {
trade.setProcessState(TakerAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
}
complete();
@ -65,13 +65,13 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
@Override
public void handleFault() {
appendToErrorMessage("Sending FiatTransferStartedMessage failed");
takerTrade.setErrorMessage(errorMessage);
trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade) {
((TakerAsBuyerTrade) takerTrade).setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof TakerAsBuyerTrade) {
((TakerAsBuyerTrade) trade).setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
}
else if (takerTrade instanceof TakerAsSellerTrade) {
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade) {
trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
}
failed();
@ -79,7 +79,7 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
});
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestDepositTxInputsMessage.class);
public TakerSendsRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerSendsRequestDepositTxInputsMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
private int retryCounter = 0;
@ -46,10 +46,10 @@ public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask {
RequestDepositTxInputsMessage message = new RequestDepositTxInputsMessage(
processModel.getId(),
processModel.getTakeOfferFeeTx().getHashAsString(),
takerTrade.getTradeAmount(),
trade.getTradeAmount(),
processModel.getTradeWalletPubKey());
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), message, new SendMessageListener() {
processModel.getMessageService().sendMessage(trade.getTradingPeer(), message, new SendMessageListener() {
@Override
public void handleResult() {
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 " +
"or cancel that trade.");
takerTrade.setErrorMessage(errorMessage);
trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed();
@ -84,7 +84,7 @@ public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask {
});
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPayDepositMessage.class);
public TakerSendsRequestPayDepositMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerSendsRequestPayDepositMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -49,7 +49,7 @@ public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
processModel.getFiatAccount(),
processModel.getAccountId());
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), message, new SendMessageListener() {
processModel.getMessageService().sendMessage(trade.getTradingPeer(), message, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer");
@ -59,24 +59,24 @@ public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
@Override
public void handleFault() {
appendToErrorMessage("Sending RequestTakerDepositPaymentMessage failed");
takerTrade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
trade.setErrorMessage(errorMessage);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(t);
if (takerTrade instanceof TakerAsBuyerTrade) {
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof TakerAsBuyerTrade) {
trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
}
else if (takerTrade instanceof TakerAsSellerTrade) {
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade) {
trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
}
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 {
private static final Logger log = LoggerFactory.getLogger(TakerSendsRequestPublishDepositTxMessage.class);
public TakerSendsRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerSendsRequestPublishDepositTxMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -44,14 +44,14 @@ public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask {
processModel.getAccountId(),
processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPublicKey(),
takerTrade.getContractAsJson(),
takerTrade.getTakerContractSignature(),
trade.getContractAsJson(),
trade.getTakerContractSignature(),
processModel.getAddressEntry().getAddressString(),
processModel.getPreparedDepositTx(),
processModel.getConnectedOutputsForAllInputs()
);
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
complete();
@ -60,19 +60,19 @@ public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask {
@Override
public void handleFault() {
appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed");
takerTrade.setErrorMessage(errorMessage);
trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishDepositTx.class);
public TakerSignsAndPublishDepositTx(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerSignsAndPublishDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
Coin inputAmount = takerTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
processModel.getTradeWalletService().signAndPublishDepositTx(
processModel.tradingPeer.getPreparedDepositTx(),
@ -60,15 +60,15 @@ public class TakerSignsAndPublishDepositTx extends TakerTradeTask {
public void onSuccess(Transaction transaction) {
log.trace("takerSignAndPublishTx succeeded " + transaction);
takerTrade.setDepositTx(transaction);
trade.setDepositTx(transaction);
if (takerTrade instanceof TakerAsBuyerTrade) {
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
takerTrade.setLifeCycleState(TakerAsBuyerTrade.LifeCycleState.PENDING);
if (trade instanceof TakerAsBuyerTrade) {
trade.setProcessState(TakerAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(TakerAsBuyerTrade.LifeCycleState.PENDING);
}
else if (takerTrade instanceof TakerAsSellerTrade) {
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
takerTrade.setLifeCycleState(TakerAsSellerTrade.LifeCycleState.PENDING);
else if (trade instanceof TakerAsSellerTrade) {
trade.setProcessState(TakerAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
trade.setLifeCycleState(TakerAsSellerTrade.LifeCycleState.PENDING);
}
complete();
@ -77,13 +77,13 @@ public class TakerSignsAndPublishDepositTx extends TakerTradeTask {
@Override
public void onFailure(@NotNull Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(t);
failed(t);
}
});
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerVerifiesAndSignsContract.class);
public TakerVerifiesAndSignsContract(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerVerifiesAndSignsContract(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -38,7 +38,7 @@ public class TakerVerifiesAndSignsContract extends TakerTradeTask {
try {
Contract contract = new Contract(
processModel.getOffer(),
takerTrade.getTradeAmount(),
trade.getTradeAmount(),
processModel.getTakeOfferFeeTx().getHashAsString(),
processModel.tradingPeer.getAccountId(),
processModel.getAccountId(),
@ -50,15 +50,15 @@ public class TakerVerifiesAndSignsContract extends TakerTradeTask {
String signature = processModel.getSignatureService().signMessage(processModel.getRegistrationKeyPair(),
contractAsJson);
takerTrade.setContract(contract);
takerTrade.setContractAsJson(contractAsJson);
takerTrade.setOffererContractSignature(signature);
takerTrade.setOffererContractSignature(processModel.tradingPeer.getContractSignature());
trade.setContract(contract);
trade.setContractAsJson(contractAsJson);
trade.setOffererContractSignature(signature);
trade.setOffererContractSignature(processModel.tradingPeer.getContractSignature());
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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> {
private static final Logger log = LoggerFactory.getLogger(OffererTradeTask.class);
protected final ProcessModel processModel;
protected final Trade offererTrade;
protected final Trade trade;
public OffererTradeTask(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererTradeTask(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
this.offererTrade = offererTrade;
processModel = offererTrade.getProcessModel();
this.trade = trade;
processModel = trade.getProcessModel();
}
@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 {
private static final Logger log = LoggerFactory.getLogger(OffererCommitDepositTx.class);
public OffererCommitDepositTx(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererCommitDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
// 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();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsContract.class);
public OffererCreatesAndSignsContract(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererCreatesAndSignsContract(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -58,7 +58,7 @@ public class OffererCreatesAndSignsContract extends OffererTradeTask {
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererCreatesAndSignsDepositTx.class);
public OffererCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
assert offererTrade.getTradeAmount() != null;
Coin inputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE).add(offererTrade.getTradeAmount());
Coin msOutputAmount = inputAmount.add(offererTrade.getSecurityDeposit());
assert trade.getTradeAmount() != null;
Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE).add(trade.getTradeAmount());
Coin msOutputAmount = inputAmount.add(trade.getSecurityDeposit());
TradeWalletService.Result result = processModel.getTradeWalletService().createAndSignDepositTx(
inputAmount,
@ -59,7 +59,7 @@ public class OffererCreatesAndSignsDepositTx extends OffererTradeTask {
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererProcessDepositTxPublishedMessage.class);
public OffererProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -44,17 +44,17 @@ public class OffererProcessDepositTxPublishedMessage extends OffererTradeTask {
checkTradeId(processModel.getId(), message);
checkNotNull(message);
offererTrade.setDepositTx(checkNotNull(message.depositTx));
trade.setDepositTx(checkNotNull(message.depositTx));
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
if (trade instanceof OffererAsBuyerTrade)
trade.setProcessState(OffererAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
else if (trade instanceof OffererAsSellerTrade)
trade.setProcessState(OffererAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererProcessFiatTransferStartedMessage.class);
public OffererProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -49,15 +49,15 @@ public class OffererProcessFiatTransferStartedMessage extends OffererTradeTask {
processModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount)));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
if (trade instanceof OffererAsBuyerTrade)
trade.setProcessState(OffererAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
else if (trade instanceof OffererAsSellerTrade)
trade.setProcessState(OffererAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererProcessRequestPayDepositFromOffererMessage.class);
public OffererProcessRequestPayDepositFromOffererMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererProcessRequestPayDepositFromOffererMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -50,12 +50,12 @@ public class OffererProcessRequestPayDepositFromOffererMessage extends OffererTr
processModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.buyerP2PEncryptPublicKey));
processModel.tradingPeer.setFiatAccount(checkNotNull(message.buyerFiatAccount));
processModel.tradingPeer.setAccountId(nonEmptyStringOf(message.buyerAccountId));
offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount)));
trade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount)));
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererSendsPayoutTxPublishedMessage.class);
public OffererSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(processModel.getId(), processModel.getPayoutTx());
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(),
processModel.getMessageService().sendMessage(trade.getTradingPeer(),
tradeMessage,
processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPubKey(),
@ -53,19 +53,19 @@ public class OffererSendsPayoutTxPublishedMessage extends OffererTradeTask {
@Override
public void handleFault() {
appendToErrorMessage("Sending PayoutTxPublishedMessage failed");
offererTrade.setErrorMessage(errorMessage);
trade.setErrorMessage(errorMessage);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof OffererAsBuyerTrade)
trade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof OffererAsSellerTrade)
trade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererSendsRequestPublishDepositTxFromTakerMessage.class);
public OffererSendsRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererSendsRequestPublishDepositTxFromTakerMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -45,14 +45,14 @@ public class OffererSendsRequestPublishDepositTxFromTakerMessage extends Offerer
processModel.getTradeWalletPubKey(),
processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPublicKey(),
offererTrade.getContractAsJson(),
offererTrade.getOffererContractSignature(),
trade.getContractAsJson(),
trade.getOffererContractSignature(),
processModel.getAddressEntry().getAddressString(),
processModel.getPreparedDepositTx(),
processModel.getConnectedOutputsForAllInputs()
);
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
processModel.getMessageService().sendMessage(trade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
complete();
@ -61,19 +61,19 @@ public class OffererSendsRequestPublishDepositTxFromTakerMessage extends Offerer
@Override
public void handleFault() {
appendToErrorMessage("Sending RequestOffererPublishDepositTxMessage failed");
offererTrade.setErrorMessage(errorMessage);
trade.setErrorMessage(errorMessage);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof OffererAsBuyerTrade)
trade.setProcessState(OffererAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof OffererAsSellerTrade)
trade.setProcessState(OffererAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(OffererSignsAndPublishPayoutTx.class);
public OffererSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public OffererSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
processModel.getTradeWalletService().signAndPublishPayoutTx(
offererTrade.getDepositTx(),
trade.getDepositTx(),
processModel.tradingPeer.getSignature(),
processModel.tradingPeer.getPayoutAmount(),
processModel.getPayoutAmount(),
@ -57,10 +57,10 @@ public class OffererSignsAndPublishPayoutTx extends OffererTradeTask {
public void onSuccess(Transaction transaction) {
processModel.setPayoutTx(transaction);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setProcessState(OffererAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
if (trade instanceof OffererAsBuyerTrade)
trade.setProcessState(OffererAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof OffererAsSellerTrade)
trade.setProcessState(OffererAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
complete();
}
@ -68,13 +68,13 @@ public class OffererSignsAndPublishPayoutTx extends OffererTradeTask {
@Override
public void onFailure(@NotNull Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(t);
failed(t);
}
});
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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
///////////////////////////////////////////////////////////////////////////////////////////
public SellerAsTakerProtocol(TakerAsSellerTrade takerTrade) {
public SellerAsTakerProtocol(TakerAsSellerTrade trade) {
log.debug("New SellerAsTakerProtocol " + this);
this.takerAsSellerTrade = takerTrade;
processModel = takerTrade.getProcessModel();
this.takerAsSellerTrade = trade;
processModel = trade.getProcessModel();
messageHandler = this::handleMessage;
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 {
private static final Logger log = LoggerFactory.getLogger(TakerCommitDepositTx.class);
public TakerCommitDepositTx(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerCommitDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
// 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();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignContract.class);
public TakerCreatesAndSignContract(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerCreatesAndSignContract(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -57,7 +57,7 @@ public class TakerCreatesAndSignContract extends TakerTradeTask {
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerCreatesAndSignsDepositTx.class);
public TakerCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerCreatesAndSignsDepositTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
assert takerTrade.getTradeAmount() != null;
Coin inputAmount = takerTrade.getSecurityDeposit().add(FeePolicy.TX_FEE).add(takerTrade.getTradeAmount());
Coin msOutputAmount = inputAmount.add(takerTrade.getSecurityDeposit());
assert trade.getTradeAmount() != null;
Coin inputAmount = trade.getSecurityDeposit().add(FeePolicy.TX_FEE).add(trade.getTradeAmount());
Coin msOutputAmount = inputAmount.add(trade.getSecurityDeposit());
TradeWalletService.Result result = processModel.getTradeWalletService().createAndSignDepositTx(
inputAmount,
@ -58,7 +58,7 @@ public class TakerCreatesAndSignsDepositTx extends TakerTradeTask {
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerProcessDepositTxPublishedMessage.class);
public TakerProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerProcessDepositTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -44,17 +44,17 @@ public class TakerProcessDepositTxPublishedMessage extends TakerTradeTask {
checkTradeId(processModel.getId(), message);
checkNotNull(message);
takerTrade.setDepositTx(checkNotNull(message.depositTx));
trade.setDepositTx(checkNotNull(message.depositTx));
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.DEPOSIT_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.DEPOSIT_PUBLISHED);
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerProcessFiatTransferStartedMessage.class);
public TakerProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerProcessFiatTransferStartedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -49,15 +49,15 @@ public class TakerProcessFiatTransferStartedMessage extends TakerTradeTask {
processModel.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.sellerPayoutAmount)));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.FIAT_PAYMENT_STARTED);
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerProcessRequestSellerDepositPaymentMessage.class);
public TakerProcessRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerProcessRequestSellerDepositPaymentMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -54,7 +54,7 @@ public class TakerProcessRequestSellerDepositPaymentMessage extends TakerTradeTa
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerSendsPayoutTxPublishedMessage.class);
public TakerSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerSendsPayoutTxPublishedMessage(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(processModel.getId(), processModel.getPayoutTx());
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(),
processModel.getMessageService().sendMessage(trade.getTradingPeer(),
tradeMessage,
processModel.tradingPeer.getP2pSigPubKey(),
processModel.tradingPeer.getP2pEncryptPubKey(),
@ -53,19 +53,19 @@ public class TakerSendsPayoutTxPublishedMessage extends TakerTradeTask {
@Override
public void handleFault() {
appendToErrorMessage("Sending PayoutTxPublishedMessage failed");
takerTrade.setErrorMessage(errorMessage);
trade.setErrorMessage(errorMessage);
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.MESSAGE_SENDING_FAILED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.MESSAGE_SENDING_FAILED);
failed();
}
});
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(TakerSignsAndPublishPayoutTx.class);
public TakerSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerSignsAndPublishPayoutTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
protected void doRun() {
try {
processModel.getTradeWalletService().signAndPublishPayoutTx(
takerTrade.getDepositTx(),
trade.getDepositTx(),
processModel.tradingPeer.getSignature(),
processModel.tradingPeer.getPayoutAmount(),
processModel.getPayoutAmount(),
@ -57,10 +57,10 @@ public class TakerSignsAndPublishPayoutTx extends TakerTradeTask {
public void onSuccess(Transaction transaction) {
processModel.setPayoutTx(transaction);
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.PAYOUT_PUBLISHED);
complete();
}
@ -68,13 +68,13 @@ public class TakerSignsAndPublishPayoutTx extends TakerTradeTask {
@Override
public void onFailure(@NotNull Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(t);
failed(t);
}
});
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(VerifyTakeOfferFeePayment.class);
public VerifyTakeOfferFeePayment(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public VerifyTakeOfferFeePayment(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -43,7 +43,7 @@ public class VerifyTakeOfferFeePayment extends OffererTradeTask {
complete();
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(VerifyTakerAccount.class);
public VerifyTakerAccount(TaskRunner taskHandler, Trade offererTrade) {
super(taskHandler, offererTrade);
public VerifyTakerAccount(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -52,19 +52,19 @@ public class VerifyTakerAccount extends OffererTradeTask {
else {
failed("Account registration validation for peer failed.");
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
if (trade instanceof OffererAsBuyerTrade)
trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
}
} catch (Throwable t) {
t.printStackTrace();
offererTrade.setThrowable(t);
trade.setThrowable(t);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (offererTrade instanceof OffererAsSellerTrade)
offererTrade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
if (trade instanceof OffererAsBuyerTrade)
trade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN);
else if (trade instanceof OffererAsSellerTrade)
trade.setLifeCycleState(OffererAsSellerTrade.LifeCycleState.OFFER_OPEN);
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 {
private static final Logger log = LoggerFactory.getLogger(BroadcastTakeOfferFeeTx.class);
public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public BroadcastTakeOfferFeeTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -48,10 +48,10 @@ public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
public void onSuccess(Transaction transaction) {
log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString());
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISHED);
complete();
}
@ -59,19 +59,19 @@ public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
public void onFailure(@NotNull Throwable t) {
t.printStackTrace();
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)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_PUBLISH_FAILED);
failed(t);
}
});
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(CreateTakeOfferFeeTx.class);
public CreateTakeOfferFeeTx(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public CreateTakeOfferFeeTx(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -42,15 +42,15 @@ public class CreateTakeOfferFeeTx extends TakerTradeTask {
processModel.setTakeOfferFeeTx(createTakeOfferFeeTx);
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
else if (takerTrade instanceof TakerAsSellerTrade)
takerTrade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
if (trade instanceof TakerAsBuyerTrade)
trade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
else if (trade instanceof TakerAsSellerTrade)
trade.setProcessState(TakerAsSellerTrade.ProcessState.TAKE_OFFER_FEE_TX_CREATED);
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(VerifyOfferFeePayment.class);
public VerifyOfferFeePayment(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public VerifyOfferFeePayment(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -42,7 +42,7 @@ public class VerifyOfferFeePayment extends TakerTradeTask {
complete();
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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 {
private static final Logger log = LoggerFactory.getLogger(VerifyOffererAccount.class);
public VerifyOffererAccount(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public VerifyOffererAccount(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
}
@Override
@ -48,7 +48,7 @@ public class VerifyOffererAccount extends TakerTradeTask {
}
} catch (Throwable t) {
t.printStackTrace();
takerTrade.setThrowable(t);
trade.setThrowable(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> {
private static final Logger log = LoggerFactory.getLogger(TakerTradeTask.class);
protected final ProcessModel processModel;
protected final Trade takerTrade;
protected final Trade trade;
public TakerTradeTask(TaskRunner taskHandler, Trade takerTrade) {
super(taskHandler, takerTrade);
public TakerTradeTask(TaskRunner taskHandler, Trade trade) {
super(taskHandler, trade);
this.takerTrade = takerTrade;
processModel = takerTrade.getProcessModel();
this.trade = trade;
processModel = trade.getProcessModel();
}
@Override

2
core/src/main/java/io/bitsquare/util/Utilities.java
View File

@ -257,7 +257,7 @@ public class Utilities {
log.warn("can't delete file : " + tmpF);
}
}
if (!folder.delete())
if (!folder.delete())
log.warn("can't delete folder : " + folder);
}
}