Merge pull request #5961 from ghubstan/2-api-fail-unfail-trade

Add API methods 'failtrade', 'unfailtrade' + test case (#2)

apitest/src/test/java/bisq/apitest/method/trade/AbstractTradeTest.java

@@ -8,6 +8,8 @@
 
 import org.slf4j.Logger;
 
+import lombok.Getter;
+
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.TestInfo;
 
@@ -36,6 +38,7 @@ public class AbstractTradeTest extends AbstractOfferTest {
     public static final ExpectedProtocolStatus EXPECTED_PROTOCOL_STATUS = new ExpectedProtocolStatus();
 
     // A Trade ID cache for use in @Test sequences.
+    @Getter
     protected static String tradeId;
 
     protected final Supplier<Integer> maxTradeStateAndPhaseChecks = () -> isLongRunningTest ? 10 : 2;

apitest/src/test/java/bisq/apitest/method/trade/FailUnfailTradeTest.java

@@ -0,0 +1,143 @@
+/*
+ * 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.apitest.method.trade;
+
+import io.grpc.StatusRuntimeException;
+
+import lombok.extern.slf4j.Slf4j;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInfo;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import static java.lang.String.format;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
+
+
+
+import bisq.apitest.method.offer.AbstractOfferTest;
+
+@Disabled
+@Slf4j
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class FailUnfailTradeTest extends AbstractTradeTest {
+
+    @BeforeAll
+    public static void setUp() {
+        AbstractOfferTest.setUp();
+    }
+
+    @BeforeEach
+    public void init() {
+        EXPECTED_PROTOCOL_STATUS.init();
+    }
+
+
+    @Test
+    @Order(1)
+    public void testFailAndUnFailBuyBTCTrade(final TestInfo testInfo) {
+        TakeBuyBTCOfferTest test = new TakeBuyBTCOfferTest();
+        test.testTakeAlicesBuyOffer(testInfo);
+
+        var tradeId = test.getTradeId();
+        aliceClient.failTrade(tradeId);
+
+        Throwable exception = assertThrows(StatusRuntimeException.class, () -> aliceClient.getTrade(tradeId));
+        String expectedExceptionMessage = format("INVALID_ARGUMENT: trade with id '%s' not found", tradeId);
+        assertEquals(expectedExceptionMessage, exception.getMessage());
+
+        try {
+            aliceClient.unFailTrade(tradeId);
+            aliceClient.getTrade(tradeId); //Throws ex if trade is still failed.
+        } catch (Exception ex) {
+            fail(ex);
+        }
+    }
+
+    @Test
+    @Order(2)
+    public void testFailAndUnFailSellBTCTrade(final TestInfo testInfo) {
+        TakeSellBTCOfferTest test = new TakeSellBTCOfferTest();
+        test.testTakeAlicesSellOffer(testInfo);
+
+        var tradeId = test.getTradeId();
+        aliceClient.failTrade(tradeId);
+
+        Throwable exception = assertThrows(StatusRuntimeException.class, () -> aliceClient.getTrade(tradeId));
+        String expectedExceptionMessage = format("INVALID_ARGUMENT: trade with id '%s' not found", tradeId);
+        assertEquals(expectedExceptionMessage, exception.getMessage());
+
+        try {
+            aliceClient.unFailTrade(tradeId);
+            aliceClient.getTrade(tradeId);  //Throws ex if trade is still failed.
+        } catch (Exception ex) {
+            fail(ex);
+        }
+    }
+
+    @Test
+    @Order(3)
+    public void testFailAndUnFailBuyXmrTrade(final TestInfo testInfo) {
+        TakeBuyXMROfferTest test = new TakeBuyXMROfferTest();
+        test.createXmrPaymentAccounts();
+        test.testTakeAlicesSellBTCForXMROffer(testInfo);
+
+        var tradeId = test.getTradeId();
+        aliceClient.failTrade(tradeId);
+
+        Throwable exception = assertThrows(StatusRuntimeException.class, () -> aliceClient.getTrade(tradeId));
+        String expectedExceptionMessage = format("INVALID_ARGUMENT: trade with id '%s' not found", tradeId);
+        assertEquals(expectedExceptionMessage, exception.getMessage());
+
+        try {
+            aliceClient.unFailTrade(tradeId);
+            aliceClient.getTrade(tradeId); //Throws ex if trade is still failed.
+        } catch (Exception ex) {
+            fail(ex);
+        }
+    }
+
+    @Test
+    @Order(4)
+    public void testFailAndUnFailTakeSellXMRTrade(final TestInfo testInfo) {
+        TakeSellXMROfferTest test = new TakeSellXMROfferTest();
+        test.createXmrPaymentAccounts();
+        test.testTakeAlicesBuyBTCForXMROffer(testInfo);
+
+        var tradeId = test.getTradeId();
+        aliceClient.failTrade(tradeId);
+
+        Throwable exception = assertThrows(StatusRuntimeException.class, () -> aliceClient.getTrade(tradeId));
+        String expectedExceptionMessage = format("INVALID_ARGUMENT: trade with id '%s' not found", tradeId);
+        assertEquals(expectedExceptionMessage, exception.getMessage());
+
+        try {
+            aliceClient.unFailTrade(tradeId);
+            aliceClient.getTrade(tradeId); //Throws ex if trade is still failed.
+        } catch (Exception ex) {
+            fail(ex);
+        }
+    }
+}

apitest/src/test/java/bisq/apitest/scenario/TradeTest.java

@@ -30,6 +30,7 @@
 
 import bisq.apitest.method.trade.AbstractTradeTest;
 import bisq.apitest.method.trade.BsqSwapTradeTest;
+import bisq.apitest.method.trade.FailUnfailTradeTest;
 import bisq.apitest.method.trade.TakeBuyBSQOfferTest;
 import bisq.apitest.method.trade.TakeBuyBTCOfferTest;
 import bisq.apitest.method.trade.TakeBuyBTCOfferWithNationalBankAcctTest;
@@ -130,4 +131,14 @@ public void testBsqSwapTradeTest(final TestInfo testInfo) {
         test.testBobTakesBsqSwapOffer();
         test.testGetBalancesAfterTrade();
     }
+
+    @Test
+    @Order(9)
+    public void testFailUnfailTrade(final TestInfo testInfo) {
+        FailUnfailTradeTest test = new FailUnfailTradeTest();
+        test.testFailAndUnFailBuyBTCTrade(testInfo);
+        test.testFailAndUnFailSellBTCTrade(testInfo);
+        test.testFailAndUnFailBuyXmrTrade(testInfo);
+        test.testFailAndUnFailTakeSellXMRTrade(testInfo);
+    }
 }

cli/src/main/java/bisq/cli/CliMain.java

@@ -559,6 +559,28 @@ public static void run(String[] args) {
                     paymentMethods.forEach(p -> out.println(p.getId()));
                     return;
                 }
+                case failtrade: {
+                    var opts = new GetTradeOptionParser(args).parse();
+                    if (opts.isForHelp()) {
+                        out.println(client.getMethodHelp(method));
+                        return;
+                    }
+                    var tradeId = opts.getTradeId();
+                    client.failTrade(tradeId);
+                    out.printf("open trade %s changed to failed trade%n", tradeId);
+                    return;
+                }
+                case unfailtrade: {
+                    var opts = new GetTradeOptionParser(args).parse();
+                    if (opts.isForHelp()) {
+                        out.println(client.getMethodHelp(method));
+                        return;
+                    }
+                    var tradeId = opts.getTradeId();
+                    client.unFailTrade(tradeId);
+                    out.printf("failed trade %s changed to open trade%n", tradeId);
+                    return;
+                }
                 case getpaymentacctform: {
                     var opts = new GetPaymentAcctFormOptionParser(args).parse();
                     if (opts.isForHelp()) {
@@ -870,6 +892,10 @@ private static void printHelp(OptionParser parser, @SuppressWarnings("SameParame
                     "Withdraw received trade funds to external wallet address");
             stream.format(rowFormat, "", "[--memo=<\"memo\">]", "");
             stream.println();
+            stream.format(rowFormat, failtrade.name(), "--trade-id=<trade-id>", "Change open trade to failed trade");
+            stream.println();
+            stream.format(rowFormat, unfailtrade.name(), "--trade-id=<trade-id>", "Change failed trade to open trade");
+            stream.println();
             stream.format(rowFormat, getpaymentmethods.name(), "", "Get list of supported payment account method ids");
             stream.println();
             stream.format(rowFormat, getpaymentacctform.name(), "--payment-method-id=<payment-method-id>", "Get a new payment account form");

cli/src/main/java/bisq/cli/GrpcClient.java

@@ -380,6 +380,14 @@ public void withdrawFunds(String tradeId, String address, String memo) {
         tradesServiceRequest.withdrawFunds(tradeId, address, memo);
     }
 
+    public void failTrade(String tradeId) {
+        tradesServiceRequest.failTrade(tradeId);
+    }
+
+    public void unFailTrade(String tradeId) {
+        tradesServiceRequest.unFailTrade(tradeId);
+    }
+
     public List<PaymentMethod> getPaymentMethods() {
         return paymentAccountsServiceRequest.getPaymentMethods();
     }

cli/src/main/java/bisq/cli/Method.java

@@ -42,6 +42,8 @@ public enum Method {
     getpaymentaccts,
     getpaymentmethods,
     gettrade,
+    failtrade,
+    unfailtrade,
     gettransaction,
     gettxfeerate,
     getunusedbsqaddress,

cli/src/main/java/bisq/cli/request/TradesServiceRequest.java

@@ -20,10 +20,12 @@
 import bisq.proto.grpc.CloseTradeRequest;
 import bisq.proto.grpc.ConfirmPaymentReceivedRequest;
 import bisq.proto.grpc.ConfirmPaymentStartedRequest;
+import bisq.proto.grpc.FailTradeRequest;
 import bisq.proto.grpc.GetTradeRequest;
 import bisq.proto.grpc.TakeOfferReply;
 import bisq.proto.grpc.TakeOfferRequest;
 import bisq.proto.grpc.TradeInfo;
+import bisq.proto.grpc.UnFailTradeRequest;
 import bisq.proto.grpc.WithdrawFundsRequest;
 
 
@@ -103,4 +105,20 @@ public void withdrawFunds(String tradeId, String address, String memo) {
         //noinspection ResultOfMethodCallIgnored
         grpcStubs.tradesService.withdrawFunds(request);
     }
+
+    public void failTrade(String tradeId) {
+        var request = FailTradeRequest.newBuilder()
+                .setTradeId(tradeId)
+                .build();
+        //noinspection ResultOfMethodCallIgnored
+        grpcStubs.tradesService.failTrade(request);
+    }
+
+    public void unFailTrade(String tradeId) {
+        var request = UnFailTradeRequest.newBuilder()
+                .setTradeId(tradeId)
+                .build();
+        //noinspection ResultOfMethodCallIgnored
+        grpcStubs.tradesService.unFailTrade(request);
+    }
 }

core/src/main/java/bisq/core/api/CoreApi.java

@@ -335,6 +335,14 @@ public String getBsqSwapTradeRole(BsqSwapTrade bsqSwapTrade) {
         return coreTradesService.getBsqSwapTradeRole(bsqSwapTrade);
     }
 
+    public void failTrade(String tradeId) {
+        coreTradesService.failTrade(tradeId);
+    }
+
+    public void unFailTrade(String tradeId) {
+        coreTradesService.unFailTrade(tradeId);
+    }
+
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Wallets
     ///////////////////////////////////////////////////////////////////////////////////////////

core/src/main/java/bisq/core/api/CoreTradesService.java

@@ -25,6 +25,7 @@
 import bisq.core.offer.bsq_swap.BsqSwapTakeOfferModel;
 import bisq.core.trade.ClosedTradableManager;
 import bisq.core.trade.TradeManager;
+import bisq.core.trade.bisq_v1.FailedTradesManager;
 import bisq.core.trade.bisq_v1.TradeResultHandler;
 import bisq.core.trade.bisq_v1.TradeUtil;
 import bisq.core.trade.model.Tradable;
@@ -63,6 +64,7 @@ class CoreTradesService {
     private final BtcWalletService btcWalletService;
     private final OfferUtil offerUtil;
     private final ClosedTradableManager closedTradableManager;
+    private final FailedTradesManager failedTradesManager;
     private final TakeOfferModel takeOfferModel;
     private final BsqSwapTakeOfferModel bsqSwapTakeOfferModel;
     private final TradeManager tradeManager;
@@ -75,6 +77,7 @@ public CoreTradesService(CoreContext coreContext,
                              BtcWalletService btcWalletService,
                              OfferUtil offerUtil,
                              ClosedTradableManager closedTradableManager,
+                             FailedTradesManager failedTradesManager,
                              TakeOfferModel takeOfferModel,
                              BsqSwapTakeOfferModel bsqSwapTakeOfferModel,
                              TradeManager tradeManager,
@@ -85,6 +88,7 @@ public CoreTradesService(CoreContext coreContext,
         this.btcWalletService = btcWalletService;
         this.offerUtil = offerUtil;
         this.closedTradableManager = closedTradableManager;
+        this.failedTradesManager = failedTradesManager;
         this.takeOfferModel = takeOfferModel;
         this.bsqSwapTakeOfferModel = bsqSwapTakeOfferModel;
         this.tradeManager = tradeManager;
@@ -269,6 +273,37 @@ Trade getTrade(String tradeId) {
                 ));
     }
 
+    void failTrade(String tradeId) {
+        // TODO Recommend that API users should use this method with extra care because
+        //  the API lacks methods for diagnosing trade problems, and does not support
+        //  interaction with mediators.  Users may accidentally fail valid trades,
+        //  although they can easily be un-failed with the 'unfailtrade' method.
+        //  The 'failtrade' and 'unfailtrade' methods are implemented at this early
+        //  stage of API development to help efficiently test a new
+        //      'gettrades --category=<open|closed|failed>'
+        //  method currently in development.
+        coreWalletsService.verifyWalletsAreAvailable();
+        coreWalletsService.verifyEncryptedWalletIsUnlocked();
+
+        var trade = getTrade(tradeId);
+        tradeManager.onMoveInvalidTradeToFailedTrades(trade);
+        log.info("Trade {} changed to failed trade.", tradeId);
+    }
+
+    void unFailTrade(String tradeId) {
+        coreWalletsService.verifyWalletsAreAvailable();
+        coreWalletsService.verifyEncryptedWalletIsUnlocked();
+
+        failedTradesManager.getTradeById(tradeId).ifPresentOrElse(failedTrade -> {
+            verifyCanUnfailTrade(failedTrade);
+            failedTradesManager.removeTrade(failedTrade);
+            tradeManager.addFailedTradeToPendingTrades(failedTrade);
+            log.info("Failed trade {} changed to open trade.", tradeId);
+        }, () -> {
+            throw new IllegalArgumentException(format("failed trade '%s' not found", tradeId));
+        });
+    }
+
     private Optional<Trade> getOpenTrade(String tradeId) {
         return tradeManager.getTradeById(tradeId);
     }
@@ -318,4 +353,30 @@ private void verifyFundsNotWithdrawn(AddressEntry fromAddressEntry) {
             throw new IllegalStateException(format("funds already withdrawn from address '%s'",
                     fromAddressEntry.getAddressString()));
     }
+
+    // Throws a RuntimeException if failed trade cannot be changed to OPEN for any reason.
+    private void verifyCanUnfailTrade(Trade failedTrade) {
+        if (tradeUtil.getTradeAddresses(failedTrade) == null)
+            throw new IllegalStateException(
+                    format("cannot change failed trade to open because no trade addresses found for '%s'",
+                            failedTrade.getId()));
+
+        if (!failedTradesManager.hasDepositTx(failedTrade))
+            throw new IllegalStateException(
+                    format("cannot change failed trade to open, no deposit tx found for '%s'",
+                            failedTrade.getId()));
+
+        if (!failedTradesManager.hasDelayedPayoutTxBytes(failedTrade))
+            throw new IllegalStateException(
+                    format("cannot change failed trade to open, no delayed payout tx found for '%s'",
+                            failedTrade.getId()));
+
+        failedTradesManager.getBlockingTradeIds(failedTrade).ifPresent(tradeIds -> {
+            throw new IllegalStateException(
+                    format("cannot change failed trade '%s' to open at this time,"
+                                    + "%ntry again after completing trade(s):%n\t%s",
+                            failedTrade.getId(),
+                            String.join(", ", tradeIds)));
+        });
+    }
 }