@ledgerhq/live-common 34.52.0 → 34.53.0-nightly.20251108023448

package/src/utils/__tests__/addressUtils.test.ts

@@ -0,0 +1,229 @@
+import { addressSplit } from "../addressUtils";
+
+describe("addressSplit", () => {
+  describe("Basic functionality", () => {
+    it("should split a simple address correctly", () => {
+      const result = addressSplit("HelloWorld", 2);
+      expect(result).toEqual({
+        start: "He",
+        middle: "lloWor",
+        end: "ld",
+      });
+    });
+
+    it("should split a longer address with size 4", () => {
+      const result = addressSplit("0x1234567890abcdef", 4);
+      expect(result).toEqual({
+        start: "0x12",
+        middle: "34567890ab",
+        end: "cdef",
+      });
+    });
+  });
+
+  describe("Boundary conditions", () => {
+    it("should handle exact boundary where size * 2 equals address length", () => {
+      const result = addressSplit("ABCDEF", 3);
+      expect(result).toEqual({
+        start: "ABC",
+        middle: "",
+        end: "DEF",
+      });
+    });
+
+    it("should handle size equal to half address length", () => {
+      const result = addressSplit("ABCDEFGH", 4);
+      expect(result).toEqual({
+        start: "ABCD",
+        middle: "",
+        end: "EFGH",
+      });
+    });
+
+    it("should handle odd-length address with equal split", () => {
+      const result = addressSplit("ABCDE", 2);
+      expect(result).toEqual({
+        start: "AB",
+        middle: "C",
+        end: "DE",
+      });
+    });
+
+    it("should handle very long address", () => {
+      const longAddress = "A".repeat(1000);
+      const result = addressSplit(longAddress, 10);
+      expect(result).toEqual({
+        start: "A".repeat(10),
+        middle: "A".repeat(980),
+        end: "A".repeat(10),
+      });
+      expect(result.start.length + result.middle.length + result.end.length).toBe(1000);
+    });
+  });
+
+  describe("Edge cases - size variations", () => {
+    it("should handle size of 0", () => {
+      const result = addressSplit("HelloWorld", 0);
+      expect(result).toEqual({
+        start: "",
+        middle: "HelloWorld",
+        end: "",
+      });
+    });
+
+    it("should handle size of 1", () => {
+      const result = addressSplit("HelloWorld", 1);
+      expect(result).toEqual({
+        start: "H",
+        middle: "elloWorl",
+        end: "d",
+      });
+    });
+
+    it("should handle negative size", () => {
+      const result = addressSplit("HelloWorld", -5);
+      expect(result).toEqual({
+        start: "",
+        middle: "HelloWorld",
+        end: "",
+      });
+    });
+
+    it("should handle size larger than half the address length", () => {
+      const result = addressSplit("Hello", 3);
+      expect(result).toEqual({
+        start: "He",
+        middle: "",
+        end: "llo",
+      });
+    });
+
+    it("should handle size equal to address length", () => {
+      const result = addressSplit("Hello", 5);
+      expect(result).toEqual({
+        start: "He",
+        middle: "",
+        end: "llo",
+      });
+    });
+
+    it("should handle size larger than address length", () => {
+      const result = addressSplit("Hello", 10);
+      expect(result).toEqual({
+        start: "He",
+        middle: "",
+        end: "llo",
+      });
+    });
+  });
+
+  describe("Edge cases - address variations", () => {
+    it("should handle empty string", () => {
+      const result = addressSplit("", 2);
+      expect(result).toEqual({
+        start: "",
+        middle: "",
+        end: "",
+      });
+    });
+
+    it("should handle single character address", () => {
+      const result = addressSplit("A", 1);
+      expect(result).toEqual({
+        start: "",
+        middle: "",
+        end: "A",
+      });
+    });
+
+    it("should handle two character address", () => {
+      const result = addressSplit("AB", 1);
+      expect(result).toEqual({
+        start: "A",
+        middle: "",
+        end: "B",
+      });
+    });
+
+    it("should handle three character address with size 1", () => {
+      const result = addressSplit("ABC", 1);
+      expect(result).toEqual({
+        start: "A",
+        middle: "B",
+        end: "C",
+      });
+    });
+  });
+
+  describe("Real-world cryptocurrency addresses", () => {
+    it("should split a Bitcoin address correctly", () => {
+      const bitcoinAddress = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa";
+      const result = addressSplit(bitcoinAddress, 5);
+      expect(result).toEqual({
+        start: "1A1zP",
+        middle: "1eP5QGefi2DMPTfTL5SLmv7D",
+        end: "ivfNa",
+      });
+    });
+
+    it("should split an Ethereum address correctly", () => {
+      const ethAddress = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb";
+      const result = addressSplit(ethAddress, 6);
+      expect(result).toEqual({
+        start: "0x742d",
+        middle: "35Cc6634C0532925a3b844Bc9e759",
+        end: "5f0bEb",
+      });
+    });
+
+    it("should handle a Solana address", () => {
+      const solanaAddress = "7EqQdEULxWcraVx3mXKFjc84LhCkMGZCkRuDpvcMwJeK";
+      const result = addressSplit(solanaAddress, 4);
+      expect(result).toEqual({
+        start: "7EqQ",
+        middle: "dEULxWcraVx3mXKFjc84LhCkMGZCkRuDpvcM",
+        end: "wJeK",
+      });
+    });
+
+    it("should handle a Polkadot address", () => {
+      const polkadotAddress = "15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5";
+      const result = addressSplit(polkadotAddress, 6);
+      expect(result).toEqual({
+        start: "15oF4u",
+        middle: "VJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMN",
+        end: "Hr6Sp5",
+      });
+    });
+
+    it("should handle a Cardano address", () => {
+      const cardanoAddress =
+        "addr1qxy3w7depgr3wle7kqwzz8u4h5f6gxqe9q0rk8w3n0d7wqxqk0n7n8s3w3w3w3w3w3w3w3w3w3w3w3w3w3w";
+      const result = addressSplit(cardanoAddress, 8);
+      expect(result).toEqual({
+        start: "addr1qxy",
+        middle: "3w7depgr3wle7kqwzz8u4h5f6gxqe9q0rk8w3n0d7wqxqk0n7n8s3w3w3w3w3w3w3w3w3w3w",
+        end: "3w3w3w3w",
+      });
+    });
+
+    it("should handle a Near protocol address", () => {
+      const nearAddress = "alice.near";
+      const result = addressSplit(nearAddress, 3);
+      expect(result).toEqual({
+        start: "ali",
+        middle: "ce.n",
+        end: "ear",
+      });
+    });
+  });
+
+  describe("Data integrity", () => {
+    it("should preserve the entire address when concatenated", () => {
+      const address = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa";
+      const result = addressSplit(address, 5);
+      const reconstructed = result.start + result.middle + result.end;
+      expect(reconstructed).toBe(address);
+    });
+  });
+});

