@ledgerhq/live-common 34.44.0-nightly.2 → 34.44.0-nightly.4

package/src/exchange/swap/postSwapState.ts

@@ -1,14 +1,60 @@
+import crypto from "crypto";
 import network from "@ledgerhq/live-network";
 import { mockPostSwapAccepted, mockPostSwapCancelled } from "./mock";
 import type { PostSwapAccepted, PostSwapCancelled } from "./types";
 import { isIntegrationTestEnv } from "./utils/isIntegrationTestEnv";
 import { getSwapAPIBaseURL, getSwapUserIP } from ".";
 
+function createSwapIntentHashes({
+  provider,
+  fromAccountId,
+  toAccountId,
+  amount,
+}: {
+  provider: string;
+  fromAccountId?: string;
+  toAccountId?: string;
+  amount?: string;
+}) {
+  // for example '2025-08-01' used to add a one day unique nonce to the swap intent hash
+  const currentday = new Date().toISOString().split("T")[0];
+
+  const swapIntentWithProvider = crypto
+    .createHash("sha256")
+    .update(
+      JSON.stringify({
+        provider,
+        fromAccountId,
+        toAccountId,
+        amount,
+        currentday,
+      }),
+    )
+    .digest("hex");
+
+  const swapIntentWithoutProvider = crypto
+    .createHash("sha256")
+    .update(
+      JSON.stringify({
+        fromAccountId,
+        toAccountId,
+        amount,
+        currentday,
+      }),
+    )
+    .digest("hex");
+
+  return { swapIntentWithProvider, swapIntentWithoutProvider };
+}
+
 export const postSwapAccepted: PostSwapAccepted = async ({
   provider,
   swapId = "",
   transactionId,
   swapAppVersion,
+  fromAccountId,
+  toAccountId,
+  amount,
   ...rest
 }) => {
   if (isIntegrationTestEnv())
@@ -21,6 +67,14 @@ export const postSwapAccepted: PostSwapAccepted = async ({
   if (!swapId) {
     return null;
   }
+
+  const { swapIntentWithProvider, swapIntentWithoutProvider } = createSwapIntentHashes({
+    provider,
+    fromAccountId,
+    toAccountId,
+    amount,
+  });
+
   try {
     const ipHeader = getSwapUserIP();
     const headers = {
@@ -31,7 +85,7 @@ export const postSwapAccepted: PostSwapAccepted = async ({
     await network({
       method: "POST",
       url: `${getSwapAPIBaseURL()}/swap/accepted`,
-      data: { provider, swapId, transactionId, ...rest },
+      data: { provider, swapId, swapIntentWithProvider, swapIntentWithoutProvider, ...rest },
       ...(Object.keys(headers).length > 0 ? { headers } : {}),
     });
   } catch (error) {
@@ -45,6 +99,13 @@ export const postSwapCancelled: PostSwapCancelled = async ({
   provider,
   swapId = "",
   swapAppVersion,
+  fromAccountId,
+  toAccountId,
+  amount,
+  seedIdFrom,
+  seedIdTo,
+  refundAddress,
+  payoutAddress,
   ...rest
 }) => {
   if (isIntegrationTestEnv()) return mockPostSwapCancelled({ provider, swapId, ...rest });
@@ -57,6 +118,22 @@ export const postSwapCancelled: PostSwapCancelled = async ({
     return null;
   }
 
+  const { swapIntentWithProvider, swapIntentWithoutProvider } = createSwapIntentHashes({
+    provider,
+    fromAccountId,
+    toAccountId,
+    amount,
+  });
+
+  // Check if the refundAddress and payoutAddress match the account addresses, just to eliminate this supposition
+  const payloadAddressMatchAccountAddress =
+    fromAccountId &&
+    toAccountId &&
+    refundAddress &&
+    payoutAddress &&
+    fromAccountId.includes(refundAddress) &&
+    toAccountId.includes(payoutAddress);
+
   try {
     const ipHeader = getSwapUserIP();
     const headers = {
@@ -64,10 +141,28 @@ export const postSwapCancelled: PostSwapCancelled = async ({
       ...(swapAppVersion ? { "x-swap-app-version": swapAppVersion } : {}),
     };
 
+    const shouldIncludeAddresses =
+      rest.statusCode === "WrongDeviceForAccountPayout" ||
+      rest.statusCode === "WrongDeviceForAccountRefund";
+
+    const requestData = {
+      provider,
+      swapId,
+      swapIntentWithProvider,
+      swapIntentWithoutProvider,
+      payloadAddressMatchAccountAddress,
+      fromAccountId: shouldIncludeAddresses ? fromAccountId : undefined,
+      toAccountId: shouldIncludeAddresses ? toAccountId : undefined,
+      payloadRefundAddress: shouldIncludeAddresses ? refundAddress : undefined,
+      payloadPayoutAddress: shouldIncludeAddresses ? payoutAddress : undefined,
+      maybeSeedMatch: seedIdFrom === seedIdTo, // Only true if both accounts are from the same seed and from the same chain type
+      ...rest,
+    };
+
     await network({
       method: "POST",
       url: `${getSwapAPIBaseURL()}/swap/cancelled`,
-      data: { provider, swapId, ...rest },
+      data: requestData,
       ...(Object.keys(headers).length > 0 ? { headers } : {}),
     });
   } catch (error) {

package/src/exchange/swap/setBroadcastTransaction.ts

@@ -12,6 +12,9 @@ export const setBroadcastTransaction = ({
   hardwareWalletType,
   swapType,
   swapAppVersion,
+  fromAccountId,
+  toAccountId,
+  amount,
 }: {
   result: { operation: Operation | string; swapId: string };
   provider: string;
@@ -20,6 +23,9 @@ export const setBroadcastTransaction = ({
   hardwareWalletType?: DeviceModelId;
   swapType?: TradeMethod;
   swapAppVersion?: string;
+  fromAccountId?: string;
+  toAccountId?: string;
+  amount?: string;
 }) => {
   const { operation, swapId } = result;
 
@@ -39,6 +45,9 @@ export const setBroadcastTransaction = ({
       hardwareWalletType,
       swapType: swapType,
       swapAppVersion,
+      fromAccountId,
+      toAccountId,
+      amount,
     });
   } else {
     postSwapAccepted({
@@ -50,6 +59,9 @@ export const setBroadcastTransaction = ({
       hardwareWalletType,
       swapType,
       swapAppVersion,
+      fromAccountId,
+      toAccountId,
+      amount,
     });
   }
 };

package/src/exchange/swap/types.ts

@@ -200,6 +200,13 @@ type SwapStateRequest = {
   hardwareWalletType: DeviceModelId;
   swapType: TradeMethod;
   swapAppVersion?: string;
+  fromAccountId?: string;
+  toAccountId?: string;
+  amount?: string;
+  seedIdFrom?: string;
+  seedIdTo?: string;
+  refundAddress?: string;
+  payoutAddress?: string;
 }>;
 
 export type SwapStateAcceptedRequest = SwapStateRequest & {

package/src/featureFlags/defaultFeatures.ts

@@ -677,6 +677,7 @@ export const DEFAULT_FEATURES: Features = {
     ...DEFAULT_FEATURE,
     params: {},
   },
+  supportDeviceApex: DEFAULT_FEATURE,
 };
 
 // Firebase SDK treat JSON values as strings

package/src/hw/customLockScreenLoad.ts

@@ -19,7 +19,7 @@ import customLockScreenFetchSize from "./customLockScreenFetchSize";
 import customLockScreenFetchHash from "./customLockScreenFetchHash";
 import { gzip } from "pako";
 import { CLSSupportedDeviceModelId } from "../device/use-cases/isCustomLockScreenSupported";
-import { getScreenSpecs } from "../device/use-cases/screenSpecs";
+import { getScreenSpecs, type ScreenSpecs } from "../device/use-cases/screenSpecs";
 import { DeviceDisconnectedWhileSendingError } from "@ledgerhq/device-management-kit";
 import { withTransport } from "../deviceSDK/transports/core";
 
@@ -60,15 +60,6 @@ export type LoadimageResult = {
   imageSize: number;
 };
 
-type ScreenSpecs = {
-  width: number;
-  height: number;
-  paddingTop: number;
-  paddingBottom: number;
-  paddingLeft: number;
-  paddingRight: number;
-};
-
 export type LoadImageRequest = {
   hexImage: string; // When provided, will skip the backup if it matches the hash.
   padImage?: boolean;
@@ -268,6 +259,11 @@ function padHexImage(hexImage: string, screenSpecs: ScreenSpecs): string {
   return result;
 }
 
+const bitsPerPixelToBppIndicator: Record<ScreenSpecs["bitsPerPixel"], number> = {
+  1: 0,
+  4: 2,
+};
+
 export async function generateCustomLockScreenImageFormat(
   hexImage: string,
   compressImage: boolean,
@@ -276,7 +272,7 @@ export async function generateCustomLockScreenImageFormat(
 ) {
   const width = screenSpecs.width;
   const height = screenSpecs.height;
-  const bpp = 2; // value for 4 bits per pixel
+  const bpp = bitsPerPixelToBppIndicator[screenSpecs.bitsPerPixel];
   const compression = compressImage ? 1 : 0;
 
   const header = Buffer.alloc(8);

package/src/modularDrawer/utils/getBalanceAndFiatValue.ts

@@ -0,0 +1,53 @@
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
+import { isAccount } from "@ledgerhq/coin-framework/account/helpers";
+import {
+  getPortfolioCount,
+  getBalanceHistoryWithCountervalue,
+} from "@ledgerhq/live-countervalues/portfolio";
+import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
+import { Currency } from "@ledgerhq/types-cryptoassets";
+import { Account, TokenAccount } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+
+/**
+ *
+ * @param account - The account to get the balance and fiat value for
+ * @param state - The current state of countervalues
+ * @param toCurrency - The currency to convert to
+ * @param discreet - Whether to show the balance in discreet mode
+ * @param showCode - Whether to show the currency code in the formatted balance
+ * @returns An object containing the balance and fiat value
+ */
+export const getBalanceAndFiatValue = (
+  account: Account | TokenAccount,
+  state: CounterValuesState,
+  toCurrency: Currency,
+  discreet: boolean = false,
+  showCode: boolean = true,
+) => {
+  const isAnAccount = isAccount(account);
+  const details = isAnAccount ? account.currency : account.token;
+  const balance = formatCurrencyUnit(details.units[0], account.balance, {
+    showCode,
+    discreet,
+  });
+
+  const count = getPortfolioCount([account], "day");
+  const { history, countervalueAvailable } = getBalanceHistoryWithCountervalue(
+    account,
+    "day",
+    count,
+    state,
+    toCurrency,
+  );
+
+  if (!countervalueAvailable) return { balance, fiatValue: undefined };
+
+  const { countervalue } = history[history.length - 1] ?? {};
+  const fiatValue = formatCurrencyUnit(toCurrency.units[0], BigNumber(countervalue ?? 0), {
+    showCode,
+    discreet,
+  });
+
+  return { balance, fiatValue };
+};

package/src/modularDrawer/utils/index.ts

@@ -1,6 +1,7 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { CurrenciesByProviderId } from "../../deposit/type";
 import { haveOneCommonProvider } from "./haveOneCommonProvider";
+import { getBalanceAndFiatValue } from "./getBalanceAndFiatValue";
 
 function isCorrespondingCurrency(
   elem: CryptoOrTokenCurrency,
@@ -27,4 +28,9 @@ const getEffectiveCurrency = (
   return provider.currenciesByNetwork.find(elem => currencyIds.includes(elem.id)) ?? currency;
 };
 
-export { isCorrespondingCurrency, getEffectiveCurrency, haveOneCommonProvider };
+export {
+  isCorrespondingCurrency,
+  getEffectiveCurrency,
+  haveOneCommonProvider,
+  getBalanceAndFiatValue,
+};

package/src/wallet-api/Exchange/server.ts

@@ -571,6 +571,9 @@ export const handlers = ({
               targetCurrencyId: toCurrency?.id,
               hardwareWalletType: deviceInfo?.modelId as DeviceModelId,
               swapAppVersion,
+              fromAccountId: fromAccount.id,
+              toAccountId: toAccount?.id,
+              amount: amountExpectedTo.toString(),
             });
 
             resolve({ operationHash, swapId });
@@ -587,6 +590,13 @@ export const handlers = ({
               hardwareWalletType: deviceInfo?.modelId as DeviceModelId,
               swapType: quoteId ? "fixed" : "float",
               swapAppVersion,
+              fromAccountId: fromAccount.id,
+              toAccountId: toAccount?.id,
+              refundAddress,
+              payoutAddress,
+              amount: amountExpectedTo.toString(),
+              seedIdFrom: mainFromAccount.seedIdentifier,
+              seedIdTo: toParentAccount?.seedIdentifier || (toAccount as Account)?.seedIdentifier,
             });
 
             reject(error);