@ledgerhq/live-common 34.48.1 → 34.49.0-nightly.0

package/src/modularDrawer/hooks/useMarketByCurrencies.ts

@@ -0,0 +1,29 @@
+import { useSelector } from "react-redux";
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { selectMarketByCurrency } from "../data/entities/marketSelectors";
+
+export const useMarketByCurrencies = (currencies: CryptoOrTokenCurrency[]) => {
+  return useSelector(state => {
+    const marketByCurrencies: Record<
+      string,
+      { price?: number; priceChangePercentage24h?: number }
+    > = {};
+    currencies.forEach(currency => {
+      const currencyMarket = selectMarketByCurrency(state, currency.id);
+      if (
+        currencyMarket &&
+        currencyMarket.price !== undefined &&
+        currencyMarket.priceChangePercentage24h !== undefined
+      ) {
+        marketByCurrencies[currency.id] = {
+          ...(currencyMarket.price && { price: currencyMarket.price }),
+          ...(currencyMarket.priceChangePercentage24h && {
+            priceChangePercentage24h:
+              Math.round(currencyMarket.priceChangePercentage24h * 100) / 100,
+          }),
+        };
+      }
+    });
+    return marketByCurrencies;
+  });
+};

package/src/modularDrawer/hooks/useSearch.ts

@@ -0,0 +1,52 @@
+import { ChangeEvent, useCallback, useState } from "react";
+
+export type UseSearchParams = {
+  /** Initial value to display in the search input */
+  initialValue?: string;
+  /** Persist the search value to the host app state (e.g., Redux) */
+  onPersistSearchValue?: (value: string) => void;
+  /** Track analytics when the debounced value changes and should be emitted */
+  onTrackSearch?: (query: string) => void;
+};
+
+export type UseSearchResult = {
+  handleSearch: (queryOrEvent: string | ChangeEvent<HTMLInputElement>) => void;
+  handleDebouncedChange: (current: string, previous: string) => void;
+  displayedValue: string | undefined;
+};
+
+const normalize = (value: string) => value.trim();
+
+export function useSearchCommon({
+  initialValue,
+  onPersistSearchValue,
+  onTrackSearch,
+}: UseSearchParams): UseSearchResult {
+  const [displayedValue, setDisplayedValue] = useState<string | undefined>(initialValue);
+
+  const handleSearch = useCallback((queryOrEvent: string | ChangeEvent<HTMLInputElement>) => {
+    const nextValue = typeof queryOrEvent === "string" ? queryOrEvent : queryOrEvent.target.value;
+    setDisplayedValue(nextValue);
+  }, []);
+
+  const shouldEmitEvent = useCallback(
+    (currentQuery: string, previousQuery: string) =>
+      currentQuery !== "" && currentQuery !== previousQuery,
+    [],
+  );
+  const handleDebouncedChange = useCallback(
+    (current: string, previous: string) => {
+      const currentQuery = normalize(current);
+      const previousQuery = normalize(previous);
+
+      onPersistSearchValue?.(currentQuery);
+
+      if (!shouldEmitEvent(currentQuery, previousQuery)) return;
+
+      onTrackSearch?.(currentQuery);
+    },
+    [onPersistSearchValue, onTrackSearch, shouldEmitEvent],
+  );
+
+  return { handleSearch, handleDebouncedChange, displayedValue };
+}

package/src/modularDrawer/modules/createAssetConfiguration.ts

@@ -4,6 +4,8 @@ import { CurrenciesByProviderId } from "../../deposit/type";
 import { composeHooks } from "../../utils/composeHooks";
 import { useLeftApyModule } from "../hooks/modules/useLeftApyModule";
 import { createUseRightBalanceAsset } from "../hooks/useRightBalanceAsset";
