@ledgerhq/live-common 34.46.0 → 34.47.0-nightly.0

package/src/families/hedera/constants.ts

@@ -0,0 +1,2 @@
+// Encapsulate for LLD & LLM
+export * from "@ledgerhq/coin-hedera/constants";

package/src/families/hedera/setup.ts

@@ -4,17 +4,21 @@ import { createBridges } from "@ledgerhq/coin-hedera/bridge/index";
 import Transport from "@ledgerhq/hw-transport";
 import Hedera from "@ledgerhq/hw-app-hedera";
 import hederaResolver from "@ledgerhq/coin-hedera/signer/index";
-import type { Account, Bridge } from "@ledgerhq/types-live";
+import type {
+  TransactionStatus,
+  Transaction,
+  HederaAccount,
+} from "@ledgerhq/coin-hedera/types/index";
+import type { Bridge } from "@ledgerhq/types-live";
 import makeCliTools from "@ledgerhq/coin-hedera/test/cli";
 import { CreateSigner, createResolver, executeWithSigner } from "../../bridge/setup";
 import { Resolver } from "../../hw/getAddress/types";
-import { TransactionStatus, Transaction } from "@ledgerhq/coin-hedera/types/index";
 
 const createSigner: CreateSigner<Hedera> = (transport: Transport) => {
   return new Hedera(transport);
 };
 
