feat(LIVE-29447): sort wallet quotes by net countervalue

Author: philipptpunkt

.changeset/bright-falcons-stack.md

@@ -0,0 +1,6 @@
+---
+"@ledgerhq/wallet-api-exchange-module": minor
+"@ledgerhq/live-common": minor
+---
+
+sort wallet-api swap quotes by net countervalue

libs/exchange-module/src/types.ts

@@ -114,6 +114,7 @@ export type SwapLiveError = {
 
 export type UniswapOrderType = "classic" | "uniswapxv2" | "all";
 export type QuotesAppPlatform = "lld" | "llm-ios" | "llm-android" | "unknown";
+export type QuoteSortBy = "netCounterValue";
 
 export type QuotesInput = {
   amount: string;
@@ -131,6 +132,7 @@ export type QuotesInput = {
 export type GetQuotesArgs = {
   providers: string[];
   data: QuotesInput;
+  sortBy?: QuoteSortBy;
   headers?: Array<[string, string]>;
   signal?: AbortSignal;
 };

libs/ledger-live-common/src/wallet-api/Exchange/quotes/getQuotes.test.ts

@@ -288,6 +288,61 @@ describe("getQuotes", () => {
     expect(fetchQuotesMock).toHaveBeenCalledTimes(1);
   });
 
+  it("returns plain Quote objects sorted by netCounterValue", async () => {
+    const feeContext = {
+      maxFeePerGas: undefined,
+      gasPrice: undefined,
+      defaultGasLimit: "21000",
+      estimatedFeesAtomic: new BigNumber(0),
+      balanceAtomic: new BigNumber("5000000000000000000"),
+      feeCurrencyId: "ethereum",
+      feeCurrencyMagnitude: 18,
+      mainAccountCurrencyId: "ethereum",
+    };
+    fetchNetworkFeeContextMock.mockResolvedValue(feeContext);
+    computeFeeEstimateMock.mockImplementation(raw => {
+      if (raw.key === "higher-receive-with-fees") {
+        return {
+          estimatedNetworkFee: { amount: "100000000000000000", currencyId: "ethereum" },
+          approvalNetworkFee: { amount: "100000000000000000", currencyId: "ethereum" },
+          notEnoughBalance: false,
+        };
+      }
+      return {
+        estimatedNetworkFee: undefined,
+        approvalNetworkFee: undefined,
+        notEnoughBalance: false,
+      };
+    });
+    fetchQuotesMock.mockResolvedValue({
+      rawQuotes: [
+        makeRawQuote({
+          key: "higher-receive-with-fees",
+          amountTo: 1,
+          networkFees: { currency: "ethereum" },
+        }),
+        makeRawQuote({
+          key: "lower-receive-no-fees",
+          amountTo: 0.99,
+          networkFees: { currency: "ethereum" },
+        }),
+      ],
+      providerErrors: [],
+    });
+
+    const response = await getQuotes(makeArgs("ethereum", "bitcoin"), {
+      ...emptyContext,
+      spotPrices: { bitcoin: 30_000, ethereum: 2_000 },
+    });
+
+    expect(response.quotes.map(q => q.key)).toEqual([
+      "lower-receive-no-fees",
+      "higher-receive-with-fees",
+    ]);
+    expect(response.quotes[0]).not.toHaveProperty("netCounterValue");
+    expect(response.quotes[0]).not.toHaveProperty("quote");
+  });
+
   describe("digested global errors (computeQuotesErrors integration)", () => {
     it("emits `amountTooLow` alongside `noQuotes` when every provider rejected on a min bound that brackets the input", async () => {
       // amount = "1", min bounds reported = "10" and "12" -> lowest is "10".

libs/ledger-live-common/src/wallet-api/Exchange/quotes/getQuotes.ts

@@ -12,6 +12,7 @@ import { fetchQuotes } from "./service/fetchQuotes";
 import { computeFeeEstimate } from "./normalizer/networkFeeEstimate";
 import { buildFormatContext } from "./normalizer/buildFormatContext";
 import { normalizeQuote } from "./normalizer";
+import { sortQuotes } from "./sorting/sortQuotes";
 import {
   QuotesErrorCodes,
   type GetQuotesArgs,
@@ -190,13 +191,19 @@ export async function getQuotes(
     const feeEstimate = feeContext ? computeFeeEstimate(raw, feeContext) : undefined;
     return normalizeQuote(raw, providerData, normalizationContext, feeEstimate, formatContext);
   });
+  const sortedQuotes = sortQuotes(quotes, {
+    sortBy: args.sortBy,
+    receiveCurrencyId: quotesInput.receiveCurrencyId,
+    spotPrices: context.spotPrices,
+    feeCurrencyMagnitude: feeContext?.feeCurrencyMagnitude,
+  });
 
   return {
-    quotes,
+    quotes: sortedQuotes,
     providerErrors,
     warnings,
     errors: computeQuotesErrors({
-      successfulQuotesCount: quotes.length,
+      successfulQuotesCount: sortedQuotes.length,
       providerErrors,
       amountFrom: args.data.amount,
     }),

libs/ledger-live-common/src/wallet-api/Exchange/quotes/sorting/buildNetCounterValue.ts

@@ -0,0 +1,43 @@
+import BigNumber from "bignumber.js";
+
+import type { Quote, QuoteEstimatedNetworkFee } from "../types";
+
+export type NetCounterValueContext = {
+  receiveCurrencyId: string;
+  spotPrices: Record<string, number>;
+  feeCurrencyMagnitude?: number;
+};
+
+function feeAmountAsDisplayValue(
+  fee: QuoteEstimatedNetworkFee | undefined,
+  feeCurrencyMagnitude: number | undefined,
+): BigNumber {
+  if (!fee || feeCurrencyMagnitude === undefined) {
+    return new BigNumber(0);
+  }
+  return new BigNumber(fee.amount).shiftedBy(-feeCurrencyMagnitude);
+}
+
+export function buildNetCounterValue(quote: Quote, context: NetCounterValueContext): BigNumber {
+  const receiveSpotPrice = context.spotPrices[context.receiveCurrencyId] || 1;
+  const receiveCounterValue = new BigNumber(quote.quoteDetails.receiveAmount).times(
+    receiveSpotPrice,
+  );
+
+  const estimatedFee = feeAmountAsDisplayValue(
+    quote.quoteDetails.estimatedNetworkFee,
+    context.feeCurrencyMagnitude,
+  );
+  const approvalFee = feeAmountAsDisplayValue(
+    quote.quoteDetails.approvalNetworkFee,
+    context.feeCurrencyMagnitude,
+  );
+  const feeCurrencyId =
+    quote.quoteDetails.estimatedNetworkFee?.currencyId ??
+    quote.quoteDetails.approvalNetworkFee?.currencyId ??
+    quote.quoteDetails.networkFees.currencyId;
+  const feeSpotPrice = context.spotPrices[feeCurrencyId] || 0;
+  const networkFeeCounterValue = estimatedFee.plus(approvalFee).times(feeSpotPrice);
+
+  return receiveCounterValue.minus(networkFeeCounterValue);
+}

libs/ledger-live-common/src/wallet-api/Exchange/quotes/sorting/sortQuotes.test.ts

@@ -0,0 +1,100 @@
+import type { Quote } from "../types";
+import { sortQuotes } from "./sortQuotes";
+
+function makeQuote(key: string, overrides: Partial<Quote["quoteDetails"]> = {}): Quote {
+  return {
+    key,
+    provider: "lifi",
+    providerDetails: {
+      name: "LiFi",
+      type: "DEX",
+      isUniswapX: false,
+      requiresKYC: false,
+      continuesInProviderLiveApp: false,
+    },
+    quoteDetails: {
+      type: "float",
+      sendAmount: 1,
+      receiveAmount: 1,
+      gasLess: false,
+      networkFees: { currencyId: "ethereum" },
+      slippage: 1,
+      exchangeRate: 1,
+      ...overrides,
+    },
+    warnings: [],
+    errors: [],
+  };
+}
+
+describe("sortQuotes", () => {
+  it("orders quotes by net countervalue descending", () => {
+    const quotes = [
+      makeQuote("low", { receiveAmount: 1 }),
+      makeQuote("high", { receiveAmount: 3 }),
+      makeQuote("middle", { receiveAmount: 2 }),
+    ];
+
+    const sorted = sortQuotes(quotes, {
+      receiveCurrencyId: "bitcoin",
+      spotPrices: { bitcoin: 30_000 },
+      feeCurrencyMagnitude: 18,
+    });
+
+    expect(sorted.map(q => q.key)).toEqual(["high", "middle", "low"]);
+  });
+
+  it("subtracts estimated and approval network fee countervalues", () => {
+    const higherReceiveWithFees = makeQuote("higher-receive-with-fees", {
+      receiveAmount: 1,
+      estimatedNetworkFee: { amount: "100000000000000000", currencyId: "ethereum" },
+      approvalNetworkFee: { amount: "100000000000000000", currencyId: "ethereum" },
+    });
+    const lowerReceiveNoFees = makeQuote("lower-receive-no-fees", {
+      receiveAmount: 0.99,
+    });
+
+    const sorted = sortQuotes([higherReceiveWithFees, lowerReceiveNoFees], {
+      receiveCurrencyId: "bitcoin",
+      spotPrices: { bitcoin: 30_000, ethereum: 2_000 },
+      feeCurrencyMagnitude: 18,
+    });
+
+    expect(sorted.map(q => q.key)).toEqual(["lower-receive-no-fees", "higher-receive-with-fees"]);
+  });
+
+  it("preserves input order for equal net countervalues", () => {
+    const quotes = [
+      makeQuote("first", { receiveAmount: 1 }),
+      makeQuote("second", { receiveAmount: 1 }),
+      makeQuote("third", { receiveAmount: 1 }),
+    ];
+
+    const sorted = sortQuotes(quotes, {
+      receiveCurrencyId: "bitcoin",
+      spotPrices: { bitcoin: 30_000 },
+      feeCurrencyMagnitude: 18,
+    });
+
+    expect(sorted.map(q => q.key)).toEqual(["first", "second", "third"]);
+  });
+
+  it("uses current live-app spot price fallbacks", () => {
+    const feePriced = makeQuote("fee-priced", {
+      receiveAmount: 10,
+      estimatedNetworkFee: { amount: "1000000000000000000", currencyId: "ethereum" },
+    });
+    const feeUnpriced = makeQuote("fee-unpriced", {
+      receiveAmount: 9,
+      estimatedNetworkFee: { amount: "1000000000000000000", currencyId: "ethereum" },
+    });
+
+    const sorted = sortQuotes([feePriced, feeUnpriced], {
+      receiveCurrencyId: "bitcoin",
+      spotPrices: {},
+      feeCurrencyMagnitude: 18,
+    });
+
+    expect(sorted.map(q => q.key)).toEqual(["fee-priced", "fee-unpriced"]);
+  });
+});

libs/ledger-live-common/src/wallet-api/Exchange/quotes/sorting/sortQuotes.ts

@@ -0,0 +1,32 @@
+import type BigNumber from "bignumber.js";
+
+import type { Quote, QuoteSortBy } from "../types";
+import { buildNetCounterValue, type NetCounterValueContext } from "./buildNetCounterValue";
+
+type RankedQuote = {
+  quote: Quote;
+  netCounterValue: BigNumber;
+};
+
+export type SortQuotesContext = NetCounterValueContext & {
+  sortBy?: QuoteSortBy;
+};
+
+function rankQuotes(quotes: Quote[], context: NetCounterValueContext): RankedQuote[] {
+  return quotes.map(quote => ({
+    quote,
+    netCounterValue: buildNetCounterValue(quote, context),
+  }));
+}
+
+export function sortQuotes(quotes: Quote[], context: SortQuotesContext): Quote[] {
+  const sortBy = context.sortBy ?? "netCounterValue";
+
+  if (sortBy !== "netCounterValue") {
+    return quotes;
+  }
+
+  return rankQuotes(quotes, context)
+    .sort((a, b) => b.netCounterValue.comparedTo(a.netCounterValue) || 0)
+    .map(({ quote }) => quote);
+}

libs/ledger-live-common/src/wallet-api/Exchange/quotes/types.ts

@@ -5,6 +5,7 @@
 export type {
   QuotesInput,
   QuotesAppPlatform,
+  QuoteSortBy,
   GetQuotesArgs,
   GetQuotesWireArgs,
   GetQuotesResponse,