+import { useLeftMarketTrendModule } from "../hooks/modules/useLeftMarketTrendModule";
+import { useRightMarketTrendModule } from "../hooks/modules/useRightMarketTrendModule";
 
 const getRightElement =
   (AssetConfigurationDeps: AssetConfigurationDeps) => (rightElement?: string) => {
@@ -11,6 +13,12 @@ const getRightElement =
       case "undefined":
         return undefined;
       case "marketTrend":
+        return (currencies: CryptoOrTokenCurrency[]) =>
+          useRightMarketTrendModule({
+            currencies,
+            useBalanceDeps: AssetConfigurationDeps.useBalanceDeps,
+            MarketPriceIndicator: AssetConfigurationDeps.MarketPriceIndicator,
+          });
       case "balance":
       default:
         return createUseRightBalanceAsset({
@@ -27,6 +35,8 @@ const getLeftElement =
         return (assets: CryptoOrTokenCurrency[]) =>
           useLeftApyModule(assets, AssetConfigurationDeps.ApyIndicator);
       case "marketTrend":
+        return (assets: CryptoOrTokenCurrency[]) =>
+          useLeftMarketTrendModule(assets, AssetConfigurationDeps.MarketPercentIndicator);
       case "undefined":
       default:
         return undefined;

package/src/modularDrawer/utils/type.ts

@@ -111,6 +111,8 @@ type Props = {
 
 export type AssetConfigurationDeps = {
   ApyIndicator: (args: { value: number; type: ApyType }) => ReactNode;
+  MarketPercentIndicator: (args: { percent: number }) => ReactNode;
+  MarketPriceIndicator: (args: { price: string; percent: number }) => ReactNode;
   useBalanceDeps: UseBalanceDeps;
   balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
 };

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

@@ -0,0 +1,470 @@
+import { handlers } from "./server";
+import { Account } from "@ledgerhq/types-live";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import BigNumber from "bignumber.js";
+import { AppPlatform, AppBranch, Visibility } from "../types";
+
+// Mock dependencies
+jest.mock("@ledgerhq/wallet-api-server", () => ({
+  RPCHandler: jest.fn(),
+  customWrapper: jest.fn(handler => handler),
+}));
+
+jest.mock("@ledgerhq/cryptoassets", () => ({
+  findTokenById: jest.fn(),
+  findTokenByAddressInCurrency: jest.fn(),
+  getCryptoCurrencyById: jest.fn(),
+}));
+
+jest.mock("../converters", () => ({
+  getAccountIdFromWalletAccountId: jest.fn(),
+  getWalletAPITransactionSignFlowInfos: jest.fn(),
+}));
+
+jest.mock("../../bridge", () => ({
+  getAccountBridge: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/live-env", () => ({
+  getEnv: jest.fn(),
+}));
+
+// Mock types
+const mockTracking = {
+  signMessageRequested: jest.fn(),
+  signMessageSuccess: jest.fn(),
+  signMessageFail: jest.fn(),
+  signMessageNoParams: jest.fn(),
+  signMessageUserRefused: jest.fn(),
+  signTransactionRequested: jest.fn(),
+  signTransactionSuccess: jest.fn(),
+  signTransactionFail: jest.fn(),
+  signTransactionNoParams: jest.fn(),
+  signTransactionAndBroadcastNoParams: jest.fn(),
+  broadcastSuccess: jest.fn(),
+  broadcastFail: jest.fn(),
+  broadcastOperationDetailsClick: jest.fn(),
+};
+
+const mockManifest = {
+  id: "test-manifest",
+  name: "Test App",
+  url: "https://test.app",
+  homepageUrl: "https://test.app",
+  icon: "data:image/png;base64,test",
+  apiVersion: "1.0.0",
+  permissions: [],
+  domains: [],
+  categories: [],
+  platforms: ["desktop", "ios"] as AppPlatform[],
+  manifestVersion: "1.0.0",
+  branch: "stable" as AppBranch,
+  currencies: [],
+  visibility: "complete" as Visibility,
+  content: {
+    shortDescription: { en: "Test app" },
+    description: { en: "Test app description" },
+  },
+};
+
+const mockEthereumCurrency: CryptoCurrency = {
+  type: "CryptoCurrency",
+  id: "ethereum",
+  coinType: 60,
+  name: "Ethereum",
+  managerAppName: "Ethereum",
+  ticker: "ETH",
+  scheme: "ethereum",
+  color: "#0ebdcd",
+  symbol: "Ξ",
+  family: "evm",
+  blockAvgTime: 15,
+  units: [
+    {
+      name: "ether",
+      code: "ETH",
+      magnitude: 18,
+    },
+  ],
+  keywords: ["eth", "ethereum"],
+  explorerViews: [],
+  explorerId: "eth",
+};
+
+const mockTokenCurrency: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/acre_btc",
+  contractAddress: "0x1234567890123456789012345678901234567890",
+  parentCurrency: mockEthereumCurrency,
+  tokenType: "erc20",
+  name: "ACRE Bitcoin",
+  ticker: "acreBTC",
+  units: [
+    {
+      name: "ACRE Bitcoin",
+      code: "acreBTC",
+      magnitude: 8,
+    },
+  ],
+};
+
+const mockAccount: Account = {
+  type: "Account",
+  id: "js:2:ethereum:0x1234567890123456789012345678901234567890:ethereum",
+  seedIdentifier: "0x1234567890123456789012345678901234567890",
+  derivationMode: "",
+  index: 0,
+  freshAddress: "0x1234567890123456789012345678901234567890",
+  freshAddressPath: "44'/60'/0'/0/0",
+  used: false,
+  blockHeight: 0,
+  creationDate: new Date(),
+  balance: new BigNumber(0),
+  spendableBalance: new BigNumber(0),
+  operationsCount: 0,
+  operations: [],
+  pendingOperations: [],
+  currency: mockEthereumCurrency,
+  lastSyncDate: new Date(),
+  swapHistory: [],
+  balanceHistoryCache: {
+    HOUR: { latestDate: null, balances: [] },
+    DAY: { latestDate: null, balances: [] },
+    WEEK: { latestDate: null, balances: [] },
+  },
+  syncHash: "0x00000000",
+  subAccounts: [],
+  nfts: [],
+};
+
+jest.mock("@ledgerhq/coin-framework/account/index", () => ({
+  getParentAccount: jest.fn(),
+  getMainAccount: jest.fn(),
+  makeEmptyTokenAccount: jest.fn(),
+  isTokenAccount: jest.fn(),
+}));
+
+describe("ACRE Server Handlers", () => {
+  let mockUiHooks: any;
+  let serverHandlers: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockUiHooks = {
+      "custom.acre.messageSign": jest.fn().mockImplementation(({ onSuccess }) => {
+        onSuccess("0x1234567890abcdef");
+      }),
+      "custom.acre.transactionSign": jest.fn().mockImplementation(({ onSuccess }) => {
+        onSuccess({
+          operation: { hash: "0x1234567890abcdef" },
+          signature: "0xabcdef1234567890",
+        });
+      }),
+      "custom.acre.transactionBroadcast": jest.fn(),
+      "custom.acre.registerAccount": jest.fn().mockImplementation(({ onSuccess }) => {
+        onSuccess();
+      }),
+    };
+
+    // 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",
+    );
+    makeEmptyTokenAccount.mockReturnValue({
+      type: "TokenAccount",
+      id: "mock-token-account-id",
+      parentId: "mock-parent-id",
+      token: mockTokenCurrency,
+      balance: new BigNumber(0),
+      spendableBalance: new BigNumber(0),
+      creationDate: new Date(),
+      operationsCount: 0,
+      operations: [],
+      pendingOperations: [],
+      balanceHistoryCache: {
+        HOUR: { latestDate: null, balances: [] },
+        DAY: { latestDate: null, balances: [] },
+        WEEK: { latestDate: null, balances: [] },
+      },
+      swapHistory: [],
+    });
+    getMainAccount.mockReturnValue(mockAccount);
+    getParentAccount.mockReturnValue(undefined);
+
+    // Mock the converter functions
+    const { getAccountIdFromWalletAccountId, getWalletAPITransactionSignFlowInfos } =
+      jest.requireMock("../converters");
+    getAccountIdFromWalletAccountId.mockReturnValue(
+      "js:2:ethereum:0x1234567890123456789012345678901234567890:ethereum",
+    );
+    getWalletAPITransactionSignFlowInfos.mockReturnValue({
+      canEditFees: true,
+      liveTx: { family: "evm" },
+      hasFeesProvided: true,
+    });
+
+    // Mock the bridge
+    const { getAccountBridge } = jest.requireMock("../../bridge");
+    getAccountBridge.mockReturnValue({
+      broadcast: jest.fn().mockResolvedValue({ hash: "0x1234567890abcdef" }),
+    });
+
+    serverHandlers = handlers({
+      accounts: [mockAccount],
+      tracking: mockTracking,
+      manifest: mockManifest,
+      uiHooks: mockUiHooks,
+    });
+  });
+
+  describe("custom.acre.messageSign", () => {
+    it("should handle message signing request successfully", async () => {
+      const mockParams = {
+        accountId: "test-account-id",
+        message: { type: "SignIn", message: "test" },
+        derivationPath: "0/0",
+        options: { hwAppId: "test-app" },
+        meta: { test: "data" },
+      };
+
+      const mockSignature = "0x1234567890abcdef";
+      mockUiHooks["custom.acre.messageSign"].mockImplementation(({ onSuccess }) => {
+        onSuccess(mockSignature);
+      });
+
+      const result = await serverHandlers["custom.acre.messageSign"](mockParams);
+
+      expect(result).toEqual({
+        hexSignedMessage: "1234567890abcdef",
+      });
+      expect(mockTracking.signMessageRequested).toHaveBeenCalledWith(mockManifest);
+      expect(mockTracking.signMessageSuccess).toHaveBeenCalledWith(mockManifest);
+    });
+
+    it("should handle missing parameters", async () => {
+      const result = await serverHandlers["custom.acre.messageSign"](null);
+
+      expect(result).toEqual({
+        hexSignedMessage: "",
+      });
+      expect(mockTracking.signMessageNoParams).toHaveBeenCalledWith(mockManifest);
+    });
+
+    it("should handle account not found", async () => {
+      const mockParams = {
+        accountId: "non-existent-account",
+        message: { type: "SignIn", message: "test" },
+        derivationPath: "0/0",
+        options: {},
+        meta: {},
+      };
+
+      // Mock getAccountIdFromWalletAccountId to return null for non-existent account
+      const { getAccountIdFromWalletAccountId } = jest.requireMock("../converters");
+      getAccountIdFromWalletAccountId.mockReturnValueOnce(null);
+
+      await expect(serverHandlers["custom.acre.messageSign"](mockParams)).rejects.toThrow(
+        "accountId non-existent-account unknown",
+      );
+    });
+  });
+
+  describe("custom.acre.transactionSign", () => {
+    it("should handle transaction signing request successfully", async () => {
+      const mockParams = {
+        accountId: "test-account-id",
+        rawTransaction: "0x1234567890abcdef",
+        options: { hwAppId: "test-app" },
+        meta: { test: "data" },
+        tokenCurrency: "ethereum/erc20/test",
+      };
+
+      const mockSignedOperation = {
+        operation: { hash: "0x1234567890abcdef" },
+        signature: "0xabcdef1234567890",
+      };
+
+      mockUiHooks["custom.acre.transactionSign"].mockImplementation(({ onSuccess }) => {
+        onSuccess(mockSignedOperation);
+      });
+
+      const result = await serverHandlers["custom.acre.transactionSign"](mockParams);
+
+      expect(result).toEqual({
+        signedTransactionHex: "307861626364656631323334353637383930",
+      });
+      expect(mockTracking.signTransactionRequested).toHaveBeenCalledWith(mockManifest);
+      expect(mockTracking.signTransactionSuccess).toHaveBeenCalledWith(mockManifest);
+    });
+
+    it("should handle missing parameters", async () => {
+      const result = await serverHandlers["custom.acre.transactionSign"](null);
+
+      expect(result).toEqual({
+        signedTransactionHex: "",
+      });
+      expect(mockTracking.signTransactionNoParams).toHaveBeenCalledWith(mockManifest);
+    });
+  });
+
+  describe("custom.acre.transactionSignAndBroadcast", () => {
+    it("should handle transaction sign and broadcast successfully", async () => {
+      const mockParams = {
+        accountId: "test-account-id",
+        rawTransaction: "0x1234567890abcdef",
+        options: { hwAppId: "test-app" },
+        meta: { test: "data" },
+        tokenCurrency: "ethereum/erc20/test",
+      };
+
+      const mockSignedOperation = {
+        operation: { hash: "0x1234567890abcdef" },
+        signature: "0xabcdef1234567890",
+      };
+
+      mockUiHooks["custom.acre.transactionSign"].mockImplementation(({ onSuccess }) => {
+        onSuccess(mockSignedOperation);
+      });
+
+      const result = await serverHandlers["custom.acre.transactionSignAndBroadcast"](mockParams);
+
+      expect(result).toEqual({
+        transactionHash: "0x1234567890abcdef",
+      });
+    });
+
+    it("should handle missing parameters", async () => {
+      const result = await serverHandlers["custom.acre.transactionSignAndBroadcast"](null);
+
+      expect(result).toEqual({
+        transactionHash: "",
+      });
+      expect(mockTracking.signTransactionAndBroadcastNoParams).toHaveBeenCalledWith(mockManifest);
+    });
+  });
+
+  describe("custom.acre.registerYieldBearingEthereumAddress", () => {
+    const mockParams = {
+      ethereumAddress: "0x9876543210987654321098765432109876543210",
+      tokenContractAddress: "0x1234567890123456789012345678901234567890",
+      meta: { test: "data" },
+    };
+
+    it("should register new yield-bearing Ethereum address successfully on mobile", async () => {
+      const result =
+        await serverHandlers["custom.acre.registerYieldBearingEthereumAddress"](mockParams);
+
+      expect(result.success).toBe(true);
+      expect(result.accountName).toBe("Yield-bearing BTC on ACRE");
+      expect(result.ethereumAddress).toBe(mockParams.ethereumAddress);
+      expect(result.tokenContractAddress).toBe(mockParams.tokenContractAddress);
+
+      // Verify UI hook was called with correct parameters
+      expect(mockUiHooks["custom.acre.registerAccount"]).toHaveBeenCalledWith({
+        parentAccount: expect.objectContaining({
+          type: "Account",
+          id: expect.stringContaining("0x9876543210987654321098765432109876543210"),
+        }),
+        accountName: "Yield-bearing BTC on ACRE",
+        existingAccounts: [mockAccount],
+        onSuccess: expect.any(Function),
+        onError: expect.any(Function),
+      });
+    });
+
+    it("should register new yield-bearing Ethereum address successfully on desktop", async () => {
+      const desktopServerHandlers = handlers({
+        accounts: [mockAccount],
+        tracking: mockTracking,
+        manifest: mockManifest,
+        uiHooks: mockUiHooks,
+      });
+
+      const result = await (
+        desktopServerHandlers["custom.acre.registerYieldBearingEthereumAddress"] as any
+      )(mockParams);
+
+      expect(result.success).toBe(true);
+
+      expect(mockUiHooks["custom.acre.registerAccount"]).toHaveBeenCalledWith({
+        parentAccount: expect.objectContaining({
+          type: "Account",
+          id: expect.stringContaining("0x9876543210987654321098765432109876543210"),
+        }),
+        accountName: "Yield-bearing BTC on ACRE",
+        existingAccounts: [mockAccount],
+        onSuccess: expect.any(Function),
+        onError: expect.any(Function),
+      });
+    });
+
+    it("should handle existing account gracefully", async () => {
+      const existingAccount = {
+        ...mockAccount,
+        freshAddress: mockParams.ethereumAddress,
+      };
+
+      const serverHandlersWithExisting = handlers({
+        accounts: [existingAccount],
+        tracking: mockTracking,
+        manifest: mockManifest,
+        uiHooks: mockUiHooks,
+      });
+
+      const result = await (
+        serverHandlersWithExisting["custom.acre.registerYieldBearingEthereumAddress"] as any
+      )(mockParams);
+
+      expect(result.success).toBe(true);
+      expect(result.parentAccountId).toBe(existingAccount.id);
+      expect(result.tokenAccountId).toBe(existingAccount.id);
+      expect(mockUiHooks["custom.acre.registerAccount"]).not.toHaveBeenCalled();
+    });
+
+    it("should handle missing UI hook", async () => {
+      const serverHandlersWithoutHook = handlers({
+        accounts: [mockAccount],
+        tracking: mockTracking,
+        manifest: mockManifest,
+        uiHooks: {
+          ...mockUiHooks,
+          "custom.acre.registerAccount": undefined,
+        },
+      });
+
+      await expect(
+        (serverHandlersWithoutHook["custom.acre.registerYieldBearingEthereumAddress"] as any)(
+          mockParams,
+        ),
+      ).rejects.toThrow("No account registration UI hook available");
+    });
+
+    it("should validate Ethereum address format", async () => {
+      const invalidParams = {
+        ...mockParams,
+        ethereumAddress: "invalid-address",
+      };
+
+      await expect(
+        serverHandlers["custom.acre.registerYieldBearingEthereumAddress"](invalidParams),
+      ).rejects.toThrow("Invalid Ethereum address format");
+    });
+
+    it("should require either tokenContractAddress or tokenTicker", async () => {
+      const invalidParams = {
+        ethereumAddress: mockParams.ethereumAddress,
+        meta: mockParams.meta,
+      };
+
+      await expect(
+        serverHandlers["custom.acre.registerYieldBearingEthereumAddress"](invalidParams),
+      ).rejects.toThrow("Either tokenContractAddress or tokenTicker must be provided");
+    });
+  });
+});