[WIP] Add cancel trade feature

core/src/main/java/bisq/core/btc/wallet/TradeWalletService.java

@@ -58,7 +58,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 import java.util.stream.Collectors;
 
 import org.slf4j.Logger;
@@ -833,6 +832,67 @@ public Transaction sellerSignsAndFinalizesPayoutTx(Transaction depositTx,
         return payoutTx;
     }
 
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // Canceled trade payoutTx
+    ///////////////////////////////////////////////////////////////////////////////////////////
+
+    public byte[] signCanceledTradePayoutTx(Transaction depositTx,
+                                            Coin buyerPayoutAmount,
+                                            Coin sellerPayoutAmount,
+                                            String buyerPayoutAddressString,
+                                            String sellerPayoutAddressString,
+                                            DeterministicKey myMultiSigKeyPair,
+                                            byte[] buyerPubKey,
+                                            byte[] sellerPubKey)
+            throws AddressFormatException, TransactionVerificationException {
+        Transaction preparedPayoutTx = createPayoutTx(depositTx, buyerPayoutAmount, sellerPayoutAmount, buyerPayoutAddressString, sellerPayoutAddressString);
+        // MS redeemScript
+        Script redeemScript = get2of2MultiSigRedeemScript(buyerPubKey, sellerPubKey);
+        // MS output from prev. tx is index 0
+        Sha256Hash sigHash = preparedPayoutTx.hashForSignature(0, redeemScript, Transaction.SigHash.ALL, false);
+        checkNotNull(myMultiSigKeyPair, "myMultiSigKeyPair must not be null");
+        if (myMultiSigKeyPair.isEncrypted()) {
+            checkNotNull(aesKey);
+        }
+        ECKey.ECDSASignature mySignature = myMultiSigKeyPair.sign(sigHash, aesKey).toCanonicalised();
+        WalletService.printTx("prepared canceled trade payoutTx for sig creation", preparedPayoutTx);
+        WalletService.verifyTransaction(preparedPayoutTx);
+        return mySignature.encodeToDER();
+    }
+
+    public Transaction finalizeCanceledTradePayoutTx(Transaction depositTx,
+                                                     byte[] buyerSignature,
+                                                     byte[] sellerSignature,
+                                                     Coin buyerPayoutAmount,
+                                                     Coin sellerPayoutAmount,
+                                                     String buyerPayoutAddressString,
+                                                     String sellerPayoutAddressString,
+                                                     DeterministicKey multiSigKeyPair,
+                                                     byte[] buyerPubKey,
+                                                     byte[] sellerPubKey)
+            throws AddressFormatException, TransactionVerificationException, WalletException {
+        Transaction payoutTx = createPayoutTx(depositTx, buyerPayoutAmount, sellerPayoutAmount, buyerPayoutAddressString, sellerPayoutAddressString);
+        // MS redeemScript
+        Script redeemScript = get2of2MultiSigRedeemScript(buyerPubKey, sellerPubKey);
+        // MS output from prev. tx is index 0
+        checkNotNull(multiSigKeyPair, "multiSigKeyPair must not be null");
+        TransactionSignature buyerTxSig = new TransactionSignature(ECKey.ECDSASignature.decodeFromDER(buyerSignature),
+                Transaction.SigHash.ALL, false);
+        TransactionSignature sellerTxSig = new TransactionSignature(ECKey.ECDSASignature.decodeFromDER(sellerSignature),
+                Transaction.SigHash.ALL, false);
+        // Take care of order of signatures. Need to be reversed here. See comment below at getMultiSigRedeemScript (seller, buyer)
+        Script inputScript = ScriptBuilder.createP2SHMultiSigInputScript(ImmutableList.of(sellerTxSig, buyerTxSig), redeemScript);
+        TransactionInput input = payoutTx.getInput(0);
+        input.setScriptSig(inputScript);
+        WalletService.printTx("canceled trade payoutTx", payoutTx);
+        WalletService.verifyTransaction(payoutTx);
+        WalletService.checkWalletConsistency(wallet);
+        WalletService.checkScriptSig(payoutTx, input, 0);
+        checkNotNull(input.getConnectedOutput(), "input.getConnectedOutput() must not be null");
+        input.verify(input.getConnectedOutput());
+        return payoutTx;
+    }
+
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Mediated payoutTx

