@ledgerhq/live-common 34.54.0-nightly.20251129023709 → 34.54.0-nightly.20251202023925

package/src/account/recentAddresses.test.ts

@@ -0,0 +1,104 @@
+import { RecentAddressesStore, setupRecentAddressesStore, getRecentAddressesStore } from ".";
+import { RECENT_ADDRESSES_COUNT_LIMIT } from "./recentAddresses";
+
+describe("RecentAddressesStore", () => {
+  const onAddAddressCompleteMock = jest.fn();
+  let store: RecentAddressesStore;
+
+  beforeEach(() => {
+    onAddAddressCompleteMock.mockClear();
+    setupRecentAddressesStore({}, onAddAddressCompleteMock);
+    store = getRecentAddressesStore();
+  });
+
+  it("should add one address and return this only address", async () => {
+    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
+    await store.addAddress("ethereum", newAddress);
+    const addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
+  });
+
+  it("should add a second address and return addresses sorted by insertion", async () => {
+    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
+    await store.addAddress("ethereum", newAddress);
+    let addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
+
+    const newAddress2 = "0xB69B37A4Fb4A18b3258f974ff6e9f529AD2647b1";
+    await store.addAddress("ethereum", newAddress2);
+    addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress2, newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(2);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress2, newAddress] });
+  });
+
+  it("should replace at first place when an address is already saved", async () => {
+    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
+    await store.addAddress("ethereum", newAddress);
+    let addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
+
+    const newAddress2 = "0xB69B37A4Fb4A18b3258f974ff6e9f529AD2647b1";
+    await store.addAddress("ethereum", newAddress2);
+    addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress2, newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(2);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress2, newAddress] });
+
+    await store.addAddress("ethereum", newAddress);
+    addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress, newAddress2]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(3);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress, newAddress2] });
+  });
+
+  it("should replace at first place and remove last element when addresses exceed count limit", async () => {
+    let expectedAddresses: string[] = [];
+    for (let index = 0; index < RECENT_ADDRESSES_COUNT_LIMIT; index++) {
+      await store.addAddress("ethereum", `0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3${index}`);
+      expectedAddresses.unshift(`0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3${index}`);
+    }
+
+    let addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual(expectedAddresses);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(RECENT_ADDRESSES_COUNT_LIMIT);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: expectedAddresses });
+
+    const newAddress2 = "0xB69B37A4Fb4A18b3258f974ff6e9f529AD2647b1";
+    expectedAddresses.splice(expectedAddresses.length - 1, 1);
+    expectedAddresses = [newAddress2, ...expectedAddresses];
+
+    await store.addAddress("ethereum", newAddress2);
+    addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual(expectedAddresses);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(RECENT_ADDRESSES_COUNT_LIMIT + 1);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: expectedAddresses });
+  });
+
+  it("should add an address of a different currency", async () => {
+    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
+    await store.addAddress("ethereum", newAddress);
+
+    let addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
+
+    const newAddress2 = "bc1pxlmrudqyq8qd8pfsc4mpmlaw56x6vtcr9m8nvp8kj3gckefc4kmqhkg4l7";
+    await store.addAddress("bitcoin", newAddress2);
+
+    addresses = store.getAddresses("bitcoin");
+    expect(addresses).toEqual([newAddress2]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(2);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({
+      ethereum: [newAddress],
+      bitcoin: [newAddress2],
+    });
+  });
+});

package/src/account/recentAddresses.ts

@@ -0,0 +1,84 @@
+export const RECENT_ADDRESSES_COUNT_LIMIT = 12;
+
+export type RecentAddressesCache = Record<string, string[]>;
+
+export interface RecentAddressesStore {
+  addAddress(currency: string, address: string): void;
+  syncAddresses(cache: RecentAddressesCache): void;
+  getAddresses(currency: string): string[];
+}
+
+type CallbackMode = "triggerCallback" | "skipCallback";
+
+let recentAddressesStore: RecentAddressesStore | null = null;
+
+export function getRecentAddressesStore(): RecentAddressesStore {
+  if (recentAddressesStore === null) {
+    throw new Error(
+      "Recent addresses store instance is null, please call function setupRecentAddressesStore in application initialization",
+    );
+  }
+  return recentAddressesStore;
+}
+
+export function setupRecentAddressesStore(
+  addressesByCurrency: RecentAddressesCache,
+  onAddAddressComplete: (addressesByCurrency: RecentAddressesCache) => void,
+): void {
+  recentAddressesStore = new RecentAddressesStoreImpl(addressesByCurrency, onAddAddressComplete);
+}
+
+class RecentAddressesStoreImpl implements RecentAddressesStore {
+  private addressesByCurrency: RecentAddressesCache = {};
+  private readonly onAddAddressComplete: (addressesByCurrency: Record<string, string[]>) => void;
+
+  constructor(
+    addressesByCurrency: RecentAddressesCache,
+    onAddAddressComplete: (addressesByCurrency: RecentAddressesCache) => void,
+  ) {
+    this.addressesByCurrency = { ...addressesByCurrency };
+    this.onAddAddressComplete = onAddAddressComplete;
+  }
+
+  addAddress(currency: string, address: string): void {
+    this.addAddressToCache(currency, address, "triggerCallback");
+  }
+
+  syncAddresses(cache: RecentAddressesCache): void {
+    const previousAddresses = { ...this.addressesByCurrency };
+    this.addressesByCurrency = { ...cache };
+    for (const currency in previousAddresses) {
+      for (const address of previousAddresses[currency]) {
+        this.addAddressToCache(currency, address, "skipCallback");
+      }
+    }
+
+    this.onAddAddressComplete(this.addressesByCurrency);
+  }
+
+  getAddresses(currency: string): string[] {
+    const addresses = this.addressesByCurrency[currency];
+    return addresses ?? [];
+  }
+
+  private addAddressToCache(currency: string, address: string, callbackMode: CallbackMode): void {
+    if (!this.addressesByCurrency[currency]) {
+      this.addressesByCurrency[currency] = [];
+    }
+
+    const addresses = this.addressesByCurrency[currency];
+    const addressIndex = addresses.indexOf(address);
+    if (addressIndex !== -1) {
+      addresses.splice(addressIndex, 1);
+    } else if (addresses.length >= RECENT_ADDRESSES_COUNT_LIMIT) {
+      addresses.pop();
+    }
+
+    addresses.unshift(address);
+    this.addressesByCurrency[currency] = [...addresses];
+
+    if (callbackMode === "triggerCallback") {
+      this.onAddAddressComplete(this.addressesByCurrency);
+    }
+  }
+}

