Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-06-20 21:04:28 -04:00
Code Issues Projects Releases Packages Wiki Activity

Change accessors

Browse source
This commit is contained in:
Manfred Karrer 2015-03-18 11:52:12 +01:00
parent ac886c1c94
commit 769037e137
76 changed files with 521 additions and 680 deletions
Download patch file Download diff file Expand all files Collapse all files

47
core/src/main/java/io/bitsquare/btc/TradeWalletService.java
View file

@ -94,7 +94,7 @@ public class TradeWalletService {
// Trade fee
///////////////////////////////////////////////////////////////////////////////////////////
public Transaction createOfferFeeTx(AddressEntry addressEntry) throws InsufficientMoneyException {
public Transaction createOfferFeeTx(AddressEntry offererAddressEntry) throws InsufficientMoneyException {
Transaction createOfferFeeTx = new Transaction(params);
Coin fee = FeePolicy.CREATE_OFFER_FEE.subtract(FeePolicy.TX_FEE);
createOfferFeeTx.addOutput(fee, feePolicy.getAddressForCreateOfferFee());
@ -102,8 +102,8 @@ public class TradeWalletService {
sendRequest.shuffleOutputs = false;
// we allow spending of unconfirmed tx (double spend risk is low and usability would suffer if we need to
// wait for 1 confirmation)
sendRequest.coinSelector = new AddressBasedCoinSelector(params, addressEntry, true);
sendRequest.changeAddress = addressEntry.getAddress();
sendRequest.coinSelector = new AddressBasedCoinSelector(params, offererAddressEntry, true);
sendRequest.changeAddress = offererAddressEntry.getAddress();
wallet.completeTx(sendRequest);
printTxWithInputs("createOfferFeeTx", createOfferFeeTx);
return createOfferFeeTx;
@ -114,7 +114,7 @@ public class TradeWalletService {
Futures.addCallback(future, callback);
}
public Transaction createTakeOfferFeeTx(AddressEntry addressEntry) throws InsufficientMoneyException {
public Transaction createTakeOfferFeeTx(AddressEntry takerAddressEntry) throws InsufficientMoneyException {
Transaction takeOfferFeeTx = new Transaction(params);
Coin fee = FeePolicy.TAKE_OFFER_FEE.subtract(FeePolicy.TX_FEE);
takeOfferFeeTx.addOutput(fee, feePolicy.getAddressForTakeOfferFee());
@ -123,8 +123,8 @@ public class TradeWalletService {
sendRequest.shuffleOutputs = false;
// we allow spending of unconfirmed takeOfferFeeTx (double spend risk is low and usability would suffer if we need to
// wait for 1 confirmation)
sendRequest.coinSelector = new AddressBasedCoinSelector(params, addressEntry, true);
sendRequest.changeAddress = addressEntry.getAddress();
sendRequest.coinSelector = new AddressBasedCoinSelector(params, takerAddressEntry, true);
sendRequest.changeAddress = takerAddressEntry.getAddress();
wallet.completeTx(sendRequest);
printTxWithInputs("takeOfferFeeTx", takeOfferFeeTx);
return takeOfferFeeTx;
@ -140,7 +140,7 @@ public class TradeWalletService {
// Trade
///////////////////////////////////////////////////////////////////////////////////////////
public TransactionDataResult offererCreatesDepositTxInputs(Coin inputAmount, AddressEntry addressInfo) throws
public TransactionDataResult offererCreatesDepositTxInputs(Coin inputAmount, AddressEntry offererAddressEntry) throws
TransactionVerificationException, WalletException {
// We pay the tx fee 2 times to the deposit tx:
@ -160,7 +160,7 @@ public class TradeWalletService {
// Fin the needed inputs to pay the output, optional add change output.
// Normally only 1 input and no change output is used, but we support multiple inputs and outputs. Our spending transaction output is from the create
// offer fee payment. In future changes (in case of no offer fee) multiple inputs might become used.
addAvailableInputsAndChangeOutputs(dummyTX, addressInfo);
addAvailableInputsAndChangeOutputs(dummyTX, offererAddressEntry);
// The completeTx() call signs the input, but we don't want to pass over signed tx inputs
// But to be safe and to support future changes (in case of no offer fee) we handle potential multiple inputs
@ -200,7 +200,7 @@ public class TradeWalletService {
Coin msOutputAmount,
List<TransactionOutput> offererConnectedOutputsForAllInputs,
List<TransactionOutput> offererOutputs,
AddressEntry addressInfo,
AddressEntry takerAddressInfo,
byte[] offererPubKey,
byte[] takerPubKey,
byte[] arbitratorPubKey) throws SigningException,
@ -213,7 +213,7 @@ public class TradeWalletService {
Coin dummyOutputAmount = takerInputAmount.subtract(FeePolicy.TX_FEE);
TransactionOutput dummyOutput = new TransactionOutput(params, dummyTx, dummyOutputAmount, new ECKey().toAddress(params));
dummyTx.addOutput(dummyOutput);
addAvailableInputsAndChangeOutputs(dummyTx, addressInfo);
addAvailableInputsAndChangeOutputs(dummyTx, takerAddressInfo);
List<TransactionInput> takerInputs = dummyTx.getInputs();
List<TransactionOutput> takerOutputs = new ArrayList<>();
// we store optional change outputs (ignoring dummyOutput)
@ -387,36 +387,39 @@ public class TradeWalletService {
verifyTransaction(payoutTx);
return new TransactionDataResult(payoutTx, offererSignature);
return new TransactionDataResult(payoutTx, offererSignature.encodeToDER());
}
public void takerSignsAndPublishPayoutTx(Transaction depositTx,
ECKey.ECDSASignature offererSignature,
byte[] offererSignature,
Coin offererPayoutAmount,
Coin takerPayoutAmount,
String offererAddressString,
AddressEntry addressEntry,
AddressEntry takerAddressEntry,
byte[] offererPubKey,
byte[] takerPubKey,
byte[] arbitratorPubKey,
FutureCallback<Transaction> callback)
throws AddressFormatException, TransactionVerificationException, WalletException {
Transaction payoutTx = createPayoutTx(depositTx, offererPayoutAmount, takerPayoutAmount, offererAddressString, addressEntry.getAddressString());
Transaction payoutTx = createPayoutTx(depositTx, offererPayoutAmount, takerPayoutAmount, offererAddressString, takerAddressEntry.getAddressString());
// We need MS script not the P2SH
Script multiSigScript = getMultiSigRedeemScript(offererPubKey, takerPubKey, arbitratorPubKey);
Sha256Hash sigHash = payoutTx.hashForSignature(0, multiSigScript, Transaction.SigHash.ALL, false);
ECKey.ECDSASignature takerSignature = addressEntry.getKeyPair().sign(sigHash);
ECKey.ECDSASignature takerSignature = takerAddressEntry.getKeyPair().sign(sigHash);
TransactionSignature takerTxSig = new TransactionSignature(takerSignature, Transaction.SigHash.ALL, false);
TransactionSignature offererTxSig = new TransactionSignature(offererSignature, Transaction.SigHash.ALL, false);
TransactionSignature offererTxSig = new TransactionSignature(ECKey.ECDSASignature.decodeFromDER(offererSignature), Transaction.SigHash.ALL, false);
Script inputScript = ScriptBuilder.createP2SHMultiSigInputScript(ImmutableList.of(offererTxSig, takerTxSig), multiSigScript);
TransactionInput input = payoutTx.getInput(0);
input.setScriptSig(inputScript);
verifyTransaction(payoutTx);
checkWalletConsistency();
checkScriptSig(payoutTx, input, 0);
input.verify(input.getConnectedOutput());
printTxWithInputs("payoutTx", payoutTx);
ListenableFuture<Transaction> broadcastComplete = walletAppKit.peerGroup().broadcastTransaction(payoutTx);
Futures.addCallback(broadcastComplete, callback);
}
@ -544,9 +547,9 @@ public class TradeWalletService {
}
///////////////////////////////////////////////////////////////////////////////////////////
// Inner classes
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
// Inner classes
///////////////////////////////////////////////////////////////////////////////////////////
public class TransactionDataResult {
private List<TransactionOutput> connectedOutputsForAllInputs;
@ -555,7 +558,7 @@ public class TradeWalletService {
private Transaction payoutTx;
private ECKey.ECDSASignature offererSignature;
private byte[] offererSignature;
public TransactionDataResult(List<TransactionOutput> connectedOutputsForAllInputs, List<TransactionOutput> outputs) {
this.connectedOutputsForAllInputs = connectedOutputsForAllInputs;
@ -568,7 +571,7 @@ public class TradeWalletService {
this.outputs = outputs;
}
public TransactionDataResult(Transaction payoutTx, ECKey.ECDSASignature offererSignature) {
public TransactionDataResult(Transaction payoutTx, byte[] offererSignature) {
this.payoutTx = payoutTx;
this.offererSignature = offererSignature;
@ -590,7 +593,7 @@ public class TradeWalletService {
return payoutTx;
}
public ECKey.ECDSASignature getOffererSignature() {
public byte[] getOffererSignature() {
return offererSignature;
}
}

7
core/src/main/java/io/bitsquare/common/taskrunner/SharedModel.java → core/src/main/java/io/bitsquare/common/taskrunner/SharedTaskModel.java
View file

@ -20,6 +20,9 @@ package io.bitsquare.common.taskrunner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SharedModel {
private static final Logger log = LoggerFactory.getLogger(SharedModel.class);
public class SharedTaskModel {
private static final Logger log = LoggerFactory.getLogger(SharedTaskModel.class);
public void persist() {
}
}

2
core/src/main/java/io/bitsquare/common/taskrunner/Task.java
View file

@ -24,7 +24,7 @@ import io.bitsquare.btc.exceptions.WalletException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class Task<T extends SharedModel> {
public abstract class Task<T extends SharedTaskModel> {
private static final Logger log = LoggerFactory.getLogger(Task.class);
public static Class<? extends Task> taskToInterceptBeforeRun;

7
core/src/main/java/io/bitsquare/common/taskrunner/TaskRunner.java
View file

@ -27,7 +27,7 @@ import java.util.concurrent.LinkedBlockingQueue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TaskRunner<T extends SharedModel> {
public class TaskRunner<T extends SharedTaskModel> {
private static final Logger log = LoggerFactory.getLogger(TaskRunner.class);
private final Queue<Class> tasks = new LinkedBlockingQueue<>();
@ -77,9 +77,14 @@ public class TaskRunner<T extends SharedModel> {
void handleComplete() {
log.trace("Task completed: " + currentTask.getSimpleName());
persistModel();
next();
}
protected void persistModel() {
// sharedModel.persist();
}
void handleErrorMessage(String errorMessage) {
log.error("Task failed: " + currentTask.getSimpleName());
log.error("errorMessage: " + errorMessage);

6
core/src/main/java/io/bitsquare/gui/main/MainViewModel.java
View file

@ -157,7 +157,7 @@ class MainViewModel implements ViewModel {
error -> log.error(error.toString()),
() -> Platform.runLater(() -> setBitcoinNetworkSyncProgress(1.0)));
Observable<BootstrapState> messageObservable = clientNode.bootstrap(user.getNetworkKeyPair(), tradeMessageService);
Observable<BootstrapState> messageObservable = clientNode.bootstrap(user.getMessageKeyPair(), tradeMessageService);
messageObservable.publish();
messageObservable.subscribe(
state -> Platform.runLater(() -> setBootstrapState(state)),
@ -350,9 +350,9 @@ class MainViewModel implements ViewModel {
}
private void addMockArbitrator() {
if (accountSettings.getAcceptedArbitrators().isEmpty() && user.getNetworkKeyPair() != null) {
if (accountSettings.getAcceptedArbitrators().isEmpty() && user.getMessageKeyPair() != null) {
byte[] pubKey = new ECKey().getPubKey();
String messagePubKeyAsHex = DSAKeyUtil.getHexStringFromPublicKey(user.getNetworkPubKey());
String messagePubKeyAsHex = DSAKeyUtil.getHexStringFromPublicKey(user.getMessagePubKey());
List<Locale> languages = new ArrayList<>();
languages.add(LanguageUtil.getDefaultLanguageLocale());
List<Arbitrator.METHOD> arbitrationMethods = new ArrayList<>();

2
core/src/main/java/io/bitsquare/gui/main/account/arbitrator/registration/ArbitratorRegistrationView.java
View file

@ -370,7 +370,7 @@ public class ArbitratorRegistrationView extends ActivatableView<AnchorPane, Void
private Arbitrator getEditedArbitrator() {
byte[] pubKey = walletService.getArbitratorDepositAddressEntry().getPubKey();
String messagePubKeyAsHex = DSAKeyUtil.getHexStringFromPublicKey(user.getNetworkPubKey());
String messagePubKeyAsHex = DSAKeyUtil.getHexStringFromPublicKey(user.getMessagePubKey());
String name = nameTextField.getText();
Coin fee = formatter.parseToCoin(arbitrationFeeTextField.getText());
String webUrl = webPageTextField.getText();

4
core/src/main/java/io/bitsquare/gui/main/account/content/irc/IrcAccountDataModel.java
View file

@ -122,9 +122,9 @@ class IrcAccountDataModel implements Activatable, DataModel {
}
private void addMockArbitrator() {
if (accountSettings.getAcceptedArbitrators().isEmpty() && user.getNetworkKeyPair() != null) {
if (accountSettings.getAcceptedArbitrators().isEmpty() && user.getMessageKeyPair() != null) {
byte[] pubKey = new ECKey().getPubKey();
String messagePubKeyAsHex = DSAKeyUtil.getHexStringFromPublicKey(user.getNetworkPubKey());
String messagePubKeyAsHex = DSAKeyUtil.getHexStringFromPublicKey(user.getMessagePubKey());
List<Locale> languages = new ArrayList<>();
languages.add(LanguageUtil.getDefaultLanguageLocale());
List<Arbitrator.METHOD> arbitrationMethods = new ArrayList<>();

4
core/src/main/java/io/bitsquare/gui/main/account/content/restrictions/RestrictionsDataModel.java
View file

@ -152,9 +152,9 @@ class RestrictionsDataModel implements Activatable, DataModel {
// TODO Remove mock later
private void addMockArbitrator() {
if (accountSettings.getAcceptedArbitrators().isEmpty() && user.getNetworkKeyPair() != null) {
if (accountSettings.getAcceptedArbitrators().isEmpty() && user.getMessageKeyPair() != null) {
byte[] pubKey = new ECKey().getPubKey();
String messagePubKeyAsHex = DSAKeyUtil.getHexStringFromPublicKey(user.getNetworkPubKey());
String messagePubKeyAsHex = DSAKeyUtil.getHexStringFromPublicKey(user.getMessagePubKey());
List<Locale> languages = new ArrayList<>();
languages.add(LanguageUtil.getDefaultLanguageLocale());
List<Arbitrator.METHOD> arbitrationMethods = new ArrayList<>();

2
core/src/main/java/io/bitsquare/gui/main/portfolio/closed/ClosedTradesDataModel.java
View file

@ -74,7 +74,7 @@ class ClosedTradesDataModel implements Activatable, DataModel {
}
public Direction getDirection(Offer offer) {
return offer.getMessagePublicKey().equals(user.getNetworkPubKey()) ?
return offer.getMessagePublicKey().equals(user.getMessagePubKey()) ?
offer.getDirection() : offer.getMirroredDirection();
}

2
core/src/main/java/io/bitsquare/gui/main/portfolio/offer/OffersDataModel.java
View file

@ -86,7 +86,7 @@ class OffersDataModel implements Activatable, DataModel {
}
public Direction getDirection(Offer offer) {
return offer.getMessagePublicKey().equals(user.getNetworkPubKey()) ?
return offer.getMessagePublicKey().equals(user.getMessagePubKey()) ?
offer.getDirection() : offer.getMirroredDirection();
}
}

4
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/PendingTradesDataModel.java
View file

@ -130,7 +130,7 @@ class PendingTradesDataModel implements Activatable, DataModel {
selectedItem = item;
if (selectedItem != null) {
isOfferer = getTrade().getOffer().getMessagePublicKey().equals(user.getNetworkPubKey());
isOfferer = getTrade().getOffer().getMessagePublicKey().equals(user.getMessagePubKey());
Trade trade = getTrade();
trade.stateProperty().addListener(stateChangeListener);
@ -253,7 +253,7 @@ class PendingTradesDataModel implements Activatable, DataModel {
}
public Direction getDirection(Offer offer) {
return offer.getMessagePublicKey().equals(user.getNetworkPubKey()) ?
return offer.getMessagePublicKey().equals(user.getMessagePubKey()) ?
offer.getDirection() : offer.getMirroredDirection();
}

2
core/src/main/java/io/bitsquare/gui/main/trade/offerbook/OfferBookDataModel.java
View file

@ -213,7 +213,7 @@ class OfferBookDataModel implements Activatable, DataModel {
}
boolean isMyOffer(Offer offer) {
return offer.getMessagePublicKey() != null && offer.getMessagePublicKey().equals(user.getNetworkPubKey());
return offer.getMessagePublicKey() != null && offer.getMessagePublicKey().equals(user.getMessagePubKey());
}
Coin getAmountAsCoin() {

4
core/src/main/java/io/bitsquare/network/Message.java
View file

@ -17,5 +17,7 @@
package io.bitsquare.network;
public interface Message {
import java.io.Serializable;
public interface Message extends Serializable {
}

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

@ -168,7 +168,7 @@ public class TradeManager {
FiatAccount currentFiatAccount = user.getCurrentBankAccount().get();
Offer offer = new Offer(id,
user.getNetworkPubKey(),
user.getMessagePubKey(),
direction,
price.getValue(),
amount,
@ -295,7 +295,7 @@ public class TradeManager {
// Offerer handles those requests
private void handleMessage(Message message, Peer sender) {
if (message instanceof RequestIsOfferAvailableMessage) {
String offerId = ((RequestIsOfferAvailableMessage) message).getOfferId();
String offerId = ((RequestIsOfferAvailableMessage) message).offerId;
checkNotNull(offerId);
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(offerId, isOfferOpen(offerId));

19
core/src/main/java/io/bitsquare/trade/protocol/availability/CheckOfferAvailabilityModel.java
View file

@ -17,20 +17,20 @@
package io.bitsquare.trade.protocol.availability;
import io.bitsquare.common.taskrunner.SharedModel;
import io.bitsquare.common.taskrunner.SharedTaskModel;
import io.bitsquare.network.Peer;
import io.bitsquare.offer.Offer;
import io.bitsquare.trade.TradeMessageService;
import io.bitsquare.trade.protocol.trade.OfferMessage;
import io.bitsquare.trade.protocol.trade.messages.OfferMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CheckOfferAvailabilityModel extends SharedModel {
public class CheckOfferAvailabilityModel extends SharedTaskModel {
private static final Logger log = LoggerFactory.getLogger(CheckOfferAvailabilityModel.class);
private final Offer offer;
private final TradeMessageService tradeMessageService;
public final Offer offer;
public final TradeMessageService tradeMessageService;
private Peer peer;
private OfferMessage message;
@ -40,15 +40,6 @@ public class CheckOfferAvailabilityModel extends SharedModel {
this.tradeMessageService = tradeMessageService;
}
// getter/setter
public Offer getOffer() {
return offer;
}
public TradeMessageService getTradeMessageService() {
return tradeMessageService;
}
public Peer getPeer() {
return peer;
}

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

@ -55,7 +55,7 @@ public class CheckOfferAvailabilityProtocol {
}
public void cleanup() {
model.getTradeMessageService().removeMessageHandler(messageHandler);
model.tradeMessageService.removeMessageHandler(messageHandler);
}
@ -64,7 +64,7 @@ public class CheckOfferAvailabilityProtocol {
///////////////////////////////////////////////////////////////////////////////////////////
public void checkOfferAvailability() {
model.getTradeMessageService().addMessageHandler(messageHandler);
model.tradeMessageService.addMessageHandler(messageHandler);
taskRunner = new TaskRunner<>(model,
() -> {

18
core/src/main/java/io/bitsquare/trade/protocol/availability/messages/ReportOfferAvailabilityMessage.java
View file

@ -17,27 +17,17 @@
package io.bitsquare.trade.protocol.availability.messages;
import io.bitsquare.trade.protocol.trade.OfferMessage;
import io.bitsquare.trade.protocol.trade.messages.OfferMessage;
import java.io.Serializable;
public class ReportOfferAvailabilityMessage implements Serializable, OfferMessage {
public class ReportOfferAvailabilityMessage extends OfferMessage implements Serializable {
private static final long serialVersionUID = 6177387534187739018L;
private final String offerId;
private final boolean isOfferOpen;
public final boolean isOfferOpen;
public ReportOfferAvailabilityMessage(String offerId, boolean isOfferOpen) {
this.offerId = offerId;
super.offerId = offerId;
this.isOfferOpen = isOfferOpen;
}
@Override
public String getOfferId() {
return offerId;
}
public boolean isOfferOpen() {
return isOfferOpen;
}
}

13
core/src/main/java/io/bitsquare/trade/protocol/availability/messages/RequestIsOfferAvailableMessage.java
View file

@ -17,23 +17,16 @@
package io.bitsquare.trade.protocol.availability.messages;
import io.bitsquare.trade.protocol.trade.OfferMessage;
import io.bitsquare.trade.protocol.trade.messages.OfferMessage;
import java.io.Serializable;
// That msg is used to ping the offerer if he is online and if the offer is still available
public class RequestIsOfferAvailableMessage implements Serializable, OfferMessage {
public class RequestIsOfferAvailableMessage extends OfferMessage implements Serializable {
private static final long serialVersionUID = 4630151440192191798L;
private final String offerId;
public RequestIsOfferAvailableMessage(String offerId) {
this.offerId = offerId;
}
@Override
public String getOfferId() {
return offerId;
super.offerId = offerId;
}

6
core/src/main/java/io/bitsquare/trade/protocol/availability/tasks/GetPeerAddress.java
View file

@ -39,7 +39,7 @@ public class GetPeerAddress extends Task<CheckOfferAvailabilityModel> {
@Override
protected void doRun() {
try {
model.getTradeMessageService().getPeerAddress(model.getOffer().getMessagePublicKey(), new GetPeerAddressListener() {
model.tradeMessageService.getPeerAddress(model.offer.getMessagePublicKey(), new GetPeerAddressListener() {
@Override
public void onResult(Peer peer) {
model.setPeer(peer);
@ -49,13 +49,13 @@ public class GetPeerAddress extends Task<CheckOfferAvailabilityModel> {
@Override
public void onFailed() {
model.getOffer().setState(Offer.State.OFFERER_OFFLINE);
model.offer.setState(Offer.State.OFFERER_OFFLINE);
failed();
}
});
} catch (Throwable t) {
model.getOffer().setState(Offer.State.FAULT);
model.offer.setState(Offer.State.FAULT);
failed(t);
}

12
core/src/main/java/io/bitsquare/trade/protocol/availability/tasks/ProcessReportOfferAvailabilityMessage.java
View file

@ -39,18 +39,18 @@ public class ProcessReportOfferAvailabilityMessage extends Task<CheckOfferAvaila
protected void doRun() {
try {
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = (ReportOfferAvailabilityMessage) model.getMessage();
checkState(model.getOffer().getId().equals(reportOfferAvailabilityMessage.getOfferId()));
checkState(model.offer.getId().equals(reportOfferAvailabilityMessage.offerId));
if (model.getOffer().getState() != Offer.State.REMOVED) {
if (reportOfferAvailabilityMessage.isOfferOpen())
model.getOffer().setState(Offer.State.AVAILABLE);
if (model.offer.getState() != Offer.State.REMOVED) {
if (reportOfferAvailabilityMessage.isOfferOpen)
model.offer.setState(Offer.State.AVAILABLE);
else
model.getOffer().setState(Offer.State.RESERVED);
model.offer.setState(Offer.State.RESERVED);
}
complete();
} catch (Throwable t) {
model.getOffer().setState(Offer.State.FAULT);
model.offer.setState(Offer.State.FAULT);
failed(t);
}

6
core/src/main/java/io/bitsquare/trade/protocol/availability/tasks/RequestIsOfferAvailable.java
View file

@ -37,7 +37,7 @@ public class RequestIsOfferAvailable extends Task<CheckOfferAvailabilityModel> {
@Override
protected void doRun() {
try {
model.getTradeMessageService().sendMessage(model.getPeer(), new RequestIsOfferAvailableMessage(model.getOffer().getId()),
model.tradeMessageService.sendMessage(model.getPeer(), new RequestIsOfferAvailableMessage(model.offer.getId()),
new SendMessageListener() {
@Override
public void handleResult() {
@ -46,13 +46,13 @@ public class RequestIsOfferAvailable extends Task<CheckOfferAvailabilityModel> {
@Override
public void handleFault() {
model.getOffer().setState(Offer.State.OFFERER_OFFLINE);
model.offer.setState(Offer.State.OFFERER_OFFLINE);
failed();
}
});
} catch (Throwable t) {
model.getOffer().setState(Offer.State.FAULT);
model.offer.setState(Offer.State.FAULT);
failed(t);
}

25
core/src/main/java/io/bitsquare/trade/protocol/placeoffer/PlaceOfferModel.java
View file

@ -20,19 +20,20 @@ package io.bitsquare.trade.protocol.placeoffer;
import io.bitsquare.btc.WalletService;
import io.bitsquare.offer.Offer;
import io.bitsquare.offer.OfferBookService;
import io.bitsquare.common.taskrunner.SharedModel;
import io.bitsquare.common.taskrunner.SharedTaskModel;
import org.bitcoinj.core.Transaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PlaceOfferModel extends SharedModel {
public class PlaceOfferModel extends SharedTaskModel {
private static final Logger log = LoggerFactory.getLogger(PlaceOfferModel.class);
private final Offer offer;
private final WalletService walletService;
private final OfferBookService offerBookService;
public final Offer offer;
public final WalletService walletService;
public final OfferBookService offerBookService;
private Transaction transaction;
public PlaceOfferModel(Offer offer,
@ -43,19 +44,6 @@ public class PlaceOfferModel extends SharedModel {
this.offerBookService = offerBookService;
}
// getter/setter
public Offer getOffer() {
return offer;
}
public WalletService getWalletService() {
return walletService;
}
public OfferBookService getOfferBookService() {
return offerBookService;
}
public void setTransaction(Transaction transaction) {
this.transaction = transaction;
}
@ -63,5 +51,4 @@ public class PlaceOfferModel extends SharedModel {
public Transaction getTransaction() {
return transaction;
}
}

2
core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/AddOfferToRemoteOfferBook.java
View file

@ -34,7 +34,7 @@ public class AddOfferToRemoteOfferBook extends Task<PlaceOfferModel> {
@Override
protected void doRun() {
model.getOfferBookService().addOffer(model.getOffer(),
model.offerBookService.addOffer(model.offer,
() -> {
complete();
},

18
core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/BroadcastCreateOfferFeeTx.java
View file

@ -19,9 +19,9 @@ package io.bitsquare.trade.protocol.placeoffer.tasks;
import io.bitsquare.btc.AddressEntry;
import io.bitsquare.btc.FeePolicy;
import io.bitsquare.trade.protocol.placeoffer.PlaceOfferModel;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.placeoffer.PlaceOfferModel;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction;
@ -49,12 +49,12 @@ public class BroadcastCreateOfferFeeTx extends Task<PlaceOfferModel> {
@Override
protected void doRun() {
Coin totalsNeeded = model.getOffer().getSecurityDeposit().add(FeePolicy.CREATE_OFFER_FEE).add(FeePolicy.TX_FEE);
AddressEntry addressEntry = model.getWalletService().getAddressEntry(model.getOffer().getId());
Coin balance = model.getWalletService().getBalanceForAddress(addressEntry.getAddress());
Coin totalsNeeded = model.offer.getSecurityDeposit().add(FeePolicy.CREATE_OFFER_FEE).add(FeePolicy.TX_FEE);
AddressEntry addressEntry = model.walletService.getAddressEntry(model.offer.getId());
Coin balance = model.walletService.getBalanceForAddress(addressEntry.getAddress());
if (balance.compareTo(totalsNeeded) >= 0) {
model.getWalletService().getTradeWalletService().broadcastCreateOfferFeeTx(model.getTransaction(), new FutureCallback<Transaction>() {
model.walletService.getTradeWalletService().broadcastCreateOfferFeeTx(model.getTransaction(), new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {
log.info("Broadcast of offer fee payment succeeded: transaction = " + transaction.toString());
@ -66,12 +66,12 @@ public class BroadcastCreateOfferFeeTx extends Task<PlaceOfferModel> {
else {
log.warn("Tx malleability happened after broadcast. We publish the changed offer to the DHT again.");
// Tx malleability happened after broadcast. We publish the changed offer to the DHT again.
model.getOfferBookService().removeOffer(model.getOffer(),
model.offerBookService.removeOffer(model.offer,
() -> {
log.info("We store now the changed txID to the offer and add that again.");
// We store now the changed txID to the offer and add that again.
model.getOffer().setOfferFeePaymentTxID(transaction.getHashAsString());
model.getOfferBookService().addOffer(model.getOffer(),
model.offer.setOfferFeePaymentTxID(transaction.getHashAsString());
model.offerBookService.addOffer(model.offer,
() -> {
complete();
},
@ -103,7 +103,7 @@ public class BroadcastCreateOfferFeeTx extends Task<PlaceOfferModel> {
protected void updateStateOnFault() {
if (!removeOfferFailed && !addOfferFailed) {
// If broadcast fails we need to remove offer from offerbook
model.getOfferBookService().removeOffer(model.getOffer(),
model.offerBookService.removeOffer(model.offer,
() -> {
log.info("Offer removed from offerbook because broadcast failed.");
},

8
core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/CreateOfferFeeTx.java
View file

@ -17,9 +17,9 @@
package io.bitsquare.trade.protocol.placeoffer.tasks;
import io.bitsquare.trade.protocol.placeoffer.PlaceOfferModel;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.placeoffer.PlaceOfferModel;
import org.bitcoinj.core.Transaction;
@ -36,11 +36,11 @@ public class CreateOfferFeeTx extends Task<PlaceOfferModel> {
@Override
protected void doRun() {
try {
Transaction transaction = model.getWalletService().getTradeWalletService().createOfferFeeTx(
model.getWalletService().getAddressEntry(model.getOffer().getId()));
Transaction transaction = model.walletService.getTradeWalletService().createOfferFeeTx(
model.walletService.getAddressEntry(model.offer.getId()));
// We assume there will be no tx malleability. We add a check later in case the published offer has a different hash.
model.getOffer().setOfferFeePaymentTxID(transaction.getHashAsString());
model.offer.setOfferFeePaymentTxID(transaction.getHashAsString());
model.setTransaction(transaction);
complete();

4
core/src/main/java/io/bitsquare/trade/protocol/placeoffer/tasks/ValidateOffer.java
View file

@ -17,9 +17,9 @@
package io.bitsquare.trade.protocol.placeoffer.tasks;
import io.bitsquare.trade.protocol.placeoffer.PlaceOfferModel;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.placeoffer.PlaceOfferModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -34,7 +34,7 @@ public class ValidateOffer extends Task<PlaceOfferModel> {
@Override
protected void doRun() {
try {
model.getOffer().validate();
model.offer.validate();
complete();
} catch (Exception e) {

115
core/src/main/java/io/bitsquare/trade/protocol/trade/OfferSharedModel.java → core/src/main/java/io/bitsquare/trade/protocol/trade/SharedTradeModel.java
View file

@ -17,58 +17,57 @@
package io.bitsquare.trade.protocol.trade;
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.SharedModel;
import io.bitsquare.common.taskrunner.SharedTaskModel;
import io.bitsquare.crypto.SignatureService;
import io.bitsquare.fiat.FiatAccount;
import io.bitsquare.offer.Offer;
import io.bitsquare.persistence.Persistence;
import io.bitsquare.trade.TradeMessageService;
import io.bitsquare.user.User;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import org.bitcoinj.crypto.DeterministicKey;
import java.security.PublicKey;
import java.io.Serializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OfferSharedModel extends SharedModel {
protected static final Logger log = LoggerFactory.getLogger(OfferSharedModel.class);
public class SharedTradeModel extends SharedTaskModel implements Serializable {
private static final long serialVersionUID = -2523252022571497157L;
protected static final Logger log = LoggerFactory.getLogger(SharedTradeModel.class);
// provided
private final Offer offer;
private final TradeMessageService tradeMessageService;
private final WalletService walletService;
private final BlockChainService blockChainService;
private final SignatureService signatureService;
private final Persistence persistence;
transient public final Offer offer;
transient public final TradeMessageService tradeMessageService;
transient public final WalletService walletService;
transient public final BlockChainService blockChainService;
transient public final SignatureService signatureService;
transient protected final Persistence persistence;
// derived
private final String id;
private final FiatAccount fiatAccount;
private final String accountId;
private final PublicKey networkPubKey;
private final byte[] registrationPubKey;
private final DeterministicKey registrationKeyPair;
private final byte[] arbitratorPubKey;
private final AddressEntry addressEntry;
private final TradeWalletService tradeWalletService;
transient public final String id;
transient public final TradeWalletService tradeWalletService;
transient public final byte[] arbitratorPubKey;
/* transient public final FiatAccount fiatAccount;
transient public final String accountId;
transient public final PublicKey messagePubKey;
transient public final byte[] registrationPubKey;
transient public final DeterministicKey registrationKeyPair;
transient public final AddressEntry addressEntry;*/
// data written/read by tasks
private TradeMessage tradeMessage;
transient private TradeMessage tradeMessage;
protected OfferSharedModel(Offer offer,
protected SharedTradeModel(Offer offer,
TradeMessageService tradeMessageService,
WalletService walletService,
BlockChainService blockChainService,
SignatureService signatureService,
User user,
Persistence persistence) {
this.offer = offer;
this.tradeMessageService = tradeMessageService;
@ -81,78 +80,22 @@ public class OfferSharedModel extends SharedModel {
tradeWalletService = walletService.getTradeWalletService();
//TODO use default arbitrator for now
arbitratorPubKey = offer.getArbitrators().get(0).getPubKey();
registrationPubKey = walletService.getRegistrationAddressEntry().getPubKey();
/* registrationPubKey = walletService.getRegistrationAddressEntry().getPubKey();
registrationKeyPair = walletService.getRegistrationAddressEntry().getKeyPair();
addressEntry = walletService.getAddressEntry(id);
fiatAccount = user.getBankAccount(offer.getBankAccountId());
accountId = user.getAccountId();
networkPubKey = user.getNetworkPubKey();
messagePubKey = user.getNetworkPubKey();*/
}
//setter
public void setTradeMessage(TradeMessage tradeMessage) {
this.tradeMessage = tradeMessage;
}
// getter
public String getId() {
return id;
}
public TradeWalletService getTradeWalletService() {
return tradeWalletService;
}
public TradeMessage getTradeMessage() {
return tradeMessage;
}
public Offer getOffer() {
return offer;
}
public TradeMessageService getTradeMessageService() {
return tradeMessageService;
}
public WalletService getWalletService() {
return walletService;
}
public BlockChainService getBlockChainService() {
return blockChainService;
}
public SignatureService getSignatureService() {
return signatureService;
}
public FiatAccount getFiatAccount() {
return fiatAccount;
}
public String getAccountId() {
return accountId;
}
public PublicKey getNetworkPubKey() {
return networkPubKey;
}
public byte[] getRegistrationPubKey() {
return registrationPubKey;
}
public DeterministicKey getRegistrationKeyPair() {
return registrationKeyPair;
}
public byte[] getArbitratorPubKey() {
return arbitratorPubKey;
}
public AddressEntry getAddressEntry() {
return addressEntry;
}
}

42
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/messages/BankTransferStartedMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/messages/BankTransferStartedMessage.java
View file

@ -15,24 +15,21 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade.offerer.messages;
import io.bitsquare.trade.protocol.trade.TradeMessage;
package io.bitsquare.trade.protocol.trade.messages;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction;
import java.io.Serializable;
public class BankTransferStartedMessage implements Serializable, TradeMessage {
public class BankTransferStartedMessage extends TradeMessage implements Serializable {
private static final long serialVersionUID = -3479634129543632523L;
private final String tradeId;
private final Transaction depositTx;
private final byte[] offererSignature;
private final Coin offererPayoutAmount;
private final Coin takerPayoutAmount;
private final String offererPayoutAddress;
public final Transaction depositTx;
public final byte[] offererSignature;
public final Coin offererPayoutAmount;
public final Coin takerPayoutAmount;
public final String offererPayoutAddress;
public BankTransferStartedMessage(String tradeId,
Transaction depositTx,
@ -47,29 +44,4 @@ public class BankTransferStartedMessage implements Serializable, TradeMessage {
this.takerPayoutAmount = takerPayoutAmount;
this.offererPayoutAddress = offererPayoutAddress;
}
@Override
public String getTradeId() {
return tradeId;
}
public Transaction getDepositTx() {
return depositTx;
}
public String getOffererPayoutAddress() {
return offererPayoutAddress;
}
public Coin getOffererPayoutAmount() {
return offererPayoutAmount;
}
public Coin getTakerPayoutAmount() {
return takerPayoutAmount;
}
public byte[] getOffererSignature() {
return offererSignature;
}
}

18
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/messages/DepositTxPublishedMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/messages/DepositTxPublishedMessage.java
View file

@ -15,31 +15,19 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade.offerer.messages;
import io.bitsquare.trade.protocol.trade.TradeMessage;
package io.bitsquare.trade.protocol.trade.messages;
import org.bitcoinj.core.Transaction;
import java.io.Serializable;
public class DepositTxPublishedMessage implements Serializable, TradeMessage {
public class DepositTxPublishedMessage extends TradeMessage implements Serializable {
private static final long serialVersionUID = -1532231540167406581L;
private final String tradeId;
private final Transaction depositTx;
public final Transaction depositTx;
public DepositTxPublishedMessage(String tradeId, Transaction depositTx) {
this.tradeId = tradeId;
this.depositTx = depositTx;
}
@Override
public String getTradeId() {
return tradeId;
}
public Transaction getDepositTx() {
return depositTx;
}
}

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

@ -15,10 +15,14 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade;
package io.bitsquare.trade.protocol.trade.messages;
import io.bitsquare.network.Message;
public interface OfferMessage extends Message {
public String getOfferId();
import java.io.Serializable;
public class OfferMessage implements Message, Serializable {
private static final long serialVersionUID = -89035992124170905L;
public String offerId;
}

17
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/messages/PayoutTxPublishedMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/messages/PayoutTxPublishedMessage.java
View file

@ -15,31 +15,20 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade.taker.messages;
import io.bitsquare.trade.protocol.trade.TradeMessage;
package io.bitsquare.trade.protocol.trade.messages;
import org.bitcoinj.core.Transaction;
import java.io.Serializable;
public class PayoutTxPublishedMessage implements Serializable, TradeMessage {
public class PayoutTxPublishedMessage extends TradeMessage implements Serializable {
private static final long serialVersionUID = 1288653559218403873L;
private final String tradeId;
private final Transaction payoutTx;
public final Transaction payoutTx;
public PayoutTxPublishedMessage(String tradeId, Transaction payoutTx) {
this.tradeId = tradeId;
this.payoutTx = payoutTx;
}
@Override
public String getTradeId() {
return tradeId;
}
public Transaction getPayoutTx() {
return payoutTx;
}
}

49
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/messages/RequestDepositPaymentMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestDepositPaymentMessage.java
View file

@ -15,10 +15,9 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade.offerer.messages;
package io.bitsquare.trade.protocol.trade.messages;
import io.bitsquare.fiat.FiatAccount;
import io.bitsquare.trade.protocol.trade.TradeMessage;
import org.bitcoinj.core.TransactionOutput;
@ -26,52 +25,26 @@ import java.io.Serializable;
import java.util.List;
public class RequestDepositPaymentMessage implements Serializable, TradeMessage {
public class RequestDepositPaymentMessage extends TradeMessage implements Serializable {
private static final long serialVersionUID = -3988720410493712913L;
private final String tradeId;
private final List<TransactionOutput> offererConnectedOutputsForAllInputs;
private final List<TransactionOutput> offererOutputs;
private final byte[] offererPubKey;
private final FiatAccount fiatAccount;
private final String accountID;
public final List<TransactionOutput> offererConnectedOutputsForAllInputs;
public final List<TransactionOutput> offererOutputs;
public final byte[] offererPubKey;
public final FiatAccount offererFiatAccount;
public final String offererAccountId;
public RequestDepositPaymentMessage(String tradeId,
List<TransactionOutput> offererConnectedOutputsForAllInputs,
List<TransactionOutput> offererOutputs,
byte[] offererPubKey,
FiatAccount fiatAccount,
String accountID) {
FiatAccount offererFiatAccount,
String offererAccountId) {
this.tradeId = tradeId;
this.offererConnectedOutputsForAllInputs = offererConnectedOutputsForAllInputs;
this.offererOutputs = offererOutputs;
this.offererPubKey = offererPubKey;
this.fiatAccount = fiatAccount;
this.accountID = accountID;
}
@Override
public String getTradeId() {
return tradeId;
}
public List<TransactionOutput> getOffererConnectedOutputsForAllInputs() {
return offererConnectedOutputsForAllInputs;
}
public List<TransactionOutput> getOffererOutputs() {
return offererOutputs;
}
public byte[] getOffererPubKey() {
return offererPubKey;
}
public FiatAccount getFiatAccount() {
return fiatAccount;
}
public String getAccountId() {
return accountID;
this.offererFiatAccount = offererFiatAccount;
this.offererAccountId = offererAccountId;
}
}

31
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/messages/RequestDepositTxInputsMessage.java → core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestDepositTxInputsMessage.java
View file

@ -15,21 +15,18 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade.taker.messages;
import io.bitsquare.trade.protocol.trade.TradeMessage;
package io.bitsquare.trade.protocol.trade.messages;
import org.bitcoinj.core.Coin;
import java.io.Serializable;
public class RequestDepositTxInputsMessage implements Serializable, TradeMessage {
public class RequestDepositTxInputsMessage extends TradeMessage implements Serializable {
private static final long serialVersionUID = -5057935061275354312L;
private final String tradeId;
private final Coin tradeAmount;
private final String takeOfferFeeTxId;
private final byte[] takerPubKey;
public final Coin tradeAmount;
public final String takeOfferFeeTxId;
public final byte[] takerPubKey;
public RequestDepositTxInputsMessage(String tradeId, String takeOfferFeeTxId, Coin tradeAmount, byte[] takerPubKey) {
this.tradeId = tradeId;
@ -37,22 +34,4 @@ public class RequestDepositTxInputsMessage implements Serializable, TradeMessage
this.tradeAmount = tradeAmount;
this.takerPubKey = takerPubKey;
}
@Override
public String getTradeId() {
return tradeId;
}
public Coin getTradeAmount() {
return tradeAmount;
}
public String getTakeOfferFeeTxId() {
return takeOfferFeeTxId;
}
public byte[] getTakerPubKey() {
return takerPubKey;
}
}

65
core/src/main/java/io/bitsquare/trade/protocol/trade/messages/RequestOffererPublishDepositTxMessage.java Normal file
View file

@ -0,0 +1,65 @@
/*
* 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.messages;
import io.bitsquare.fiat.FiatAccount;
import org.bitcoinj.core.Transaction;
import org.bitcoinj.core.TransactionOutput;
import java.io.Serializable;
import java.security.PublicKey;
import java.util.List;
public class RequestOffererPublishDepositTxMessage extends TradeMessage implements Serializable {
private static final long serialVersionUID = 2179683654379803071L;
public final FiatAccount takerFiatAccount;
public final String takerAccountId;
public final PublicKey takerMessagePublicKey;
public final String takerContractAsJson;
public final String takerContractSignature;
public final String takerPayoutAddress;
public final Transaction takersDepositTx;
public final List<TransactionOutput> takerConnectedOutputsForAllInputs;
public final List<TransactionOutput> takerOutputs;
public RequestOffererPublishDepositTxMessage(String tradeId,
FiatAccount takerFiatAccount,
String takerAccountId,
PublicKey takerMessagePublicKey,
String takerContractAsJson,
String takerContractSignature,
String takerPayoutAddress,
Transaction takersDepositTx,
List<TransactionOutput> takerConnectedOutputsForAllInputs,
List<TransactionOutput> takerOutputs) {
this.tradeId = tradeId;
this.takerFiatAccount = takerFiatAccount;
this.takerAccountId = takerAccountId;
this.takerMessagePublicKey = takerMessagePublicKey;
this.takerContractAsJson = takerContractAsJson;
this.takerContractSignature = takerContractSignature;
this.takerPayoutAddress = takerPayoutAddress;
this.takersDepositTx = takersDepositTx;
this.takerConnectedOutputsForAllInputs = takerConnectedOutputsForAllInputs;
this.takerOutputs = takerOutputs;
}
}

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

@ -15,10 +15,14 @@
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.trade.protocol.trade;
package io.bitsquare.trade.protocol.trade.messages;
import io.bitsquare.network.Message;
public interface TradeMessage extends Message {
public String getTradeId();
import java.io.Serializable;
public class TradeMessage implements Message, Serializable {
private static final long serialVersionUID = 7572470983485004081L;
public String tradeId;
}

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

@ -21,7 +21,7 @@ import io.bitsquare.network.Message;
import io.bitsquare.network.Peer;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.handlers.MessageHandler;
import io.bitsquare.trade.protocol.trade.TradeMessage;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.BuyerAsOffererModel;
import io.bitsquare.trade.protocol.trade.offerer.tasks.GetOffererDepositTxInputs;
import io.bitsquare.trade.protocol.trade.offerer.tasks.ProcessPayoutTxPublishedMessage;
@ -36,19 +36,17 @@ import io.bitsquare.trade.protocol.trade.offerer.tasks.SignPayoutTx;
import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyAndSignContract;
import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyTakeOfferFeePayment;
import io.bitsquare.trade.protocol.trade.offerer.tasks.VerifyTakerAccount;
import io.bitsquare.trade.protocol.trade.taker.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.taker.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.taker.messages.RequestOffererPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage;
import org.bitcoinj.core.Transaction;
import org.bitcoinj.core.TransactionConfidence;
import javafx.application.Platform;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static io.bitsquare.util.Validator.nonEmptyStringOf;
import static io.bitsquare.util.Validator.*;
public class BuyerAsOffererProtocol {
private static final Logger log = LoggerFactory.getLogger(BuyerAsOffererProtocol.class);
@ -56,15 +54,19 @@ public class BuyerAsOffererProtocol {
private final BuyerAsOffererModel model;
private final MessageHandler messageHandler;
private TransactionConfidence.Listener transactionConfidenceListener;
private TransactionConfidence transactionConfidence;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public BuyerAsOffererProtocol(BuyerAsOffererModel model) {
log.debug("New BuyerAsOffererProtocol " + this);
this.model = model;
messageHandler = this::handleMessage;
model.getTradeMessageService().addMessageHandler(messageHandler);
model.tradeMessageService.addMessageHandler(messageHandler);
}
@ -73,15 +75,20 @@ public class BuyerAsOffererProtocol {
///////////////////////////////////////////////////////////////////////////////////////////
public void cleanup() {
model.getTradeMessageService().removeMessageHandler(messageHandler);
log.debug("cleanup " + this);
model.tradeMessageService.removeMessageHandler(messageHandler);
if (transactionConfidence != null) {
if (!transactionConfidence.removeEventListener(transactionConfidenceListener))
throw new RuntimeException("Remove transactionConfidenceListener failed.");
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Incoming message handling
///////////////////////////////////////////////////////////////////////////////////////////
private void handleRequestDepositTxInputsMessage(RequestDepositTxInputsMessage tradeMessage, Peer taker) {
checkTradeId(model.id, tradeMessage);
model.setTradeMessage(tradeMessage);
model.taker.peer = taker;
@ -107,20 +114,18 @@ public class BuyerAsOffererProtocol {
BuyerAsOffererTaskRunner<BuyerAsOffererModel> taskRunner = new BuyerAsOffererTaskRunner<>(model,
() -> {
log.debug("taskRunner at handleRequestOffererPublishDepositTxMessage completed");
TransactionConfidence confidence = model.getTrade().getDepositTx().getConfidence();
confidence.addEventListener(new TransactionConfidence.Listener() {
transactionConfidenceListener = new TransactionConfidence.Listener() {
@Override
public void onConfidenceChanged(Transaction tx, ChangeReason reason) {
log.trace("onConfidenceChanged " + tx.getConfidence());
if (reason == ChangeReason.TYPE && tx.getConfidence().getConfidenceType() == TransactionConfidence.ConfidenceType.BUILDING) {
model.getTrade().setState(Trade.State.DEPOSIT_CONFIRMED);
//TODO not sure if that works
Platform.runLater(() -> confidence.removeEventListener(this));
model.trade.setState(Trade.State.DEPOSIT_CONFIRMED);
}
}
});
};
transactionConfidence = model.trade.getDepositTx().getConfidence();
transactionConfidence.addEventListener(transactionConfidenceListener);
},
(errorMessage) -> {
log.error(errorMessage);
@ -189,9 +194,9 @@ public class BuyerAsOffererProtocol {
log.trace("handleNewMessage: message = " + message.getClass().getSimpleName());
if (message instanceof TradeMessage) {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.getTradeId());
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.getTradeId().equals(model.getOffer().getId())) {
if (tradeMessage.tradeId.equals(model.id)) {
if (tradeMessage instanceof RequestDepositTxInputsMessage) {
handleRequestDepositTxInputsMessage((RequestDepositTxInputsMessage) tradeMessage, peer);
}

2
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/BuyerAsOffererTaskRunner.java
View file

@ -34,7 +34,7 @@ class BuyerAsOffererTaskRunner<T extends BuyerAsOffererModel> extends TaskRunner
/* @Override
public void handleFault(String message, @NotNull Throwable throwable) {
sharedModel.getTrade().setState(Trade.State.FAILED);
sharedModel.trade.setState(Trade.State.FAILED);
super.handleFault(message, throwable);
}*/
}

40
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/BuyerAsOffererModel.java
View file

@ -23,7 +23,7 @@ import io.bitsquare.crypto.SignatureService;
import io.bitsquare.persistence.Persistence;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.TradeMessageService;
import io.bitsquare.trade.protocol.trade.OfferSharedModel;
import io.bitsquare.trade.protocol.trade.SharedTradeModel;
import io.bitsquare.user.User;
import org.bitcoinj.core.Transaction;
@ -33,17 +33,17 @@ import java.io.Serializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class BuyerAsOffererModel extends OfferSharedModel implements Serializable {
public class BuyerAsOffererModel extends SharedTradeModel implements Serializable {
private static final long serialVersionUID = 5000457153390911569L;
private static final Logger log = LoggerFactory.getLogger(BuyerAsOffererModel.class);
private final Trade trade;
transient public final Trade trade;
public final TakerModel taker;
public final OffererModel offerer;
private Transaction publishedDepositTx;
private String takeOfferFeeTxId;
public BuyerAsOffererModel(Trade trade,
TradeMessageService tradeMessageService,
WalletService walletService,
@ -56,19 +56,39 @@ public class BuyerAsOffererModel extends OfferSharedModel implements Serializabl
walletService,
blockChainService,
signatureService,
user,
persistence);
this.trade = trade;
taker = new TakerModel();
offerer = new OffererModel();
Object modelObject = persistence.read(this, "BuyerAsOffererModel_" + id);
if (modelObject instanceof BuyerAsOffererModel) {
BuyerAsOffererModel persistedModel = (BuyerAsOffererModel) modelObject;
log.debug("Model reconstructed form persisted model.");
offerer.pubKey = getAddressEntry().getPubKey();
setPublishedDepositTx(persistedModel.getPublishedDepositTx());
setTakeOfferFeeTxId(persistedModel.takeOfferFeeTxId);
taker = persistedModel.taker;
offerer = persistedModel.offerer;
}
else {
taker = new TakerModel();
offerer = new OffererModel();
}
offerer.registrationPubKey = walletService.getRegistrationAddressEntry().getPubKey();
offerer.registrationKeyPair = walletService.getRegistrationAddressEntry().getKeyPair();
offerer.addressEntry = walletService.getAddressEntry(id);
offerer.fiatAccount = user.getBankAccount(offer.getBankAccountId());
offerer.accountId = user.getAccountId();
offerer.messagePubKey = user.getMessagePubKey();
offerer.pubKey = offerer.addressEntry.getPubKey();
}
public Trade getTrade() {
return trade;
// Get called form taskRunner after each completed task
@Override
public void persist() {
persistence.write(this, "BuyerAsOffererModel_" + id, this);
}
public Transaction getPublishedDepositTx() {

24
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/models/OffererModel.java
View file

@ -17,25 +17,39 @@
package io.bitsquare.trade.protocol.trade.offerer.models;
import io.bitsquare.btc.AddressEntry;
import io.bitsquare.fiat.FiatAccount;
import io.bitsquare.network.Peer;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.ECKey;
import org.bitcoinj.core.Transaction;
import org.bitcoinj.core.TransactionOutput;
import org.bitcoinj.crypto.DeterministicKey;
import java.io.Serializable;
import java.security.PublicKey;
import java.util.List;
public class OffererModel implements Serializable {
private static final long serialVersionUID = -1845177552607819927L;
public byte[] pubKey;
public ECKey.ECDSASignature payoutSignature;
// Those fields are set at constructor but not declared as final because constructor is not called in case model gets created from a persisted model
// Declared transient as they will be provided in any case at construction time
transient public FiatAccount fiatAccount;
transient public String accountId;
transient public PublicKey messagePubKey;
transient public byte[] registrationPubKey;
transient public DeterministicKey registrationKeyPair;
transient public AddressEntry addressEntry;
transient public byte[] pubKey;
// written by tasks
public byte[] payoutSignature;
public Coin payoutAmount;
public List<TransactionOutput> connectedOutputsForAllInputs;
public List<TransactionOutput> outputs;
public Transaction payoutTx;
public Peer peer;
public Transaction preparedPayoutTx;
}

7
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/GetOffererDepositTxInputs.java
View file

@ -17,7 +17,6 @@
package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.btc.AddressEntry;
import io.bitsquare.btc.FeePolicy;
import io.bitsquare.btc.TradeWalletService;
import io.bitsquare.common.taskrunner.Task;
@ -39,9 +38,9 @@ public class GetOffererDepositTxInputs extends Task<BuyerAsOffererModel> {
@Override
protected void doRun() {
try {
Coin offererInputAmount = model.getTrade().getSecurityDeposit().add(FeePolicy.TX_FEE);
AddressEntry addressInfo = model.getAddressEntry();
TradeWalletService.TransactionDataResult result = model.getTradeWalletService().offererCreatesDepositTxInputs(offererInputAmount, addressInfo);
Coin offererInputAmount = model.trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
TradeWalletService.TransactionDataResult result = model.tradeWalletService.offererCreatesDepositTxInputs(offererInputAmount,
model.offerer.addressEntry);
model.offerer.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs();
model.offerer.outputs = result.getOutputs();

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

@ -19,7 +19,7 @@ package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.models.BuyerAsOffererModel;
import io.bitsquare.trade.protocol.trade.taker.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
@ -39,11 +39,11 @@ public class ProcessPayoutTxPublishedMessage extends Task<BuyerAsOffererModel> {
@Override
protected void doRun() {
try {
checkTradeId(model.getId(), model.getTradeMessage());
checkTradeId(model.id, model.getTradeMessage());
model.getTrade().setPayoutTx(checkNotNull(((PayoutTxPublishedMessage) model.getTradeMessage()).getPayoutTx()));
model.trade.setPayoutTx(checkNotNull(((PayoutTxPublishedMessage) model.getTradeMessage()).payoutTx));
model.getTrade().setState(Trade.State.PAYOUT_PUBLISHED);
model.trade.setState(Trade.State.PAYOUT_PUBLISHED);
complete();
} catch (Throwable t) {

13
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/ProcessRequestDepositTxInputsMessage.java
View file

@ -21,7 +21,7 @@ import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.protocol.trade.offerer.models.BuyerAsOffererModel;
import io.bitsquare.trade.protocol.trade.taker.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -39,12 +39,13 @@ public class ProcessRequestDepositTxInputsMessage extends Task<BuyerAsOffererMod
@Override
protected void doRun() {
try {
checkTradeId(model.getId(), model.getTradeMessage());
Trade trade = model.getTrade();
checkTradeId(model.id, model.getTradeMessage());
Trade trade = model.trade;
RequestDepositTxInputsMessage requestDepositTxInputsMessage = (RequestDepositTxInputsMessage) model.getTradeMessage();
trade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(requestDepositTxInputsMessage.getTradeAmount())));
model.setTakeOfferFeeTxId(nonEmptyStringOf(requestDepositTxInputsMessage.getTakeOfferFeeTxId()));
model.taker.pubKey = checkNotNull(requestDepositTxInputsMessage.getTakerPubKey());
trade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(requestDepositTxInputsMessage.tradeAmount)));
model.setTakeOfferFeeTxId(nonEmptyStringOf(requestDepositTxInputsMessage.takeOfferFeeTxId));
model.taker.pubKey = checkNotNull(requestDepositTxInputsMessage.takerPubKey);
complete();
} catch (Throwable t) {

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

@ -20,7 +20,7 @@ package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.offerer.models.BuyerAsOffererModel;
import io.bitsquare.trade.protocol.trade.taker.messages.RequestOffererPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -38,18 +38,18 @@ public class ProcessRequestOffererPublishDepositTxMessage extends Task<BuyerAsOf
@Override
protected void doRun() {
try {
checkTradeId(model.getId(), model.getTradeMessage());
checkTradeId(model.id, model.getTradeMessage());
RequestOffererPublishDepositTxMessage message = (RequestOffererPublishDepositTxMessage) model.getTradeMessage();
model.taker.fiatAccount = checkNotNull(message.getTakerBankAccount());
model.taker.accountId = nonEmptyStringOf(message.getTakerAccountId());
model.taker.messagePublicKey = checkNotNull(message.getTakerMessagePublicKey());
model.taker.contractAsJson = nonEmptyStringOf(message.getTakerContractAsJson());
model.taker.payoutAddress = nonEmptyStringOf(message.getTakerPayoutAddress());
model.taker.depositTx = checkNotNull(message.getTakersDepositTx());
model.taker.connectedOutputsForAllInputs = checkNotNull(message.getTakerConnectedOutputsForAllInputs());
checkArgument(message.getTakerConnectedOutputsForAllInputs().size() > 0);
model.taker.outputs = checkNotNull(message.getTakerOutputs());
model.taker.fiatAccount = checkNotNull(message.takerFiatAccount);
model.taker.accountId = nonEmptyStringOf(message.takerAccountId);
model.taker.messagePublicKey = checkNotNull(message.takerMessagePublicKey);
model.taker.contractAsJson = nonEmptyStringOf(message.takerContractAsJson);
model.taker.payoutAddress = nonEmptyStringOf(message.takerPayoutAddress);
model.taker.depositTx = checkNotNull(message.takersDepositTx);
model.taker.connectedOutputsForAllInputs = checkNotNull(message.takerConnectedOutputsForAllInputs);
checkArgument(message.takerConnectedOutputsForAllInputs.size() > 0);
model.taker.outputs = checkNotNull(message.takerOutputs);
complete();
} catch (Throwable t) {

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

@ -19,7 +19,7 @@ package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.trade.listeners.SendMessageListener;
import io.bitsquare.trade.protocol.trade.offerer.models.BuyerAsOffererModel;
import io.bitsquare.trade.protocol.trade.offerer.messages.RequestDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositPaymentMessage;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
@ -36,14 +36,14 @@ public class RequestDepositPayment extends Task<BuyerAsOffererModel> {
@Override
protected void doRun() {
RequestDepositPaymentMessage tradeMessage = new RequestDepositPaymentMessage(
model.getId(),
model.id,
model.offerer.connectedOutputsForAllInputs,
model.offerer.outputs,
model.offerer.pubKey,
model.getFiatAccount(),
model.getAccountId());
model.offerer.fiatAccount,
model.offerer.accountId);
model.getTradeMessageService().sendMessage(model.taker.peer, tradeMessage, new SendMessageListener() {
model.tradeMessageService.sendMessage(model.taker.peer, tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("RequestTakerDepositPaymentMessage successfully arrived at peer");

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

@ -19,7 +19,7 @@ package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.trade.listeners.SendMessageListener;
import io.bitsquare.trade.protocol.trade.offerer.models.BuyerAsOffererModel;
import io.bitsquare.trade.protocol.trade.offerer.messages.BankTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.messages.BankTransferStartedMessage;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
@ -36,13 +36,13 @@ public class SendBankTransferStartedMessage extends Task<BuyerAsOffererModel> {
@Override
protected void doRun() {
BankTransferStartedMessage tradeMessage = new BankTransferStartedMessage(
model.getId(),
model.id,
model.getPublishedDepositTx(),
model.offerer.payoutSignature.encodeToDER(),
model.offerer.payoutSignature,
model.offerer.payoutAmount,
model.taker.payoutAmount,
model.getAddressEntry().getAddressString());
model.getTradeMessageService().sendMessage(model.taker.peer, tradeMessage, new SendMessageListener() {
model.offerer.addressEntry.getAddressString());
model.tradeMessageService.sendMessage(model.taker.peer, tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("Sending BankTransferInitedMessage succeeded.");

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

@ -19,7 +19,7 @@ package io.bitsquare.trade.protocol.trade.offerer.tasks;
import io.bitsquare.trade.listeners.SendMessageListener;
import io.bitsquare.trade.protocol.trade.offerer.models.BuyerAsOffererModel;
import io.bitsquare.trade.protocol.trade.offerer.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
@ -35,9 +35,9 @@ public class SendDepositTxIdToTaker extends Task<BuyerAsOffererModel> {
@Override
protected void doRun() {
DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(model.getId(), model.getTrade().getDepositTx());
DepositTxPublishedMessage tradeMessage = new DepositTxPublishedMessage(model.id, model.trade.getDepositTx());
model.getTradeMessageService().sendMessage(model.taker.peer, tradeMessage, new SendMessageListener() {
model.tradeMessageService.sendMessage(model.taker.peer, tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("DepositTxPublishedMessage successfully arrived at peer");

4
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/SetupListenerForBlockChainConfirmation.java
View file

@ -37,14 +37,14 @@ public class SetupListenerForBlockChainConfirmation extends Task<BuyerAsOffererM
@Override
protected void doRun() {
TransactionConfidence confidence = model.getTrade().getDepositTx().getConfidence();
TransactionConfidence confidence = model.trade.getDepositTx().getConfidence();
confidence.addEventListener(new TransactionConfidence.Listener() {
@Override
public void onConfidenceChanged(Transaction tx, ChangeReason reason) {
log.trace("onConfidenceChanged " + tx.getConfidence());
if (reason == ChangeReason.TYPE && tx.getConfidence().getConfidenceType() == TransactionConfidence.ConfidenceType.BUILDING) {
model.getTrade().setState(Trade.State.DEPOSIT_CONFIRMED);
model.trade.setState(Trade.State.DEPOSIT_CONFIRMED);
boolean removed = confidence.removeEventListener(this);
log.debug("listener removed? " + removed);

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

@ -43,8 +43,8 @@ public class SignAndPublishDepositTx extends Task<BuyerAsOffererModel> {
@Override
protected void doRun() {
try {
Coin offererInputAmount = model.getTrade().getSecurityDeposit().add(FeePolicy.TX_FEE);
model.getTradeWalletService().offererSignsAndPublishTx(
Coin offererInputAmount = model.trade.getSecurityDeposit().add(FeePolicy.TX_FEE);
model.tradeWalletService.offererSignsAndPublishTx(
model.taker.depositTx,
model.offerer.connectedOutputsForAllInputs,
model.taker.connectedOutputsForAllInputs,
@ -52,15 +52,15 @@ public class SignAndPublishDepositTx extends Task<BuyerAsOffererModel> {
offererInputAmount,
model.offerer.pubKey,
model.taker.pubKey,
model.getArbitratorPubKey(),
model.arbitratorPubKey,
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {
log.trace("offererSignAndPublishTx succeeded " + transaction);
model.setPublishedDepositTx(transaction);
model.getTrade().setDepositTx(transaction);
model.getTrade().setState(Trade.State.DEPOSIT_PUBLISHED);
model.trade.setDepositTx(transaction);
model.trade.setState(Trade.State.DEPOSIT_PUBLISHED);
complete();
}

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

@ -38,22 +38,22 @@ public class SignPayoutTx extends Task<BuyerAsOffererModel> {
@Override
protected void doRun() {
try {
Trade trade = model.getTrade();
Trade trade = model.trade;
Coin securityDeposit = trade.getSecurityDeposit();
Coin offererPayoutAmount = trade.getTradeAmount().add(securityDeposit);
@SuppressWarnings("UnnecessaryLocalVariable") Coin takerPayoutAmount = securityDeposit;
TradeWalletService.TransactionDataResult result = model.getTradeWalletService().offererCreatesAndSignsPayoutTx(
TradeWalletService.TransactionDataResult result = model.tradeWalletService.offererCreatesAndSignsPayoutTx(
trade.getDepositTx(),
offererPayoutAmount,
takerPayoutAmount,
model.taker.payoutAddress,
model.getWalletService().getAddressEntry(trade.getId()),
model.walletService.getAddressEntry(trade.getId()),
model.offerer.pubKey,
model.taker.pubKey,
model.getArbitratorPubKey());
model.arbitratorPubKey);
model.offerer.payoutTx = result.getPayoutTx();
model.offerer.preparedPayoutTx = result.getPayoutTx();
model.offerer.payoutSignature = result.getOffererSignature();
model.offerer.payoutAmount = offererPayoutAmount;
model.taker.payoutAmount = takerPayoutAmount;

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

@ -36,20 +36,20 @@ public class VerifyAndSignContract extends Task<BuyerAsOffererModel> {
@Override
protected void doRun() {
Trade trade = model.getTrade();
Trade trade = model.trade;
Contract contract = new Contract(
model.getOffer(),
model.offer,
trade.getTradeAmount(),
model.getTakeOfferFeeTxId(),
model.getAccountId(),
model.offerer.accountId,
model.taker.accountId,
model.getFiatAccount(),
model.offerer.fiatAccount,
model.taker.fiatAccount,
model.getNetworkPubKey(),
model.offerer.messagePubKey,
model.taker.messagePublicKey);
String contractAsJson = Utilities.objectToJson(contract);
String signature = model.getSignatureService().signMessage(model.getRegistrationKeyPair(), contractAsJson);
String signature = model.signatureService.signMessage(model.offerer.registrationKeyPair, contractAsJson);
trade.setContract(contract);
trade.setContractAsJson(contractAsJson);

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

@ -34,7 +34,7 @@ public class VerifyTakeOfferFeePayment extends Task<BuyerAsOffererModel> {
@Override
protected void doRun() {
//TODO mocked yet, need a confidence listeners
int numOfPeersSeenTx = model.getWalletService().getNumOfPeersSeenTx(model.getTakeOfferFeeTxId());
int numOfPeersSeenTx = model.walletService.getNumOfPeersSeenTx(model.getTakeOfferFeeTxId());
/* if (numOfPeersSeenTx > 2) {
resultHandler.handleResult();
}*/

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

@ -34,8 +34,8 @@ public class VerifyTakerAccount extends Task<BuyerAsOffererModel> {
@Override
protected void doRun() {
//TODO mocked yet
if (model.getBlockChainService().verifyAccountRegistration()) {
if (model.getBlockChainService().isAccountBlackListed(model.taker.accountId, model.taker.fiatAccount)) {
if (model.blockChainService.verifyAccountRegistration()) {
if (model.blockChainService.isAccountBlackListed(model.taker.accountId, model.taker.fiatAccount)) {
log.error("Taker is blacklisted");
failed("Taker is blacklisted");
}

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

@ -21,10 +21,10 @@ import io.bitsquare.network.Message;
import io.bitsquare.network.Peer;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.handlers.MessageHandler;
import io.bitsquare.trade.protocol.trade.TradeMessage;
import io.bitsquare.trade.protocol.trade.offerer.messages.BankTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.offerer.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.offerer.messages.RequestDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import io.bitsquare.trade.protocol.trade.messages.BankTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.taker.models.SellerAsTakerModel;
import io.bitsquare.trade.protocol.trade.taker.tasks.BroadcastTakeOfferFeeTx;
import io.bitsquare.trade.protocol.trade.taker.tasks.CreateAndSignContract;
@ -65,9 +65,10 @@ public class SellerAsTakerProtocol {
///////////////////////////////////////////////////////////////////////////////////////////
public SellerAsTakerProtocol(SellerAsTakerModel model) {
log.debug("New SellerAsTakerProtocol " + this);
this.model = model;
messageHandler = this::handleMessage;
model.getTradeMessageService().addMessageHandler(messageHandler);
model.tradeMessageService.addMessageHandler(messageHandler);
}
@ -76,7 +77,8 @@ public class SellerAsTakerProtocol {
///////////////////////////////////////////////////////////////////////////////////////////
public void cleanup() {
model.getTradeMessageService().removeMessageHandler(messageHandler);
log.debug("cleanup " + this);
model.tradeMessageService.removeMessageHandler(messageHandler);
}
public void takeAvailableOffer() {
@ -145,7 +147,7 @@ public class SellerAsTakerProtocol {
SellerAsTakerTaskRunner<SellerAsTakerModel> taskRunner = new SellerAsTakerTaskRunner<>(model,
() -> {
log.debug("taskRunner at handleBankTransferInitedMessage completed");
model.getTrade().setState(Trade.State.FIAT_PAYMENT_STARTED);
model.trade.setState(Trade.State.FIAT_PAYMENT_STARTED);
},
(errorMessage) -> {
log.error(errorMessage);
@ -186,9 +188,9 @@ public class SellerAsTakerProtocol {
log.trace("handleNewMessage: message = " + message.getClass().getSimpleName());
if (message instanceof TradeMessage) {
TradeMessage tradeMessage = (TradeMessage) message;
nonEmptyStringOf(tradeMessage.getTradeId());
nonEmptyStringOf(tradeMessage.tradeId);
if (tradeMessage.getTradeId().equals(model.getId())) {
if (tradeMessage.tradeId.equals(model.id)) {
if (tradeMessage instanceof RequestDepositPaymentMessage) {
handleRequestDepositPaymentMessage((RequestDepositPaymentMessage) tradeMessage);
}

2
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/SellerAsTakerTaskRunner.java
View file

@ -34,7 +34,7 @@ class SellerAsTakerTaskRunner<T extends SellerAsTakerModel> extends TaskRunner<S
/* @Override
public void handleErrorMessage(String errorMessage) {
sharedModel.getTrade().setState(Trade.State.FAILED);
sharedModel.trade.setState(Trade.State.FAILED);
super.handleErrorMessage(errorMessage);
}*/
}

121
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/messages/RequestOffererPublishDepositTxMessage.java
View file

@ -1,121 +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.messages;
import io.bitsquare.fiat.FiatAccount;
import io.bitsquare.trade.protocol.trade.TradeMessage;
import org.bitcoinj.core.Transaction;
import org.bitcoinj.core.TransactionOutput;
import java.io.Serializable;
import java.security.PublicKey;
import java.util.List;
public class RequestOffererPublishDepositTxMessage implements Serializable, TradeMessage {
private static final long serialVersionUID = 2179683654379803071L;
private final String tradeId;
private final FiatAccount fiatAccount;
private final String accountID;
private final PublicKey takerMessagePublicKey;
private final String contractAsJson;
private final String takerContractSignature;
private final String takerPayoutAddress;
private final Transaction takersDepositTx;
private final List<TransactionOutput> takerConnectedOutputsForAllInputs;
private final List<TransactionOutput> takerOutputs;
public RequestOffererPublishDepositTxMessage(String tradeId,
FiatAccount fiatAccount,
String accountID,
PublicKey takerMessagePublicKey,
String contractAsJson,
String takerContractSignature,
String takerPayoutAddress,
Transaction takersDepositTx,
List<TransactionOutput> takerConnectedOutputsForAllInputs,
List<TransactionOutput> takerOutputs) {
this.tradeId = tradeId;
this.fiatAccount = fiatAccount;
this.accountID = accountID;
this.takerMessagePublicKey = takerMessagePublicKey;
this.contractAsJson = contractAsJson;
this.takerContractSignature = takerContractSignature;
this.takerPayoutAddress = takerPayoutAddress;
this.takersDepositTx = takersDepositTx;
this.takerConnectedOutputsForAllInputs = takerConnectedOutputsForAllInputs;
this.takerOutputs = takerOutputs;
}
@Override
public String getTradeId() {
return tradeId;
}
public FiatAccount getTakerBankAccount() {
return fiatAccount;
}
public String getTakerAccountId() {
return accountID;
}
public PublicKey getTakerMessagePublicKey() {
return takerMessagePublicKey;
}
public String getTakerContractAsJson() {
return contractAsJson;
}
public String getTakerContractSignature() {
return takerContractSignature;
}
public List<TransactionOutput> getTakerOutputs() {
return takerOutputs;
}
public FiatAccount getFiatAccount() {
return fiatAccount;
}
public String getAccountID() {
return accountID;
}
public String getContractAsJson() {
return contractAsJson;
}
public String getTakerPayoutAddress() {
return takerPayoutAddress;
}
public Transaction getTakersDepositTx() {
return takersDepositTx;
}
public List<TransactionOutput> getTakerConnectedOutputsForAllInputs() {
return takerConnectedOutputsForAllInputs;
}
}

12
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/OffererModel.java
View file

@ -17,10 +17,10 @@
package io.bitsquare.trade.protocol.trade.taker.models;
import io.bitsquare.fiat.FiatAccount;
import io.bitsquare.network.Peer;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.ECKey;
import org.bitcoinj.core.TransactionOutput;
import java.io.Serializable;
@ -30,16 +30,14 @@ import java.util.List;
public class OffererModel implements Serializable {
private static final long serialVersionUID = 1582902150121576205L;
public OffererModel(Peer peer) {
this.peer = peer;
}
public final Peer peer;
public Peer peer;
public byte[] pubKey;
public Coin payoutAmount;
public String payoutAddress;
public List<TransactionOutput> connectedOutputsForAllInputs;
public List<TransactionOutput> outputs;
public ECKey.ECDSASignature signature;
public byte[] signature;
public FiatAccount fiatAccount;
public String accountId;
}

46
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/SellerAsTakerModel.java
View file

@ -24,7 +24,7 @@ import io.bitsquare.network.Peer;
import io.bitsquare.persistence.Persistence;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.TradeMessageService;
import io.bitsquare.trade.protocol.trade.OfferSharedModel;
import io.bitsquare.trade.protocol.trade.SharedTradeModel;
import io.bitsquare.user.User;
import org.bitcoinj.core.Transaction;
@ -34,18 +34,18 @@ import java.io.Serializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SellerAsTakerModel extends OfferSharedModel implements Serializable {
public class SellerAsTakerModel extends SharedTradeModel implements Serializable {
private static final long serialVersionUID = -963501132927618376L;
private static final Logger log = LoggerFactory.getLogger(SellerAsTakerModel.class);
private final Trade trade;
public final Trade trade;
public final TakerModel taker;
public final OffererModel offerer;
private Transaction publishedDepositTx;
private Transaction takeOfferFeeTx;
private Transaction payoutTx;
public SellerAsTakerModel(Trade trade,
Peer offererPeer,
TradeMessageService tradeMessageService,
@ -59,20 +59,42 @@ public class SellerAsTakerModel extends OfferSharedModel implements Serializable
walletService,
blockChainService,
signatureService,
user,
persistence);
this.trade = trade;
taker = new TakerModel();
offerer = new OffererModel(offererPeer);
Object modelObject = persistence.read(this, "SellerAsTakerModel_" + id);
if (modelObject instanceof SellerAsTakerModel) {
SellerAsTakerModel persistedModel = (SellerAsTakerModel) modelObject;
log.debug("Model reconstructed form persisted model.");
taker.pubKey = getAddressEntry().getPubKey();
setPublishedDepositTx(persistedModel.getPublishedDepositTx());
setTakeOfferFeeTx(persistedModel.getTakeOfferFeeTx());
setPayoutTx(persistedModel.payoutTx);
taker = persistedModel.taker;
offerer = persistedModel.offerer;
}
else {
taker = new TakerModel();
offerer = new OffererModel();
}
offerer.peer = offererPeer;
taker.registrationPubKey = walletService.getRegistrationAddressEntry().getPubKey();
taker.registrationKeyPair = walletService.getRegistrationAddressEntry().getKeyPair();
taker.addressEntry = walletService.getAddressEntry(id);
taker.fiatAccount = user.getBankAccount(offer.getBankAccountId());
taker.accountId = user.getAccountId();
taker.messagePubKey = user.getMessagePubKey();
taker.pubKey = taker.addressEntry.getPubKey();
}
public Trade getTrade() {
return trade;
// Get called form taskRunner after each completed task
@Override
public void persist() {
persistence.write(this, "SellerAsTakerModel_" + id, this);
}
public Transaction getPublishedDepositTx() {

24
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/models/TakerModel.java
View file

@ -17,25 +17,37 @@
package io.bitsquare.trade.protocol.trade.taker.models;
import io.bitsquare.btc.AddressEntry;
import io.bitsquare.fiat.FiatAccount;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction;
import org.bitcoinj.core.TransactionOutput;
import org.bitcoinj.crypto.DeterministicKey;
import java.io.Serializable;
import java.security.PublicKey;
import java.util.List;
public class TakerModel implements Serializable {
private static final long serialVersionUID = -4041809885931756860L;
private static long serialVersionUID = -4041809885931756860L;
// Those fields are set at constructor but not declared as final because constructor is not called in case model gets created from a persisted model
// Declared transient as they will be provided in any case at construction time
transient public FiatAccount fiatAccount;
transient public String accountId;
transient public PublicKey messagePubKey;
transient public byte[] registrationPubKey;
transient public DeterministicKey registrationKeyPair;
transient public AddressEntry addressEntry;
transient public byte[] pubKey;
// written by tasks
public List<TransactionOutput> connectedOutputsForAllInputs;
public List<TransactionOutput> outputs;
public Transaction depositTx;
public FiatAccount fiatAccount;
public String accountId;
public Coin payoutAmount;
public byte[] pubKey;
public Transaction preparedDepositTx;
}

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

@ -41,20 +41,20 @@ public class BroadcastTakeOfferFeeTx extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
try {
model.getTradeWalletService().broadcastTakeOfferFeeTx(model.getTakeOfferFeeTx(),
model.tradeWalletService.broadcastTakeOfferFeeTx(model.getTakeOfferFeeTx(),
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {
log.debug("Take offer fee published successfully. Transaction ID = " + transaction.getHashAsString());
model.getTrade().setState(Trade.State.TAKE_OFFER_FEE_PUBLISHED);
model.trade.setState(Trade.State.TAKE_OFFER_FEE_PUBLISHED);
complete();
}
@Override
public void onFailure(@NotNull Throwable t) {
model.getTrade().setState(Trade.State.TAKE_OFFER_FEE_PUBLISH_FAILED);
model.trade.setState(Trade.State.TAKE_OFFER_FEE_PUBLISH_FAILED);
failed(t);
}
});
@ -62,7 +62,7 @@ public class BroadcastTakeOfferFeeTx extends Task<SellerAsTakerModel> {
appendToErrorMessage("Take offer fee payment failed. Maybe your network connection was lost. Please try again.");
appendToErrorMessage(e.getMessage());
model.getTrade().setState(Trade.State.FAULT);
model.trade.setState(Trade.State.FAULT);
failed(e);
}

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

@ -36,19 +36,19 @@ public class CreateAndSignContract extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
Trade trade = model.getTrade();
Trade trade = model.trade;
Contract contract = new Contract(
model.getOffer(),
model.offer,
trade.getTradeAmount(),
model.getTakeOfferFeeTx().getHashAsString(),
model.offerer.accountId,
model.taker.accountId,
model.getAccountId(),
model.offerer.fiatAccount,
model.taker.fiatAccount,
model.getFiatAccount(),
model.getOffer().getMessagePublicKey(),
model.getNetworkPubKey());
model.offer.getMessagePublicKey(),
model.taker.messagePubKey);
String contractAsJson = Utilities.objectToJson(contract);
String signature = model.getSignatureService().signMessage(model.getRegistrationKeyPair(), contractAsJson);
String signature = model.signatureService.signMessage(model.taker.registrationKeyPair, contractAsJson);
trade.setContract(contract);
trade.setContractAsJson(contractAsJson);

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

@ -37,16 +37,16 @@ public class CreateTakeOfferFeeTx extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
try {
Transaction createTakeOfferFeeTx = model.getTradeWalletService().createTakeOfferFeeTx(model.getAddressEntry());
Transaction createTakeOfferFeeTx = model.tradeWalletService.createTakeOfferFeeTx(model.taker.addressEntry);
model.setTakeOfferFeeTx(createTakeOfferFeeTx);
model.getTrade().setState(Trade.State.TAKE_OFFER_FEE_TX_CREATED);
model.trade.setState(Trade.State.TAKE_OFFER_FEE_TX_CREATED);
complete();
} catch (Exception e) {
appendToErrorMessage(e.getMessage());
model.getTrade().setState(Trade.State.FAULT);
model.trade.setState(Trade.State.FAULT);
failed(e);
}

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

@ -19,11 +19,9 @@ package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.offerer.messages.BankTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.messages.BankTransferStartedMessage;
import io.bitsquare.trade.protocol.trade.taker.models.SellerAsTakerModel;
import org.bitcoinj.core.ECKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -40,14 +38,14 @@ public class ProcessBankTransferStartedMessage extends Task<SellerAsTakerModel>
@Override
protected void doRun() {
try {
checkTradeId(model.getId(), model.getTradeMessage());
checkTradeId(model.id, model.getTradeMessage());
BankTransferStartedMessage message = (BankTransferStartedMessage) model.getTradeMessage();
model.setPublishedDepositTx(checkNotNull(message.getDepositTx()));
model.offerer.signature = checkNotNull(ECKey.ECDSASignature.decodeFromDER(message.getOffererSignature()));
model.offerer.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.getOffererPayoutAmount()));
model.taker.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.getTakerPayoutAmount()));
model.offerer.payoutAddress = nonEmptyStringOf(message.getOffererPayoutAddress());
model.setPublishedDepositTx(checkNotNull(message.depositTx));
model.offerer.signature = checkNotNull(message.offererSignature);
model.offerer.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.offererPayoutAmount));
model.taker.payoutAmount = positiveCoinOf(nonZeroCoinOf(message.takerPayoutAmount));
model.offerer.payoutAddress = nonEmptyStringOf(message.offererPayoutAddress);
complete();
} catch (Throwable t) {

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

@ -17,7 +17,7 @@
package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.trade.protocol.trade.offerer.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.messages.DepositTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.taker.models.SellerAsTakerModel;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
@ -38,10 +38,10 @@ public class ProcessDepositTxPublishedMessage extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
try {
checkTradeId(model.getId(), model.getTradeMessage());
checkTradeId(model.id, model.getTradeMessage());
DepositTxPublishedMessage message = (DepositTxPublishedMessage) model.getTradeMessage();
model.setPublishedDepositTx(checkNotNull(message.getDepositTx()));
model.setPublishedDepositTx(checkNotNull(message.depositTx));
complete();
} catch (Throwable t) {

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

@ -19,7 +19,7 @@ package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.offerer.messages.RequestDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositPaymentMessage;
import io.bitsquare.trade.protocol.trade.taker.models.SellerAsTakerModel;
import org.slf4j.Logger;
@ -38,15 +38,15 @@ public class ProcessRequestDepositPaymentMessage extends Task<SellerAsTakerModel
@Override
protected void doRun() {
try {
checkTradeId(model.getId(), model.getTradeMessage());
checkTradeId(model.id, model.getTradeMessage());
RequestDepositPaymentMessage message = (RequestDepositPaymentMessage) model.getTradeMessage();
model.offerer.connectedOutputsForAllInputs = checkNotNull(message.getOffererConnectedOutputsForAllInputs());
checkArgument(message.getOffererConnectedOutputsForAllInputs().size() > 0);
model.offerer.outputs = checkNotNull(message.getOffererOutputs());
model.offerer.pubKey = checkNotNull(message.getOffererPubKey());
model.taker.fiatAccount = checkNotNull(message.getFiatAccount());
model.taker.accountId = nonEmptyStringOf(message.getAccountId());
model.offerer.connectedOutputsForAllInputs = checkNotNull(message.offererConnectedOutputsForAllInputs);
checkArgument(message.offererConnectedOutputsForAllInputs.size() > 0);
model.offerer.outputs = checkNotNull(message.offererOutputs);
model.offerer.pubKey = checkNotNull(message.offererPubKey);
model.offerer.fiatAccount = checkNotNull(message.offererFiatAccount);
model.offerer.accountId = nonEmptyStringOf(message.offererAccountId);
complete();
} catch (Throwable t) {

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

@ -19,7 +19,7 @@ package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.trade.listeners.SendMessageListener;
import io.bitsquare.trade.protocol.trade.taker.models.SellerAsTakerModel;
import io.bitsquare.trade.protocol.trade.taker.messages.PayoutTxPublishedMessage;
import io.bitsquare.trade.protocol.trade.messages.PayoutTxPublishedMessage;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
@ -35,8 +35,8 @@ public class SendPayoutTxToOfferer extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(model.getId(), model.getPayoutTx());
model.getTradeMessageService().sendMessage(model.offerer.peer, tradeMessage, new SendMessageListener() {
PayoutTxPublishedMessage tradeMessage = new PayoutTxPublishedMessage(model.id, model.getPayoutTx());
model.tradeMessageService.sendMessage(model.offerer.peer, tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("PayoutTxPublishedMessage successfully arrived at peer");

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

@ -22,7 +22,7 @@ import io.bitsquare.trade.listeners.SendMessageListener;
import io.bitsquare.trade.protocol.trade.taker.models.SellerAsTakerModel;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.protocol.trade.taker.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -39,13 +39,13 @@ public class SendRequestDepositTxInputsMessage extends Task<SellerAsTakerModel>
@Override
protected void doRun() {
RequestDepositTxInputsMessage msg = new RequestDepositTxInputsMessage(
model.getId(),
model.id,
model.getTakeOfferFeeTx().getHashAsString(),
model.getTrade().getTradeAmount(),
model.trade.getTradeAmount(),
model.taker.pubKey
);
model.getTradeMessageService().sendMessage(model.offerer.peer, msg, new SendMessageListener() {
model.tradeMessageService.sendMessage(model.offerer.peer, msg, new SendMessageListener() {
@Override
public void handleResult() {
log.trace("Sending TakeOfferFeePayedMessage succeeded.");
@ -58,7 +58,7 @@ public class SendRequestDepositTxInputsMessage extends Task<SellerAsTakerModel>
// We try to repeat once and if that fails as well we persist the state for a later retry.
if (retryCounter == 0) {
retryCounter++;
// doRun();
// doRun();
}
else {
failed();
@ -71,6 +71,6 @@ public class SendRequestDepositTxInputsMessage extends Task<SellerAsTakerModel>
protected void updateStateOnFault() {
appendToErrorMessage("Sending TakeOfferFeePayedMessage to offerer failed. Maybe the network connection was lost or the offerer lost his connection. " +
"We persisted the state of the trade, please try again later or cancel that trade.");
model.getTrade().setState(Trade.State.MESSAGE_SENDING_FAILED);
model.trade.setState(Trade.State.MESSAGE_SENDING_FAILED);
}
}

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

@ -20,7 +20,7 @@ package io.bitsquare.trade.protocol.trade.taker.tasks;
import io.bitsquare.common.taskrunner.Task;
import io.bitsquare.common.taskrunner.TaskRunner;
import io.bitsquare.trade.listeners.SendMessageListener;
import io.bitsquare.trade.protocol.trade.taker.messages.RequestOffererPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.messages.RequestOffererPublishDepositTxMessage;
import io.bitsquare.trade.protocol.trade.taker.models.SellerAsTakerModel;
import org.slf4j.Logger;
@ -36,19 +36,19 @@ public class SendSignedTakerDepositTx extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
RequestOffererPublishDepositTxMessage tradeMessage = new RequestOffererPublishDepositTxMessage(
model.getId(),
model.getFiatAccount(),
model.getAccountId(),
model.getNetworkPubKey(),
model.getTrade().getContractAsJson(),
model.getTrade().getTakerContractSignature(),
model.getAddressEntry().getAddressString(),
model.taker.depositTx,
model.id,
model.taker.fiatAccount,
model.taker.accountId,
model.taker.messagePubKey,
model.trade.getContractAsJson(),
model.trade.getTakerContractSignature(),
model.taker.addressEntry.getAddressString(),
model.taker.preparedDepositTx,
model.taker.connectedOutputsForAllInputs,
model.taker.outputs
);
model.getTradeMessageService().sendMessage(model.offerer.peer, tradeMessage, new SendMessageListener() {
model.tradeMessageService.sendMessage(model.offerer.peer, tradeMessage, new SendMessageListener() {
@Override
public void handleResult() {
complete();

8
core/src/main/java/io/bitsquare/trade/protocol/trade/taker/tasks/SignAndPublishPayoutTx.java
View file

@ -41,21 +41,21 @@ public class SignAndPublishPayoutTx extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
try {
model.getTradeWalletService().takerSignsAndPublishPayoutTx(
model.tradeWalletService.takerSignsAndPublishPayoutTx(
model.getPublishedDepositTx(),
model.offerer.signature,
model.offerer.payoutAmount,
model.taker.payoutAmount,
model.offerer.payoutAddress,
model.getAddressEntry(),
model.taker.addressEntry,
model.offerer.pubKey,
model.taker.pubKey,
model.getArbitratorPubKey(),
model.arbitratorPubKey,
new FutureCallback<Transaction>() {
@Override
public void onSuccess(Transaction transaction) {
model.setPayoutTx(transaction);
model.getTrade().setState(Trade.State.PAYOUT_PUBLISHED);
model.trade.setState(Trade.State.PAYOUT_PUBLISHED);
complete();
}

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

@ -37,9 +37,9 @@ public class TakerCommitDepositTx extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
try {
Transaction transaction = model.getTradeWalletService().takerCommitsDepositTx(model.getPublishedDepositTx());
model.getTrade().setDepositTx(transaction);
model.getTrade().setState(Trade.State.DEPOSIT_PUBLISHED);
Transaction transaction = model.tradeWalletService.takerCommitsDepositTx(model.getPublishedDepositTx());
model.trade.setDepositTx(transaction);
model.trade.setState(Trade.State.DEPOSIT_PUBLISHED);
complete();
} catch (Throwable t) {

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

@ -39,23 +39,23 @@ public class TakerCreatesAndSignsDepositTx extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
try {
Coin takerInputAmount = model.getTrade().getTradeAmount().add(model.getTrade().getSecurityDeposit()).add(FeePolicy.TX_FEE);
Coin msOutputAmount = takerInputAmount.add(model.getTrade().getSecurityDeposit());
Coin takerInputAmount = model.trade.getTradeAmount().add(model.trade.getSecurityDeposit()).add(FeePolicy.TX_FEE);
Coin msOutputAmount = takerInputAmount.add(model.trade.getSecurityDeposit());
TradeWalletService.TransactionDataResult result = model.getTradeWalletService().takerCreatesAndSignsDepositTx(
TradeWalletService.TransactionDataResult result = model.tradeWalletService.takerCreatesAndSignsDepositTx(
takerInputAmount,
msOutputAmount,
model.offerer.connectedOutputsForAllInputs,
model.offerer.outputs,
model.getAddressEntry(),
model.taker.addressEntry,
model.offerer.pubKey,
model.taker.pubKey,
model.getArbitratorPubKey());
model.arbitratorPubKey);
model.taker.connectedOutputsForAllInputs = result.getConnectedOutputsForAllInputs();
model.taker.outputs = result.getOutputs();
model.taker.depositTx = result.getDepositTx();
model.taker.preparedDepositTx = result.getDepositTx();
complete();
} catch (Exception e) {
@ -67,6 +67,6 @@ public class TakerCreatesAndSignsDepositTx extends Task<SellerAsTakerModel> {
protected void updateStateOnFault() {
Trade.State state = Trade.State.FAULT;
state.setErrorMessage(errorMessage);
model.getTrade().setState(state);
model.trade.setState(state);
}
}

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

@ -34,7 +34,7 @@ public class VerifyOfferFeePayment extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
//TODO impl. missing
int numOfPeersSeenTx = model.getWalletService().getNumOfPeersSeenTx(model.getTakeOfferFeeTx().getHashAsString());
int numOfPeersSeenTx = model.walletService.getNumOfPeersSeenTx(model.getTakeOfferFeeTx().getHashAsString());
/* if (numOfPeersSeenTx > 2) {
resultHandler.handleResult();
}*/

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

@ -33,8 +33,8 @@ public class VerifyOffererAccount extends Task<SellerAsTakerModel> {
@Override
protected void doRun() {
if (model.getBlockChainService().verifyAccountRegistration()) {
if (model.getBlockChainService().isAccountBlackListed(model.taker.accountId, model.taker.fiatAccount)) {
if (model.blockChainService.verifyAccountRegistration()) {
if (model.blockChainService.isAccountBlackListed(model.offerer.accountId, model.offerer.fiatAccount)) {
failed("Taker is blacklisted.");
}
else {

14
core/src/main/java/io/bitsquare/user/User.java
View file

@ -43,7 +43,7 @@ import javafx.collections.ObservableList;
public class User implements Serializable {
private static final long serialVersionUID = 7409078808248518638L;
private KeyPair networkKeyPair;
private KeyPair messageKeyPair;
private String accountID;
// Used for serialisation (ObservableList cannot be serialized) -> serialisation will change anyway so that is
@ -71,13 +71,13 @@ public class User implements Serializable {
if (persistedUser != null) {
fiatAccounts.setAll(persistedUser.getSerializedBankAccounts());
setCurrentBankAccount(persistedUser.getSerializedCurrentBankAccount());
networkKeyPair = persistedUser.getNetworkKeyPair();
messageKeyPair = persistedUser.getMessageKeyPair();
accountID = persistedUser.getAccountId();
}
else {
// First time
// TODO use separate thread. DSAKeyUtil.getKeyPair() runs in same thread now
networkKeyPair = DSAKeyUtil.generateKeyPair();
messageKeyPair = DSAKeyUtil.generateKeyPair();
}
}
@ -160,12 +160,12 @@ public class User implements Serializable {
return null;
}
public KeyPair getNetworkKeyPair() {
return networkKeyPair;
public KeyPair getMessageKeyPair() {
return messageKeyPair;
}
public PublicKey getNetworkPubKey() {
return networkKeyPair.getPublic();
public PublicKey getMessagePubKey() {
return messageKeyPair.getPublic();
}
public ObjectProperty<FiatAccount> currentBankAccountProperty() {

4
core/src/main/java/io/bitsquare/util/Validator.java
View file

@ -17,7 +17,7 @@
package io.bitsquare.util;
import io.bitsquare.trade.protocol.trade.TradeMessage;
import io.bitsquare.trade.protocol.trade.messages.TradeMessage;
import org.bitcoinj.core.Coin;
@ -52,7 +52,7 @@ public class Validator {
}
public static void checkTradeId(String tradeId, TradeMessage tradeMessage) {
checkArgument(tradeId.equals(tradeMessage.getTradeId()));
checkArgument(tradeId.equals(tradeMessage.tradeId));
}

2
core/src/main/resources/logback.xml
View file

@ -30,7 +30,7 @@
<logger name="io.bitsquare" level="TRACE"/>
<logger name="io.bitsquare.gui.util.Profiler" level="ERROR"/>
<logger name="io.bitsquare.persistence.Persistence" level="ERROR"/>
<!-- <logger name="io.bitsquare.persistence.Persistence" level="ERROR"/>-->
<logger name="io.bitsquare.locale.BSResources" level="ERROR"/>
<logger name="org.bitcoinj" level="DEBUG"/>

2
core/src/test/java/io/bitsquare/trade/protocol/placeoffer/PlaceOfferProtocolTest.java
View file

@ -98,7 +98,7 @@ public class PlaceOfferProtocolTest {
tomP2PNode = new TomP2PNode(bootstrappedPeerBuilder);
tradeMessageService = new TomP2PTradeMessageService(tomP2PNode);
Observable<BootstrapState> messageObservable = tomP2PNode.bootstrap(user.getNetworkKeyPair(), tradeMessageService);
Observable<BootstrapState> messageObservable = tomP2PNode.bootstrap(user.getMessageKeyPair(), tradeMessageService);
messageObservable.publish();
messageObservable.subscribe(
state -> log.trace("state changed: " + state),