package/src/utils/__tests__/getAccountTuplesForCurrency.test.ts

@@ -1,8 +1,12 @@
-import { getCryptoCurrencyById, findTokenById } from "@ledgerhq/cryptoassets";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 import { genAccount } from "../../mock/account";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Account, TokenAccount } from "@ledgerhq/types-live";
 import { getAccountTuplesForCurrency } from "../getAccountTuplesForCurrency";
+import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
+import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
+
+initializeLegacyTokens(addTokens);
 
 function* accountGenerator(currency: CryptoCurrency): Generator<Account> {
   let id = 0;
@@ -66,9 +70,16 @@ describe("getAccountTuplesForCurrency", () => {
   });
 
   describe("TokenCurrency", () => {
-    const token = findTokenById("ethereum/erc20/aave");
-    if (!token) throw new Error("AAVE token not found");
-    const aaveToken = token;
+    const aaveToken = {
+      type: "TokenCurrency" as const,
+      id: "ethereum/erc20/aave",
+      name: "Aave Token",
+      ticker: "AAVE",
+      units: [{ name: "Aave Token", code: "AAVE", magnitude: 18 }],
+      contractAddress: "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9",
+      parentCurrency: getCryptoCurrencyById("ethereum"),
+      tokenType: "erc20" as const,
+    };
 
     test("returns correct parent accounts including a new subAccount when a TokenCurrency is provided", () => {
       const ethAccounts = [

package/src/utils/addressUtils.ts

@@ -0,0 +1,40 @@
+/**
+ * Split an address into start, middle, and end sections
+ *
+ * @param address - The address string to split
+ * @param size - The number of characters to include in the start and end sections
+ * @returns An object containing the start, middle, and end portions of the address
+ * @example
+ * addressSplit("HelloWorld", 2) // => { start: "He", middle: "lloWor", end: "ld" }
+ */
+export function addressSplit(
+  address: string,
+  size: number,
+): { start: string; middle: string; end: string } {
+  if (!address) {
+    return { start: "", middle: "", end: "" };
+  }
+
+  if (size < 0) {
+    return { start: "", middle: address, end: "" };
+  } else if (size === 0) {
+    return { start: "", middle: address, end: "" };
+  }
+
+  // Handle edge case of address length smaller than or equal to size * 2
+  // In this case, we can't extract both start and end without overlapping
+  if (address.length <= size * 2) {
+    const halfLength = Math.floor(address.length / 2);
+    return {
+      start: address.slice(0, halfLength),
+      middle: "",
+      end: address.slice(halfLength),
+    };
+  }
+
+  const start = address.slice(0, size);
+  const end = address.slice(-size);
+  const middle = address.slice(size, -size);
+
+  return { start, middle, end };
+}

package/src/wallet-api/ACRE/server.test.ts

@@ -11,11 +11,13 @@ jest.mock("@ledgerhq/wallet-api-server", () => ({
 }));
 
 jest.mock("@ledgerhq/cryptoassets", () => ({
-  findTokenById: jest.fn(),
-  findTokenByAddressInCurrency: jest.fn(),
   getCryptoCurrencyById: jest.fn(),
 }));
 
+jest.mock("../../bridge/crypto-assets/index", () => ({
+  getCryptoAssetsStore: jest.fn(),
+}));
+
 jest.mock("../converters", () => ({
   getAccountIdFromWalletAccountId: jest.fn(),
   getWalletAPITransactionSignFlowInfos: jest.fn(),
@@ -148,8 +150,15 @@ describe("ACRE Server Handlers", () => {
   let mockUiHooks: any;
   let serverHandlers: any;
 
+  const { getCryptoAssetsStore } = jest.requireMock("../../bridge/crypto-assets/index");
+
   beforeEach(() => {
     jest.clearAllMocks();
+
+    getCryptoAssetsStore.mockReturnValue({
+      findTokenByAddressInCurrency: jest.fn().mockResolvedValue(mockTokenCurrency),
+      findTokenById: jest.fn().mockResolvedValue(mockTokenCurrency),
+    });
     mockUiHooks = {
       "custom.acre.messageSign": jest.fn().mockImplementation(({ onSuccess }) => {
         onSuccess("0x1234567890abcdef");
@@ -166,12 +175,6 @@ describe("ACRE Server Handlers", () => {
       }),
     };
 
-    // Mock the cryptoassets functions globally
-    const { findTokenByAddressInCurrency, getCryptoCurrencyById } =
-      jest.requireMock("@ledgerhq/cryptoassets");
-    findTokenByAddressInCurrency.mockReturnValue(mockTokenCurrency);
-    getCryptoCurrencyById.mockReturnValue(mockEthereumCurrency);
-
     // Mock the account functions
     const { makeEmptyTokenAccount, getMainAccount, getParentAccount } = jest.requireMock(
       "@ledgerhq/coin-framework/account/index",

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

@@ -8,7 +8,7 @@ import {
   isTokenAccount,
 } from "@ledgerhq/coin-framework/account/index";
 import { Account, AccountLike, AnyMessage, Operation, SignedOperation } from "@ledgerhq/types-live";
-import { findTokenById, findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
+import { getCryptoAssetsStore } from "../../bridge/crypto-assets/index";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import {
   MessageSignParams,
@@ -115,16 +115,19 @@ function validateInputs(params: RegisterYieldBearingEthereumAddressParams): {
 }
 
 // Helper function to find acreToken by address or token id
-function findAcreToken(
+async function findAcreToken(
   tokenContractAddress?: string,
   tokenTicker?: string,
-): { token: TokenCurrency; contractAddress: string } {
+): Promise<{ token: TokenCurrency; contractAddress: string }> {
   let foundToken: TokenCurrency | undefined;
   // Try to find token by contract address first (if provided)
   if (tokenContractAddress) {
-    foundToken = findTokenByAddressInCurrency(tokenContractAddress, "ethereum");
+    foundToken = await getCryptoAssetsStore().findTokenByAddressInCurrency(
+      tokenContractAddress,
+      "ethereum",
+    );
   } else if (tokenTicker) {
-    foundToken = findTokenById(tokenTicker.toLowerCase());
+    foundToken = await getCryptoAssetsStore().findTokenById(tokenTicker.toLowerCase());
   }
   if (!foundToken) {
     throw new Error(
@@ -202,7 +205,7 @@ export const handlers = ({
   manifest: AppManifest;
   uiHooks: ACREUiHooks;
 }) => {
-  function signTransaction({
+  async function signTransaction({
     accountId: walletAccountId,
     rawTransaction,
     options,
@@ -213,17 +216,17 @@ export const handlers = ({
     tracking.signTransactionRequested(manifest);
     if (!transaction) {
       tracking.signTransactionFail(manifest);
-      return Promise.reject(new Error("Transaction required"));
+      throw new Error("Transaction required");
     }
     const accountId = getAccountIdFromWalletAccountId(walletAccountId);
     if (!accountId) {
       tracking.signTransactionFail(manifest);
-      return Promise.reject(new Error(`accountId ${walletAccountId} unknown`));
+      throw new Error(`accountId ${walletAccountId} unknown`);
     }
     const account = accounts.find(account => account.id === accountId);
     if (!account) {
       tracking.signTransactionFail(manifest);
-      return Promise.reject(new Error("Account required"));
+      throw new Error("Account required");
     }
 
     const parentAccount = getParentAccount(account, accounts);
@@ -233,7 +236,9 @@ export const handlers = ({
       : account.currency.family;
 
     const mainAccount = getMainAccount(account, parentAccount);
-    const currency = tokenCurrency ? findTokenById(tokenCurrency) : null;
+    const currency = tokenCurrency
+      ? await getCryptoAssetsStore().findTokenById(tokenCurrency)
+      : null;
     const signerAccount = currency ? makeEmptyTokenAccount(mainAccount, currency) : account;
     const { canEditFees, liveTx, hasFeesProvided } = getWalletAPITransactionSignFlowInfos({
       walletApiTransaction: transaction,
@@ -241,10 +246,8 @@ export const handlers = ({
     });
 
     if (accountFamily !== liveTx.family) {
-      return Promise.reject(
-        new Error(
-          `Account and transaction must be from the same family. Account family: ${accountFamily}, Transaction family: ${liveTx.family}`,
-        ),
+      throw new Error(
+        `Account and transaction must be from the same family. Account family: ${accountFamily}, Transaction family: ${liveTx.family}`,
       );
     }
 
@@ -291,13 +294,13 @@ export const handlers = ({
       const accountId = getAccountIdFromWalletAccountId(walletAccountId);
       if (!accountId) {
         tracking.signMessageFail(manifest);
-        return Promise.reject(new Error(`accountId ${walletAccountId} unknown`));
+        throw new Error(`accountId ${walletAccountId} unknown`);
       }
 
       const account = accounts.find(account => account.id === accountId);
       if (account === undefined) {
         tracking.signMessageFail(manifest);
-        return Promise.reject(new Error("account not found"));
+        throw new Error("account not found");
       }
 
       const path = fromRelativePath(getMainAccount(account).freshAddressPath, derivationPath);
@@ -328,7 +331,7 @@ export const handlers = ({
             if (done) return;
             done = true;
             tracking.signMessageFail(manifest);
-            reject(error);
+            reject(error instanceof Error ? error : new Error(String(error)));
           },
         });
       });
@@ -379,7 +382,9 @@ export const handlers = ({
         return Promise.reject(new Error("Account required"));
       }
 
-      const currency = tokenCurrency ? findTokenById(tokenCurrency) : null;
+      const currency = tokenCurrency
+        ? await getCryptoAssetsStore().findTokenById(tokenCurrency)
+        : null;
       const parentAccount = getParentAccount(account, accounts);
       const mainAccount = getMainAccount(account, parentAccount);
       const signerAccount = currency ? makeEmptyTokenAccount(mainAccount, currency) : account;
@@ -415,10 +420,8 @@ export const handlers = ({
       }
       const validatedInputs = validateInputs(params);
       const ethereumCurrency = getCryptoCurrencyById("ethereum");
-      const { token: existingToken, contractAddress: finalTokenContractAddress } = findAcreToken(
-        validatedInputs.tokenContractAddress,
-        validatedInputs.tokenTicker,
-      );
+      const { token: existingToken, contractAddress: finalTokenContractAddress } =
+        await findAcreToken(validatedInputs.tokenContractAddress, validatedInputs.tokenTicker);
       const existingBearingAccount = accounts.find(
         account =>
           "freshAddress" in account &&

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

@@ -4,7 +4,8 @@ import {
   getParentAccount,
   makeEmptyTokenAccount,
 } from "@ledgerhq/coin-framework/account/index";
-import { findTokenById, listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
+import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
+import { getCryptoAssetsStore } from "../../bridge/crypto-assets/index";
 import { decodeSwapPayload } from "@ledgerhq/hw-app-exchange";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { Account, AccountLike, getCurrencyForAccount, TokenAccount } from "@ledgerhq/types-live";
@@ -172,7 +173,7 @@ export const handlers = ({
 
         // Use `if else` instead of switch to leverage TS type narrowing and avoid `params` force cast.
         if (params.exchangeType == "SWAP") {
-          exchangeParams = extractSwapStartParam(params, accounts);
+          exchangeParams = await extractSwapStartParam(params, accounts);
         } else if (params.exchangeType == "SELL") {
           exchangeParams = extractSellStartParam(params, accounts);
         } else {
@@ -237,7 +238,7 @@ export const handlers = ({
           let toParentAccount = getParentAccount(toAccount, accounts);
           let newTokenAccount: TokenAccount | undefined;
           if (params.tokenCurrency) {
-            const currency = findTokenById(params.tokenCurrency);
+            const currency = await getCryptoAssetsStore().findTokenById(params.tokenCurrency);
             if (!currency) {
               throw new ServerError(createCurrencyNotFound(params.tokenCurrency));
             }
@@ -397,10 +398,10 @@ export const handlers = ({
 
       tracking.startExchangeRequested(trackingParams);
 
-      const exchangeStartParams: ExchangeStartParamsUiRequest = extractSwapStartParam(
+      const exchangeStartParams: ExchangeStartParamsUiRequest = (await extractSwapStartParam(
         params,
         accounts,
-      ) as SwapStartParamsUiRequest;
+      )) as SwapStartParamsUiRequest;
 
       const {
         fromCurrency,
@@ -621,10 +622,10 @@ export const handlers = ({
     }),
   }) as const satisfies Handlers;
 
-function extractSwapStartParam(
+async function extractSwapStartParam(
   params: ExchangeStartSwapParams,
   accounts: AccountLike[],
-): ExchangeStartParamsUiRequest {
+): Promise<ExchangeStartParamsUiRequest> {
   if (!("fromAccountId" in params && "toAccountId" in params)) {
     throw new ExchangeError(createWrongSwapParams(params));
   }
@@ -657,7 +658,9 @@ function extractSwapStartParam(
   const fromParentAccount = getParentAccount(fromAccount, accounts);
   const toParentAccount = toAccount ? getParentAccount(toAccount, accounts) : undefined;
 
-  const currency = params.tokenCurrency ? findTokenById(params.tokenCurrency) : null;
+  const currency = params.tokenCurrency
+    ? await getCryptoAssetsStore().findTokenById(params.tokenCurrency)
+    : null;
   const newTokenAccount = currency ? makeEmptyTokenAccount(toAccount, currency) : null;
 
   return {

package/src/wallet-api/logic.test.ts

@@ -26,6 +26,10 @@ import { TrackingAPI } from "./tracking";
 import { cryptocurrenciesById } from "@ledgerhq/cryptoassets/currencies";
 import { setSupportedCurrencies } from "../currencies";
 import { initialState as walletState } from "@ledgerhq/live-wallet/store";
+import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
+import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
+
+initializeLegacyTokens(addTokens);
 
 describe("receiveOnAccountLogic", () => {
   // Given