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

Refactor trade object

Browse Source
This commit is contained in:
Manfred Karrer 2015-03-26 18:56:54 +01:00
parent 0ddd025b93
commit a9f6d8481b
9 changed files with 109 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
core/src/main/java/io/bitsquare/offer/tomp2p/TomP2POfferBookService.java
View File

@ -195,12 +195,12 @@ public class TomP2POfferBookService extends TomP2PDHTService implements OfferBoo
e.printStackTrace();
}
}
log.trace("Get offers with offers.size(): " + offers.size());
executor.execute(() -> offerRepositoryListeners.stream().forEach(listener ->
listener.onOffersReceived(offers)));
}
log.trace("Get offers from DHT was successful. Stored data: [key: " + locationKey
log.trace("Get offers from DHT was successful. Received data: [key: " + locationKey
+ ", values: " + futureGet.dataMap() + "]");
}
else {

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

@ -18,9 +18,12 @@
package io.bitsquare.trade;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.protocol.trade.offerer.OffererAsBuyerProtocol;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.TransactionConfidence;
import org.bitcoinj.utils.Fiat;
import com.google.common.base.Throwables;
import com.google.common.util.concurrent.FutureCallback;
@ -42,6 +45,7 @@ public class OffererTrade extends Trade implements Serializable {
private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(OffererTrade.class);
///////////////////////////////////////////////////////////////////////////////////////////
// Enum
///////////////////////////////////////////////////////////////////////////////////////////
@ -66,11 +70,14 @@ public class OffererTrade extends Trade implements Serializable {
EXCEPTION
}
protected OffererProcessState processState;
protected OffererLifeCycleState lifeCycleState;
transient protected ObjectProperty<OffererProcessState> processStateProperty = new SimpleObjectProperty<>(processState);
transient protected ObjectProperty<OffererLifeCycleState> lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState);
private Coin tradeAmount;
private Peer tradingPeer;
private OffererProcessState processState;
private OffererLifeCycleState lifeCycleState;
transient private ObjectProperty<OffererProcessState> processStateProperty = new SimpleObjectProperty<>(processState);
transient private ObjectProperty<OffererLifeCycleState> lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState);
///////////////////////////////////////////////////////////////////////////////////////////
@ -89,6 +96,7 @@ public class OffererTrade extends Trade implements Serializable {
lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState);
}
public void onFiatPaymentStarted() {
((OffererAsBuyerProtocol) protocol).onFiatPaymentStarted();
}
@ -123,28 +131,46 @@ public class OffererTrade extends Trade implements Serializable {
lifeCycleStateProperty.set(lifeCycleState);
}
public void setTradeAmount(Coin tradeAmount) {
this.tradeAmount = tradeAmount;
tradeAmountProperty.set(tradeAmount);
tradeVolumeProperty.set(getTradeVolume());
}
public void setTradingPeer(Peer tradingPeer) {
this.tradingPeer = tradingPeer;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Getters
///////////////////////////////////////////////////////////////////////////////////////////
public OffererProcessState getProcessState() {
return processState;
}
public OffererLifeCycleState getLifeCycleState() {
return lifeCycleState;
}
@Override
public ReadOnlyObjectProperty<OffererProcessState> processStateProperty() {
return processStateProperty;
}
@Override
public ReadOnlyObjectProperty<OffererLifeCycleState> lifeCycleStateProperty() {
return lifeCycleStateProperty;
}
@Override
public Coin getTradeAmount() {
return tradeAmount;
}
@Override
public Fiat getTradeVolume() {
return offer.getVolumeByAmount(tradeAmount);
}
@Override
public Peer getTradingPeer() {
return tradingPeer;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Private

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

@ -18,9 +18,12 @@
package io.bitsquare.trade;
import io.bitsquare.offer.Offer;
import io.bitsquare.p2p.Peer;
import io.bitsquare.trade.protocol.trade.taker.TakerAsSellerProtocol;
import org.bitcoinj.core.Coin;
import org.bitcoinj.core.TransactionConfidence;
import org.bitcoinj.utils.Fiat;
import com.google.common.base.Throwables;
import com.google.common.util.concurrent.FutureCallback;
@ -42,7 +45,6 @@ public class TakerTrade extends Trade implements Serializable {
private static final long serialVersionUID = 1L;
transient private static final Logger log = LoggerFactory.getLogger(TakerTrade.class);
///////////////////////////////////////////////////////////////////////////////////////////
// Enum
///////////////////////////////////////////////////////////////////////////////////////////
@ -70,19 +72,28 @@ public class TakerTrade extends Trade implements Serializable {
EXCEPTION
}
protected TakerProcessState processState;
protected TakerLifeCycleState lifeCycleState;
transient protected ObjectProperty<TakerProcessState> processStateProperty = new SimpleObjectProperty<>(processState);
transient protected ObjectProperty<TakerLifeCycleState> lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState);
private final Coin tradeAmount;
private final Peer tradingPeer;
private TakerProcessState processState;
private TakerLifeCycleState lifeCycleState;
transient private ObjectProperty<TakerProcessState> processStateProperty = new SimpleObjectProperty<>(processState);
transient private ObjectProperty<TakerLifeCycleState> lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState);
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
public TakerTrade(Offer offer) {
public TakerTrade(Offer offer, Coin tradeAmount, Peer peer) {
super(offer);
this.tradeAmount = tradeAmount;
this.tradingPeer = peer;
tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount);
tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume()); // cannot be set before offer is set
}
// Serialized object does not create our transient objects
@ -91,6 +102,8 @@ public class TakerTrade extends Trade implements Serializable {
processStateProperty = new SimpleObjectProperty<>(processState);
lifeCycleStateProperty = new SimpleObjectProperty<>(lifeCycleState);
tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount);
tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume());
}
public void onFiatPaymentReceived() {
@ -127,20 +140,36 @@ public class TakerTrade extends Trade implements Serializable {
///////////////////////////////////////////////////////////////////////////////////////////
// Getters
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public ReadOnlyObjectProperty<TakerProcessState> processStateProperty() {
return processStateProperty;
}
@Override
public ReadOnlyObjectProperty<TakerLifeCycleState> lifeCycleStateProperty() {
return lifeCycleStateProperty;
}
@Override
public Coin getTradeAmount() {
return tradeAmount;
}
@Override
public Fiat getTradeVolume() {
return offer.getVolumeByAmount(tradeAmount);
}
@Override
public Peer getTradingPeer() {
return tradingPeer;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Private
///////////////////////////////////////////////////////////////////////////////////////////
@Override
protected void setConfidenceListener() {
TransactionConfidence transactionConfidence = depositTx.getConfidence();

56
core/src/main/java/io/bitsquare/trade/Trade.java
View File

@ -27,7 +27,6 @@ import org.bitcoinj.core.Coin;
import org.bitcoinj.core.Transaction;
import org.bitcoinj.utils.Fiat;
import java.io.IOException;
import java.io.Serializable;
import java.util.Date;
@ -57,20 +56,18 @@ abstract public class Trade implements Serializable {
protected final Offer offer;
protected final Date date;
protected Coin tradeAmount;
protected Contract contract;
protected String contractAsJson;
protected String takerContractSignature;
protected String offererContractSignature;
protected Transaction depositTx;
protected Transaction payoutTx;
protected Peer tradingPeer;
protected int depthInBlocks = 0;
transient protected String errorMessage;
transient protected Throwable throwable;
transient protected ObjectProperty<Coin> tradeAmountProperty;
transient protected ObjectProperty<Fiat> tradeVolumeProperty;
transient protected ObjectProperty<Coin> tradeAmountProperty = new SimpleObjectProperty<>();
transient protected ObjectProperty<Fiat> tradeVolumeProperty = new SimpleObjectProperty<>();
///////////////////////////////////////////////////////////////////////////////////////////
@ -79,25 +76,14 @@ abstract public class Trade implements Serializable {
public Trade(Offer offer) {
this.offer = offer;
date = new Date();
tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount);
tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume()); // cannot be set before offer is set
}
// Serialized object does not create our transient objects
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
tradeAmountProperty = new SimpleObjectProperty<>(tradeAmount);
tradeVolumeProperty = new SimpleObjectProperty<>(getTradeVolume());
}
// The deserialized tx has not actual confidence data, so we need to get the fresh one from the wallet.
public void updateTxFromWallet(TradeWalletService tradeWalletService) {
if (depositTx != null) {
depositTx = tradeWalletService.commitsDepositTx(depositTx);
setConfidenceListener();
}
if (depositTx != null)
setDepositTx(tradeWalletService.commitsDepositTx(depositTx));
}
public void setDepositTx(Transaction tx) {
@ -134,18 +120,6 @@ abstract public class Trade implements Serializable {
// Setters
///////////////////////////////////////////////////////////////////////////////////////////
public void setTradeAmount(Coin tradeAmount) {
this.tradeAmount = tradeAmount;
tradeAmountProperty.set(tradeAmount);
tradeVolumeProperty.set(getTradeVolume());
}
public void setTradingPeer(Peer tradingPeer) {
this.tradingPeer = tradingPeer;
}
public void setTakerContractSignature(String takerSignature) {
this.takerContractSignature = takerSignature;
}
@ -154,10 +128,6 @@ abstract public class Trade implements Serializable {
this.offererContractSignature = offererContractSignature;
}
public Coin getTradeAmount() {
return tradeAmount;
}
public Contract getContract() {
return contract;
}
@ -187,10 +157,6 @@ abstract public class Trade implements Serializable {
// Getters
///////////////////////////////////////////////////////////////////////////////////////////
public Fiat getTradeVolume() {
return offer.getVolumeByAmount(tradeAmount);
}
public String getTakerContractSignature() {
return takerContractSignature;
}
@ -227,10 +193,6 @@ abstract public class Trade implements Serializable {
return date;
}
public Peer getTradingPeer() {
return tradingPeer;
}
public ReadOnlyObjectProperty<Coin> tradeAmountProperty() {
return tradeAmountProperty;
}
@ -251,6 +213,12 @@ abstract public class Trade implements Serializable {
public abstract ReadOnlyObjectProperty<? extends LifeCycleState> lifeCycleStateProperty();
public abstract Coin getTradeAmount();
public abstract Fiat getTradeVolume();
public abstract Peer getTradingPeer();
protected abstract void setConfidenceListener();
@Override
@ -260,14 +228,12 @@ abstract public class Trade implements Serializable {
", mailboxMessage=" + mailboxMessage +
", offer=" + offer +
", date=" + date +
", tradeAmount=" + tradeAmount +
", contract=" + contract +
", contractAsJson='" + contractAsJson + '\'' +
", takerContractSignature='" + takerContractSignature + '\'' +
", offererContractSignature='" + offererContractSignature + '\'' +
", depositTx=" + depositTx +
", payoutTx=" + payoutTx +
", tradingPeer=" + tradingPeer +
", depthInBlocks=" + depthInBlocks +
'}';
}

9
core/src/main/java/io/bitsquare/trade/TradeManager.java
View File

@ -107,7 +107,7 @@ public class TradeManager {
@Inject
public TradeManager(User user, AccountSettings accountSettings,
MessageService messageService, MailboxService mailboxService, AddressService addressService, BlockChainService blockChainService,
WalletService walletService, TradeWalletService tradeWalletService, SignatureService signatureService,
WalletService walletService, TradeWalletService tradeWalletService, SignatureService signatureService,
EncryptionService<MailboxMessage> encryptionService,
OfferBookService offerBookService, ArbitrationRepository arbitrationRepository, @Named("storage.dir") File storageDir) {
this.user = user;
@ -179,6 +179,7 @@ public class TradeManager {
TakerTrade takerTrade = (TakerTrade) trade;
TakerAsSellerProtocol sellerTakesOfferProtocol = createTakerAsSellerProtocol(takerTrade);
takerTrade.setProtocol(sellerTakesOfferProtocol);
takerTrade.updateTxFromWallet(tradeWalletService);
}
}
@ -305,7 +306,7 @@ public class TradeManager {
// TODO handle overpaid securityDeposit
Coin amountToWithdraw = trade.getSecurityDeposit();
if (trade instanceof OffererTrade)
amountToWithdraw = amountToWithdraw.add(trade.getTradeAmount());
amountToWithdraw = amountToWithdraw.add(((OffererTrade) trade).getTradeAmount());
FutureCallback<Transaction> callback = new FutureCallback<Transaction>() {
@Override
@ -411,9 +412,7 @@ public class TradeManager {
///////////////////////////////////////////////////////////////////////////////////////////
private TakerTrade takeAvailableOffer(Coin amount, Offer offer, Peer peer) {
TakerTrade takerTrade = new TakerTrade(offer);
takerTrade.setTradeAmount(amount);
takerTrade.setTradingPeer(peer);
TakerTrade takerTrade = new TakerTrade(offer, amount, peer);
takerTrade.setLifeCycleState(TakerTrade.TakerLifeCycleState.PENDING);
pendingTrades.add(takerTrade);

2
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/OffererAsBuyerProtocol.java
View File

@ -107,7 +107,7 @@ public class OffererAsBuyerProtocol implements Protocol {
// We don't store anything in the model as we might be in a trade process and receive that request from another peer who wants to take the offer
// at the same time
boolean isOfferOpen = model.trade.getLifeCycleState() == OffererTrade.OffererLifeCycleState.OPEN_OFFER;
boolean isOfferOpen = model.trade.lifeCycleStateProperty().get() == OffererTrade.OffererLifeCycleState.OPEN_OFFER;
ReportOfferAvailabilityMessage reportOfferAvailabilityMessage = new ReportOfferAvailabilityMessage(model.id, isOfferOpen);
model.messageService.sendMessage(sender, reportOfferAvailabilityMessage, new SendMessageListener() {
@Override

10
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/CreateAndSignPayoutTx.java
View File

@ -19,7 +19,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.Trade;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import org.bitcoinj.core.Coin;
@ -37,13 +37,13 @@ public class CreateAndSignPayoutTx extends Task<OffererAsBuyerModel> {
@Override
protected void doRun() {
try {
Trade trade = model.trade;
Coin securityDeposit = trade.getSecurityDeposit();
Coin offererPayoutAmount = trade.getTradeAmount().add(securityDeposit);
OffererTrade offererTrade = model.trade;
Coin securityDeposit = offererTrade.getSecurityDeposit();
Coin offererPayoutAmount = offererTrade.getTradeAmount().add(securityDeposit);
@SuppressWarnings("UnnecessaryLocalVariable") Coin takerPayoutAmount = securityDeposit;
byte[] offererPayoutTxSignature = model.tradeWalletService.offererCreatesAndSignsPayoutTx(
trade.getDepositTx(),
offererTrade.getDepositTx(),
offererPayoutAmount,
takerPayoutAmount,
model.offerer.addressEntry,

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

@ -19,7 +19,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.Trade;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.messages.RequestDepositTxInputsMessage;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
@ -40,10 +40,10 @@ public class ProcessRequestDepositTxInputsMessage extends Task<OffererAsBuyerMod
protected void doRun() {
try {
checkTradeId(model.id, model.getTradeMessage());
Trade trade = model.trade;
OffererTrade offererTrade = model.trade;
RequestDepositTxInputsMessage requestDepositTxInputsMessage = (RequestDepositTxInputsMessage) model.getTradeMessage();
trade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(requestDepositTxInputsMessage.tradeAmount)));
offererTrade.setTradeAmount(positiveCoinOf(nonZeroCoinOf(requestDepositTxInputsMessage.tradeAmount)));
model.setTakeOfferFeeTxId(nonEmptyStringOf(requestDepositTxInputsMessage.takeOfferFeeTxId));
model.taker.tradeWalletPubKey = checkNotNull(requestDepositTxInputsMessage.takerTradeWalletPubKey);

14
core/src/main/java/io/bitsquare/trade/protocol/trade/offerer/tasks/VerifyAndSignContract.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.Contract;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.OffererTrade;
import io.bitsquare.trade.protocol.trade.offerer.models.OffererAsBuyerModel;
import io.bitsquare.util.Utilities;
@ -37,11 +37,11 @@ public class VerifyAndSignContract extends Task<OffererAsBuyerModel> {
@Override
protected void doRun() {
try {
Trade trade = model.trade;
OffererTrade offererTrade = model.trade;
Contract contract = new Contract(
model.offer,
trade.getTradeAmount(),
offererTrade.getTradeAmount(),
model.getTakeOfferFeeTxId(),
model.offerer.accountId,
model.taker.accountId,
@ -52,10 +52,10 @@ public class VerifyAndSignContract extends Task<OffererAsBuyerModel> {
String contractAsJson = Utilities.objectToJson(contract);
String signature = model.signatureService.signMessage(model.offerer.registrationKeyPair, contractAsJson);
trade.setContract(contract);
trade.setContractAsJson(contractAsJson);
trade.setOffererContractSignature(signature);
trade.setTakerContractSignature(model.taker.contractSignature);
offererTrade.setContract(contract);
offererTrade.setContractAsJson(contractAsJson);
offererTrade.setOffererContractSignature(signature);
offererTrade.setTakerContractSignature(model.taker.contractSignature);
complete();
} catch (Throwable t) {