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

Merge ProcessModels

Browse Source
This commit is contained in:
Manfred Karrer 2015-04-02 12:44:50 +02:00
parent 238f36cffd
commit ef6e72aaaa
57 changed files with 463 additions and 784 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
core/src/main/java/io/bitsquare/trade/OffererTrade.java
View File

@ -21,7 +21,6 @@ import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.trade.ProcessModel;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererProcessModel;
import org.bitcoinj.core.Coin;
import org.bitcoinj.utils.Fiat;
@ -92,7 +91,7 @@ public abstract class OffererTrade extends Trade implements Serializable {
@Override
public ProcessModel createProcessModel() {
return new OffererProcessModel();
return new ProcessModel();
}
@ -100,8 +99,8 @@ public abstract class OffererTrade extends Trade implements Serializable {
// Getter/Setter for Mutable objects
///////////////////////////////////////////////////////////////////////////////////////////
public OffererProcessModel getProcessModel() {
return (OffererProcessModel) processModel;
public ProcessModel getProcessModel() {
return processModel;
}
public void setTradingPeer(Peer tradingPeer) {

7
core/src/main/java/io/bitsquare/trade/TakerTrade.java
View File

@ -21,7 +21,6 @@ import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.Peer;
import io.bitsquare.storage.Storage;
import io.bitsquare.trade.protocol.trade.ProcessModel;
import io.bitsquare.trade.protocol.trade.taker.models.TakerProcessModel;
import org.bitcoinj.core.Coin;
import org.bitcoinj.utils.Fiat;
@ -92,7 +91,7 @@ public abstract class TakerTrade extends Trade implements Serializable {
@Override
public ProcessModel createProcessModel() {
return new TakerProcessModel();
return new ProcessModel();
}
@ -121,8 +120,8 @@ public abstract class TakerTrade extends Trade implements Serializable {
return tradingPeer;
}
public TakerProcessModel getProcessModel() {
return (TakerProcessModel) processModel;
public ProcessModel getProcessModel() {
return processModel;
}
public ReadOnlyObjectProperty<Coin> tradeAmountProperty() {

133
core/src/main/java/io/bitsquare/trade/protocol/trade/ProcessModel.java
View File

@ -18,21 +18,33 @@
package io.bitsquare.trade.protocol.trade;
import io.bitsquare.arbitration.ArbitrationRepository;
import io.bitsquare.btc.AddressEntry;
import io.bitsquare.btc.BlockChainService;
import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.btc.WalletService;
import io.bitsquare.common.taskrunner.Model;
import io.bitsquare.crypto.SignatureService;
import io.bitsquare.fiat.FiatAccount;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.MailboxMessage;
import io.bitsquare.p2p.MessageService;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.shared.models.TradingPeer;
import io.bitsquare.user.User;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction;
import org.bitcoinj.core.TransactionOutput;
import org.bitcoinj.crypto.DeterministicKey;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.security.PublicKey;
import java.util.List;
import javax.annotation.Nullable;
import org.slf4j.Logger;
@ -52,14 +64,25 @@ public class ProcessModel extends Model implements Serializable {
transient private SignatureService signatureService;
transient private ArbitrationRepository arbitrationRepository;
transient private Offer offer;
transient protected User user;
// Mutable
public final TradingPeer tradingPeer;
transient private MailboxMessage mailboxMessage;
transient private TradeMessage tradeMessage;
private String takeOfferFeeTxId;
private Transaction payoutTx;
private List<TransactionOutput> connectedOutputsForAllInputs;
private Coin payoutAmount;
private Transaction preparedDepositTx;
private List<TransactionOutput> outputs; // used to verify amounts with change outputs
private byte[] payoutTxSignature;
private Transaction takeOfferFeeTx;
protected ProcessModel() {
public ProcessModel() {
log.trace("Created by constructor");
tradingPeer = new TradingPeer();
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
@ -82,6 +105,7 @@ public class ProcessModel extends Model implements Serializable {
this.blockChainService = blockChainService;
this.signatureService = signatureService;
this.arbitrationRepository = arbitrationRepository;
this.user = user;
}
@ -151,4 +175,111 @@ public class ProcessModel extends Model implements Serializable {
"offer=" + offer +
'}';
}
@Nullable
public Transaction getPayoutTx() {
return payoutTx;
}
public void setPayoutTx(Transaction payoutTx) {
this.payoutTx = payoutTx;
}
@Nullable
public Transaction getTakeOfferFeeTx() {
return takeOfferFeeTx;
}
public void setTakeOfferFeeTx(Transaction takeOfferFeeTx) {
this.takeOfferFeeTx = takeOfferFeeTx;
}
public FiatAccount getFiatAccount() {
return user.getFiatAccount(offer.getBankAccountId());
}
public DeterministicKey getRegistrationKeyPair() {
return walletService.getRegistrationAddressEntry().getKeyPair();
}
public String getAccountId() {
return user.getAccountId();
}
public PublicKey getP2pSigPubKey() {
return user.getP2PSigPubKey();
}
public PublicKey getP2pEncryptPublicKey() {
return user.getP2PEncryptPubKey();
}
public byte[] getRegistrationPubKey() {
return walletService.getRegistrationAddressEntry().getPubKey();
}
public AddressEntry getAddressEntry() {
return walletService.getAddressEntry(offer.getId());
}
public byte[] getTradeWalletPubKey() {
return getAddressEntry().getPubKey();
}
public PublicKey getP2pEncryptPubKey() {
return user.getP2PEncryptPubKey();
}
@Nullable
public List<TransactionOutput> getConnectedOutputsForAllInputs() {
return connectedOutputsForAllInputs;
}
public void setConnectedOutputsForAllInputs(List<TransactionOutput> connectedOutputsForAllInputs) {
this.connectedOutputsForAllInputs = connectedOutputsForAllInputs;
}
@Nullable
public Coin getPayoutAmount() {
return payoutAmount;
}
public void setPayoutAmount(Coin payoutAmount) {
this.payoutAmount = payoutAmount;
}
@Nullable
public Transaction getPreparedDepositTx() {
return preparedDepositTx;
}
public void setPreparedDepositTx(Transaction preparedDepositTx) {
this.preparedDepositTx = preparedDepositTx;
}
@Nullable
public List<TransactionOutput> getOutputs() {
return outputs;
}
public void setOutputs(List<TransactionOutput> outputs) {
this.outputs = outputs;
}
@Nullable
public byte[] getPayoutTxSignature() {
return payoutTxSignature;
}
public void setPayoutTxSignature(byte[] payoutTxSignature) {
this.payoutTxSignature = payoutTxSignature;
}
public String getTakeOfferFeeTxId() {
return takeOfferFeeTxId;
}
public void setTakeOfferFeeTxId(String takeOfferFeeTxId) {
this.takeOfferFeeTxId = takeOfferFeeTxId;
}
}

30
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/BuyerAsOffererProtocol.java
View File

@ -27,6 +27,7 @@ import io.bitsquare.trade.OffererAsBuyerTrade;
import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.protocol.availability.messages.ReportOfferAvailabilityMessage;
import io.bitsquare.trade.protocol.availability.messages.RequestIsOfferAvailableMessage;
import io.bitsquare.trade.protocol.trade.ProcessModel;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererCommitsPayoutTx;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererCreatesAndSignPayoutTx;
import io.bitsquare.trade.protocol.trade.buyer.offerer.tasks.OffererCreatesDepositTxInputs;
@ -42,7 +43,6 @@ import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererProcessModel;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakeOfferFeePayment;
import io.bitsquare.trade.protocol.trade.shared.offerer.tasks.VerifyTakerAccount;
@ -56,7 +56,7 @@ public class BuyerAsOffererProtocol implements Protocol {
private MessageHandler messageHandler;
private final OffererAsBuyerTrade offererAsBuyerTrade;
private final OffererProcessModel offererTradeProcessModel;
private final ProcessModel processModel;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
@ -65,10 +65,10 @@ public class BuyerAsOffererProtocol implements Protocol {
public BuyerAsOffererProtocol(OffererAsBuyerTrade model) {
log.debug("New OffererProtocol " + this);
this.offererAsBuyerTrade = model;
offererTradeProcessModel = offererAsBuyerTrade.getProcessModel();
processModel = offererAsBuyerTrade.getProcessModel();
messageHandler = this::handleMessage;
offererTradeProcessModel.getMessageService().addMessageHandler(messageHandler);
processModel.getMessageService().addMessageHandler(messageHandler);
}
@ -79,8 +79,8 @@ public class BuyerAsOffererProtocol implements Protocol {
public void setMailboxMessage(MailboxMessage mailboxMessage) {
log.debug("setMailboxMessage " + mailboxMessage);
// Might be called twice, so check that its only processed once
if (offererTradeProcessModel.getMailboxMessage() == null) {
offererTradeProcessModel.setMailboxMessage(mailboxMessage);
if (processModel.getMailboxMessage() == null) {
processModel.setMailboxMessage(mailboxMessage);
if (mailboxMessage instanceof PayoutTxPublishedMessage) {
handlePayoutTxPublishedMessage((PayoutTxPublishedMessage) mailboxMessage);
}
@ -91,7 +91,7 @@ public class BuyerAsOffererProtocol implements Protocol {
log.debug("cleanup " + this);
if (messageHandler != null) {
offererTradeProcessModel.getMessageService().removeMessageHandler(messageHandler);
processModel.getMessageService().removeMessageHandler(messageHandler);
messageHandler = null;
}
}
@ -103,15 +103,15 @@ public class BuyerAsOffererProtocol implements Protocol {
// OpenOffer requests
private void handleRequestIsOfferAvailableMessage(RequestIsOfferAvailableMessage tradeMessage, Peer sender) {
try {
checkTradeId(offererTradeProcessModel.getId(), tradeMessage);
checkTradeId(processModel.getId(), tradeMessage);
// We don't store anything in the offererTradeProcessModel as we might be in a trade process and receive that request from another peer who wants
// to take the
// offer
// at the same time
boolean isOfferOpen = offererAsBuyerTrade.lifeCycleStateProperty().get() == OffererAsBuyerTrade.LifeCycleState.OFFER_OPEN;
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(offererTradeProcessModel.getId(), isOfferOpen);
offererTradeProcessModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(processModel.getId(), isOfferOpen);
processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@Override
public void handleResult() {
// Offerer does not do anything at that moment. Peer might only watch the offer and does not start a trade.
@ -132,8 +132,8 @@ public class BuyerAsOffererProtocol implements Protocol {
// Trade started. We reserve the offer for that taker. If anything goes wrong we reset the offer as open.
private void handleRequestDepositTxInputsMessage(RequestDepositTxInputsMessage tradeMessage, Peer taker) {
checkTradeId(offererTradeProcessModel.getId(), tradeMessage);
offererTradeProcessModel.setTradeMessage(tradeMessage);
checkTradeId(processModel.getId(), tradeMessage);
processModel.setTradeMessage(tradeMessage);
offererAsBuyerTrade.setTradingPeer(taker);
offererAsBuyerTrade.setLifeCycleState(OffererAsBuyerTrade.LifeCycleState.OFFER_RESERVED);
@ -150,7 +150,7 @@ public class BuyerAsOffererProtocol implements Protocol {
}
private void handleRequestPublishDepositTxMessage(RequestPublishDepositTxMessage tradeMessage) {
offererTradeProcessModel.setTradeMessage(tradeMessage);
processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsBuyerTrade> taskRunner = new TaskRunner<>(offererAsBuyerTrade,
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
@ -189,13 +189,13 @@ public class BuyerAsOffererProtocol implements Protocol {
///////////////////////////////////////////////////////////////////////////////////////////
private void handlePayoutTxPublishedMessage(PayoutTxPublishedMessage tradeMessage) {
offererTradeProcessModel.setTradeMessage(tradeMessage);
processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsBuyerTrade> taskRunner = new TaskRunner<>(offererAsBuyerTrade,
() -> {
log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
// we are done!
offererTradeProcessModel.onComplete();
processModel.onComplete();
},
this::handleTaskRunnerFault);

2
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererCommitsPayoutTx.java
View File

@ -36,7 +36,7 @@ public class OffererCommitsPayoutTx extends OffererTradeTask {
@Override
protected void doRun() {
try {
Transaction transaction = offererTradeProcessModel.getTradeWalletService().commitTx(offererTrade.getPayoutTx());
Transaction transaction = processModel.getTradeWalletService().commitTx(offererTrade.getPayoutTx());
offererTrade.setPayoutTx(transaction);

18
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererCreatesAndSignPayoutTx.java
View File

@ -41,19 +41,19 @@ public class OffererCreatesAndSignPayoutTx extends OffererTradeTask {
Coin offererPayoutAmount = securityDeposit.add(offererTrade.getTradeAmount());
Coin takerPayoutAmount = securityDeposit;
byte[] offererPayoutTxSignature = offererTradeProcessModel.getTradeWalletService().createAndSignPayoutTx(
byte[] offererPayoutTxSignature = processModel.getTradeWalletService().createAndSignPayoutTx(
offererTrade.getDepositTx(),
offererPayoutAmount,
takerPayoutAmount,
offererTradeProcessModel.getAddressEntry(),
offererTradeProcessModel.tradingPeer.getPayoutAddressString(),
offererTradeProcessModel.getTradeWalletPubKey(),
offererTradeProcessModel.tradingPeer.getTradeWalletPubKey(),
offererTradeProcessModel.getArbitratorPubKey());
processModel.getAddressEntry(),
processModel.tradingPeer.getPayoutAddressString(),
processModel.getTradeWalletPubKey(),
processModel.tradingPeer.getTradeWalletPubKey(),
processModel.getArbitratorPubKey());
offererTradeProcessModel.setPayoutTxSignature(offererPayoutTxSignature);
offererTradeProcessModel.setPayoutAmount(offererPayoutAmount);
offererTradeProcessModel.tradingPeer.setPayoutAmount(takerPayoutAmount);
processModel.setPayoutTxSignature(offererPayoutTxSignature);
processModel.setPayoutAmount(offererPayoutAmount);
processModel.tradingPeer.setPayoutAmount(takerPayoutAmount);
complete();
} catch (Throwable t) {

8
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererCreatesDepositTxInputs.java
View File

@ -42,11 +42,11 @@ public class OffererCreatesDepositTxInputs extends OffererTradeTask {
try {
log.debug("offererTrade.id" + offererTrade.getId());
Coin inputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
TradeWalletService.Result result = offererTradeProcessModel.getTradeWalletService().createDepositTxInputs(inputAmount,
offererTradeProcessModel.getAddressEntry());
TradeWalletService.Result result = processModel.getTradeWalletService().createDepositTxInputs(inputAmount,
processModel.getAddressEntry());
offererTradeProcessModel.setConnectedOutputsForAllInputs(result.getConnectedOutputsForAllInputs());
offererTradeProcessModel.setOutputs(result.getOutputs());
processModel.setConnectedOutputsForAllInputs(result.getConnectedOutputsForAllInputs());
processModel.setOutputs(result.getOutputs());
complete();
} catch (Throwable t) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererProcessPayoutTxPublishedMessage.java
View File

@ -40,8 +40,8 @@ public class OffererProcessPayoutTxPublishedMessage extends OffererTradeTask {
@Override
protected void doRun() {
try {
PayoutTxPublishedMessage message = (PayoutTxPublishedMessage) offererTradeProcessModel.getTradeMessage();
checkTradeId(offererTradeProcessModel.getId(), message);
PayoutTxPublishedMessage message = (PayoutTxPublishedMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
offererTrade.setPayoutTx(checkNotNull(message.payoutTx));

8
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererProcessRequestDepositTxInputsMessage.java
View File

@ -40,13 +40,13 @@ public class OffererProcessRequestDepositTxInputsMessage extends OffererTradeTas
@Override
protected void doRun() {
try {
RequestDepositTxInputsMessage message = (RequestDepositTxInputsMessage) offererTradeProcessModel.getTradeMessage();
checkTradeId(offererTradeProcessModel.getId(), message);
RequestDepositTxInputsMessage message = (RequestDepositTxInputsMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount)));
offererTradeProcessModel.setTakeOfferFeeTxId(nonEmptyStringOf(message.takeOfferFeeTxId));
offererTradeProcessModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.takerTradeWalletPubKey));
processModel.setTakeOfferFeeTxId(nonEmptyStringOf(message.takeOfferFeeTxId));
processModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.takerTradeWalletPubKey));
complete();
} catch (Throwable t) {

22
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererProcessRequestPublishDepositTxMessage.java
View File

@ -40,19 +40,19 @@ public class OffererProcessRequestPublishDepositTxMessage extends OffererTradeTa
@Override
protected void doRun() {
try {
RequestPublishDepositTxMessage message = (RequestPublishDepositTxMessage) offererTradeProcessModel.getTradeMessage();
checkTradeId(offererTradeProcessModel.getId(), message);
RequestPublishDepositTxMessage message = (RequestPublishDepositTxMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
offererTradeProcessModel.tradingPeer.setFiatAccount(checkNotNull(message.takerFiatAccount));
offererTradeProcessModel.tradingPeer.setAccountId(nonEmptyStringOf(message.takerAccountId));
offererTradeProcessModel.tradingPeer.setP2pSigPubKey(checkNotNull(message.takerP2PSigPublicKey));
offererTradeProcessModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.takerP2PEncryptPublicKey));
offererTradeProcessModel.tradingPeer.setContractAsJson(nonEmptyStringOf(message.takerContractAsJson));
offererTradeProcessModel.tradingPeer.setContractSignature(nonEmptyStringOf(message.takerContractSignature));
offererTradeProcessModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.takerPayoutAddressString));
offererTradeProcessModel.tradingPeer.setPreparedDepositTx(checkNotNull(message.takersPreparedDepositTx));
offererTradeProcessModel.tradingPeer.setConnectedOutputsForAllInputs(checkNotNull(message.takerConnectedOutputsForAllInputs));
processModel.tradingPeer.setFiatAccount(checkNotNull(message.takerFiatAccount));
processModel.tradingPeer.setAccountId(nonEmptyStringOf(message.takerAccountId));
processModel.tradingPeer.setP2pSigPubKey(checkNotNull(message.takerP2PSigPublicKey));
processModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.takerP2PEncryptPublicKey));
processModel.tradingPeer.setContractAsJson(nonEmptyStringOf(message.takerContractAsJson));
processModel.tradingPeer.setContractSignature(nonEmptyStringOf(message.takerContractSignature));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.takerPayoutAddressString));
processModel.tradingPeer.setPreparedDepositTx(checkNotNull(message.takersPreparedDepositTx));
processModel.tradingPeer.setConnectedOutputsForAllInputs(checkNotNull(message.takerConnectedOutputsForAllInputs));
checkArgument(message.takerConnectedOutputsForAllInputs.size() > 0);
complete();

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererSendsDepositTxPublishedMessage.java
View File

@ -38,9 +38,9 @@ public class OffererSendsDepositTxPublishedMessage extends OffererTradeTask {
@Override
protected void doRun() {
try {
DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(offererTradeProcessModel.getId(), offererTrade.getDepositTx());
DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(processModel.getId(), offererTrade.getDepositTx());
offererTradeProcessModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("DepositTxPublishedMessage successfully arrived at peer");

16
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererSendsFiatTransferStartedMessage.java
View File

@ -38,15 +38,15 @@ public class OffererSendsFiatTransferStartedMessage extends OffererTradeTask {
@Override
protected void doRun() {
try {
FiatTransferStartedMessage tradeMessage = new FiatTransferStartedMessage(offererTradeProcessModel.getId(),
offererTradeProcessModel.getPayoutTxSignature(),
offererTradeProcessModel.getPayoutAmount(),
offererTradeProcessModel.tradingPeer.getPayoutAmount(),
offererTradeProcessModel.getAddressEntry().getAddressString());
FiatTransferStartedMessage tradeMessage = new FiatTransferStartedMessage(processModel.getId(),
processModel.getPayoutTxSignature(),
processModel.getPayoutAmount(),
processModel.tradingPeer.getPayoutAmount(),
processModel.getAddressEntry().getAddressString());
offererTradeProcessModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage,
offererTradeProcessModel.tradingPeer.getP2pSigPubKey(),
offererTradeProcessModel.tradingPeer.getP2pEncryptPubKey(),
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage,
processModel.tradingPeer.getP2pSigPubKey(),
processModel.tradingPeer.getP2pEncryptPubKey(),
new SendMessageListener() {
@Override
public void handleResult() {

18
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererSendsRequestSellerDepositPaymentMessage.java
View File

@ -39,16 +39,16 @@ public class OffererSendsRequestSellerDepositPaymentMessage extends OffererTrade
protected void doRun() {
try {
RequestPayDepositMessage tradeMessage = new RequestPayDepositMessage(
offererTradeProcessModel.getId(),
offererTradeProcessModel.getConnectedOutputsForAllInputs(),
offererTradeProcessModel.getOutputs(),
offererTradeProcessModel.getTradeWalletPubKey(),
offererTradeProcessModel.getP2pSigPubKey(),
offererTradeProcessModel.getP2pEncryptPubKey(),
offererTradeProcessModel.getFiatAccount(),
offererTradeProcessModel.getAccountId());
processModel.getId(),
processModel.getConnectedOutputsForAllInputs(),
processModel.getOutputs(),
processModel.getTradeWalletPubKey(),
processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPubKey(),
processModel.getFiatAccount(),
processModel.getAccountId());
offererTradeProcessModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer");

16
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererSignsAndPublishDepositTx.java
View File

@ -46,15 +46,15 @@ public class OffererSignsAndPublishDepositTx extends OffererTradeTask {
try {
Coin inputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
offererTradeProcessModel.getTradeWalletService().signAndPublishDepositTx(
offererTradeProcessModel.tradingPeer.getPreparedDepositTx(),
offererTradeProcessModel.getConnectedOutputsForAllInputs(),
offererTradeProcessModel.tradingPeer.getConnectedOutputsForAllInputs(),
offererTradeProcessModel.getOutputs(),
processModel.getTradeWalletService().signAndPublishDepositTx(
processModel.tradingPeer.getPreparedDepositTx(),
processModel.getConnectedOutputsForAllInputs(),
processModel.tradingPeer.getConnectedOutputsForAllInputs(),
processModel.getOutputs(),
inputAmount,
offererTradeProcessModel.getTradeWalletPubKey(),
offererTradeProcessModel.tradingPeer.getTradeWalletPubKey(),
offererTradeProcessModel.getArbitratorPubKey(),
processModel.getTradeWalletPubKey(),
processModel.tradingPeer.getTradeWalletPubKey(),
processModel.getArbitratorPubKey(),
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {

20
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/offerer/tasks/OffererVerifiesAndSignsContract.java
View File

@ -39,23 +39,23 @@ public class OffererVerifiesAndSignsContract extends OffererTradeTask {
protected void doRun() {
try {
Contract contract = new Contract(
offererTradeProcessModel.getOffer(),
processModel.getOffer(),
offererTrade.getTradeAmount(),
offererTradeProcessModel.getTakeOfferFeeTxId(),
offererTradeProcessModel.getAccountId(),
offererTradeProcessModel.tradingPeer.getAccountId(),
offererTradeProcessModel.getFiatAccount(),
offererTradeProcessModel.tradingPeer.getFiatAccount(),
offererTradeProcessModel.getP2pSigPubKey(),
offererTradeProcessModel.tradingPeer.getP2pSigPubKey());
processModel.getTakeOfferFeeTxId(),
processModel.getAccountId(),
processModel.tradingPeer.getAccountId(),
processModel.getFiatAccount(),
processModel.tradingPeer.getFiatAccount(),
processModel.getP2pSigPubKey(),
processModel.tradingPeer.getP2pSigPubKey());
String contractAsJson = Utilities.objectToJson(contract);
String signature = offererTradeProcessModel.getSignatureService().signMessage(offererTradeProcessModel.getRegistrationKeyPair(),
String signature = processModel.getSignatureService().signMessage(processModel.getRegistrationKeyPair(),
contractAsJson);
offererTrade.setContract(contract);
offererTrade.setContractAsJson(contractAsJson);
offererTrade.setOffererContractSignature(signature);
offererTrade.setTakerContractSignature(offererTradeProcessModel.tradingPeer.getContractSignature());
offererTrade.setTakerContractSignature(processModel.tradingPeer.getContractSignature());
complete();
} catch (Throwable t) {

18
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/BuyerAsTakerProtocol.java
View File

@ -24,6 +24,7 @@ import io.bitsquare.p2p.MessageHandler;
import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.TakerAsBuyerTrade;
import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.protocol.trade.ProcessModel;
import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerCommitsPayoutTx;
import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerCreatesAndSignsPayoutTx;
import io.bitsquare.trade.protocol.trade.buyer.taker.tasks.TakerCreatesDepositTxInputs;
@ -41,7 +42,6 @@ import io.bitsquare.trade.protocol.trade.shared.taker.tasks.BroadcastTakeOfferFe
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;
import io.bitsquare.trade.protocol.trade.taker.models.TakerProcessModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -52,7 +52,7 @@ public class BuyerAsTakerProtocol implements Protocol {
private static final Logger log = LoggerFactory.getLogger(BuyerAsTakerProtocol.class);
private final TakerAsBuyerTrade takerAsBuyerTrade;
private final TakerProcessModel takerTradeProcessModel;
private final ProcessModel processModel;
private final MessageHandler messageHandler;
@ -63,10 +63,10 @@ public class BuyerAsTakerProtocol implements Protocol {
public BuyerAsTakerProtocol(TakerAsBuyerTrade takerTrade) {
log.debug("New SellerAsTakerProtocol " + this);
this.takerAsBuyerTrade = takerTrade;
takerTradeProcessModel = takerTrade.getProcessModel();
processModel = takerTrade.getProcessModel();
messageHandler = this::handleMessage;
takerTradeProcessModel.getMessageService().addMessageHandler(messageHandler);
processModel.getMessageService().addMessageHandler(messageHandler);
}
@ -76,7 +76,7 @@ public class BuyerAsTakerProtocol implements Protocol {
public void cleanup() {
log.debug("cleanup " + this);
takerTradeProcessModel.getMessageService().removeMessageHandler(messageHandler);
processModel.getMessageService().removeMessageHandler(messageHandler);
}
public void setMailboxMessage(MailboxMessage mailboxMessage) {
@ -113,7 +113,7 @@ public class BuyerAsTakerProtocol implements Protocol {
///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestPublishDepositTxMessage tradeMessage) {
takerTradeProcessModel.setTradeMessage(tradeMessage);
processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsBuyerTrade> taskRunner = new TaskRunner<>(takerAsBuyerTrade,
() -> log.debug("taskRunner at handleRequestPublishDepositTxMessage completed"),
@ -152,13 +152,13 @@ public class BuyerAsTakerProtocol implements Protocol {
///////////////////////////////////////////////////////////////////////////////////////////
private void handle(PayoutTxPublishedMessage tradeMessage) {
takerTradeProcessModel.setTradeMessage(tradeMessage);
processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsBuyerTrade> taskRunner = new TaskRunner<>(takerAsBuyerTrade,
() -> {
log.debug("taskRunner at handlePayoutTxPublishedMessage completed");
// we are done!
takerTradeProcessModel.onComplete();
processModel.onComplete();
},
this::handleTaskRunnerFault);
@ -179,7 +179,7 @@ public class BuyerAsTakerProtocol implements Protocol {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(takerTradeProcessModel.getId())) {
if (tradeMessage.tradeId.equals(processModel.getId())) {
if (tradeMessage instanceof RequestPublishDepositTxMessage) {
handle((RequestPublishDepositTxMessage) tradeMessage);
}

2
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerCommitsPayoutTx.java
View File

@ -36,7 +36,7 @@ public class TakerCommitsPayoutTx extends TakerTradeTask {
@Override
protected void doRun() {
try {
Transaction transaction = takerTradeProcessModel.getTradeWalletService().commitTx(takerTrade.getPayoutTx());
Transaction transaction = processModel.getTradeWalletService().commitTx(takerTrade.getPayoutTx());
takerTrade.setPayoutTx(transaction);

18
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerCreatesAndSignsPayoutTx.java
View File

@ -43,19 +43,19 @@ public class TakerCreatesAndSignsPayoutTx extends TakerTradeTask {
Coin takerPayoutAmount = securityDeposit.add(takerTrade.getTradeAmount());
byte[] takerPayoutTxSignature = takerTradeProcessModel.getTradeWalletService().createAndSignPayoutTx(
byte[] takerPayoutTxSignature = processModel.getTradeWalletService().createAndSignPayoutTx(
takerTrade.getDepositTx(),
takerPayoutAmount,
offererPayoutAmount,
takerTradeProcessModel.getAddressEntry(),
takerTradeProcessModel.tradingPeer.getPayoutAddressString(),
takerTradeProcessModel.getTradeWalletPubKey(),
takerTradeProcessModel.tradingPeer.getTradeWalletPubKey(),
takerTradeProcessModel.getArbitratorPubKey());
processModel.getAddressEntry(),
processModel.tradingPeer.getPayoutAddressString(),
processModel.getTradeWalletPubKey(),
processModel.tradingPeer.getTradeWalletPubKey(),
processModel.getArbitratorPubKey());
takerTradeProcessModel.setPayoutTxSignature(takerPayoutTxSignature);
takerTradeProcessModel.setPayoutAmount(takerPayoutAmount);
takerTradeProcessModel.tradingPeer.setPayoutAmount(offererPayoutAmount);
processModel.setPayoutTxSignature(takerPayoutTxSignature);
processModel.setPayoutAmount(takerPayoutAmount);
processModel.tradingPeer.setPayoutAmount(offererPayoutAmount);
complete();
} catch (Throwable t) {

8
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerCreatesDepositTxInputs.java
View File

@ -40,11 +40,11 @@ public class TakerCreatesDepositTxInputs extends TakerTradeTask {
try {
log.debug("takerTrade.id" + takerTrade.getId());
Coin inputAmount = takerTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
TradeWalletService.Result result = takerTradeProcessModel.getTradeWalletService().createDepositTxInputs(inputAmount,
takerTradeProcessModel.getAddressEntry());
TradeWalletService.Result result = processModel.getTradeWalletService().createDepositTxInputs(inputAmount,
processModel.getAddressEntry());
takerTradeProcessModel.setConnectedOutputsForAllInputs(result.getConnectedOutputsForAllInputs());
takerTradeProcessModel.setOutputs(result.getOutputs());
processModel.setConnectedOutputsForAllInputs(result.getConnectedOutputsForAllInputs());
processModel.setOutputs(result.getOutputs());
complete();
} catch (Throwable t) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerProcessPayoutTxPublishedMessage.java
View File

@ -40,8 +40,8 @@ public class TakerProcessPayoutTxPublishedMessage extends TakerTradeTask {
@Override
protected void doRun() {
try {
PayoutTxPublishedMessage message = (PayoutTxPublishedMessage) takerTradeProcessModel.getTradeMessage();
checkTradeId(takerTradeProcessModel.getId(), message);
PayoutTxPublishedMessage message = (PayoutTxPublishedMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
takerTrade.setPayoutTx(checkNotNull(message.payoutTx));

26
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerProcessRequestPublishDepositTxFromTakerMessage.java
View File

@ -38,21 +38,21 @@ public class TakerProcessRequestPublishDepositTxFromTakerMessage extends TakerTr
@Override
protected void doRun() {
try {
RequestPublishDepositTxFromTakerMessage message = (RequestPublishDepositTxFromTakerMessage) takerTradeProcessModel.getTradeMessage();
checkTradeId(takerTradeProcessModel.getId(), message);
RequestPublishDepositTxFromTakerMessage message = (RequestPublishDepositTxFromTakerMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
takerTradeProcessModel.tradingPeer.setFiatAccount(checkNotNull(message.takerFiatAccount));
takerTradeProcessModel.tradingPeer.setAccountId(nonEmptyStringOf(message.takerAccountId));
takerTradeProcessModel.tradingPeer.setP2pSigPubKey(checkNotNull(message.takerP2PSigPublicKey));
takerTradeProcessModel.tradingPeer.setP2pSigPubKey(checkNotNull(message.takerP2PSigPublicKey));
takerTradeProcessModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.sellerTradeWalletPubKey));
takerTradeProcessModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.takerP2PEncryptPublicKey));
takerTradeProcessModel.tradingPeer.setContractAsJson(nonEmptyStringOf(message.takerContractAsJson));
takerTradeProcessModel.tradingPeer.setContractSignature(nonEmptyStringOf(message.takerContractSignature));
takerTradeProcessModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.takerPayoutAddressString));
takerTradeProcessModel.tradingPeer.setPreparedDepositTx(checkNotNull(message.takersPreparedDepositTx));
takerTradeProcessModel.tradingPeer.setConnectedOutputsForAllInputs(checkNotNull(message.takerConnectedOutputsForAllInputs));
processModel.tradingPeer.setFiatAccount(checkNotNull(message.takerFiatAccount));
processModel.tradingPeer.setAccountId(nonEmptyStringOf(message.takerAccountId));
processModel.tradingPeer.setP2pSigPubKey(checkNotNull(message.takerP2PSigPublicKey));
processModel.tradingPeer.setP2pSigPubKey(checkNotNull(message.takerP2PSigPublicKey));
processModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.sellerTradeWalletPubKey));
processModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.takerP2PEncryptPublicKey));
processModel.tradingPeer.setContractAsJson(nonEmptyStringOf(message.takerContractAsJson));
processModel.tradingPeer.setContractSignature(nonEmptyStringOf(message.takerContractSignature));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.takerPayoutAddressString));
processModel.tradingPeer.setPreparedDepositTx(checkNotNull(message.takersPreparedDepositTx));
processModel.tradingPeer.setConnectedOutputsForAllInputs(checkNotNull(message.takerConnectedOutputsForAllInputs));
checkArgument(message.takerConnectedOutputsForAllInputs.size() > 0);
complete();

4
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsDepositTxPublishedMessage.java
View File

@ -38,9 +38,9 @@ public class TakerSendsDepositTxPublishedMessage extends TakerTradeTask {
@Override
protected void doRun() {
try {
DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(takerTradeProcessModel.getId(), takerTrade.getDepositTx());
DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(processModel.getId(), takerTrade.getDepositTx());
takerTradeProcessModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("DepositTxPublishedMessage successfully arrived at peer");

16
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsFiatTransferStartedMessage.java
View File

@ -38,15 +38,15 @@ public class TakerSendsFiatTransferStartedMessage extends TakerTradeTask {
@Override
protected void doRun() {
try {
FiatTransferStartedMessage tradeMessage = new FiatTransferStartedMessage(takerTradeProcessModel.getId(),
takerTradeProcessModel.getPayoutTxSignature(),
takerTradeProcessModel.getPayoutAmount(),
takerTradeProcessModel.tradingPeer.getPayoutAmount(),
takerTradeProcessModel.getAddressEntry().getAddressString());
FiatTransferStartedMessage tradeMessage = new FiatTransferStartedMessage(processModel.getId(),
processModel.getPayoutTxSignature(),
processModel.getPayoutAmount(),
processModel.tradingPeer.getPayoutAmount(),
processModel.getAddressEntry().getAddressString());
takerTradeProcessModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage,
takerTradeProcessModel.getP2pSigPubKey(),
takerTradeProcessModel.getP2pEncryptPubKey(),
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage,
processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPubKey(),
new SendMessageListener() {
@Override
public void handleResult() {

10
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsRequestDepositTxInputsMessage.java
View File

@ -42,14 +42,14 @@ public class TakerSendsRequestDepositTxInputsMessage extends TakerTradeTask {
@Override
protected void doRun() {
try {
assert takerTradeProcessModel.getTakeOfferFeeTx() != null;
assert processModel.getTakeOfferFeeTx() != null;
RequestDepositTxInputsMessage message = new RequestDepositTxInputsMessage(
takerTradeProcessModel.getId(),
takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString(),
processModel.getId(),
processModel.getTakeOfferFeeTx().getHashAsString(),
takerTrade.getTradeAmount(),
takerTradeProcessModel.getTradeWalletPubKey());
processModel.getTradeWalletPubKey());
takerTradeProcessModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), message, new SendMessageListener() {
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), message, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("Sending TakeOfferFeePayedMessage succeeded.");

18
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsRequestPayDepositMessage.java
View File

@ -39,17 +39,17 @@ public class TakerSendsRequestPayDepositMessage extends TakerTradeTask {
protected void doRun() {
try {
RequestPayDepositFromOffererMessage message = new RequestPayDepositFromOffererMessage(
takerTradeProcessModel.getId(),
processModel.getId(),
model.getTradeAmount(),
takerTradeProcessModel.getConnectedOutputsForAllInputs(),
takerTradeProcessModel.getOutputs(),
takerTradeProcessModel.getTradeWalletPubKey(),
takerTradeProcessModel.getP2pSigPubKey(),
takerTradeProcessModel.getP2pEncryptPubKey(),
takerTradeProcessModel.getFiatAccount(),
takerTradeProcessModel.getAccountId());
processModel.getConnectedOutputsForAllInputs(),
processModel.getOutputs(),
processModel.getTradeWalletPubKey(),
processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPubKey(),
processModel.getFiatAccount(),
processModel.getAccountId());
takerTradeProcessModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), message, new SendMessageListener() {
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), message, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer");

18
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSendsRequestPublishDepositTxMessage.java
View File

@ -39,19 +39,19 @@ public class TakerSendsRequestPublishDepositTxMessage extends TakerTradeTask {
protected void doRun() {
try {
RequestPublishDepositTxMessage tradeMessage = new RequestPublishDepositTxMessage(
takerTradeProcessModel.getId(),
takerTradeProcessModel.getFiatAccount(),
takerTradeProcessModel.getAccountId(),
takerTradeProcessModel.getP2pSigPubKey(),
takerTradeProcessModel.getP2pEncryptPublicKey(),
processModel.getId(),
processModel.getFiatAccount(),
processModel.getAccountId(),
processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPublicKey(),
takerTrade.getContractAsJson(),
takerTrade.getTakerContractSignature(),
takerTradeProcessModel.getAddressEntry().getAddressString(),
takerTradeProcessModel.getPreparedDepositTx(),
takerTradeProcessModel.getConnectedOutputsForAllInputs()
processModel.getAddressEntry().getAddressString(),
processModel.getPreparedDepositTx(),
processModel.getConnectedOutputsForAllInputs()
);
takerTradeProcessModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
complete();

16
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerSignsAndPublishDepositTx.java
View File

@ -46,15 +46,15 @@ public class TakerSignsAndPublishDepositTx extends TakerTradeTask {
try {
Coin inputAmount = takerTrade.getSecurityDeposit().add(FeePolicy.TX_FEE);
takerTradeProcessModel.getTradeWalletService().signAndPublishDepositTx(
takerTradeProcessModel.tradingPeer.getPreparedDepositTx(),
takerTradeProcessModel.getConnectedOutputsForAllInputs(),
takerTradeProcessModel.tradingPeer.getConnectedOutputsForAllInputs(),
takerTradeProcessModel.getOutputs(),
processModel.getTradeWalletService().signAndPublishDepositTx(
processModel.tradingPeer.getPreparedDepositTx(),
processModel.getConnectedOutputsForAllInputs(),
processModel.tradingPeer.getConnectedOutputsForAllInputs(),
processModel.getOutputs(),
inputAmount,
takerTradeProcessModel.getTradeWalletPubKey(),
takerTradeProcessModel.tradingPeer.getTradeWalletPubKey(),
takerTradeProcessModel.getArbitratorPubKey(),
processModel.getTradeWalletPubKey(),
processModel.tradingPeer.getTradeWalletPubKey(),
processModel.getArbitratorPubKey(),
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {

20
core/src/main/java/io/bitsquare/trade/protocol/trade/buyer/taker/tasks/TakerVerifiesAndSignsContract.java
View File

@ -37,23 +37,23 @@ public class TakerVerifiesAndSignsContract extends TakerTradeTask {
protected void doRun() {
try {
Contract contract = new Contract(
takerTradeProcessModel.getOffer(),
processModel.getOffer(),
takerTrade.getTradeAmount(),
takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString(),
takerTradeProcessModel.tradingPeer.getAccountId(),
takerTradeProcessModel.getAccountId(),
takerTradeProcessModel.tradingPeer.getFiatAccount(),
takerTradeProcessModel.getFiatAccount(),
takerTradeProcessModel.tradingPeer.getP2pSigPubKey(),
takerTradeProcessModel.getP2pSigPubKey());
processModel.getTakeOfferFeeTx().getHashAsString(),
processModel.tradingPeer.getAccountId(),
processModel.getAccountId(),
processModel.tradingPeer.getFiatAccount(),
processModel.getFiatAccount(),
processModel.tradingPeer.getP2pSigPubKey(),
processModel.getP2pSigPubKey());
String contractAsJson = Utilities.objectToJson(contract);
String signature = takerTradeProcessModel.getSignatureService().signMessage(takerTradeProcessModel.getRegistrationKeyPair(),
String signature = processModel.getSignatureService().signMessage(processModel.getRegistrationKeyPair(),
contractAsJson);
takerTrade.setContract(contract);
takerTrade.setContractAsJson(contractAsJson);
takerTrade.setOffererContractSignature(signature);
takerTrade.setOffererContractSignature(takerTradeProcessModel.tradingPeer.getContractSignature());
takerTrade.setOffererContractSignature(processModel.tradingPeer.getContractSignature());
complete();
} catch (Throwable t) {

218
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererProcessModel.java
View File

@ -1,218 +0,0 @@
/*
* This file is part of Bitsquare.
*
* Bitsquare is free software: you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or (at
* your option) any later version.
*
* Bitsquare is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
* License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade.offerer.models;
import io.bitsquare.arbitration.ArbitrationRepository;
import io.bitsquare.btc.AddressEntry;
import io.bitsquare.btc.BlockChainService;
import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.btc.WalletService;
import io.bitsquare.crypto.SignatureService;
import io.bitsquare.fiat.FiatAccount;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.MessageService;
import io.bitsquare.trade.protocol.trade.ProcessModel;
import io.bitsquare.trade.protocol.trade.shared.models.TradingPeer;
import io.bitsquare.user.User;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction;
import org.bitcoinj.core.TransactionOutput;
import org.bitcoinj.crypto.DeterministicKey;
import java.io.IOException;
import java.io.Serializable;
import java.security.PublicKey;
import java.util.List;
import javax.annotation.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererProcessModel extends ProcessModel implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(OffererProcessModel.class);
// Immutable
public final TradingPeer tradingPeer;
// Transient/Immutable
private transient Offer offer;
private transient WalletService walletService;
private transient User user;
// Mutable
private String takeOfferFeeTxId;
private Transaction payoutTx;
private byte[] payoutTxSignature;
private Coin payoutAmount;
private List<TransactionOutput> connectedOutputsForAllInputs;
private List<TransactionOutput> outputs; // used to verify amounts with change outputs
private Transaction preparedDepositTx;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor, initialization
///////////////////////////////////////////////////////////////////////////////////////////
public OffererProcessModel() {
log.trace("Created by constructor");
tradingPeer = new TradingPeer();
}
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
log.trace("Created from serialized form.");
}
public void onAllServicesInitialized(Offer offer,
MessageService messageService,
WalletService walletService,
TradeWalletService tradeWalletService,
BlockChainService blockChainService,
SignatureService signatureService,
ArbitrationRepository arbitrationRepository,
User user) {
log.trace("onAllServicesInitialized");
super.onAllServicesInitialized(offer,
messageService,
walletService,
tradeWalletService,
blockChainService,
signatureService,
arbitrationRepository,
user);
this.offer = offer;
this.walletService = walletService;
this.user = user;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Getter/Setter for Mutable objects
///////////////////////////////////////////////////////////////////////////////////////////
@Nullable
public String getTakeOfferFeeTxId() {
return takeOfferFeeTxId;
}
public void setTakeOfferFeeTxId(String takeOfferFeeTxId) {
this.takeOfferFeeTxId = takeOfferFeeTxId;
}
public Transaction getPayoutTx() {
return payoutTx;
}
public void setPayoutTx(Transaction payoutTx) {
this.payoutTx = payoutTx;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Getter only
///////////////////////////////////////////////////////////////////////////////////////////
public FiatAccount getFiatAccount() {
return user.getFiatAccount(offer.getBankAccountId());
}
public String getAccountId() {
return user.getAccountId();
}
public PublicKey getP2pSigPubKey() {
return user.getP2PSigPubKey();
}
public PublicKey getP2pEncryptPublicKey() {
return user.getP2PEncryptPubKey();
}
public PublicKey getP2pEncryptPubKey() {
return user.getP2PEncryptPubKey();
}
public byte[] getRegistrationPubKey() {
return walletService.getRegistrationAddressEntry().getPubKey();
}
public DeterministicKey getRegistrationKeyPair() {
return walletService.getRegistrationAddressEntry().getKeyPair();
}
public AddressEntry getAddressEntry() {
return walletService.getAddressEntry(offer.getId());
}
public byte[] getTradeWalletPubKey() {
return getAddressEntry().getPubKey();
}
///////////////////////////////////////////////////////////////////////////////////////////
// Getter/Setter for Mutable objects
///////////////////////////////////////////////////////////////////////////////////////////
public List<TransactionOutput> getOutputs() {
return outputs;
}
public void setOutputs(List<TransactionOutput> outputs) {
this.outputs = outputs;
}
public byte[] getPayoutTxSignature() {
return payoutTxSignature;
}
public void setPayoutTxSignature(byte[] payoutTxSignature) {
this.payoutTxSignature = payoutTxSignature;
}
public Coin getPayoutAmount() {
return payoutAmount;
}
public void setPayoutAmount(Coin payoutAmount) {
this.payoutAmount = payoutAmount;
}
public List<TransactionOutput> getConnectedOutputsForAllInputs() {
return connectedOutputsForAllInputs;
}
public void setConnectedOutputsForAllInputs(List<TransactionOutput> connectedOutputsForAllInputs) {
this.connectedOutputsForAllInputs = connectedOutputsForAllInputs;
}
public Transaction getPreparedDepositTx() {
return preparedDepositTx;
}
public void setPreparedDepositTx(Transaction preparedDepositTx) {
this.preparedDepositTx = preparedDepositTx;
}
}

6
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/OffererTradeTask.java
View File

@ -20,21 +20,21 @@ package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererProcessModel;
import io.bitsquare.trade.protocol.trade.ProcessModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererTradeTask extends Task<OffererTrade> {
private static final Logger log = LoggerFactory.getLogger(OffererTradeTask.class);
protected final OffererProcessModel offererTradeProcessModel;
protected final ProcessModel processModel;
protected final OffererTrade offererTrade;
public OffererTradeTask(TaskRunner taskHandler, OffererTrade offererTrade) {
super(taskHandler, offererTrade);
this.offererTrade = offererTrade;
offererTradeProcessModel = offererTrade.getProcessModel();
processModel = offererTrade.getProcessModel();
}
@Override

24
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/SellerAsOffererProtocol.java
View File

@ -27,11 +27,11 @@ import io.bitsquare.trade.OffererAsSellerTrade;
import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.protocol.availability.messages.ReportOfferAvailabilityMessage;
import io.bitsquare.trade.protocol.availability.messages.RequestIsOfferAvailableMessage;
import io.bitsquare.trade.protocol.trade.ProcessModel;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.messages.FiatTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestPayDepositMessage;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererProcessModel;
import io.bitsquare.trade.protocol.trade.seller.offerer.tasks.OffererCommitDepositTx;
import io.bitsquare.trade.protocol.trade.seller.offerer.tasks.OffererCreatesAndSignsContract;
import io.bitsquare.trade.protocol.trade.seller.offerer.tasks.OffererCreatesAndSignsDepositTx;
@ -54,7 +54,7 @@ public class SellerAsOffererProtocol implements Protocol {
private final MessageHandler messageHandler;
private final OffererAsSellerTrade offererAsSellerTrade;
private final OffererProcessModel offererTradeProcessModel;
private final ProcessModel processModel;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
@ -63,10 +63,10 @@ public class SellerAsOffererProtocol implements Protocol {
public SellerAsOffererProtocol(OffererAsSellerTrade model) {
log.debug("New OffererProtocol " + this);
this.offererAsSellerTrade = model;
offererTradeProcessModel = offererAsSellerTrade.getProcessModel();
processModel = offererAsSellerTrade.getProcessModel();
messageHandler = this::handleMessage;
offererTradeProcessModel.getMessageService().addMessageHandler(messageHandler);
processModel.getMessageService().addMessageHandler(messageHandler);
}
@ -88,7 +88,7 @@ public class SellerAsOffererProtocol implements Protocol {
public void cleanup() {
log.debug("cleanup " + this);
offererTradeProcessModel.getMessageService().removeMessageHandler(messageHandler);
processModel.getMessageService().removeMessageHandler(messageHandler);
}
///////////////////////////////////////////////////////////////////////////////////////////
@ -101,7 +101,7 @@ public class SellerAsOffererProtocol implements Protocol {
private void handle(RequestIsOfferAvailableMessage tradeMessage, Peer sender) {
try {
checkTradeId(offererTradeProcessModel.getId(), tradeMessage);
checkTradeId(processModel.getId(), tradeMessage);
// We don't store anything in the offererTradeProcessModel as we might be in a trade process and receive that request from another peer who wants
// to take the
@ -109,8 +109,8 @@ public class SellerAsOffererProtocol implements Protocol {
// at the same time
boolean isOfferOpen = offererAsSellerTrade.lifeCycleStateProperty().get() == OffererAsSellerTrade.LifeCycleState.OFFER_OPEN;
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(offererTradeProcessModel.getId(), isOfferOpen);
offererTradeProcessModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(processModel.getId(), isOfferOpen);
processModel.getMessageService().sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@Override
public void handleResult() {
// Offerer does not do anything at that moment. Peer might only watch the offer and does not start a trade.
@ -135,7 +135,7 @@ public class SellerAsOffererProtocol implements Protocol {
///////////////////////////////////////////////////////////////////////////////////////////
private void handle(RequestPayDepositMessage tradeMessage, Peer sender) {
offererTradeProcessModel.setTradeMessage(tradeMessage);
processModel.setTradeMessage(tradeMessage);
offererAsSellerTrade.setTradingPeer(sender);
@ -154,7 +154,7 @@ public class SellerAsOffererProtocol implements Protocol {
}
private void handle(DepositTxPublishedMessage tradeMessage) {
offererTradeProcessModel.setTradeMessage(tradeMessage);
processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsSellerTrade> taskRunner = new TaskRunner<>(offererAsSellerTrade,
() -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"),
@ -168,7 +168,7 @@ public class SellerAsOffererProtocol implements Protocol {
}
private void handle(FiatTransferStartedMessage tradeMessage) {
offererTradeProcessModel.setTradeMessage(tradeMessage);
processModel.setTradeMessage(tradeMessage);
TaskRunner<OffererAsSellerTrade> taskRunner = new TaskRunner<>(offererAsSellerTrade,
() -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"),
@ -192,7 +192,7 @@ public class SellerAsOffererProtocol implements Protocol {
log.debug("taskRunner at handleFiatReceivedUIEvent completed");
// we are done!
offererTradeProcessModel.onComplete();
processModel.onComplete();
},
this::handleTaskRunnerFault);

2
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererCommitDepositTx.java
View File

@ -37,7 +37,7 @@ public class OffererCommitDepositTx extends OffererTradeTask {
protected void doRun() {
try {
// To access tx confidence we need to add that tx into our wallet.
Transaction depositTx = offererTradeProcessModel.getTradeWalletService().commitTx(offererTrade.getDepositTx());
Transaction depositTx = processModel.getTradeWalletService().commitTx(offererTrade.getDepositTx());
offererTrade.setDepositTx(depositTx);

20
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererCreatesAndSignsContract.java
View File

@ -36,19 +36,19 @@ public class OffererCreatesAndSignsContract extends OffererTradeTask {
@Override
protected void doRun() {
try {
assert offererTradeProcessModel.getTakeOfferFeeTxId() != null;
assert processModel.getTakeOfferFeeTxId() != null;
Contract contract = new Contract(
offererTradeProcessModel.getOffer(),
processModel.getOffer(),
model.getTradeAmount(),
offererTradeProcessModel.getTakeOfferFeeTxId(),
offererTradeProcessModel.getAccountId(),
offererTradeProcessModel.getAccountId(),
offererTradeProcessModel.getFiatAccount(),
offererTradeProcessModel.getFiatAccount(),
offererTradeProcessModel.getOffer().getP2PSigPubKey(),
offererTradeProcessModel.getP2pSigPubKey());
processModel.getTakeOfferFeeTxId(),
processModel.getAccountId(),
processModel.getAccountId(),
processModel.getFiatAccount(),
processModel.getFiatAccount(),
processModel.getOffer().getP2PSigPubKey(),
processModel.getP2pSigPubKey());
String contractAsJson = Utilities.objectToJson(contract);
String signature = offererTradeProcessModel.getSignatureService().signMessage(offererTradeProcessModel.getRegistrationKeyPair(),
String signature = processModel.getSignatureService().signMessage(processModel.getRegistrationKeyPair(),
contractAsJson);
model.setContract(contract);

18
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererCreatesAndSignsDepositTx.java
View File

@ -42,19 +42,19 @@ public class OffererCreatesAndSignsDepositTx extends OffererTradeTask {
Coin inputAmount = offererTrade.getSecurityDeposit().add(FeePolicy.TX_FEE).add(offererTrade.getTradeAmount());
Coin msOutputAmount = inputAmount.add(offererTrade.getSecurityDeposit());
TradeWalletService.Result result = offererTradeProcessModel.getTradeWalletService().createAndSignDepositTx(
TradeWalletService.Result result = processModel.getTradeWalletService().createAndSignDepositTx(
inputAmount,
msOutputAmount,
offererTradeProcessModel.tradingPeer.getConnectedOutputsForAllInputs(),
offererTradeProcessModel.tradingPeer.getOutputs(),
offererTradeProcessModel.getAddressEntry(),
offererTradeProcessModel.tradingPeer.getTradeWalletPubKey(),
offererTradeProcessModel.getTradeWalletPubKey(),
offererTradeProcessModel.getArbitratorPubKey());
processModel.tradingPeer.getConnectedOutputsForAllInputs(),
processModel.tradingPeer.getOutputs(),
processModel.getAddressEntry(),
processModel.tradingPeer.getTradeWalletPubKey(),
processModel.getTradeWalletPubKey(),
processModel.getArbitratorPubKey());
offererTradeProcessModel.setConnectedOutputsForAllInputs(result.getConnectedOutputsForAllInputs());
offererTradeProcessModel.setPreparedDepositTx(result.getDepositTx());
processModel.setConnectedOutputsForAllInputs(result.getConnectedOutputsForAllInputs());
processModel.setPreparedDepositTx(result.getDepositTx());
complete();
} catch (Throwable t) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererProcessDepositTxPublishedMessage.java
View File

@ -40,8 +40,8 @@ public class OffererProcessDepositTxPublishedMessage extends OffererTradeTask {
@Override
protected void doRun() {
try {
DepositTxPublishedMessage message = (DepositTxPublishedMessage) offererTradeProcessModel.getTradeMessage();
checkTradeId(offererTradeProcessModel.getId(), message);
DepositTxPublishedMessage message = (DepositTxPublishedMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
offererTrade.setDepositTx(checkNotNull(message.depositTx));

12
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererProcessFiatTransferStartedMessage.java
View File

@ -40,14 +40,14 @@ public class OffererProcessFiatTransferStartedMessage extends OffererTradeTask {
@Override
protected void doRun() {
try {
FiatTransferStartedMessage message = (FiatTransferStartedMessage) offererTradeProcessModel.getTradeMessage();
checkTradeId(offererTradeProcessModel.getId(), message);
FiatTransferStartedMessage message = (FiatTransferStartedMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
offererTradeProcessModel.tradingPeer.setSignature(checkNotNull(message.buyerSignature));
offererTradeProcessModel.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.sellerPayoutAmount)));
offererTradeProcessModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount)));
offererTradeProcessModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
processModel.tradingPeer.setSignature(checkNotNull(message.buyerSignature));
processModel.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.sellerPayoutAmount)));
processModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount)));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);

18
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererProcessRequestPayDepositFromOffererMessage.java
View File

@ -38,18 +38,18 @@ public class OffererProcessRequestPayDepositFromOffererMessage extends OffererTr
@Override
protected void doRun() {
try {
RequestPayDepositFromOffererMessage message = (RequestPayDepositFromOffererMessage) offererTradeProcessModel.getTradeMessage();
checkTradeId(offererTradeProcessModel.getId(), message);
RequestPayDepositFromOffererMessage message = (RequestPayDepositFromOffererMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
offererTradeProcessModel.tradingPeer.setConnectedOutputsForAllInputs(checkNotNull(message.buyerConnectedOutputsForAllInputs));
processModel.tradingPeer.setConnectedOutputsForAllInputs(checkNotNull(message.buyerConnectedOutputsForAllInputs));
checkArgument(message.buyerConnectedOutputsForAllInputs.size() > 0);
offererTradeProcessModel.tradingPeer.setOutputs(checkNotNull(message.buyerOutputs));
offererTradeProcessModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.buyerTradeWalletPubKey));
offererTradeProcessModel.tradingPeer.setP2pSigPubKey(checkNotNull(message.buyerP2PSigPublicKey));
offererTradeProcessModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.buyerP2PEncryptPublicKey));
offererTradeProcessModel.tradingPeer.setFiatAccount(checkNotNull(message.buyerFiatAccount));
offererTradeProcessModel.tradingPeer.setAccountId(nonEmptyStringOf(message.buyerAccountId));
processModel.tradingPeer.setOutputs(checkNotNull(message.buyerOutputs));
processModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.buyerTradeWalletPubKey));
processModel.tradingPeer.setP2pSigPubKey(checkNotNull(message.buyerP2PSigPublicKey));
processModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.buyerP2PEncryptPublicKey));
processModel.tradingPeer.setFiatAccount(checkNotNull(message.buyerFiatAccount));
processModel.tradingPeer.setAccountId(nonEmptyStringOf(message.buyerAccountId));
offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(message.tradeAmount)));
complete();

8
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererSendsPayoutTxPublishedMessage.java
View File

@ -38,11 +38,11 @@ public class OffererSendsPayoutTxPublishedMessage extends OffererTradeTask {
@Override
protected void doRun() {
try {
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(offererTradeProcessModel.getId(), offererTradeProcessModel.getPayoutTx());
offererTradeProcessModel.getMessageService().sendMessage(offererTrade.getTradingPeer(),
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(processModel.getId(), processModel.getPayoutTx());
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(),
tradeMessage,
offererTradeProcessModel.getP2pSigPubKey(),
offererTradeProcessModel.getP2pEncryptPubKey(),
processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPubKey(),
new SendMessageListener() {
@Override
public void handleResult() {

20
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererSendsRequestPublishDepositTxFromTakerMessage.java
View File

@ -39,20 +39,20 @@ public class OffererSendsRequestPublishDepositTxFromTakerMessage extends Offerer
protected void doRun() {
try {
RequestPublishDepositTxFromTakerMessage tradeMessage = new RequestPublishDepositTxFromTakerMessage(
offererTradeProcessModel.getId(),
offererTradeProcessModel.getFiatAccount(),
offererTradeProcessModel.getAccountId(),
offererTradeProcessModel.getTradeWalletPubKey(),
offererTradeProcessModel.getP2pSigPubKey(),
offererTradeProcessModel.getP2pEncryptPublicKey(),
processModel.getId(),
processModel.getFiatAccount(),
processModel.getAccountId(),
processModel.getTradeWalletPubKey(),
processModel.getP2pSigPubKey(),
processModel.getP2pEncryptPublicKey(),
offererTrade.getContractAsJson(),
offererTrade.getOffererContractSignature(),
offererTradeProcessModel.getAddressEntry().getAddressString(),
offererTradeProcessModel.getPreparedDepositTx(),
offererTradeProcessModel.getConnectedOutputsForAllInputs()
processModel.getAddressEntry().getAddressString(),
processModel.getPreparedDepositTx(),
processModel.getConnectedOutputsForAllInputs()
);
offererTradeProcessModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
processModel.getMessageService().sendMessage(offererTrade.getTradingPeer(), tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
complete();

20
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/offerer/tasks/OffererSignsAndPublishPayoutTx.java
View File

@ -42,20 +42,20 @@ public class OffererSignsAndPublishPayoutTx extends OffererTradeTask {
@Override
protected void doRun() {
try {
offererTradeProcessModel.getTradeWalletService().signAndPublishPayoutTx(
processModel.getTradeWalletService().signAndPublishPayoutTx(
offererTrade.getDepositTx(),
offererTradeProcessModel.tradingPeer.getSignature(),
offererTradeProcessModel.tradingPeer.getPayoutAmount(),
offererTradeProcessModel.getPayoutAmount(),
offererTradeProcessModel.tradingPeer.getPayoutAddressString(),
offererTradeProcessModel.getAddressEntry(),
offererTradeProcessModel.tradingPeer.getTradeWalletPubKey(),
offererTradeProcessModel.getTradeWalletPubKey(),
offererTradeProcessModel.getArbitratorPubKey(),
processModel.tradingPeer.getSignature(),
processModel.tradingPeer.getPayoutAmount(),
processModel.getPayoutAmount(),
processModel.tradingPeer.getPayoutAddressString(),
processModel.getAddressEntry(),
processModel.tradingPeer.getTradeWalletPubKey(),
processModel.getTradeWalletPubKey(),
processModel.getArbitratorPubKey(),
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {
offererTradeProcessModel.setPayoutTx(transaction);
processModel.setPayoutTx(transaction);
if (offererTrade instanceof OffererAsBuyerTrade)
offererTrade.setProcessState(OffererAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);

24
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/SellerAsTakerProtocol.java
View File

@ -25,6 +25,7 @@ import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.TakerAsSellerTrade;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.Protocol;
import io.bitsquare.trade.protocol.trade.ProcessModel;
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.messages.DepositTxPublishedMessage;
@ -43,7 +44,6 @@ import io.bitsquare.trade.protocol.trade.shared.taker.tasks.BroadcastTakeOfferFe
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;
import io.bitsquare.trade.protocol.trade.taker.models.TakerProcessModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -54,7 +54,7 @@ public class SellerAsTakerProtocol implements Protocol {
private static final Logger log = LoggerFactory.getLogger(SellerAsTakerProtocol.class);
private final TakerAsSellerTrade takerAsSellerTrade;
private final TakerProcessModel takerTradeProcessModel;
private final ProcessModel processModel;
private final MessageHandler messageHandler;
@ -65,10 +65,10 @@ public class SellerAsTakerProtocol implements Protocol {
public SellerAsTakerProtocol(TakerAsSellerTrade takerTrade) {
log.debug("New SellerAsTakerProtocol " + this);
this.takerAsSellerTrade = takerTrade;
takerTradeProcessModel = takerTrade.getProcessModel();
processModel = takerTrade.getProcessModel();
messageHandler = this::handleMessage;
takerTradeProcessModel.getMessageService().addMessageHandler(messageHandler);
processModel.getMessageService().addMessageHandler(messageHandler);
}
@ -78,14 +78,14 @@ public class SellerAsTakerProtocol implements Protocol {
public void cleanup() {
log.debug("cleanup " + this);
takerTradeProcessModel.getMessageService().removeMessageHandler(messageHandler);
processModel.getMessageService().removeMessageHandler(messageHandler);
}
public void setMailboxMessage(MailboxMessage mailboxMessage) {
log.debug("setMailboxMessage " + mailboxMessage);
// Might be called twice, so check that its only processed once
if (takerTradeProcessModel.getMailboxMessage() == null) {
takerTradeProcessModel.setMailboxMessage(mailboxMessage);
if (processModel.getMailboxMessage() == null) {
processModel.setMailboxMessage(mailboxMessage);
if (mailboxMessage instanceof FiatTransferStartedMessage) {
handleFiatTransferStartedMessage((FiatTransferStartedMessage) mailboxMessage);
}
@ -114,7 +114,7 @@ public class SellerAsTakerProtocol implements Protocol {
///////////////////////////////////////////////////////////////////////////////////////////
private void handleRequestTakerDepositPaymentMessage(RequestPayDepositMessage tradeMessage) {
takerTradeProcessModel.setTradeMessage(tradeMessage);
processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerTrade> taskRunner = new TaskRunner<>(takerAsSellerTrade,
() -> log.debug("taskRunner at handleTakerDepositPaymentRequestMessage completed"),
@ -131,7 +131,7 @@ public class SellerAsTakerProtocol implements Protocol {
}
private void handleDepositTxPublishedMessage(DepositTxPublishedMessage tradeMessage) {
takerTradeProcessModel.setTradeMessage(tradeMessage);
processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsSellerTrade> taskRunner = new TaskRunner<>(takerAsSellerTrade,
() -> log.debug("taskRunner at handleDepositTxPublishedMessage completed"),
@ -145,7 +145,7 @@ public class SellerAsTakerProtocol implements Protocol {
}
private void handleFiatTransferStartedMessage(FiatTransferStartedMessage tradeMessage) {
takerTradeProcessModel.setTradeMessage(tradeMessage);
processModel.setTradeMessage(tradeMessage);
TaskRunner<TakerAsSellerTrade> taskRunner = new TaskRunner<>(takerAsSellerTrade,
() -> log.debug("taskRunner at handleFiatTransferStartedMessage completed"),
@ -169,7 +169,7 @@ public class SellerAsTakerProtocol implements Protocol {
log.debug("taskRunner at handleFiatReceivedUIEvent completed");
// we are done!
takerTradeProcessModel.onComplete();
processModel.onComplete();
},
this::handleTaskRunnerFault);
@ -191,7 +191,7 @@ public class SellerAsTakerProtocol implements Protocol {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.tradeId.equals(takerTradeProcessModel.getId())) {
if (tradeMessage.tradeId.equals(processModel.getId())) {
if (tradeMessage instanceof RequestPayDepositMessage) {
handleRequestTakerDepositPaymentMessage((RequestPayDepositMessage) tradeMessage);
}

2
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerCommitDepositTx.java
View File

@ -37,7 +37,7 @@ public class TakerCommitDepositTx extends TakerTradeTask {
protected void doRun() {
try {
// To access tx confidence we need to add that tx into our wallet.
Transaction depositTx = takerTradeProcessModel.getTradeWalletService().commitTx(takerTrade.getDepositTx());
Transaction depositTx = processModel.getTradeWalletService().commitTx(takerTrade.getDepositTx());
takerTrade.setDepositTx(depositTx);

20
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerCreatesAndSignContract.java
View File

@ -36,19 +36,19 @@ public class TakerCreatesAndSignContract extends TakerTradeTask {
@Override
protected void doRun() {
try {
assert takerTradeProcessModel.getTakeOfferFeeTx() != null;
assert processModel.getTakeOfferFeeTx() != null;
Contract contract = new Contract(
takerTradeProcessModel.getOffer(),
processModel.getOffer(),
model.getTradeAmount(),
takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString(),
takerTradeProcessModel.tradingPeer.getAccountId(),
takerTradeProcessModel.getAccountId(),
takerTradeProcessModel.tradingPeer.getFiatAccount(),
takerTradeProcessModel.getFiatAccount(),
takerTradeProcessModel.getOffer().getP2PSigPubKey(),
takerTradeProcessModel.getP2pSigPubKey());
processModel.getTakeOfferFeeTx().getHashAsString(),
processModel.tradingPeer.getAccountId(),
processModel.getAccountId(),
processModel.tradingPeer.getFiatAccount(),
processModel.getFiatAccount(),
processModel.getOffer().getP2PSigPubKey(),
processModel.getP2pSigPubKey());
String contractAsJson = Utilities.objectToJson(contract);
String signature = takerTradeProcessModel.getSignatureService().signMessage(takerTradeProcessModel.getRegistrationKeyPair(), contractAsJson);
String signature = processModel.getSignatureService().signMessage(processModel.getRegistrationKeyPair(), contractAsJson);
model.setContract(contract);
model.setContractAsJson(contractAsJson);

18
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerCreatesAndSignsDepositTx.java
View File

@ -42,18 +42,18 @@ public class TakerCreatesAndSignsDepositTx extends TakerTradeTask {
Coin inputAmount = takerTrade.getSecurityDeposit().add(FeePolicy.TX_FEE).add(takerTrade.getTradeAmount());
Coin msOutputAmount = inputAmount.add(takerTrade.getSecurityDeposit());
TradeWalletService.Result result = takerTradeProcessModel.getTradeWalletService().createAndSignDepositTx(
TradeWalletService.Result result = processModel.getTradeWalletService().createAndSignDepositTx(
inputAmount,
msOutputAmount,
takerTradeProcessModel.tradingPeer.getConnectedOutputsForAllInputs(),
takerTradeProcessModel.tradingPeer.getOutputs(),
takerTradeProcessModel.getAddressEntry(),
takerTradeProcessModel.tradingPeer.getTradeWalletPubKey(),
takerTradeProcessModel.getTradeWalletPubKey(),
takerTradeProcessModel.getArbitratorPubKey());
processModel.tradingPeer.getConnectedOutputsForAllInputs(),
processModel.tradingPeer.getOutputs(),
processModel.getAddressEntry(),
processModel.tradingPeer.getTradeWalletPubKey(),
processModel.getTradeWalletPubKey(),
processModel.getArbitratorPubKey());
takerTradeProcessModel.setConnectedOutputsForAllInputs(result.getConnectedOutputsForAllInputs());
takerTradeProcessModel.setPreparedDepositTx(result.getDepositTx());
processModel.setConnectedOutputsForAllInputs(result.getConnectedOutputsForAllInputs());
processModel.setPreparedDepositTx(result.getDepositTx());
complete();
} catch (Throwable t) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerProcessDepositTxPublishedMessage.java
View File

@ -40,8 +40,8 @@ public class TakerProcessDepositTxPublishedMessage extends TakerTradeTask {
@Override
protected void doRun() {
try {
DepositTxPublishedMessage message = (DepositTxPublishedMessage) takerTradeProcessModel.getTradeMessage();
checkTradeId(takerTradeProcessModel.getId(), message);
DepositTxPublishedMessage message = (DepositTxPublishedMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
takerTrade.setDepositTx(checkNotNull(message.depositTx));

12
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerProcessFiatTransferStartedMessage.java
View File

@ -40,14 +40,14 @@ public class TakerProcessFiatTransferStartedMessage extends TakerTradeTask {
@Override
protected void doRun() {
try {
FiatTransferStartedMessage message = (FiatTransferStartedMessage) takerTradeProcessModel.getTradeMessage();
checkTradeId(takerTradeProcessModel.getId(), message);
FiatTransferStartedMessage message = (FiatTransferStartedMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
takerTradeProcessModel.tradingPeer.setSignature(checkNotNull(message.buyerSignature));
takerTradeProcessModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount)));
takerTradeProcessModel.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.sellerPayoutAmount)));
takerTradeProcessModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
processModel.tradingPeer.setSignature(checkNotNull(message.buyerSignature));
processModel.tradingPeer.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.buyerPayoutAmount)));
processModel.setPayoutAmount(positiveCoinOf(nonZeroCoinOf(message.sellerPayoutAmount)));
processModel.tradingPeer.setPayoutAddressString(nonEmptyStringOf(message.buyerPayoutAddress));
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.FIAT_PAYMENT_STARTED);

18
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerProcessRequestSellerDepositPaymentMessage.java
View File

@ -38,18 +38,18 @@ public class TakerProcessRequestSellerDepositPaymentMessage extends TakerTradeTa
@Override
protected void doRun() {
try {
RequestPayDepositMessage message = (RequestPayDepositMessage) takerTradeProcessModel.getTradeMessage();
checkTradeId(takerTradeProcessModel.getId(), message);
RequestPayDepositMessage message = (RequestPayDepositMessage) processModel.getTradeMessage();
checkTradeId(processModel.getId(), message);
checkNotNull(message);
takerTradeProcessModel.tradingPeer.setConnectedOutputsForAllInputs(checkNotNull(message.buyerConnectedOutputsForAllInputs));
processModel.tradingPeer.setConnectedOutputsForAllInputs(checkNotNull(message.buyerConnectedOutputsForAllInputs));
checkArgument(message.buyerConnectedOutputsForAllInputs.size() > 0);
takerTradeProcessModel.tradingPeer.setOutputs(checkNotNull(message.buyerOutputs));
takerTradeProcessModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.buyerTradeWalletPubKey));
takerTradeProcessModel.tradingPeer.setP2pSigPubKey(checkNotNull(message.buyerP2PSigPublicKey));
takerTradeProcessModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.buyerP2PEncryptPublicKey));
takerTradeProcessModel.tradingPeer.setFiatAccount(checkNotNull(message.buyerFiatAccount));
takerTradeProcessModel.tradingPeer.setAccountId(nonEmptyStringOf(message.buyerAccountId));
processModel.tradingPeer.setOutputs(checkNotNull(message.buyerOutputs));
processModel.tradingPeer.setTradeWalletPubKey(checkNotNull(message.buyerTradeWalletPubKey));
processModel.tradingPeer.setP2pSigPubKey(checkNotNull(message.buyerP2PSigPublicKey));
processModel.tradingPeer.setP2pEncryptPubKey(checkNotNull(message.buyerP2PEncryptPublicKey));
processModel.tradingPeer.setFiatAccount(checkNotNull(message.buyerFiatAccount));
processModel.tradingPeer.setAccountId(nonEmptyStringOf(message.buyerAccountId));
complete();
} catch (Throwable t) {

8
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerSendsPayoutTxPublishedMessage.java
View File

@ -38,11 +38,11 @@ public class TakerSendsPayoutTxPublishedMessage extends TakerTradeTask {
@Override
protected void doRun() {
try {
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(takerTradeProcessModel.getId(), takerTradeProcessModel.getPayoutTx());
takerTradeProcessModel.getMessageService().sendMessage(takerTrade.getTradingPeer(),
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(processModel.getId(), processModel.getPayoutTx());
processModel.getMessageService().sendMessage(takerTrade.getTradingPeer(),
tradeMessage,
takerTradeProcessModel.tradingPeer.getP2pSigPubKey(),
takerTradeProcessModel.tradingPeer.getP2pEncryptPubKey(),
processModel.tradingPeer.getP2pSigPubKey(),
processModel.tradingPeer.getP2pEncryptPubKey(),
new SendMessageListener() {
@Override
public void handleResult() {

20
core/src/main/java/io/bitsquare/trade/protocol/trade/seller/taker/tasks/TakerSignsAndPublishPayoutTx.java
View File

@ -42,20 +42,20 @@ public class TakerSignsAndPublishPayoutTx extends TakerTradeTask {
@Override
protected void doRun() {
try {
takerTradeProcessModel.getTradeWalletService().signAndPublishPayoutTx(
processModel.getTradeWalletService().signAndPublishPayoutTx(
takerTrade.getDepositTx(),
takerTradeProcessModel.tradingPeer.getSignature(),
takerTradeProcessModel.tradingPeer.getPayoutAmount(),
takerTradeProcessModel.getPayoutAmount(),
takerTradeProcessModel.tradingPeer.getPayoutAddressString(),
takerTradeProcessModel.getAddressEntry(),
takerTradeProcessModel.tradingPeer.getTradeWalletPubKey(),
takerTradeProcessModel.getTradeWalletPubKey(),
takerTradeProcessModel.getArbitratorPubKey(),
processModel.tradingPeer.getSignature(),
processModel.tradingPeer.getPayoutAmount(),
processModel.getPayoutAmount(),
processModel.tradingPeer.getPayoutAddressString(),
processModel.getAddressEntry(),
processModel.tradingPeer.getTradeWalletPubKey(),
processModel.getTradeWalletPubKey(),
processModel.getArbitratorPubKey(),
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {
takerTradeProcessModel.setPayoutTx(transaction);
processModel.setPayoutTx(transaction);
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.PAYOUT_PUBLISHED);

2
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/offerer/tasks/VerifyTakeOfferFeePayment.java
View File

@ -35,7 +35,7 @@ public class VerifyTakeOfferFeePayment extends OffererTradeTask {
protected void doRun() {
try {
//TODO mocked yet, need a confidence listeners
int numOfPeersSeenTx = offererTradeProcessModel.getWalletService().getNumOfPeersSeenTx(offererTradeProcessModel.getTakeOfferFeeTxId());
int numOfPeersSeenTx = processModel.getWalletService().getNumOfPeersSeenTx(processModel.getTakeOfferFeeTxId());
/* if (numOfPeersSeenTx > 2) {
resultHandler.handleResult();
}*/

6
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/offerer/tasks/VerifyTakerAccount.java
View File

@ -37,9 +37,9 @@ public class VerifyTakerAccount extends OffererTradeTask {
protected void doRun() {
try {
//TODO mocked yet
if (offererTradeProcessModel.getBlockChainService().verifyAccountRegistration()) {
if (offererTradeProcessModel.getBlockChainService().isAccountBlackListed(offererTradeProcessModel.tradingPeer.getAccountId(),
offererTradeProcessModel
if (processModel.getBlockChainService().verifyAccountRegistration()) {
if (processModel.getBlockChainService().isAccountBlackListed(processModel.tradingPeer.getAccountId(),
processModel
.tradingPeer
.getFiatAccount())) {
log.error("Taker is blacklisted");

2
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/taker/tasks/BroadcastTakeOfferFeeTx.java
View File

@ -42,7 +42,7 @@ public class BroadcastTakeOfferFeeTx extends TakerTradeTask {
@Override
protected void doRun() {
try {
takerTradeProcessModel.getTradeWalletService().broadcastTakeOfferFeeTx(takerTradeProcessModel.getTakeOfferFeeTx(),
processModel.getTradeWalletService().broadcastTakeOfferFeeTx(processModel.getTakeOfferFeeTx(),
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {

4
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/taker/tasks/CreateTakeOfferFeeTx.java
View File

@ -38,9 +38,9 @@ public class CreateTakeOfferFeeTx extends TakerTradeTask {
@Override
protected void doRun() {
try {
Transaction createTakeOfferFeeTx = takerTradeProcessModel.getTradeWalletService().createTakeOfferFeeTx(takerTradeProcessModel.getAddressEntry());
Transaction createTakeOfferFeeTx = processModel.getTradeWalletService().createTakeOfferFeeTx(processModel.getAddressEntry());
takerTradeProcessModel.setTakeOfferFeeTx(createTakeOfferFeeTx);
processModel.setTakeOfferFeeTx(createTakeOfferFeeTx);
if (takerTrade instanceof TakerAsBuyerTrade)
takerTrade.setProcessState(TakerAsBuyerTrade.ProcessState.TAKE_OFFER_FEE_TX_CREATED);

2
core/src/main/java/io/bitsquare/trade/protocol/trade/shared/taker/tasks/VerifyOfferFeePayment.java
View File

@ -35,7 +35,7 @@ public class VerifyOfferFeePayment extends TakerTradeTask {
protected void doRun() {
try {
//TODO impl. missing
int numOfPeersSeenTx = takerTradeProcessModel.getWalletService().getNumOfPeersSeenTx(takerTradeProcessModel.getTakeOfferFeeTx().getHashAsString());
int numOfPeersSeenTx = processModel.getWalletService().getNumOfPeersSeenTx(processModel.getTakeOfferFeeTx().getHashAsString());
/* if (numOfPeersSeenTx > 2) {
resultHandler.handleResult();
}*/

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

@ -34,9 +34,9 @@ public class VerifyOffererAccount extends TakerTradeTask {
@Override
protected void doRun() {
try {
if (takerTradeProcessModel.getBlockChainService().verifyAccountRegistration()) {
if (takerTradeProcessModel.getBlockChainService().isAccountBlackListed(takerTradeProcessModel.tradingPeer.getAccountId(),
takerTradeProcessModel.tradingPeer.getFiatAccount())) {
if (processModel.getBlockChainService().verifyAccountRegistration()) {
if (processModel.getBlockChainService().isAccountBlackListed(processModel.tradingPeer.getAccountId(),
processModel.tradingPeer.getFiatAccount())) {
failed("Taker is blacklisted.");
}
else {

232
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerProcessModel.java
View File

@ -1,232 +0,0 @@
/*
* This file is part of Bitsquare.
*
* Bitsquare is free software: you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or (at
* your option) any later version.
*
* Bitsquare is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
* License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade.taker.models;
import io.bitsquare.arbitration.ArbitrationRepository;
import io.bitsquare.btc.AddressEntry;
import io.bitsquare.btc.BlockChainService;
import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.btc.WalletService;
import io.bitsquare.crypto.SignatureService;
import io.bitsquare.fiat.FiatAccount;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.MessageService;
import io.bitsquare.trade.protocol.trade.ProcessModel;
import io.bitsquare.trade.protocol.trade.shared.models.TradingPeer;
import io.bitsquare.user.User;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction;
import org.bitcoinj.core.TransactionOutput;
import org.bitcoinj.crypto.DeterministicKey;
import java.io.IOException;
import java.io.Serializable;
import java.security.PublicKey;
import java.util.List;
import javax.annotation.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Fully serializable, no transient fields
* <p/>
* Holds all data which are needed between tasks. All relevant data for the trade itself are stored in Trade.
*/
public class TakerProcessModel extends ProcessModel implements Serializable {
// That object is saved to disc. We need to take care of changes to not break deserialization.
private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(TakerProcessModel.class);
// Immutable
public final TradingPeer tradingPeer;
// Transient/Immutable
transient private Offer offer;
transient private WalletService walletService;
transient private User user;
// Mutable
private Transaction takeOfferFeeTx;
private Transaction payoutTx;
private List<TransactionOutput> connectedOutputsForAllInputs;
private Coin payoutAmount;
private Transaction preparedDepositTx;
private List<TransactionOutput> outputs; // used to verify amounts with change outputs
private byte[] payoutTxSignature;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor, initialization
///////////////////////////////////////////////////////////////////////////////////////////
public TakerProcessModel() {
log.trace("Created by constructor");
tradingPeer = new TradingPeer();
}
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
log.trace("Created from serialized form.");
}
@Override
public void onAllServicesInitialized(Offer offer,
MessageService messageService,
WalletService walletService,
TradeWalletService tradeWalletService,
BlockChainService blockChainService,
SignatureService signatureService,
ArbitrationRepository arbitrationRepository,
User user) {
log.trace("onAllServicesInitialized");
super.onAllServicesInitialized(offer,
messageService,
walletService,
tradeWalletService,
blockChainService,
signatureService,
arbitrationRepository,
user);
this.offer = offer;
this.walletService = walletService;
this.user = user;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Getter/Setter for Mutable objects
///////////////////////////////////////////////////////////////////////////////////////////
@Nullable
public Transaction getPayoutTx() {
return payoutTx;
}
public void setPayoutTx(Transaction payoutTx) {
this.payoutTx = payoutTx;
}
@Nullable
public Transaction getTakeOfferFeeTx() {
return takeOfferFeeTx;
}
public void setTakeOfferFeeTx(Transaction takeOfferFeeTx) {
this.takeOfferFeeTx = takeOfferFeeTx;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Getter only
///////////////////////////////////////////////////////////////////////////////////////////
public FiatAccount getFiatAccount() {
return user.getFiatAccount(offer.getBankAccountId());
}
public DeterministicKey getRegistrationKeyPair() {
return walletService.getRegistrationAddressEntry().getKeyPair();
}
public String getAccountId() {
return user.getAccountId();
}
public PublicKey getP2pSigPubKey() {
return user.getP2PSigPubKey();
}
public PublicKey getP2pEncryptPublicKey() {
return user.getP2PEncryptPubKey();
}
public byte[] getRegistrationPubKey() {
return walletService.getRegistrationAddressEntry().getPubKey();
}
public AddressEntry getAddressEntry() {
return walletService.getAddressEntry(offer.getId());
}
public byte[] getTradeWalletPubKey() {
return getAddressEntry().getPubKey();
}
public PublicKey getP2pEncryptPubKey() {
return user.getP2PEncryptPubKey();
}
///////////////////////////////////////////////////////////////////////////////////////////
// Getter/Setter for Mutable objects
///////////////////////////////////////////////////////////////////////////////////////////
@Nullable
public List<TransactionOutput> getConnectedOutputsForAllInputs() {
return connectedOutputsForAllInputs;
}
public void setConnectedOutputsForAllInputs(List<TransactionOutput> connectedOutputsForAllInputs) {
this.connectedOutputsForAllInputs = connectedOutputsForAllInputs;
}
@Nullable
public Coin getPayoutAmount() {
return payoutAmount;
}
public void setPayoutAmount(Coin payoutAmount) {
this.payoutAmount = payoutAmount;
}
@Nullable
public Transaction getPreparedDepositTx() {
return preparedDepositTx;
}
public void setPreparedDepositTx(Transaction preparedDepositTx) {
this.preparedDepositTx = preparedDepositTx;
}
@Nullable
public List<TransactionOutput> getOutputs() {
return outputs;
}
public void setOutputs(List<TransactionOutput> outputs) {
this.outputs = outputs;
}
@Nullable
public byte[] getPayoutTxSignature() {
return payoutTxSignature;
}
public void setPayoutTxSignature(byte[] payoutTxSignature) {
this.payoutTxSignature = payoutTxSignature;
}
}

6
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/TakerTradeTask.java
View File

@ -20,21 +20,21 @@ package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.TakerTrade;
import io.bitsquare.trade.protocol.trade.taker.models.TakerProcessModel;
import io.bitsquare.trade.protocol.trade.ProcessModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TakerTradeTask extends Task<TakerTrade> {
private static final Logger log = LoggerFactory.getLogger(TakerTradeTask.class);
protected final TakerProcessModel takerTradeProcessModel;
protected final ProcessModel processModel;
protected final TakerTrade takerTrade;
public TakerTradeTask(TaskRunner taskHandler, TakerTrade takerTrade) {
super(taskHandler, takerTrade);
this.takerTrade = takerTrade;
takerTradeProcessModel = takerTrade.getProcessModel();
processModel = takerTrade.getProcessModel();
}
@Override