@ledgerhq/live-common 34.37.0 → 34.38.0-next.0

package/src/exchange/providers/swap.integration.test.ts

@@ -1,19 +1,4 @@
-import { fetchAndMergeProviderData, findExchangeCurrencyData } from "./swap";
-
-describe("findExchangeCurrencyData", () => {
-  it("returns all data in expected format", async () => {
-    // When
-    const currencies = await findExchangeCurrencyData("arbitrum");
-
-    // Then
-    expect(currencies).toEqual({
-      config: "0345544808457468657265756d0d0345544812000000000000a4b1",
-      id: "arbitrum",
-      signature:
-        "30450221008ca557e4acc2fa290a6a44c2b0eb5232712ba69b23df93645a320bcff9789fd9022017e6e05582806a9d4b7b2aaaedbcc3471bd26e10ad686e4f313fc0b1068b5d64",
-    });
-  });
-});
+import { fetchAndMergeProviderData } from "./swap";
 
 describe("fetchAndMergeProviderData", () => {
   it("returns all data in expected format", async () => {
@@ -31,6 +16,11 @@ describe("fetchAndMergeProviderData", () => {
         mainUrl: "https://changelly.com/",
         name: "Changelly",
         needsKYC: false,
+        usefulUrls: [
+          "https://changelly.com/terms-of-use",
+          "https://changelly.com/aml-kyc",
+          "https://support.changelly.com/en/support/tickets/new",
+        ],
         publicKey: {
           curve: "secp256k1",
           data: Buffer.from(
@@ -47,6 +37,33 @@ describe("fetchAndMergeProviderData", () => {
         type: "CEX",
         version: 1,
       },
+      changelly_v2: {
+        displayName: "Changelly",
+        name: "Changelly",
+        useInExchangeApp: true,
+        publicKey: {
+          curve: "secp256k1",
+          data: Buffer.from(
+            "0480d7c0d3a9183597395f58dda05999328da6f18fabd5cda0aff8e8e3fc633436a2dbf48ecb23d40df7c3c7d3e774b77b4b5df0e9f7e08cf1cdf2dba788eb085b",
+            "hex",
+          ),
+        },
+        signature: Buffer.from(
+          "3045022100c2db00da651cfcc84702f75ab5f131a3f037592080ea750a6f665a8cb36797c802200e594938cdf2c836b34717f57487002a0588f2088f64f00a6c4d320fd37db6fa",
+          "hex",
+        ),
+        needsKYC: false,
+        type: "CEX",
+        usefulUrls: [
+          "https://changelly.com/terms-of-use",
+          "https://changelly.com/aml-kyc",
+          "https://support.changelly.com/en/support/tickets/new",
+        ],
+        termsOfUseUrl: "https://changelly.com/terms-of-use",
+        supportUrl: "https://support.changelly.com/en/support/home",
+        mainUrl: "https://changelly.com/",
+        version: 2,
+      },
       changenow: {
         name: "ChangeNOW",
         publicKey: {

package/src/exchange/providers/swap.ts

@@ -15,6 +15,7 @@ export type AdditionalProviderConfig = SwapProviderConfig & { type: "DEX" | "CEX
   version?: number;
   termsOfUseUrl: string;
   supportUrl: string;
+  usefulUrls?: string[];
   mainUrl: string;
   useInExchangeApp: boolean;
   displayName: string;
@@ -39,10 +40,41 @@ const DEFAULT_SWAP_PROVIDERS: Record<string, ProviderConfig & Partial<Additional
     needsKYC: false,
     needsBearerToken: false,
     type: "CEX",
+    usefulUrls: [
+      "https://changelly.com/terms-of-use",
+      "https://changelly.com/aml-kyc",
+      "https://support.changelly.com/en/support/tickets/new",
+    ],
     termsOfUseUrl: "https://changelly.com/terms-of-use",
     supportUrl: "https://support.changelly.com/en/support/home",
     mainUrl: "https://changelly.com/",
   },
+  changelly_v2: {
+    name: "Changelly",
+    publicKey: {
+      curve: "secp256k1",
+      data: Buffer.from(
+        "0480d7c0d3a9183597395f58dda05999328da6f18fabd5cda0aff8e8e3fc633436a2dbf48ecb23d40df7c3c7d3e774b77b4b5df0e9f7e08cf1cdf2dba788eb085b",
+        "hex",
+      ),
+    },
+    signature: Buffer.from(
+      "3045022100c2db00da651cfcc84702f75ab5f131a3f037592080ea750a6f665a8cb36797c802200e594938cdf2c836b34717f57487002a0588f2088f64f00a6c4d320fd37db6fa",
+      "hex",
+    ),
+    needsKYC: false,
+    needsBearerToken: false,
+    type: "CEX",
+    usefulUrls: [
+      "https://changelly.com/terms-of-use",
+      "https://changelly.com/aml-kyc",
+      "https://support.changelly.com/en/support/tickets/new",
+    ],
+    termsOfUseUrl: "https://changelly.com/terms-of-use",
+    supportUrl: "https://support.changelly.com/en/support/home",
+    mainUrl: "https://changelly.com/",
+    version: 2,
+  },
   exodus: {
     name: "exodus",
     publicKey: {

package/src/families/evm/config.ts

@@ -104,7 +104,7 @@ const evmConfig: CurrencyLiveConfigDefinition = {
         type: "ledger",
         explorerId: "eth",
       },
-      showNfts: true,
+      showNfts: false,
     },
   },
   config_currency_sonic: {
@@ -266,7 +266,7 @@ const evmConfig: CurrencyLiveConfigDefinition = {
         type: "ledger",
         explorerId: "matic",
       },
-      showNfts: true,
+      showNfts: false,
     },
   },
   config_currency_reosc: {

package/src/featureFlags/defaultFeatures.ts

@@ -396,6 +396,13 @@ export const DEFAULT_FEATURES: Features = {
     },
   },
 
+  buySellLoader: {
+    enabled: false,
+    params: {
+      durationMs: 0,
+    },
+  },
+
   buySellShortcut: {
     enabled: false,
   },
@@ -422,6 +429,10 @@ export const DEFAULT_FEATURES: Features = {
     },
   },
 
+  ptxSwapLiveAppKycWarning: {
+    enabled: false,
+  },
+
   llmAnalyticsOptInPrompt: {
     enabled: false,
     params: {
@@ -605,6 +616,7 @@ export const DEFAULT_FEATURES: Features = {
       live_app: true,
       receive_flow: true,
       send_flow: true,
+      enableModularization: false,
     },
   },
   llNftSupport: DEFAULT_FEATURE,

package/src/featureFlags/stakePrograms/index.test.ts

@@ -35,13 +35,13 @@ const feature_stake_programs_json: Feature_StakePrograms = {
 
 describe("stakeProgramsToEarnParam", () => {
   it("should return `undefined` when there are no redirects", () => {
-    const result = stakeProgramsToEarnParam(feature_stake_programs_empty_json);
-    expect(result).toEqual(undefined);
+    const { stakeProgramsParam } = stakeProgramsToEarnParam(feature_stake_programs_empty_json);
+    expect(stakeProgramsParam).toEqual(undefined);
   });
 
   it("should return a record of stake earn params", () => {
-    const result = stakeProgramsToEarnParam(feature_stake_programs_json);
-    expect(result).toEqual({
+    const { stakeProgramsParam } = stakeProgramsToEarnParam(feature_stake_programs_json);
+    expect(stakeProgramsParam).toEqual({
       "ethereum/erc20/usd__coin": "kiln-widget",
       "ethereum/erc20/usd_tether__erc20_": "earn",
       tron: "stakekit",

package/src/featureFlags/stakePrograms/index.ts

@@ -1,19 +1,18 @@
-import type { Feature_StakePrograms, PlatformManifestId } from "@ledgerhq/types-live";
+import type { Feature_StakePrograms } from "@ledgerhq/types-live";
 
-export const stakeProgramsToEarnParam = (
-  stakePrograms: Feature_StakePrograms | null,
-): Record<PlatformManifestId, string> | undefined => {
+export const stakeProgramsToEarnParam = (stakePrograms: Feature_StakePrograms | null) => {
+  const list = stakePrograms?.params?.list ?? [];
   const redirects = stakePrograms?.params?.redirects ?? {};
   const result: Record<string, string> = {};
   const keys = Object.keys(redirects);
   if (keys.length === 0) {
-    return undefined;
+    return { stakeProgramsParam: undefined, stakeCurrenciesParam: [] };
   }
   keys.forEach(key => {
     result[key] = redirects[key].platform;
   });
 
-  return result;
+  return { stakeProgramsParam: result, stakeCurrenciesParam: list };
 };
 
 type StablecoinYield = "dapp" | "api" | "inactive";

package/src/hooks/useOFACGeoBlockCheck.ts

@@ -20,7 +20,7 @@ export const useOFACGeoBlockCheck = ({
     queryKey: ["ofac-geo-block", geoBlockingFeatureFlagKey],
     queryFn: async () => {
       if (!platformOfacGeoBlocking?.enabled) return false;
-      const res = await fetch(`${baseURL()}/v3/market`);
+      const res = await fetch(`${baseURL()}/v3/markets`);
       return res.status === 451;
     },
   });

package/src/hooks/useShowProviderLoadingTransition.test.ts

@@ -0,0 +1,112 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { renderHook } from "@testing-library/react";
+import { LiveAppManifest } from "../platform/types";
+import { INTERNAL_APP_IDS } from "../wallet-api/constants";
+import { useFeature } from "../featureFlags";
+import { useInternalAppIds } from "./useInternalAppIds";
+
+import { useShowProviderLoadingTransition } from "./useShowProviderLoadingTransition";
+
+jest.mock("../featureFlags", () => ({
+  useFeature: jest.fn(),
+}));
+jest.mock("../wallet-api/constants", () => ({
+  INTERNAL_APP_IDS: ["internal-app-id-1", "internal-app-id-2"],
+}));
+jest.mock("./useInternalAppIds", () => ({
+  useInternalAppIds: jest.fn(),
+}));
+
+describe("useShowProviderLoadingTransition", () => {
+  const mockUseFeature = useFeature as jest.Mock;
+  const mockUseInternalAppIds = useInternalAppIds as jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return false when feature is disabled", () => {
+    mockUseFeature.mockReturnValue({ enabled: false, params: {} });
+    const { result } = renderHook(() =>
+      useShowProviderLoadingTransition({
+        manifest: { id: "test-app-id" } as LiveAppManifest,
+        isLoading: true,
+      }),
+    );
+    expect(result.current).toBe(false);
+  });
+
+  it("should return false for internal apps", () => {
+    mockUseFeature.mockReturnValue({ enabled: true, params: {} });
+    mockUseInternalAppIds.mockReturnValue(INTERNAL_APP_IDS);
+    const { result } = renderHook(() =>
+      useShowProviderLoadingTransition({
+        manifest: { id: "internal-app-id-1" } as LiveAppManifest,
+        isLoading: true,
+      }),
+    );
+    expect(result.current).toBe(false);
+  });
+
+  it("should return true when loading and feature is enabled", () => {
+    mockUseFeature.mockReturnValue({ enabled: true, params: {} });
+    mockUseInternalAppIds.mockReturnValue([]);
+    const { result } = renderHook(() =>
+      useShowProviderLoadingTransition({
+        manifest: { id: "test-app-id" } as LiveAppManifest,
+        isLoading: true,
+      }),
+    );
+    expect(result.current).toBe(true);
+  });
+
+  it("should handle extended loading state", () => {
+    jest.useFakeTimers();
+    mockUseFeature.mockReturnValue({ enabled: true, params: { durationMs: 1000 } });
+    mockUseInternalAppIds.mockReturnValue([]);
+
+    const { result, rerender } = renderHook(
+      ({ isLoading }) =>
+        useShowProviderLoadingTransition({
+          manifest: { id: "test-app-id" } as LiveAppManifest,
+          isLoading,
+        }),
+      {
+        initialProps: { isLoading: true },
+      },
+    );
+
+    expect(result.current).toBe(true);
+
+    // Simulate the timeout
+    jest.advanceTimersByTime(1000);
+
+    rerender({ isLoading: false });
+
+    expect(result.current).toBe(false);
+
+    jest.useRealTimers();
+  });
+  it("should clear timeout on unmount", () => {
+    jest.useFakeTimers();
+    mockUseFeature.mockReturnValue({ enabled: true, params: { durationMs: 1000 } });
+    mockUseInternalAppIds.mockReturnValue([]);
+
+    const { unmount } = renderHook(() =>
+      useShowProviderLoadingTransition({
+        manifest: { id: "test-app-id" } as LiveAppManifest,
+        isLoading: true,
+      }),
+    );
+
+    unmount();
+
+    // Advance timers to ensure no memory leaks
+    jest.advanceTimersByTime(1000);
+
+    jest.useRealTimers();
+  });
+});

package/src/hooks/useShowProviderLoadingTransition.ts

@@ -0,0 +1,57 @@
+import { useEffect, useRef, useState } from "react";
+
+import { useFeature } from "../featureFlags/index";
+import { INTERNAL_APP_IDS } from "../wallet-api/constants";
+import { useInternalAppIds } from "./useInternalAppIds";
+import { LiveAppManifest } from "../platform/types";
+
+export function useShowProviderLoadingTransition({
+  isLoading,
+  manifest,
+}: {
+  manifest: LiveAppManifest;
+  isLoading: boolean;
+}) {
+  const isEnabled = useProviderInterstitalEnabled({ manifest });
+  const [extendedInitialLoading, setExtendedInitialLoading] = useState(false);
+
+  const timeoutRef = useRef<NodeJS.Timeout | null>(null);
+  const buySellLoaderFF = useFeature("buySellLoader");
+  const durationMs = buySellLoaderFF?.params?.durationMs ?? 0;
+  const internalAppIds = useInternalAppIds() || INTERNAL_APP_IDS;
+  const isAppInternal = internalAppIds.includes(manifest.id);
+
+  useEffect(() => {
+    if (isEnabled && isLoading && !extendedInitialLoading) {
+      setExtendedInitialLoading(true);
+
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+
+      timeoutRef.current = setTimeout(() => {
+        setExtendedInitialLoading(false);
+      }, durationMs);
+    }
+  }, [durationMs, extendedInitialLoading, isAppInternal, isEnabled, isLoading]);
+
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    };
+  }, []);
+
+  return isEnabled && (isLoading || extendedInitialLoading);
+}
+
+export function useProviderInterstitalEnabled({ manifest }: { manifest?: LiveAppManifest }) {
+  const buySellLoaderFF = useFeature("buySellLoader");
+  const internalAppIds = useInternalAppIds() || INTERNAL_APP_IDS;
+
+  if (!manifest) {
+    return false;
+  }
+
+  const isAppInternal = internalAppIds.includes(manifest.id);
+  const isEnabled = buySellLoaderFF?.enabled && !isAppInternal;
+
+  return isEnabled;
+}

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

@@ -65,6 +65,8 @@ export type CompleteExchangeUiRequest = {
   swapId?: string;
   amountExpectedTo?: number;
   magnitudeAwareRate?: BigNumber;
+  refundAddress?: string;
+  payoutAddress?: string;
 };
 
 type ExchangeStartParamsUiRequest =
@@ -286,11 +288,15 @@ export const handlers = ({
 
         let amountExpectedTo;
         let magnitudeAwareRate;
+        let refundAddress;
+        let payoutAddress;
         if (params.exchangeType === "SWAP") {
           // Get amountExpectedTo and magnitudeAwareRate from binary payload
           const decodePayload = await decodeSwapPayload(params.hexBinaryPayload);
           amountExpectedTo = new BigNumber(decodePayload.amountToWallet.toString());
           magnitudeAwareRate = tx.amount && amountExpectedTo.dividedBy(tx.amount);
+          refundAddress = decodePayload.refundAddress;
+          payoutAddress = decodePayload.payoutAddress;
         }
 
         return new Promise((resolve, reject) =>
@@ -306,6 +312,8 @@ export const handlers = ({
               swapId: params.exchangeType === "SWAP" ? params.swapId : undefined,
               amountExpectedTo,
               magnitudeAwareRate,
+              refundAddress,
+              payoutAddress,
             },
             onSuccess: (transactionHash: string) => {
               tracking.completeExchangeSuccess({

package/src/wallet-api/ModularDrawer/types.ts

@@ -12,11 +12,15 @@ export type ModularDrawerConfiguration = {
   };
 };
 
-const filterOptions = ["topNetworks"] as const;
-const assetsLeftElementOptions = ["apy", "priceVariation"] as const;
-const assetsRightElementOptions = ["balance", "marketTrend"] as const;
-const networksLeftElementOptions = ["numberOfAccounts", "numberOfAccountsAndApy"] as const;
-const networksRightElementOptions = ["balance"] as const;
+export const filterOptions = ["topNetworks", "undefined"] as const;
+export const assetsLeftElementOptions = ["apy", "priceVariation", "undefined"] as const;
+export const assetsRightElementOptions = ["balance", "marketTrend", "undefined"] as const;
+export const networksLeftElementOptions = [
+  "numberOfAccounts",
+  "numberOfAccountsAndApy",
+  "undefined",
+] as const;
+export const networksRightElementOptions = ["balance", "undefined"] as const;
 
 export const EnhancedModularDrawerConfigurationSchema = z.object({
   assets: z

package/src/wallet-api/ModularDrawer/utils.ts

@@ -19,7 +19,7 @@ export function validateAndTransformConfigurationWithZod(
   const result = EnhancedModularDrawerConfigurationSchema.safeParse(config);
 
   if (!result.success) {
-    console.warn("Modulare Drawer invalid configuration received:", result.error);
+    console.warn("Modular Drawer invalid configuration received:", result.error);
     return {};
   }