core/src/main/java/bisq/core/proto/network/CoreNetworkProtoResolver.java

@@ -46,6 +46,8 @@
 import bisq.core.support.dispute.messages.PeerOpenedDisputeMessage;
 import bisq.core.support.dispute.refund.refundagent.RefundAgent;
 import bisq.core.support.messages.ChatMessage;
+import bisq.core.trade.messages.CancelTradeRequestAcceptedMessage;
+import bisq.core.trade.messages.CancelTradeRequestRejectedMessage;
 import bisq.core.trade.messages.CounterCurrencyTransferStartedMessage;
 import bisq.core.trade.messages.DelayedPayoutTxSignatureRequest;
 import bisq.core.trade.messages.DelayedPayoutTxSignatureResponse;
@@ -58,6 +60,7 @@
 import bisq.core.trade.messages.PayoutTxPublishedMessage;
 import bisq.core.trade.messages.PeerPublishedDelayedPayoutTxMessage;
 import bisq.core.trade.messages.RefreshTradeStateRequest;
+import bisq.core.trade.messages.RequestCancelTradeMessage;
 import bisq.core.trade.messages.TraderSignedWitnessMessage;
 import bisq.core.trade.statistics.TradeStatistics;
 
@@ -174,6 +177,13 @@ public NetworkEnvelope fromProto(protobuf.NetworkEnvelope proto) throws Protobuf
                 case MEDIATED_PAYOUT_TX_PUBLISHED_MESSAGE:
                     return MediatedPayoutTxPublishedMessage.fromProto(proto.getMediatedPayoutTxPublishedMessage(), messageVersion);
 
+                case REQUEST_CANCEL_TRADE_MESSAGE:
+                    return RequestCancelTradeMessage.fromProto(proto.getRequestCancelTradeMessage(), messageVersion);
+                case CANCEL_TRADE_ACCEPTED_MESSAGE:
+                    return CancelTradeRequestAcceptedMessage.fromProto(proto.getCancelTradeAcceptedMessage(), messageVersion);
+                case CANCEL_TRADE_REJECTED_MESSAGE:
+                    return CancelTradeRequestRejectedMessage.fromProto(proto.getCancelTradeRejectedMessage(), messageVersion);
+
                 case OPEN_NEW_DISPUTE_MESSAGE:
                     return OpenNewDisputeMessage.fromProto(proto.getOpenNewDisputeMessage(), this, messageVersion);
                 case PEER_OPENED_DISPUTE_MESSAGE:

core/src/main/java/bisq/core/trade/CanceledTradeState.java

