API daemon 'getoffer' & 'gettrade' support for BSQ swaps #1

apitest/src/test/java/bisq/apitest/method/offer/AbstractOfferTest.java

@@ -17,7 +17,6 @@
 
 package bisq.apitest.method.offer;
 
-import bisq.proto.grpc.BsqSwapOfferInfo;
 import bisq.proto.grpc.OfferInfo;
 
 import protobuf.PaymentAccount;
@@ -112,11 +111,6 @@ public static void setUp() {
     protected final Function<List<OfferInfo>, String> toOffersTable = (offers) ->
             new TableBuilder(OFFER_TBL, offers).build().toString();
 
-    // TODO
-    protected final Function<BsqSwapOfferInfo, String> toBsqSwapOfferTable = (offer) ->
-            new TableBuilder(OFFER_TBL, offer).build().toString();
-
-
     public static void initSwapPaymentAccounts() {
         // A bot may not know what the default 'BSQ Swap' account name is,
         // but API test cases do:  the value of the i18n property 'BSQ_SWAP'.

apitest/src/test/java/bisq/apitest/method/offer/BsqSwapOfferTest.java

@@ -17,7 +17,7 @@
 
 package bisq.apitest.method.offer;
 
-import bisq.proto.grpc.BsqSwapOfferInfo;
+import bisq.proto.grpc.OfferInfo;
 
 import lombok.extern.slf4j.Slf4j;
 
@@ -121,21 +121,20 @@ private void createBsqSwapOffer() {
         assertEquals(5_000, bsqSwapOffer.getPrice());
         assertEquals(1_000_000L, bsqSwapOffer.getAmount());
         assertEquals(1_000_000L, bsqSwapOffer.getMinAmount());
-        // assertEquals(alicesBsqAcct.getId(), atomicOffer.getMakerPaymentAccountId());
         assertEquals(BSQ, bsqSwapOffer.getBaseCurrencyCode());
         assertEquals(BTC, bsqSwapOffer.getCounterCurrencyCode());
 
         testGetMyBsqSwapOffer(bsqSwapOffer);
         testGetBsqSwapOffer(bsqSwapOffer);
     }
 
-    private void testGetMyBsqSwapOffer(BsqSwapOfferInfo bsqSwapOfferInfo) {
+    private void testGetMyBsqSwapOffer(OfferInfo bsqSwapOffer) {
         int numFetchAttempts = 0;
         while (true) {
             try {
                 numFetchAttempts++;
-                var fetchedBsqSwapOffer = aliceClient.getMyBsqSwapOffer(bsqSwapOfferInfo.getId());
-                assertEquals(bsqSwapOfferInfo.getId(), fetchedBsqSwapOffer.getId());
+                var fetchedBsqSwapOffer = aliceClient.getMyOffer(bsqSwapOffer.getId());
+                assertEquals(bsqSwapOffer.getId(), fetchedBsqSwapOffer.getId());
                 log.debug("Alice found her (my) new bsq swap offer on attempt # {}.", numFetchAttempts);
                 break;
             } catch (Exception ex) {
@@ -149,13 +148,13 @@ private void testGetMyBsqSwapOffer(BsqSwapOfferInfo bsqSwapOfferInfo) {
         }
     }
 
-    private void testGetBsqSwapOffer(BsqSwapOfferInfo bsqSwapOfferInfo) {
+    private void testGetBsqSwapOffer(OfferInfo bsqSwapOffer) {
         int numFetchAttempts = 0;
         while (true) {
             try {
                 numFetchAttempts++;
-                var fetchedBsqSwapOffer = bobClient.getBsqSwapOffer(bsqSwapOfferInfo.getId());
-                assertEquals(bsqSwapOfferInfo.getId(), fetchedBsqSwapOffer.getId());
+                var fetchedBsqSwapOffer = bobClient.getOffer(bsqSwapOffer.getId());
+                assertEquals(bsqSwapOffer.getId(), fetchedBsqSwapOffer.getId());
                 log.debug("Bob found new available bsq swap offer on attempt # {}.", numFetchAttempts);
                 break;
             } catch (Exception ex) {

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

@@ -37,7 +37,9 @@ public class AbstractTradeTest extends AbstractOfferTest {
     protected static String tradeId;
 
     protected final Supplier<Integer> maxTradeStateAndPhaseChecks = () -> isLongRunningTest ? 10 : 2;
-    private final Function<GrpcClient, String> toUserName = (client) -> client.equals(aliceClient) ? "Alice" : "Bob";
+    protected final Function<TradeInfo, String> toTradeDetailTable = (trade) ->
+            new TableBuilder(TRADE_DETAIL_TBL, trade).build().toString();
+    protected final Function<GrpcClient, String> toUserName = (client) -> client.equals(aliceClient) ? "Alice" : "Bob";
 
     @BeforeAll
     public static void initStaticFixtures() {

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

@@ -17,8 +17,8 @@
 
 package bisq.apitest.method.trade;
 
-import bisq.proto.grpc.BsqSwapOfferInfo;
-import bisq.proto.grpc.BsqSwapTradeInfo;
+import bisq.proto.grpc.OfferInfo;
+import bisq.proto.grpc.TradeInfo;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -47,11 +47,12 @@
 
 
 import bisq.apitest.method.offer.AbstractOfferTest;
+import bisq.cli.GrpcClient;
 
 @Disabled
 @Slf4j
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
-public class BsqSwapTradeTest extends AbstractOfferTest {
+public class BsqSwapTradeTest extends AbstractTradeTest {
 
     private static final String BISQ_FEE_CURRENCY_CODE = BSQ;
 
@@ -81,54 +82,79 @@ public void testGetBalancesBeforeTrade() {
     @Test
     @Order(2)
     public void testAliceCreateBsqSwapBuyOffer() {
-        var bsqSwapOffer = aliceClient.createBsqSwapOffer(BUY.name(),
-                1_000_000L,
+        var mySwapOffer = aliceClient.createBsqSwapOffer(BUY.name(),
+                1_000_000L,     // 0.01 BTC
                 1_000_000L,
                 "0.00005",
                 alicesBsqSwapAcct.getId());
-        log.debug("BsqSwap Sell BSQ (Buy BTC) OFFER:\n{}", bsqSwapOffer);
-        var newOfferId = bsqSwapOffer.getId();
+        log.debug("Pending BsqSwap Sell BSQ (Buy BTC) OFFER:\n{}", toOfferTable.apply(mySwapOffer));
+        var newOfferId = mySwapOffer.getId();
         assertNotEquals("", newOfferId);
-        assertEquals(BUY.name(), bsqSwapOffer.getDirection());
-        assertEquals(5_000, bsqSwapOffer.getPrice());
-        assertEquals(1_000_000L, bsqSwapOffer.getAmount());
-        assertEquals(1_000_000L, bsqSwapOffer.getMinAmount());
-        // assertEquals(alicesBsqAcct.getId(), atomicOffer.getMakerPaymentAccountId());
-        assertEquals(BSQ, bsqSwapOffer.getBaseCurrencyCode());
-        assertEquals(BTC, bsqSwapOffer.getCounterCurrencyCode());
+        assertEquals(BUY.name(), mySwapOffer.getDirection());
+        assertEquals(5_000, mySwapOffer.getPrice());
+        assertEquals(1_000_000L, mySwapOffer.getAmount());
+        assertEquals(1_000_000L, mySwapOffer.getMinAmount());
+        assertEquals(BSQ, mySwapOffer.getBaseCurrencyCode());
+        assertEquals(BTC, mySwapOffer.getCounterCurrencyCode());
+
+        genBtcBlocksThenWait(1, 2_500);
+
+        mySwapOffer = aliceClient.getMyOffer(newOfferId);
+        log.debug("My fetched BsqSwap Sell BSQ (Buy BTC) OFFER:\n{}", toOfferTable.apply(mySwapOffer));
+        assertNotEquals(0, mySwapOffer.getMakerFee());
     }
 
     @Test
     @Order(3)
     public void testBobTakesBsqSwapOffer() {
-        var bsqSwapOffer = getAvailableBsqSwapOffer();
-        var bsqSwapTradeInfo = bobClient.takeBsqSwapOffer(bsqSwapOffer.getId(),
+        var availableSwapOffer = getAvailableBsqSwapOffer(bobClient);
+        var swapTrade = bobClient.takeBsqSwapOffer(availableSwapOffer.getId(),
                 bobsBsqSwapAcct.getId(),
                 BISQ_FEE_CURRENCY_CODE);
-        log.debug("Trade at t1: {}", bsqSwapTradeInfo);
-        assertEquals(PREPARATION.name(), bsqSwapTradeInfo.getState());
+        tradeId = swapTrade.getTradeId(); // Cache the tradeId for following test case(s).
+        log.debug("BsqSwap Trade at PREPARATION:\n{}", toTradeDetailTable.apply(swapTrade));
+        assertEquals(PREPARATION.name(), swapTrade.getState());
         genBtcBlocksThenWait(1, 3_000);
 
-        bsqSwapTradeInfo = getBsqSwapTrade(bsqSwapTradeInfo.getTradeId());
-        log.debug("Trade at t2: {}", bsqSwapTradeInfo);
-        assertEquals(COMPLETED.name(), bsqSwapTradeInfo.getState());
+        swapTrade = getBsqSwapTrade(bobClient, swapTrade.getTradeId());
+        log.debug("BsqSwap Trade at COMPLETION:\n{}", toTradeDetailTable.apply(swapTrade));
+        assertEquals(COMPLETED.name(), swapTrade.getState());
     }
 
     @Test
     @Order(4)
+    public void testCompletedSwapTxConfirmations() {
+        sleep(2_000); // Wait for TX confirmation to happen on node.
+
+        var alicesTrade = getBsqSwapTrade(aliceClient, tradeId);
+        log.debug("Alice's BsqSwap Trade at COMPLETION:\n{}", toTradeDetailTable.apply(alicesTrade));
+        assertEquals(1, alicesTrade.getBsqSwapTradeInfo().getNumConfirmations());
+
+        var bobsTrade = getBsqSwapTrade(bobClient, tradeId);
+        log.debug("Bob's BsqSwap Trade at COMPLETION:\n{}", toTradeDetailTable.apply(bobsTrade));
+        assertEquals(1, bobsTrade.getBsqSwapTradeInfo().getNumConfirmations());
+
+        genBtcBlocksThenWait(1, 2_000);
+
+        bobsTrade = getBsqSwapTrade(bobClient, tradeId);
+        log.debug("Bob's BsqSwap Trade at COMPLETION:\n{}", toTradeDetailTable.apply(bobsTrade));
+        assertEquals(2, bobsTrade.getBsqSwapTradeInfo().getNumConfirmations());
+    }
+
+    @Test
+    @Order(5)
     public void testGetBalancesAfterTrade() {
-        sleep(2_500); // Give wallet time to finish processing TX.
         var alicesBalances = aliceClient.getBalances();
         log.debug("Alice's After Trade Balance:\n{}", formatBalancesTbls(alicesBalances));
         var bobsBalances = bobClient.getBalances();
         log.debug("Bob's After Trade Balance:\n{}", formatBalancesTbls(bobsBalances));
     }
 
-    private BsqSwapOfferInfo getAvailableBsqSwapOffer() {
-        List<BsqSwapOfferInfo> bsqSwapOffers = new ArrayList<>();
+    private OfferInfo getAvailableBsqSwapOffer(GrpcClient client) {
+        List<OfferInfo> bsqSwapOffers = new ArrayList<>();
         int numFetchAttempts = 0;
         while (bsqSwapOffers.size() == 0) {
-            bsqSwapOffers.addAll(bobClient.getBsqSwapOffers(BUY.name(), BSQ));
+            bsqSwapOffers.addAll(client.getBsqSwapOffers(BUY.name()));
             numFetchAttempts++;
             if (bsqSwapOffers.size() == 0) {
                 log.warn("No available bsq swap offers found after {} fetch attempts.", numFetchAttempts);
@@ -150,12 +176,12 @@ private BsqSwapOfferInfo getAvailableBsqSwapOffer() {
         return bsqSwapOffer;
     }
 
-    private BsqSwapTradeInfo getBsqSwapTrade(String tradeId) {
+    private TradeInfo getBsqSwapTrade(GrpcClient client, String tradeId) {
         int numFetchAttempts = 0;
         while (true) {
             try {
                 numFetchAttempts++;
-                return bobClient.getBsqSwapTrade(tradeId);
+                return client.getBsqSwapTrade(tradeId);
             } catch (Exception ex) {
                 log.warn(ex.getMessage());
                 if (numFetchAttempts > 9) {

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

@@ -101,7 +101,9 @@ public void testTakeSellBSQOffer(final TestInfo testInfo) {
     @Order(6)
     public void testBsqSwapTradeTest(final TestInfo testInfo) {
         BsqSwapTradeTest test = new BsqSwapTradeTest();
+        test.testGetBalancesBeforeTrade();
         test.testAliceCreateBsqSwapBuyOffer();
         test.testBobTakesBsqSwapOffer();
+        test.testGetBalancesAfterTrade();
     }
 }

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

@@ -20,17 +20,14 @@
 import bisq.proto.grpc.AddressBalanceInfo;
 import bisq.proto.grpc.BalancesInfo;
 import bisq.proto.grpc.BsqBalanceInfo;
-import bisq.proto.grpc.BsqSwapOfferInfo;
-import bisq.proto.grpc.BsqSwapTradeInfo;
 import bisq.proto.grpc.BtcBalanceInfo;
-import bisq.proto.grpc.CreateBsqSwapOfferRequest;
 import bisq.proto.grpc.GetMethodHelpRequest;
+import bisq.proto.grpc.GetOfferCategoryReply;
 import bisq.proto.grpc.GetVersionRequest;
 import bisq.proto.grpc.OfferInfo;
 import bisq.proto.grpc.RegisterDisputeAgentRequest;
 import bisq.proto.grpc.StopRequest;
 import bisq.proto.grpc.TakeBsqSwapOfferReply;
-import bisq.proto.grpc.TakeBsqSwapOfferRequest;
 import bisq.proto.grpc.TakeOfferReply;
 import bisq.proto.grpc.TradeInfo;
 import bisq.proto.grpc.TxFeeRateInfo;
@@ -142,19 +139,20 @@ public TxInfo getTransaction(String txId) {
         return walletsServiceRequest.getTransaction(txId);
     }
 
-    public BsqSwapOfferInfo createBsqSwapOffer(String direction,
-                                               long amount,
-                                               long minAmount,
-                                               String fixedPrice,
-                                               String paymentAcctId) {
-        var request = CreateBsqSwapOfferRequest.newBuilder()
-                .setDirection(direction)
-                .setAmount(amount)
-                .setMinAmount(minAmount)
-                .setPrice(fixedPrice)
-                .setPaymentAccountId(paymentAcctId)
-                .build();
-        return grpcStubs.offersService.createBsqSwapOffer(request).getBsqSwapOffer();
+    public GetOfferCategoryReply.OfferCategory getAvailableOfferCategory(String offerId) {
+        return offersServiceRequest.getAvailableOfferCategory(offerId);
+    }
+
+    public OfferInfo createBsqSwapOffer(String direction,
+                                        long amount,
+                                        long minAmount,
+                                        String fixedPrice,
+                                        String paymentAcctId) {
+        return offersServiceRequest.createBsqSwapOffer(direction,
+                amount,
+                minAmount,
+                fixedPrice,
+                paymentAcctId);
     }
 
     public OfferInfo createFixedPricedOffer(String direction,
@@ -263,24 +261,24 @@ public void cancelOffer(String offerId) {
         offersServiceRequest.cancelOffer(offerId);
     }
 
-    public BsqSwapOfferInfo getBsqSwapOffer(String offerId) {
+    public OfferInfo getBsqSwapOffer(String offerId) {
         return offersServiceRequest.getBsqSwapOffer(offerId);
     }
 
     public OfferInfo getOffer(String offerId) {
         return offersServiceRequest.getOffer(offerId);
     }
 
-    public BsqSwapOfferInfo getMyBsqSwapOffer(String offerId) {
+    public OfferInfo getMyBsqSwapOffer(String offerId) {
         return offersServiceRequest.getMyBsqSwapOffer(offerId);
     }
 
     public OfferInfo getMyOffer(String offerId) {
         return offersServiceRequest.getMyOffer(offerId);
     }
 
-    public List<BsqSwapOfferInfo> getBsqSwapOffers(String direction, String currencyCode) {
-        return offersServiceRequest.getBsqSwapOffers(direction, currencyCode);
+    public List<OfferInfo> getBsqSwapOffers(String direction) {
+        return offersServiceRequest.getBsqSwapOffers(direction);
     }
 
     public List<OfferInfo> getOffers(String direction, String currencyCode) {
@@ -303,12 +301,12 @@ public List<OfferInfo> getBsqOffersSortedByDate() {
         return offersServiceRequest.getBsqOffersSortedByDate();
     }
 
-    public List<BsqSwapOfferInfo> getBsqSwapOffersSortedByDate() {
+    public List<OfferInfo> getBsqSwapOffersSortedByDate() {
         return offersServiceRequest.getBsqSwapOffersSortedByDate();
     }
 
-    public List<BsqSwapOfferInfo> getMyBsqSwapOffers(String direction, String currencyCode) {
-        return offersServiceRequest.getMyBsqSwapOffers(direction, currencyCode);
+    public List<OfferInfo> getMyBsqSwapOffers(String direction) {
+        return offersServiceRequest.getMyBsqSwapOffers(direction);
     }
 
     public List<OfferInfo> getMyOffers(String direction, String currencyCode) {
@@ -335,38 +333,35 @@ public List<OfferInfo> getMyBsqOffersSortedByDate() {
         return offersServiceRequest.getMyBsqOffersSortedByDate();
     }
 
-    public List<BsqSwapOfferInfo> getMyBsqSwapBsqOffersSortedByDate() {
+    public List<OfferInfo> getMyBsqSwapBsqOffersSortedByDate() {
         return offersServiceRequest.getMyBsqSwapOffersSortedByDate();
     }
 
     public OfferInfo getMostRecentOffer(String direction, String currencyCode) {
         return offersServiceRequest.getMostRecentOffer(direction, currencyCode);
     }
 
-    public List<BsqSwapOfferInfo> sortBsqSwapOffersByDate(List<BsqSwapOfferInfo> offerInfoList) {
-        return offersServiceRequest.sortBsqSwapOffersByDate(offerInfoList);
+    public List<OfferInfo> sortBsqSwapOffersByDate(List<OfferInfo> offers) {
+        return offersServiceRequest.sortOffersByDate(offers);
     }
 
-    public List<OfferInfo> sortOffersByDate(List<OfferInfo> offerInfoList) {
-        return offersServiceRequest.sortOffersByDate(offerInfoList);
+    public List<OfferInfo> sortOffersByDate(List<OfferInfo> offers) {
+        return offersServiceRequest.sortOffersByDate(offers);
     }
 
     public TakeBsqSwapOfferReply getTakeBsqSwapOfferReply(String offerId,
                                                           String paymentAccountId,
                                                           String takerFeeCurrencyCode) {
-        var request = TakeBsqSwapOfferRequest.newBuilder()
-                .setOfferId(offerId)
-                .setPaymentAccountId(paymentAccountId)
-                .setTakerFeeCurrencyCode(takerFeeCurrencyCode)
-                .build();
-        return grpcStubs.tradesService.takeBsqSwapOffer(request);
+        return tradesServiceRequest.getTakeBsqSwapOfferReply(offerId,
+                paymentAccountId,
+                takerFeeCurrencyCode);
     }
 
     public TakeOfferReply getTakeOfferReply(String offerId, String paymentAccountId, String takerFeeCurrencyCode) {
         return tradesServiceRequest.getTakeOfferReply(offerId, paymentAccountId, takerFeeCurrencyCode);
     }
 
-    public BsqSwapTradeInfo takeBsqSwapOffer(String offerId, String paymentAccountId, String takerFeeCurrencyCode) {
+    public TradeInfo takeBsqSwapOffer(String offerId, String paymentAccountId, String takerFeeCurrencyCode) {
         var reply = getTakeBsqSwapOfferReply(offerId, paymentAccountId, takerFeeCurrencyCode);
         if (reply.hasBsqSwapTrade())
             return reply.getBsqSwapTrade();
@@ -378,7 +373,7 @@ public TradeInfo takeOffer(String offerId, String paymentAccountId, String taker
         return tradesServiceRequest.takeOffer(offerId, paymentAccountId, takerFeeCurrencyCode);
     }
 
-    public BsqSwapTradeInfo getBsqSwapTrade(String tradeId) {
+    public TradeInfo getBsqSwapTrade(String tradeId) {
         return tradesServiceRequest.getBsqSwapTrade(tradeId);
     }