package/src/exchange/swap/postSwapState.ts

@@ -106,6 +106,7 @@ export const postSwapCancelled: PostSwapCancelled = async ({
   seedIdTo,
   refundAddress,
   payoutAddress,
+  data,
   ...rest
 }) => {
   if (isIntegrationTestEnv()) return mockPostSwapCancelled({ provider, swapId, ...rest });
@@ -138,7 +139,8 @@ export const postSwapCancelled: PostSwapCancelled = async ({
 
     const shouldIncludeAddresses =
       rest.statusCode === "WrongDeviceForAccountPayout" ||
-      rest.statusCode === "WrongDeviceForAccountRefund";
+      rest.statusCode === "WrongDeviceForAccountRefund" ||
+      rest.statusCode === "FeeNotLoaded";
 
     const requestData = {
       provider,
@@ -147,11 +149,14 @@ export const postSwapCancelled: PostSwapCancelled = async ({
       swapIntentWithoutProvider,
       payloadAddressMatchAccountAddress,
       fromAmount,
-      fromAccountAddress: shouldIncludeAddresses ? fromAccountAddress : undefined,
-      toAccountAddress: shouldIncludeAddresses ? toAccountAddress : undefined,
-      payloadRefundAddress: shouldIncludeAddresses ? refundAddress : undefined,
-      payloadPayoutAddress: shouldIncludeAddresses ? payoutAddress : undefined,
+      ...(shouldIncludeAddresses && {
+        fromAccountAddress,
+        toAccountAddress,
+        payloadRefundAddress: refundAddress,
+        payloadPayoutAddress: payoutAddress,
+      }),
       maybeSeedMatch: seedIdFrom === seedIdTo, // Only true if both accounts are from the same seed and from the same chain type
+      data,
       ...rest,
     };
 

package/src/exchange/swap/types.ts

@@ -214,7 +214,9 @@ export type SwapStateAcceptedRequest = SwapStateRequest & {
   transactionId: string;
 };
 
-export type SwapStateCancelledRequest = SwapStateRequest;
+export type SwapStateCancelledRequest = SwapStateRequest & {
+  data?: string;
+};
 
 export type PostSwapAccepted = (arg0: SwapStateAcceptedRequest) => Promise<null>;
 

package/src/featureFlags/defaultFeatures.ts

@@ -731,6 +731,7 @@ export const DEFAULT_FEATURES: Features = {
     },
   },
   zcashShielded: DEFAULT_FEATURE,
+  llmNanoOnboardingFundWallet: DEFAULT_FEATURE,
 };
 
 // Firebase SDK treat JSON values as strings

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

@@ -53,6 +53,8 @@ import { getSwapStepFromError } from "../../exchange/error";
 import { postSwapCancelled } from "../../exchange/swap";
 import { DeviceModelId } from "@ledgerhq/types-devices";
 import { setBroadcastTransaction } from "../../exchange/swap/setBroadcastTransaction";
+import { Transaction as EvmTransaction } from "@ledgerhq/coin-evm/types/index";
+import { padHexString } from "@ledgerhq/hw-app-eth";
 
 export { ExchangeType };
 
@@ -599,6 +601,9 @@ export const handlers = ({
               fromAmount,
               seedIdFrom: mainFromAccount.seedIdentifier,
               seedIdTo: toParentAccount?.seedIdentifier || (toAccount as Account)?.seedIdentifier,
+              data: (transaction as EvmTransaction).data
+                ? `0x${padHexString((transaction as EvmTransaction).data?.toString("hex") || "")}`
+                : "0x",
             });
 
             reject(error);