-const bridge: Bridge<Transaction, Account, TransactionStatus> = createBridges(
+const bridge: Bridge<Transaction, HederaAccount, TransactionStatus> = createBridges(
   executeWithSigner(createSigner),
 );
 

package/src/families/solana/setup.ts

@@ -19,6 +19,7 @@ import { SolanaCoinConfig } from "@ledgerhq/coin-solana/config";
 import { getCryptoCurrencyById } from "../../currencies";
 import { signMessage } from "@ledgerhq/coin-solana/hw-signMessage";
 import { LegacySignerSolana } from "@ledgerhq/live-signer-solana";
+import { getCryptoAssetsStore } from "../../bridge/crypto-assets";
 
 const createSigner: CreateSigner<SolanaSigner> = (transport: Transport) =>
   new LegacySignerSolana(transport);
@@ -30,6 +31,7 @@ const getCurrencyConfig = () => {
 const bridge: Bridge<Transaction, SolanaAccount, TransactionStatus> = createBridges(
   executeWithSigner(createSigner),
   getCurrencyConfig,
+  getCryptoAssetsStore,
 );
 
 const messageSigner = {

package/src/families/sui/__snapshots__/bridge.integration.test.ts.snap

@@ -14,9 +14,10 @@ exports[`sui currency bridge scanAccounts sui seed 1 1`] = `
     "pendingOperations": [],
     "seedIdentifier": "e5fb8c817b97e9e9aec677b9e822e8a60c7471624f36b701c94560b88195a8e7",
     "spendableBalance": "102696240",
+    "subAccounts": [],
     "suiResources": {},
     "swapHistory": [],
-    "syncHash": undefined,
+    "syncHash": "6p9XjoTwZ81o9xTkodgswDbETbrN5Lkv1b2shBN4p99s",
     "used": true,
   },
   {
@@ -31,6 +32,7 @@ exports[`sui currency bridge scanAccounts sui seed 1 1`] = `
     "pendingOperations": [],
     "seedIdentifier": "e5fb8c817b97e9e9aec677b9e822e8a60c7471624f36b701c94560b88195a8e7",
     "spendableBalance": "0",
+    "subAccounts": [],
     "suiResources": {},
     "swapHistory": [],
     "syncHash": undefined,

package/src/families/sui/constants.ts

@@ -0,0 +1,2 @@
+// Encapsulate for LLD et LLM
+export * from "@ledgerhq/coin-sui/constants";

package/src/families/sui/logic.ts

@@ -0,0 +1,2 @@
+// Encapsulate for LLD et LLM
+export * from "@ledgerhq/coin-sui/logic";

package/src/families/sui/react.ts

@@ -0,0 +1,115 @@
+import { useEffect, useMemo, useState } from "react";
+import { FIGMENT_SUI_VALIDATOR_ADDRESS } from "@ledgerhq/coin-sui/constants";
+import { BigNumber } from "bignumber.js";
+import { SuiAccount, SuiResources, SuiValidator, MappedStake } from "./types";
+import { getAccountCurrency } from "../../account";
+import { Unit } from "@ledgerhq/types-cryptoassets";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { getCurrentSuiPreloadData } from "@ledgerhq/coin-sui/preload";
+import { getOperationExtra } from "@ledgerhq/coin-sui/getOperationExtra";
+import { OperationType } from "@ledgerhq/types-live";
+
+export function useSuiMappedStakingPositions(account: SuiAccount) {
+  const { validators } = getCurrentSuiPreloadData();
+  const stakingPositions = account.suiResources?.stakes;
+
+  const unit = getAccountCurrency(account).units[0];
+
+  return useMemo(
+    () => mapStakingPositions(stakingPositions ?? [], validators, unit),
+    [stakingPositions, validators, unit],
+  );
+}
+
+export function useGetExtraDetails(account: SuiAccount, type: OperationType, digest: string) {
+  if (!account.suiResources) {
+    account.suiResources = {};
+  }
+  if (!account.suiResources.cachedOps) {
+    account.suiResources.cachedOps = {};
+  }
+  const cache = account.suiResources.cachedOps;
+  const [data, setData] = useState(cache[digest]);
+
+  useEffect(() => {
+    if (type !== "DELEGATE" && type !== "UNDELEGATE") return;
+    if (data) return;
+    getOperationExtra(digest).then(result => {
+      setData(result);
+      cache[digest] = result;
+    });
+  }, [data, digest, cache, type]);
+
+  return data;
+}
+
+export function useLedgerFirstShuffledValidatorsSui(search: string) {
+  const { validators: unorderedValidators } = getCurrentSuiPreloadData();
+  const validators = reorderValidators(unorderedValidators);
+  return useMemo(() => {
+    if (validators.length === 0 || !search || search === "") {
+      return validators;
+    }
+
+    const lowercaseSearch = search.toLowerCase();
+
+    const filtered = validators.filter(
+      validator =>
+        validator.suiAddress?.toLowerCase().includes(lowercaseSearch) ||
+        validator.name.toLowerCase().includes(lowercaseSearch),
+    );
+
+    return filtered;
+  }, [validators, search]);
+}
+
+function reorderValidators(validators: SuiValidator[]): SuiValidator[] {
+  const sortedValidators = [...validators].sort((a, b) =>
+    new BigNumber(b.stakingPoolSuiBalance).minus(new BigNumber(a.stakingPoolSuiBalance)).toNumber(),
+  );
+
+  // move Ledger validator to the first position
+  const ledgerValidator = sortedValidators.find(
+    v => v.suiAddress === FIGMENT_SUI_VALIDATOR_ADDRESS,
+  );
+
+  if (ledgerValidator) {
+    const sortedValidatorsLedgerFirst = sortedValidators.filter(
+      v => v.suiAddress !== FIGMENT_SUI_VALIDATOR_ADDRESS,
+    );
+    sortedValidatorsLedgerFirst.unshift(ledgerValidator);
+
+    return sortedValidatorsLedgerFirst;
+  }
+
+  return sortedValidators;
+}
+
+type Stake = Required<SuiResources>["stakes"];
+
+export const mapStakingPositions = (
+  stakingPositions: Stake,
+  validators: SuiValidator[],
+  unit: Unit,
+): MappedStake[] => {
+  const data = stakingPositions.flatMap(sp =>
+    sp.stakes.map(s => ({ ...s, validatorAddress: sp.validatorAddress })),
+  );
+  return data.map<MappedStake>(sp => {
+    const rank = validators.findIndex(v => v.suiAddress === sp.validatorAddress);
+    const validator = validators[rank] ?? sp;
+    const formatConfig = {
+      disableRounding: false,
+      alwaysShowSign: false,
+      showCode: true,
+    };
+
+    return {
+      ...sp,
+      rank,
+      validator,
+      stakedSuiId: sp.stakedSuiId,
+      formattedAmount: formatCurrencyUnit(unit, BigNumber(sp.principal), formatConfig),
+    };
+  });
+};

package/src/families/sui/types.ts

@@ -0,0 +1,2 @@
+// Encapsulate for LLD et LLM
+export * from "@ledgerhq/coin-sui/types";

package/src/families/tron/data.mock.ts

@@ -1,7 +1,7 @@
 import { fromAccountRaw } from "../../account/serialization";
 import { TronAccount } from "@ledgerhq/coin-tron/types/index";
 import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
-import { CryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/type";
+import type { CryptoAssetsStore } from "@ledgerhq/types-live";
 
 export const __NEXT_REWARD_DATE__ = new Date(Date.now() - 6 * 60 * 60 * 1000);
 

package/src/featureFlags/defaultFeatures.ts

@@ -625,6 +625,7 @@ export const DEFAULT_FEATURES: Features = {
     },
   },
   lldModularDrawerBackendData: DEFAULT_FEATURE,
+  llmModularDrawerBackendData: DEFAULT_FEATURE,
   llmModularDrawer: {
     ...DEFAULT_FEATURE,
     params: {

package/src/market/utils/countervalueFormatter.ts

@@ -12,7 +12,6 @@ export const counterValueFormatter = ({
   if (!value) {
     return "-";
   }
-
   return new Intl.NumberFormat(locale, {
     style: currency ? "currency" : "decimal",
     currency,

package/src/market/utils/types.ts

@@ -144,6 +144,7 @@ export type MarketItemResponse = {
   circulatingSupply: number;
   fullyDilutedValuation: number;
   high24h: number;
+  currencyId: string;
   id: string;
   image: string;
   ledgerIds: string[];
@@ -167,6 +168,9 @@ export type MarketItemResponse = {
   totalVolume: number;
   updatedAt: string;
 };
+
+export type PartialMarketItemResponse = Partial<MarketItemResponse>;
+
 export type MarketItemPerformer = {
   id: string;
   name: string;

package/src/modularDrawer/__mocks__/currencies.mock.ts

@@ -1,5 +1,5 @@
-import { getCryptoCurrencyById } from "@ledgerhq/live-common/currencies/index";
 import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { getCryptoCurrencyById } from "../../currencies";
 
 export const mockBtcCryptoCurrency = getCryptoCurrencyById("bitcoin");
 export const mockEthCryptoCurrency = getCryptoCurrencyById("ethereum");

package/src/modularDrawer/__mocks__/useGroupedCurrenciesByProvider.mock.ts

@@ -1,4 +1,4 @@
-import { LoadingStatus } from "@ledgerhq/live-common/deposit/type";
+import { LoadingStatus } from "../../deposit/type";
 import {
   arbitrumToken,
   mockArbitrumCryptoCurrency,

package/src/modularDrawer/data/entities/index.ts

@@ -0,0 +1,79 @@
+import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { ApiAsset } from "@ledgerhq/cryptoassets";
+import { PartialMarketItemResponse } from "@ledgerhq/live-common/market/utils/types";
+
+// Types for crypto asset metadata
+export interface CryptoAssetMeta {
+  /** Asset identifier */
+  id: string;
+  /** Asset ticker symbol */
+  ticker: string;
+  /** Asset display name */
+  name: string;
+  /** Map of network IDs to their corresponding asset IDs */
+  assetsIds: Record<string, string>;
+}
+
+// Types for network information
+export interface NetworkInfo {
+  /** Network identifier */
+  id: string;
+  /** Network display name */
+  name: string;
+}
+
+// Types for interest rate data
+export interface InterestRate {
+  /** Currency identifier */
+  currencyId: string;
+  /** Interest rate value */
+  rate: number;
+  /** Type of rate (NRR, APR, APY, etc.) */
+  type: string;
+  /** Timestamp when the rate was fetched */
+  fetchAt: string;
+}
+
+// Types for currency ordering
+export interface CurrenciesOrder {
+  /** Sorting key (e.g., "marketCap") */
+  key: string;
+  /** Sort order (e.g., "desc") */
+  order: string;
+  /** Ordered list of currency IDs */
+  currenciesIds: string[];
+  /** Ordered list of meta-currency IDs */
+  metaCurrencyIds: string[];
+}
+
+// Types for raw API response (before transformation)
+export interface RawApiResponse {
+  /** Grouped crypto assets by meta-currency */
+  cryptoAssets: Record<string, CryptoAssetMeta>;
+  /** Network information */
+  networks: Record<string, NetworkInfo>;
+  /** Raw crypto currencies and token currencies from API */
+  cryptoOrTokenCurrencies: Record<string, ApiAsset>;
+  /** Interest rates for various currencies */
+  interestRates: Record<string, InterestRate>;
+  /** Market data for currencies */
+  markets: Record<string, PartialMarketItemResponse>;
+  /** Currency ordering information */
+  currenciesOrder: CurrenciesOrder;
+}
+
+// Types for transformed API response (after transformation)
+export interface AssetsData {
+  /** Grouped crypto assets by meta-currency */
+  cryptoAssets: Record<string, CryptoAssetMeta>;
+  /** Network information */
+  networks: Record<string, NetworkInfo>;
+  /** Transformed crypto currencies and token currencies compatible with Ledger Live */
+  cryptoOrTokenCurrencies: Record<string, CryptoOrTokenCurrency>;
+  /** Interest rates for various currencies */
+  interestRates: Record<string, InterestRate>;
+  /** Market data for currencies */
+  markets: Record<string, PartialMarketItemResponse>;
+  /** Currency ordering information */
+  currenciesOrder: CurrenciesOrder;
+}

package/src/modularDrawer/data/state-manager/api.ts

@@ -0,0 +1,62 @@
+import { createApi, fetchBaseQuery, FetchBaseQueryMeta } from "@reduxjs/toolkit/query/react";
+import { convertApiAssets } from "@ledgerhq/cryptoassets";
+import { AssetsData, RawApiResponse } from "../entities";
+import { getEnv } from "@ledgerhq/live-env";
+
+export enum AssetsDataTags {
+  Assets = "Assets",
+}
+
+export interface GetAssetsDataParams {
+  cursor?: string;
+  search?: string;
+  currencyIds?: string[];
+}
+
+export interface AssetsDataWithPagination extends AssetsData {
+  pagination: {
+    nextCursor?: string;
+  };
+}
+
+function transformAssetsResponse(
+  response: RawApiResponse,
+  meta?: FetchBaseQueryMeta,
+): AssetsDataWithPagination {
+  const enrichedCryptoOrTokenCurrencies = convertApiAssets(response.cryptoOrTokenCurrencies);
+
+  const nextCursor = meta?.response?.headers.get("x-ledger-next") || undefined;
+
+  return {
+    ...response,
+    cryptoOrTokenCurrencies: enrichedCryptoOrTokenCurrencies,
+    pagination: {
+      nextCursor,
+    },
+  };
+}
+
+export const assetsDataApi = createApi({
+  reducerPath: "assetsDataApi",
+  baseQuery: fetchBaseQuery({
+    baseUrl: __DEV__ ? getEnv("DADA_API_STAGING") : getEnv("DADA_API_PROD"),
+  }),
+  tagTypes: [AssetsDataTags.Assets],
+  endpoints: build => ({
+    getAssetsData: build.query<AssetsDataWithPagination, GetAssetsDataParams>({
+      query: ({ cursor, search, currencyIds: _currencyIds }) => ({
+        url: "assets",
+        params: {
+          ...(cursor && { cursor }),
+          ...(search && { search }),
+          // ...(currencyIds && currencyIds.length > 0 && { currencyIds }),
+          pageSize: 100,
+        },
+      }),
+      providesTags: [AssetsDataTags.Assets],
+      transformResponse: transformAssetsResponse,
+    }),
+  }),
+});
+
+export const { useGetAssetsDataQuery } = assetsDataApi;

package/src/modularDrawer/hooks/__test__/useAssetsData.test.ts

@@ -0,0 +1,139 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { renderHook } from "@testing-library/react";
+import { useAssetsData } from "../useAssetsData";
+import { useGetAssetsDataQuery } from "../../data/state-manager/api";
+
+jest.mock("../../data/state-manager/api", () => ({
+  useGetAssetsDataQuery: jest.fn(),
+}));
+
+const mockSetCursor = jest.fn();
+jest.mock("react", () => ({
+  ...jest.requireActual("react"),
+  useState: jest.fn(() => [undefined, mockSetCursor]),
+  useCallback: jest.fn(fn => fn),
+  useMemo: jest.fn(fn => fn()),
+}));
+
+const mockUseGetAssetsDataQuery = jest.mocked(useGetAssetsDataQuery);
+
+describe("useAssetsData", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return loading state when API is loading", () => {
+    mockUseGetAssetsDataQuery.mockReturnValue({
+      data: undefined,
+      isLoading: true,
+      error: undefined,
+      refetch: jest.fn(),
+      isFetching: false,
+      isSuccess: false,
+      isError: false,
+      currentData: undefined,
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.isLoading).toBe(true);
+    expect(result.current.data).toBe(undefined);
+    expect(result.current.hasMore).toBe(false);
+  });
+
+  it("should return data and hasMore when API returns data", () => {
+    const mockData = {
+      assetsData: [],
+      pagination: { nextCursor: "test-cursor" },
+    };
+    mockUseGetAssetsDataQuery.mockReturnValue({
+      data: mockData,
+      isLoading: false,
+      error: undefined,
+      refetch: jest.fn(),
+      isFetching: false,
+      isSuccess: true,
+      isError: false,
+      currentData: mockData,
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.data).toBe(mockData);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.hasMore).toBe(true);
+  });
+
+  it("should return error when API has error", () => {
+    const mockError = new Error("API Error");
+    mockUseGetAssetsDataQuery.mockReturnValue({
+      data: undefined,
+      isLoading: false,
+      error: mockError,
+      refetch: jest.fn(),
+      isFetching: false,
+      isSuccess: false,
+      isError: true,
+      currentData: undefined,
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.error).toBe(mockError);
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  it("should call setCursor when loadNext is called and there's a nextCursor", () => {
+    const nextCursor = "next-cursor-456";
+    mockUseGetAssetsDataQuery.mockReturnValue({
+      data: {
+        assetsData: [],
+        pagination: { nextCursor },
+      },
+      isLoading: false,
+      error: undefined,
+      refetch: jest.fn(),
+      isFetching: false,
+      isSuccess: true,
+      isError: false,
+      currentData: {
+        assetsData: [],
+        pagination: { nextCursor },
+      },
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    result.current.loadNext();
+
+    expect(mockSetCursor).toHaveBeenCalledWith(nextCursor);
+  });
+
+  it("should not call setCursor when there's no nextCursor", () => {
+    mockUseGetAssetsDataQuery.mockReturnValue({
+      data: {
+        assetsData: [],
+        pagination: { nextCursor: undefined },
+      },
+      isLoading: false,
+      error: undefined,
+      refetch: jest.fn(),
+      isFetching: false,
+      isSuccess: true,
+      isError: false,
+      currentData: {
+        assetsData: [],
+        pagination: { nextCursor: undefined },
+      },
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    result.current.loadNext();
+
+    expect(mockSetCursor).not.toHaveBeenCalled();
+  });
+});

package/src/modularDrawer/hooks/modules/useAssetAccountCounts.tsx

@@ -0,0 +1,36 @@
+import { Observable } from "rxjs";
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { getAccountTuplesForCurrency } from "../../../utils/getAccountTuplesForCurrency";
+import type { Account } from "@ledgerhq/types-live";
+import { WalletAPIAccount } from "../../../wallet-api/types";
+
+type AccountModuleParams = {
+  assets: CryptoOrTokenCurrency[];
+  nestedAccounts: Account[];
+  accountIds: Map<string, boolean> | undefined;
+  formatLabel: (count: number) => string;
+  accounts$?: Observable<WalletAPIAccount[]>;
+};
+
+export type AssetCountItem = {
+  asset: CryptoOrTokenCurrency;
+  label: string;
+  count: number;
+};
+
+export const useAssetAccountCounts = ({
+  assets,
+  nestedAccounts,
+  accountIds,
+  formatLabel,
+}: AccountModuleParams): AssetCountItem[] =>
+  assets
+    .map(asset => {
+      const { length } = getAccountTuplesForCurrency(asset, nestedAccounts, accountIds);
+      return {
+        asset,
+        label: formatLabel(length),
+        count: length,
+      };
+    })
+    .sort((a, b) => b.count - a.count);

package/src/modularDrawer/hooks/modules/useLeftApyModule.tsx

@@ -0,0 +1,26 @@
+import React from "react";
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { ApyType } from "../../types";
+
+const createApyItem = ({
+  value,
+  type,
+  ApyIndicator,
+}: {
+  value: number;
+  type: ApyType;
+  ApyIndicator: React.ComponentType<{ value: number; type: ApyType }>;
+}) => <ApyIndicator value={value} type={type} />;
+
+export const useLeftApyModule = (
+  assets: CryptoOrTokenCurrency[],
+  ApyIndicator: React.ComponentType<{ value: number; type: ApyType }>,
+) => {
+  const value = 5.11; // TODO to be retrieved from DADA
+  const type = "APY"; // TODO to be retrieved from DADA
+
+  return assets.map(asset => ({
+    ...asset,
+    leftElement: createApyItem({ value, type, ApyIndicator }),
+  }));
+};

package/src/modularDrawer/hooks/useAssetsData.ts

@@ -0,0 +1,36 @@
+import { useState, useCallback } from "react";
+import { useGetAssetsDataQuery } from "../data/state-manager/api";
+
+export function useAssetsData({
+  search,
+  currencyIds,
+}: {
+  search?: string;
+  currencyIds?: string[];
+}) {
+  const [cursor, setCursor] = useState<string | undefined>(undefined);
+  const { data, error, isLoading, isSuccess } = useGetAssetsDataQuery({
+    cursor,
+    search,
+    currencyIds,
+  });
+
+  const loadNext = useCallback(() => {
+    const nextCursor = data?.pagination?.nextCursor;
+    if (nextCursor) {
+      setCursor(nextCursor);
+    }
+  }, [data?.pagination?.nextCursor]);
+
+  const hasMore = Boolean(data?.pagination?.nextCursor);
+
+  return {
+    data,
+    error,
+    isLoading,
+    isSuccess,
+    hasMore,
+    cursor,
+    loadNext,
+  };
+}

package/src/modularDrawer/types.ts

@@ -0,0 +1 @@
+export type ApyType = "NRR" | "APY" | "APR";