@ledgerhq/live-common 34.53.0-nightly.20251112023812 → 34.53.0-nightly.20251113023835

package/src/bridge/useBridgeTransaction.test.ts

@@ -12,6 +12,7 @@ import useBridgeTransaction, {
 } from "./useBridgeTransaction";
 import { setSupportedCurrencies } from "../currencies";
 import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
+import { shouldSyncBeforeTx } from "./useBridgeTransaction";
 
 const BTC = getCryptoCurrencyById("bitcoin");
 
@@ -26,6 +27,13 @@ LiveConfig.setConfig({
   },
 });
 
+jest.mock("@ledgerhq/live-config/LiveConfig", () => ({
+  LiveConfig: {
+    getValueByKey: jest.fn(),
+    setConfig: jest.fn(),
+  },
+}));
+
 describe("useBridgeTransaction", () => {
   test("initialize with a BTC account settles the transaction", async () => {
     const mainAccount = genAccount("mocked-account-1", { currency: BTC });
@@ -78,4 +86,60 @@ describe("useBridgeTransaction", () => {
       setGlobalOnBridgeError(before);
     }
   });
+
+  describe("shouldSyncBeforeTx", () => {
+    const mockCurrency = { id: "btc" } as any;
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    test("returns true when currency-specific config has syncBeforeTx = true", () => {
+      (LiveConfig.getValueByKey as jest.Mock).mockImplementation((key: string) => {
+        if (key === "config_currency_btc") return { syncBeforeTx: true };
+        return null;
+      });
+
+      const result = shouldSyncBeforeTx(mockCurrency);
+      expect(result).toBe(true);
+      expect(LiveConfig.getValueByKey).toHaveBeenCalledWith("config_currency_btc");
+      expect(LiveConfig.getValueByKey).toHaveBeenCalledWith("config_currency");
+    });
+
+    test("returns false when currency-specific config has syncBeforeTx = false", () => {
+      (LiveConfig.getValueByKey as jest.Mock).mockImplementation((key: string) => {
+        if (key === "config_currency_btc") return { syncBeforeTx: false };
+        return null;
+      });
+
+      const result = shouldSyncBeforeTx(mockCurrency);
+      expect(result).toBe(false);
+    });
+
+    test("returns true when shared config has syncBeforeTx = true and no currency-specific config", () => {
+      (LiveConfig.getValueByKey as jest.Mock).mockImplementation((key: string) => {
+        if (key === "config_currency") return { syncBeforeTx: true };
+        return null;
+      });
+
+      const result = shouldSyncBeforeTx(mockCurrency);
+      expect(result).toBe(true);
+    });
+
+    test("returns false when neither config has syncBeforeTx", () => {
+      (LiveConfig.getValueByKey as jest.Mock).mockReturnValue({});
+      const result = shouldSyncBeforeTx(mockCurrency);
+      expect(result).toBe(false);
+    });
+
+    test("returns false when shared config has syncBeforeTx = false", () => {
+      (LiveConfig.getValueByKey as jest.Mock).mockImplementation((key: string) => {
+        if (key === "config_currency") return { syncBeforeTx: false };
+        return null;
+      });
+
+      const result = shouldSyncBeforeTx(mockCurrency);
+      expect(result).toBe(false);
+    });
+  });
 });

package/src/bridge/useBridgeTransaction.ts

@@ -6,6 +6,8 @@ import { getMainAccount } from "../account";
 import { delay } from "../promise";
 import type { Account, AccountBridge, AccountLike } from "@ledgerhq/types-live";
 import type { Transaction, TransactionStatus } from "../generated/types";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 
 export type State<T extends Transaction = Transaction> = {
   account: AccountLike | null | undefined;
@@ -15,6 +17,8 @@ export type State<T extends Transaction = Transaction> = {
   statusOnTransaction: T | null | undefined;
   errorAccount: Error | null | undefined;
   errorStatus: Error | null | undefined;
+  syncing: boolean;
+  synced: boolean;
 };
 
 export type Result<T extends Transaction = Transaction> = {
@@ -55,6 +59,12 @@ type Actions<T extends Transaction = Transaction> =
   | {
       type: "setTransaction";
       transaction: T;
+    }
+  | {
+      type: "onStartSync";
+    }
+  | {
+      type: "onSync";
     };
 
 type Reducer<T extends Transaction = Transaction> = (
@@ -76,6 +86,18 @@ const initial: State<Transaction> = {
   statusOnTransaction: null,
   errorAccount: null,
   errorStatus: null,
+  syncing: false,
+  synced: false,
+};
+
+export const shouldSyncBeforeTx = (currency: CryptoCurrency): boolean => {
+  const currencyConfig = LiveConfig.getValueByKey(`config_currency_${currency.id}`);
+  const sharedConfig = LiveConfig.getValueByKey("config_currency");
+  if (currencyConfig && "syncBeforeTx" in currencyConfig) {
+    return currencyConfig.syncBeforeTx === true;
+  } else {
+    return sharedConfig && "syncBeforeTx" in sharedConfig && sharedConfig.syncBeforeTx === true;
+  }
 };
 
 const makeInit =
@@ -142,6 +164,8 @@ const reducer = <T extends Transaction = Transaction>(
           account,
           parentAccount,
           transaction: t,
+          syncing: false,
+          synced: false,
         } as State<T>;
       } catch (e: any) {
         return {
@@ -149,6 +173,8 @@ const reducer = <T extends Transaction = Transaction>(
           account,
           parentAccount,
           errorAccount: e,
+          syncing: false,
+          synced: false,
         } as State<T>;
       }
     }
@@ -177,6 +203,12 @@ const reducer = <T extends Transaction = Transaction>(
       if (action.error === state.errorStatus) return state;
       return { ...state, errorStatus: action.error };
 
+    case "onStartSync":
+      return { ...state, syncing: true, synced: false };
+
+    case "onSync":
+      return { ...state, syncing: false, synced: true };
+
     default:
       return state;
   }
@@ -190,7 +222,17 @@ const useBridgeTransaction = <T extends Transaction = Transaction>(
   optionalInit?: (() => Partial<State<T>>) | null | undefined,
 ): Result<T> => {
   const [
-    { account, parentAccount, transaction, status, statusOnTransaction, errorAccount, errorStatus },
+    {
+      account,
+      parentAccount,
+      transaction,
+      status,
+      statusOnTransaction,
+      syncing,
+      synced,
+      errorAccount,
+      errorStatus,
+    },
     dispatch,
   ] = useReducer(reducer as Reducer<T>, undefined, makeInit<T>(optionalInit));
   const setAccount = useCallback(
@@ -223,15 +265,39 @@ const useBridgeTransaction = <T extends Transaction = Transaction>(
   const mainAccount = account ? getMainAccount(account, parentAccount) : null;
   const errorDelay = useRef(INITIAL_ERROR_RETRY_DELAY);
   const statusIsPending = useRef(false); // Stores if status already being processed
+  const shouldSync = mainAccount && shouldSyncBeforeTx(mainAccount.currency);
+
+  useEffect(() => {
+    if (mainAccount === null || synced || syncing) return;
+
+    if (!shouldSync) return; // skip sync if not required by currency config
+
+    dispatch({ type: "onStartSync" });
+    const bridge = getAccountBridge(mainAccount, null);
+    const sub = bridge.sync(mainAccount, { paginationConfig: {} }).subscribe({
+      error: (_: Error) => {
+        // we do not block the user in case of error for now but it should be the case
+        dispatch({ type: "onSync" });
+      },
+      complete: () => {
+        dispatch({ type: "onSync" });
+      },
+    });
+
+    return () => {
+      sub.unsubscribe();
+    };
+  }, [mainAccount, synced, syncing, shouldSync]);
 
   const bridgePending = transaction !== statusOnTransaction;
+
   // when transaction changes, prepare the transaction
   useEffect(() => {
     let ignore = false;
     let errorTimeout: NodeJS.Timeout | null;
     // If bridge is not pending, transaction change is due to
     // the last onStatus dispatch (prepareTransaction changed original transaction) and must be ignored
-    if (!bridgePending) return;
+    if (!bridgePending && !synced) return;
 
     if (mainAccount && transaction) {
       // We don't debounce first status refresh, but any subsequent to avoid multiple calls
@@ -301,7 +367,7 @@ const useBridgeTransaction = <T extends Transaction = Transaction>(
         errorTimeout = null;
       }
     };
-  }, [transaction, mainAccount, bridgePending, dispatch]);
+  }, [transaction, mainAccount, bridgePending, dispatch, synced]);
 
   const bridgeError = errorAccount || errorStatus;
 
@@ -320,7 +386,7 @@ const useBridgeTransaction = <T extends Transaction = Transaction>(
     parentAccount,
     setAccount,
     bridgeError,
-    bridgePending,
+    bridgePending: bridgePending && (shouldSync ? !synced : true),
   };
 };
 

package/src/e2e/index.ts

@@ -4,11 +4,12 @@ import { getFeature, DEFAULT_FEATURES } from "../featureFlags";
 
 export const getAllFeatureFlags = (
   appLanguage?: string,
+  localOverrides?: { [key in FeatureId]?: Feature | undefined },
 ): Partial<{ [key in FeatureId]: Feature }> => {
   const res: Partial<{ [key in FeatureId]: Feature }> = {};
   Object.keys(DEFAULT_FEATURES).forEach(k => {
     const key = k as keyof typeof DEFAULT_FEATURES;
-    const value = getFeature({ key, appLanguage });
+    const value = getFeature({ key, appLanguage, localOverrides });
     if (value !== null) res[key] = value;
   });
   return res;

package/src/exchange/swap/hooks/useFromState.test.ts

@@ -11,9 +11,28 @@ import useBridgeTransaction from "../../../bridge/useBridgeTransaction";
 import { genTokenAccount } from "@ledgerhq/coin-framework/mocks/account";
 import { genAccount } from "../../../mock/account";
 import { useFromState } from "./useFromState";
+import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 
 const BTC = getCryptoCurrencyById("bitcoin");
 const ETH = getCryptoCurrencyById("ethereum");
+LiveConfig.setConfig({
+  config_currency_bitcoin: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+    },
+  },
+  config_currency_ethereum: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+    },
+  },
+});
 const USDT = {
   type: "TokenCurrency" as const,
   id: "ethereum/erc20/usd_tether__erc20_",