Build out 'createoffer' API method

apitest/src/test/java/bisq/apitest/method/MethodTest.java

@@ -22,6 +22,7 @@
 import bisq.proto.grpc.GetFundingAddressesRequest;
 import bisq.proto.grpc.GetPaymentAccountsRequest;
 import bisq.proto.grpc.LockWalletRequest;
+import bisq.proto.grpc.MarketPriceRequest;
 import bisq.proto.grpc.RegisterDisputeAgentRequest;
 import bisq.proto.grpc.RemoveWalletPasswordRequest;
 import bisq.proto.grpc.SetWalletPasswordRequest;
@@ -75,6 +76,10 @@ protected final GetFundingAddressesRequest createGetFundingAddressesRequest() {
         return GetFundingAddressesRequest.newBuilder().build();
     }
 
+    protected final MarketPriceRequest createMarketPriceRequest(String currencyCode) {
+        return MarketPriceRequest.newBuilder().setCurrencyCode(currencyCode).build();
+    }
+
     // Convenience methods for calling frequently used & thoroughly tested gRPC services.
 
     protected final long getBalance(BisqAppConfig bisqAppConfig) {
@@ -115,9 +120,9 @@ protected final CreatePaymentAccountRequest createCreatePerfectMoneyPaymentAccou
     }
 
     protected final PaymentAccount getDefaultPerfectDummyPaymentAccount(BisqAppConfig bisqAppConfig) {
-        var getPaymentAccountsRequest = GetPaymentAccountsRequest.newBuilder().build();
+        var req = GetPaymentAccountsRequest.newBuilder().build();
         var paymentAccountsService = grpcStubs(bisqAppConfig).paymentAccountsService;
-        PaymentAccount paymentAccount = paymentAccountsService.getPaymentAccounts(getPaymentAccountsRequest)
+        PaymentAccount paymentAccount = paymentAccountsService.getPaymentAccounts(req)
                 .getPaymentAccountsList()
                 .stream()
                 .sorted(comparing(PaymentAccount::getCreationDate))
@@ -126,6 +131,11 @@ protected final PaymentAccount getDefaultPerfectDummyPaymentAccount(BisqAppConfi
         return paymentAccount;
     }
 
+    protected final double getMarketPrice(BisqAppConfig bisqAppConfig, String currencyCode) {
+        var req = createMarketPriceRequest(currencyCode);
+        return grpcStubs(bisqAppConfig).priceService.getMarketPrice(req).getPrice();
+    }
+
     // Static conveniences for test methods and test case fixture setups.
 
     protected static RegisterDisputeAgentRequest createRegisterDisputeAgentRequest(String disputeAgentType) {

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

@@ -45,7 +45,7 @@
 @Slf4j
 abstract class AbstractCreateOfferTest extends MethodTest {
 
-    protected static GrpcStubs alice;
+    protected static GrpcStubs aliceStubs;
 
     @BeforeAll
     public static void setUp() {
@@ -56,7 +56,7 @@ static void startSupportingApps() {
         try {
             // setUpScaffold(new String[]{"--supportingApps", "bitcoind,seednode,alicedaemon", "--enableBisqDebugging", "true"});
             setUpScaffold(bitcoind, seednode, alicedaemon);
-            alice = grpcStubs(alicedaemon);
+            aliceStubs = grpcStubs(alicedaemon);
 
             // Generate 1 regtest block for alice's wallet to show 10 BTC balance,
             // and give alicedaemon time to parse the new block.
@@ -79,7 +79,7 @@ protected final List<OfferInfo> getOffersSortedByDate(String direction, String c
         var req = GetOffersRequest.newBuilder()
                 .setDirection(direction)
                 .setCurrencyCode(currencyCode).build();
-        var reply = alice.offersService.getOffers(req);
+        var reply = aliceStubs.offersService.getOffers(req);
         return sortOffersByDate(reply.getOffersList());
     }
 
@@ -89,6 +89,10 @@ protected final List<OfferInfo> sortOffersByDate(List<OfferInfo> offerInfoList)
                 .collect(Collectors.toList());
     }
 
+    protected final double getPrice(String currencyCode) {
+        return getMarketPrice(alicedaemon, currencyCode);
+    }
+
     @AfterAll
     public static void tearDown() {
         tearDownScaffold();

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

@@ -53,7 +53,7 @@ public void testCreateUSDBTCBuyOfferUsingFixedPrice10000() {
                 .setPrice("10000")
                 .setBuyerSecurityDeposit(Restrictions.getDefaultBuyerSecurityDepositAsPercent())
                 .build();
-        var newOffer = alice.offersService.createOffer(req).getOffer();
+        var newOffer = aliceStubs.offersService.createOffer(req).getOffer();
         String newOfferId = newOffer.getId();
         assertNotEquals("", newOfferId);
         assertEquals("BUY", newOffer.getDirection());
@@ -94,7 +94,7 @@ public void testCreateUSDBTCBuyOfferUsingFixedPrice100001234() {
                 .setPrice("10000.1234")
                 .setBuyerSecurityDeposit(Restrictions.getDefaultBuyerSecurityDepositAsPercent())
                 .build();
-        var newOffer = alice.offersService.createOffer(req).getOffer();
+        var newOffer = aliceStubs.offersService.createOffer(req).getOffer();
         String newOfferId = newOffer.getId();
         assertNotEquals("", newOfferId);
         assertEquals("BUY", newOffer.getDirection());

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

@@ -18,10 +18,16 @@
 package bisq.apitest.method.offer;
 
 import bisq.core.btc.wallet.Restrictions;
+import bisq.core.monetary.Altcoin;
 
 import bisq.proto.grpc.CreateOfferRequest;
 import bisq.proto.grpc.OfferInfo;
 
+import org.bitcoinj.utils.Fiat;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
 import lombok.extern.slf4j.Slf4j;
 
 import org.junit.jupiter.api.MethodOrderer;
@@ -30,9 +36,15 @@
 import org.junit.jupiter.api.TestMethodOrder;
 
 import static bisq.apitest.config.BisqAppConfig.alicedaemon;
+import static bisq.common.util.MathUtils.roundDouble;
+import static bisq.common.util.MathUtils.scaleDownByPowerOf10;
+import static bisq.common.util.MathUtils.scaleUpByPowerOf10;
+import static bisq.core.locale.CurrencyUtil.isCryptoCurrency;
+import static java.lang.String.format;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static protobuf.OfferPayload.Direction.BUY;
 
 @Slf4j
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
@@ -42,19 +54,19 @@ public class CreateOfferUsingMarketPriceMarginTest extends AbstractCreateOfferTe
     @Order(1)
     public void testCreateUSDBTCBuyOffer5PctPriceMargin() {
         var paymentAccount = getDefaultPerfectDummyPaymentAccount(alicedaemon);
+        double priceMarginPctInput = 5.00;
         var req = CreateOfferRequest.newBuilder()
                 .setPaymentAccountId(paymentAccount.getId())
                 .setDirection("buy")
                 .setCurrencyCode("usd")
                 .setAmount(10000000)
                 .setMinAmount(10000000)
                 .setUseMarketBasedPrice(true)
-                .setMarketPriceMargin(5.00)
+                .setMarketPriceMargin(priceMarginPctInput)
                 .setPrice("0")
                 .setBuyerSecurityDeposit(Restrictions.getDefaultBuyerSecurityDepositAsPercent())
                 .build();
-        var newOffer = alice.offersService.createOffer(req).getOffer();
-        log.info(newOffer.toString());
+        var newOffer = aliceStubs.offersService.createOffer(req).getOffer();
 
         String newOfferId = newOffer.getId();
         assertNotEquals("", newOfferId);
@@ -77,25 +89,27 @@ public void testCreateUSDBTCBuyOffer5PctPriceMargin() {
         assertEquals("", offer.getPaymentAccountId());
         assertEquals("BTC", offer.getBaseCurrencyCode());
         assertEquals("USD", offer.getCounterCurrencyCode());
+
+        assertMarketBasedPriceDiff(offer, priceMarginPctInput);
     }
 
     @Test
     @Order(2)
     public void testCreateNZDBTCBuyOfferMinus2PctPriceMargin() {
         var paymentAccount = getDefaultPerfectDummyPaymentAccount(alicedaemon);
+        double priceMarginPctInput = -2.00;
         var req = CreateOfferRequest.newBuilder()
                 .setPaymentAccountId(paymentAccount.getId())
                 .setDirection("buy")
                 .setCurrencyCode("nzd")
                 .setAmount(10000000)
                 .setMinAmount(10000000)
                 .setUseMarketBasedPrice(true)
-                .setMarketPriceMargin(-2.00)
+                .setMarketPriceMargin(priceMarginPctInput)
                 .setPrice("0")
                 .setBuyerSecurityDeposit(Restrictions.getDefaultBuyerSecurityDepositAsPercent())
                 .build();
-        var newOffer = alice.offersService.createOffer(req).getOffer();
-        log.info(newOffer.toString());
+        var newOffer = aliceStubs.offersService.createOffer(req).getOffer();
 
         String newOfferId = newOffer.getId();
         assertNotEquals("", newOfferId);
@@ -118,5 +132,134 @@ public void testCreateNZDBTCBuyOfferMinus2PctPriceMargin() {
         assertEquals("", offer.getPaymentAccountId());
         assertEquals("BTC", offer.getBaseCurrencyCode());
         assertEquals("NZD", offer.getCounterCurrencyCode());
+
+        assertMarketBasedPriceDiff(offer, priceMarginPctInput);
+    }
+
+    @Test
+    @Order(3)
+    public void testCreateGBPBTCSellOfferMinus1Point5PctPriceMargin() {
+        var paymentAccount = getDefaultPerfectDummyPaymentAccount(alicedaemon);
+        double priceMarginPctInput = -1.5;
+        var req = CreateOfferRequest.newBuilder()
+                .setPaymentAccountId(paymentAccount.getId())
+                .setDirection("sell")
+                .setCurrencyCode("gbp")
+                .setAmount(10000000)
+                .setMinAmount(10000000)
+                .setUseMarketBasedPrice(true)
+                .setMarketPriceMargin(priceMarginPctInput)
+                .setPrice("0")
+                .setBuyerSecurityDeposit(Restrictions.getDefaultBuyerSecurityDepositAsPercent())
+                .build();
+        var newOffer = aliceStubs.offersService.createOffer(req).getOffer();
+        log.info(newOffer.toString());
+
+        String newOfferId = newOffer.getId();
+        assertNotEquals("", newOfferId);
+        assertEquals("SELL", newOffer.getDirection());
+        assertTrue(newOffer.getUseMarketBasedPrice());
+        assertEquals(10000000, newOffer.getAmount());
+        assertEquals(10000000, newOffer.getMinAmount());
+        assertEquals(1500000, newOffer.getBuyerSecurityDeposit());
+        assertEquals(paymentAccount.getId(), newOffer.getPaymentAccountId());
+        assertEquals("BTC", newOffer.getBaseCurrencyCode());
+        assertEquals("GBP", newOffer.getCounterCurrencyCode());
+
+        OfferInfo offer = getMostRecentOffer("sell", "gbp");
+        assertEquals(newOfferId, offer.getId());
+        assertEquals("SELL", offer.getDirection());
+        assertTrue(offer.getUseMarketBasedPrice());
+        assertEquals(10000000, offer.getAmount());
+        assertEquals(10000000, offer.getMinAmount());
+        assertEquals(1500000, offer.getBuyerSecurityDeposit());
+        assertEquals("", offer.getPaymentAccountId());
+        assertEquals("BTC", offer.getBaseCurrencyCode());
+        assertEquals("GBP", offer.getCounterCurrencyCode());
+
+        assertMarketBasedPriceDiff(offer, priceMarginPctInput);
+    }
+
+    @Test
+    @Order(4)
+    public void testCreateBRLBTCSellOffer6Point55PctPriceMargin() {
+        var paymentAccount = getDefaultPerfectDummyPaymentAccount(alicedaemon);
+        double priceMarginPctInput = 6.55;
+        var req = CreateOfferRequest.newBuilder()
+                .setPaymentAccountId(paymentAccount.getId())
+                .setDirection("sell")
+                .setCurrencyCode("brl")
+                .setAmount(10000000)
+                .setMinAmount(10000000)
+                .setUseMarketBasedPrice(true)
+                .setMarketPriceMargin(priceMarginPctInput)
+                .setPrice("0")
+                .setBuyerSecurityDeposit(Restrictions.getDefaultBuyerSecurityDepositAsPercent())
+                .build();
+        var newOffer = aliceStubs.offersService.createOffer(req).getOffer();
+        log.info(newOffer.toString());
+
+        String newOfferId = newOffer.getId();
+        assertNotEquals("", newOfferId);
+        assertEquals("SELL", newOffer.getDirection());
+        assertTrue(newOffer.getUseMarketBasedPrice());
+        assertEquals(10000000, newOffer.getAmount());
+        assertEquals(10000000, newOffer.getMinAmount());
+        assertEquals(1500000, newOffer.getBuyerSecurityDeposit());
+        assertEquals(paymentAccount.getId(), newOffer.getPaymentAccountId());
+        assertEquals("BTC", newOffer.getBaseCurrencyCode());
+        assertEquals("BRL", newOffer.getCounterCurrencyCode());
+
+        OfferInfo offer = getMostRecentOffer("sell", "brl");
+        assertEquals(newOfferId, offer.getId());
+        assertEquals("SELL", offer.getDirection());
+        assertTrue(offer.getUseMarketBasedPrice());
+        assertEquals(10000000, offer.getAmount());
+        assertEquals(10000000, offer.getMinAmount());
+        assertEquals(1500000, offer.getBuyerSecurityDeposit());
+        assertEquals("", offer.getPaymentAccountId());
+        assertEquals("BTC", offer.getBaseCurrencyCode());
+        assertEquals("BRL", offer.getCounterCurrencyCode());
+
+        assertMarketBasedPriceDiff(offer, priceMarginPctInput);
+    }
+
+    private void assertMarketBasedPriceDiff(OfferInfo offer, double priceMarginPctInput) {
+        // Assert the mkt price margin difference ( %) is < 1% from the expected difference.
+        String counterCurrencyCode = offer.getCounterCurrencyCode();
+        double lastPrice = getPrice(counterCurrencyCode);
+        int precision = isCryptoCurrency(counterCurrencyCode) ? Altcoin.SMALLEST_UNIT_EXPONENT : Fiat.SMALLEST_UNIT_EXPONENT;
+        double scaledOfferPrice = scaleDownByPowerOf10(offer.getPrice(), precision);
+        assertTrue(() -> {
+            double expectedPriceMarginPct = scaleDownByPowerOf10(priceMarginPctInput, 2);
+            double actualPriceMarginPct = offer.getDirection().equals(BUY.name())
+                    ? getPercentageDifference(scaledOfferPrice, lastPrice)
+                    : getPercentageDifference(lastPrice, scaledOfferPrice);
+            double diff = expectedPriceMarginPct - actualPriceMarginPct;
+            if (diff > 0.0001) {
+                String priceCalculationWarning = format("The calculated price was %.2f%s off"
+                                + " mkt price, not the expected %.2f%s off mkt price.%n"
+                                + "Offer %s",
+                        scaleUpByPowerOf10(actualPriceMarginPct, 2), "%",
+                        priceMarginPctInput, "%",
+                        offer);
+                double onePercent = 0.01;
+                if (diff > Math.abs(onePercent)) {
+                    log.error(priceCalculationWarning);
+                    return false;
+                } else {
+                    log.warn(priceCalculationWarning);
+                    return true;
+                }
+            } else {
+                return true;
+            }
+        });
+    }
+
+    private double getPercentageDifference(double price1, double price2) {
+        return new BigDecimal(roundDouble((1 - (price1 / price2)), 5))
+                .setScale(4, RoundingMode.HALF_UP)
+                .doubleValue();
     }
 }

cli/src/main/java/bisq/cli/GrpcStubs.java

@@ -21,6 +21,7 @@
 import bisq.proto.grpc.GetVersionGrpc;
 import bisq.proto.grpc.OffersGrpc;
 import bisq.proto.grpc.PaymentAccountsGrpc;
+import bisq.proto.grpc.PriceGrpc;
 import bisq.proto.grpc.WalletsGrpc;
 
 import io.grpc.CallCredentials;
@@ -34,6 +35,7 @@ public class GrpcStubs {
     public final GetVersionGrpc.GetVersionBlockingStub versionService;
     public final OffersGrpc.OffersBlockingStub offersService;
     public final PaymentAccountsGrpc.PaymentAccountsBlockingStub paymentAccountsService;
+    public final PriceGrpc.PriceBlockingStub priceService;
     public final WalletsGrpc.WalletsBlockingStub walletsService;
 
     public GrpcStubs(String apiHost, int apiPort, String apiPassword) {
@@ -52,6 +54,7 @@ public GrpcStubs(String apiHost, int apiPort, String apiPassword) {
         this.versionService = GetVersionGrpc.newBlockingStub(channel).withCallCredentials(credentials);
         this.offersService = OffersGrpc.newBlockingStub(channel).withCallCredentials(credentials);
         this.paymentAccountsService = PaymentAccountsGrpc.newBlockingStub(channel).withCallCredentials(credentials);
+        this.priceService = PriceGrpc.newBlockingStub(channel).withCallCredentials(credentials);
         this.walletsService = WalletsGrpc.newBlockingStub(channel).withCallCredentials(credentials);
     }
 }

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

@@ -22,6 +22,7 @@
 import bisq.core.offer.Offer;
 import bisq.core.offer.OfferPayload;
 import bisq.core.payment.PaymentAccount;
+import bisq.core.provider.price.MarketPrice;
 import bisq.core.trade.handlers.TransactionResultHandler;
 import bisq.core.trade.statistics.TradeStatistics2;
 import bisq.core.trade.statistics.TradeStatisticsManager;
@@ -50,17 +51,20 @@ public class CoreApi {
     private final CoreDisputeAgentsService coreDisputeAgentsService;
     private final CoreOffersService coreOffersService;
     private final CorePaymentAccountsService paymentAccountsService;
+    private final CorePriceService corePriceService;
     private final CoreWalletsService walletsService;
     private final TradeStatisticsManager tradeStatisticsManager;
 
     @Inject
     public CoreApi(CoreDisputeAgentsService coreDisputeAgentsService,
                    CoreOffersService coreOffersService,
                    CorePaymentAccountsService paymentAccountsService,
+                   CorePriceService corePriceService,
                    CoreWalletsService walletsService,
                    TradeStatisticsManager tradeStatisticsManager) {
         this.coreDisputeAgentsService = coreDisputeAgentsService;
         this.coreOffersService = coreOffersService;
+        this.corePriceService = corePriceService;
         this.paymentAccountsService = paymentAccountsService;
         this.walletsService = walletsService;
         this.tradeStatisticsManager = tradeStatisticsManager;
@@ -153,6 +157,14 @@ public Set<PaymentAccount> getPaymentAccounts() {
         return paymentAccountsService.getPaymentAccounts();
     }
 
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // Prices
+    ///////////////////////////////////////////////////////////////////////////////////////////
+
+    public double getMarketPrice(String currencyCode) {
+        return corePriceService.getMarketPrice(currencyCode);
+    }
+
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Wallets
     ///////////////////////////////////////////////////////////////////////////////////////////