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

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,83 @@
+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 {
+  search?: string;
+  currencyIds?: string[];
+}
+
+export interface PageParam {
+  cursor?: 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.infiniteQuery<AssetsDataWithPagination, GetAssetsDataParams, PageParam>({
+      query: ({ pageParam, queryArg }) => {
+        const params = {
+          pageSize: 100,
+          ...(pageParam?.cursor && { cursor: pageParam.cursor }),
+          // ...(queryArg?.currencyIds && queryArg?.currencyIds.length > 0 && { currencyIds: queryArg.currencyIds }),
+          ...(queryArg?.search && { search: queryArg.search }),
+        };
+
+        return {
+          url: "assets",
+          params,
+        };
+      },
+      providesTags: [AssetsDataTags.Assets],
+      transformResponse: transformAssetsResponse,
+      infiniteQueryOptions: {
+        initialPageParam: {
+          cursor: "",
+        },
+        getNextPageParam: lastPage => {
+          if (lastPage.pagination.nextCursor) {
+            return {
+              cursor: lastPage.pagination.nextCursor,
+            };
+          } else {
+            return undefined;
+          }
+        },
+      },
+    }),
+  }),
+});
+
+export const { useGetAssetsDataInfiniteQuery } = assetsDataApi;

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

@@ -0,0 +1,200 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { renderHook } from "@testing-library/react";
+import { useAssetsData } from "../useAssetsData";
+import { useGetAssetsDataInfiniteQuery } from "../../data/state-manager/api";
+
+jest.mock("../../data/state-manager/api", () => ({
+  useGetAssetsDataInfiniteQuery: jest.fn(),
+}));
+
+const mockuseGetAssetsDataInfiniteQuery = jest.mocked(useGetAssetsDataInfiniteQuery);
+
+const defaultMockValues = {
+  data: undefined,
+  isLoading: false,
+  error: undefined,
+  fetchNextPage: jest.fn(),
+  isSuccess: true,
+  isFetching: false,
+  isError: false,
+  fetchPreviousPage: jest.fn(),
+  isFetchingPreviousPage: false,
+  refetch: jest.fn(),
+  status: "success",
+};
+
+describe("useAssetsData", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return loading state when API is loading", () => {
+    mockuseGetAssetsDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+      isLoading: true,
+      status: "pending",
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.isLoading).toBe(true);
+    expect(result.current.data).toBe(undefined);
+  });
+
+  it("should return combined data from multiple pages", () => {
+    const mockPages = [
+      {
+        cryptoAssets: { bitcoin: { id: "bitcoin", name: "Bitcoin" } },
+        networks: { bitcoin: { id: "bitcoin", name: "Bitcoin" } },
+        cryptoOrTokenCurrencies: { bitcoin: { id: "bitcoin" } },
+        interestRates: {},
+        markets: {},
+        currenciesOrder: {
+          currenciesIds: ["bitcoin"],
+          metaCurrencyIds: ["bitcoin"],
+          key: "marketCap",
+          order: "desc",
+        },
+        pagination: { nextCursor: "cursor-2" },
+      },
+      {
+        cryptoAssets: { ethereum: { id: "ethereum", name: "Ethereum" } },
+        networks: { ethereum: { id: "ethereum", name: "Ethereum" } },
+        cryptoOrTokenCurrencies: { ethereum: { id: "ethereum" } },
+        interestRates: {},
+        markets: {},
+        currenciesOrder: {
+          currenciesIds: ["ethereum"],
+          metaCurrencyIds: ["ethereum"],
+          key: "marketCap",
+          order: "desc",
+        },
+        pagination: { nextCursor: undefined },
+      },
+    ];
+
+    mockuseGetAssetsDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+      data: { pages: mockPages, pageParams: [{ cursor: "" }, { cursor: "cursor-2" }] },
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.data).toEqual({
+      cryptoAssets: {
+        bitcoin: { id: "bitcoin", name: "Bitcoin" },
+        ethereum: { id: "ethereum", name: "Ethereum" },
+      },
+      networks: {
+        bitcoin: { id: "bitcoin", name: "Bitcoin" },
+        ethereum: { id: "ethereum", name: "Ethereum" },
+      },
+      cryptoOrTokenCurrencies: {
+        bitcoin: { id: "bitcoin" },
+        ethereum: { id: "ethereum" },
+      },
+      interestRates: {},
+      markets: {},
+      currenciesOrder: {
+        currenciesIds: ["bitcoin", "ethereum"],
+        metaCurrencyIds: ["bitcoin", "ethereum"],
+        key: "marketCap",
+        order: "desc",
+      },
+      pagination: { nextCursor: undefined },
+    });
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  it("should return error when API has error", () => {
+    const mockError = new Error("API Error");
+    mockuseGetAssetsDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+      data: undefined,
+      error: mockError,
+      isSuccess: false,
+      isError: true,
+      status: "error",
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.error).toBe(mockError);
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  it("should provide loadNext function when there's a nextCursor", () => {
+    const mockFetchNextPage = jest.fn();
+    const mockPages = [
+      {
+        cryptoAssets: {},
+        networks: {},
+        cryptoOrTokenCurrencies: {},
+        interestRates: {},
+        markets: {},
+        currenciesOrder: {
+          currenciesIds: [],
+          metaCurrencyIds: [],
+          key: "marketCap",
+          order: "desc",
+        },
+        pagination: { nextCursor: "next-cursor-456" },
+      },
+    ];
+
+    mockuseGetAssetsDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+      data: { pages: mockPages, pageParams: [{ cursor: "" }] },
+      fetchNextPage: mockFetchNextPage,
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.loadNext).toBeDefined();
+    result.current.loadNext?.();
+
+    expect(mockFetchNextPage).toHaveBeenCalled();
+  });
+
+  it("should not provide loadNext function when there's no nextCursor", () => {
+    const mockPages = [
+      {
+        cryptoAssets: {},
+        networks: {},
+        cryptoOrTokenCurrencies: {},
+        interestRates: {},
+        markets: {},
+        currenciesOrder: {
+          currenciesIds: [],
+          metaCurrencyIds: [],
+          key: "marketCap",
+          order: "desc",
+        },
+        pagination: { nextCursor: undefined },
+      },
+    ];
+
+    mockuseGetAssetsDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+      data: { pages: mockPages, pageParams: [{ cursor: "" }] },
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.loadNext).toBeUndefined();
+  });
+
+  it("should return undefined data when no pages exist", () => {
+    mockuseGetAssetsDataInfiniteQuery.mockReturnValue({
+      ...defaultMockValues,
+    });
+
+    const { result } = renderHook(() => useAssetsData({}));
+
+    expect(result.current.data).toBeUndefined();
+    expect(result.current.loadNext).toBeUndefined();
+  });
+});

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 }),
+  }));
+};