@@ -0,0 +1,50 @@
+/*
+ * This file is part of Bisq.
+ *
+ * Bisq 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.
+ *
+ * Bisq 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 Bisq. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package bisq.core.trade;
+
+public enum CanceledTradeState {
+    REQUEST_MSG_SENT,
+    REQUEST_MSG_ARRIVED,
+    REQUEST_MSG_IN_MAILBOX,
+    REQUEST_MSG_SEND_FAILED,
+
+    // Peer received request
+    RECEIVED_CANCEL_REQUEST,
+
+    // Requester received reject msg
+    RECEIVED_ACCEPTED_MSG,
+
+    // Peer accepted
+    PAYOUT_TX_PUBLISHED,
+    PAYOUT_TX_PUBLISHED_MSG_SENT,
+    PAYOUT_TX_PUBLISHED_MSG_ARRIVED,
+    PAYOUT_TX_PUBLISHED_MSG_IN_MAILBOX,
+    PAYOUT_TX_PUBLISHED_MSG_SEND_FAILED,
+
+    // Request sees tx
+    PAYOUT_TX_SEEN_IN_NETWORK,
+
+    // Peer rejected
+    REQUEST_CANCELED_MSG_SENT,
+    REQUEST_CANCELED_MSG_ARRIVED,
+    REQUEST_CANCELED_MSG_IN_MAILBOX,
+    REQUEST_CANCELED_MSG_SEND_FAILED,
+
+    // Requester received reject msg
+    RECEIVED_REJECTED_MSG,
+}

core/src/main/java/bisq/core/trade/Trade.java

@@ -450,6 +450,12 @@ public static protobuf.Trade.TradePeriodState toProtoMessage(Trade.TradePeriodSt
     @Getter
     transient final private IntegerProperty assetTxProofResultUpdateProperty = new SimpleIntegerProperty();
 
+    @Getter
+    // Added at v1.3.9
+    public CanceledTradeState canceledTradeState;
+    @Getter
+    transient final private ObjectProperty<CanceledTradeState> canceledTradeStateProperty = new SimpleObjectProperty<>();
+
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Constructor, initialization
@@ -563,6 +569,7 @@ public Message toProtoMessage() {
         Optional.ofNullable(delayedPayoutTxBytes).ifPresent(e -> builder.setDelayedPayoutTxBytes(ByteString.copyFrom(delayedPayoutTxBytes)));
         Optional.ofNullable(counterCurrencyExtraData).ifPresent(e -> builder.setCounterCurrencyExtraData(counterCurrencyExtraData));
         Optional.ofNullable(assetTxProofResult).ifPresent(e -> builder.setAssetTxProofResult(assetTxProofResult.name()));
+        Optional.ofNullable(canceledTradeState).ifPresent(e -> builder.setCanceledTradeState(canceledTradeState.name()));
 
         return builder.build();
     }
@@ -605,6 +612,8 @@ public static Trade fromProto(Trade trade, protobuf.Trade proto, CoreProtoResolv
         }
         trade.setAssetTxProofResult(persistedAssetTxProofResult);
 
+        trade.setCanceledTradeState(ProtoUtil.enumFromProto(CanceledTradeState.class, proto.getCanceledTradeState()));
+
         trade.chatMessages.addAll(proto.getChatMessageList().stream()
                 .map(ChatMessage::fromPayloadProto)
                 .collect(Collectors.toList()));
@@ -893,6 +902,11 @@ public void setAssetTxProofResult(@Nullable AssetTxProofResult assetTxProofResul
         persist();
     }
 
+    public void setCanceledTradeState(CanceledTradeState canceledTradeState) {
+        this.canceledTradeState = canceledTradeState;
+        canceledTradeStateProperty.set(canceledTradeState);
+        persist();
+    }
 
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Getter
@@ -1230,6 +1244,7 @@ public String toString() {
                 ",\n     refundResultState=" + refundResultState +
                 ",\n     refundResultStateProperty=" + refundResultStateProperty +
                 ",\n     lastRefreshRequestDate=" + lastRefreshRequestDate +
+                ",\n     canceledTradeState=" + canceledTradeState +
                 "\n}";
     }
 }

core/src/main/java/bisq/core/trade/TradeCancellationManager.java

@@ -0,0 +1,117 @@
+/*
+ * This file is part of Bisq.
+ *
+ * Bisq 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.
+ *
+ * Bisq 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 Bisq. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package bisq.core.trade;
+
+import bisq.core.btc.wallet.Restrictions;
+import bisq.core.offer.Offer;
+import bisq.core.trade.protocol.ProcessModel;
+
+import bisq.common.handlers.ErrorMessageHandler;
+import bisq.common.handlers.ResultHandler;
+
+import org.bitcoinj.core.Coin;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+
+import lombok.extern.slf4j.Slf4j;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+@Slf4j
+@Singleton
+public final class TradeCancellationManager {
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // Constructor
+    ///////////////////////////////////////////////////////////////////////////////////////////
+
+    @Inject
+    public TradeCancellationManager() {
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // API
+    ///////////////////////////////////////////////////////////////////////////////////////////
+
+    public void requestCancelTrade(Trade trade,
+                                   ResultHandler resultHandler,
+                                   ErrorMessageHandler errorMessageHandler) {
+        ProcessModel processModel = trade.getProcessModel();
+        Offer offer = checkNotNull(trade.getOffer());
+        Coin secDepositOfRequester = getSecurityDepositForRequester();
+        Coin totalSecDeposit = offer.getSellerSecurityDeposit().add(offer.getBuyerSecurityDeposit());
+        Coin secDepositForForPeer = totalSecDeposit.subtract(secDepositOfRequester);
+        Coin tradeAmount = checkNotNull(trade.getTradeAmount(), "tradeAmount must not be null");
+        if (trade instanceof BuyerTrade) {
+            processModel.setBuyerPayoutAmountFromCanceledTrade(secDepositOfRequester.value);
+            processModel.setSellerPayoutAmountFromCanceledTrade(tradeAmount.add(secDepositForForPeer).value);
+        } else {
+            processModel.setBuyerPayoutAmountFromCanceledTrade(secDepositForForPeer.value);
+            processModel.setSellerPayoutAmountFromCanceledTrade(tradeAmount.add(secDepositOfRequester).value);
+        }
+        trade.getTradeProtocol().onRequestCancelTrade(resultHandler, errorMessageHandler);
+    }
+
+    public Coin getSecurityDepositForRequester() {
+        return Restrictions.getMinRefundAtMediatedDispute();
+    }
+
+    private Coin getTotalSecDepositForAcceptingTrader(Offer offer) {
+        Coin totalSecDeposit = offer.getSellerSecurityDeposit().add(offer.getBuyerSecurityDeposit());
+        return totalSecDeposit.subtract(getSecurityDepositForRequester());
+    }
+
+    public Coin getDefaultSecDepositOfAcceptingTrader(Trade trade) {
+        Offer offer = checkNotNull(trade.getOffer());
+        return trade instanceof BuyerTrade ?
+                offer.getBuyerSecurityDeposit() :
+                offer.getSellerSecurityDeposit();
+    }
+
+    public Coin getLostSecDepositOfRequestingTrader(Trade trade) {
+        Offer offer = checkNotNull(trade.getOffer());
+        return getTotalSecDepositForAcceptingTrader(offer).subtract(getDefaultSecDepositOfAcceptingTrader(trade));
+    }
+
+    public void acceptCancelTradeRequest(Trade trade,
+                                         ResultHandler resultHandler,
+                                         ErrorMessageHandler errorMessageHandler) {
+        ProcessModel processModel = trade.getProcessModel();
+        Offer offer = checkNotNull(trade.getOffer());
+        Coin secDepositOfRequester = getSecurityDepositForRequester();
+        Coin totalSecDeposit = offer.getSellerSecurityDeposit().add(offer.getBuyerSecurityDeposit());
+        Coin secDepositOfAcceptingTrader = totalSecDeposit.subtract(secDepositOfRequester);
+        Coin tradeAmount = checkNotNull(trade.getTradeAmount(), "tradeAmount must not be null");
+        if (trade instanceof BuyerTrade) {
+            processModel.setBuyerPayoutAmountFromCanceledTrade(secDepositOfAcceptingTrader.value);
+            processModel.setSellerPayoutAmountFromCanceledTrade(tradeAmount.add(secDepositOfRequester).value);
+        } else {
+            processModel.setBuyerPayoutAmountFromCanceledTrade(secDepositOfRequester.value);
+            processModel.setSellerPayoutAmountFromCanceledTrade(tradeAmount.add(secDepositOfAcceptingTrader).value);
+        }
+        trade.getTradeProtocol().onAcceptCancelTradeRequest(resultHandler, errorMessageHandler);
+    }
+
+    public void rejectCancelTradeRequest(Trade trade,
+                                         ResultHandler resultHandler,
+                                         ErrorMessageHandler errorMessageHandler) {
+        trade.getTradeProtocol().onRejectCancelTradeRequest(resultHandler, errorMessageHandler);
+    }
+}

core/src/main/java/bisq/core/trade/TradeManager.java

@@ -673,6 +673,16 @@ private void removeTrade(Trade trade) {
     }
 
 
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // Canceled trade
+    ///////////////////////////////////////////////////////////////////////////////////////////
+
+    public void closeCanceledTrade(Trade trade) {
+        addTradeToClosedTrades(trade);
+        btcWalletService.swapTradeEntryToAvailableEntry(trade.getId(), AddressEntry.Context.TRADE_PAYOUT);
+    }
+
+
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Dispute
     ///////////////////////////////////////////////////////////////////////////////////////////