@ledgerhq/live-common 34.53.0-nightly.20251120023735 → 34.53.0

package/src/wallet-api/react.ts

@@ -1,38 +1,26 @@
 import { useMemo, useState, useEffect, useRef, useCallback, RefObject } from "react";
-import { useDispatch } from "react-redux";
 import semver from "semver";
 import { intervalToDuration } from "date-fns";
+
 import { Account, AccountLike, AnyMessage, Operation, SignedOperation } from "@ledgerhq/types-live";
-import {
-  WalletHandlers,
-  ServerConfig,
-  WalletAPIServer,
-  useWalletAPIServer as useWalletAPIServerRaw,
-} from "@ledgerhq/wallet-api-server";
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { WalletHandlers, ServerConfig, WalletAPIServer } from "@ledgerhq/wallet-api-server";
+import { useWalletAPIServer as useWalletAPIServerRaw } from "@ledgerhq/wallet-api-server/lib/react";
 import { Transport, Permission } from "@ledgerhq/wallet-api-core";
-import { first } from "rxjs/operators";
-import { getEnv } from "@ledgerhq/live-env";
-import { UserRefusedOnDevice } from "@ledgerhq/errors";
-import { WalletState } from "@ledgerhq/live-wallet/store";
-import { endpoints as calEndpoints } from "@ledgerhq/cryptoassets/cal-client/state-manager/api";
-import { ThunkDispatch, UnknownAction } from "@reduxjs/toolkit";
-import { InfiniteData } from "@reduxjs/toolkit/query";
-import type {
-  TokensDataWithPagination,
-  PageParam,
-} from "@ledgerhq/cryptoassets/lib/cal-client/state-manager/types";
-import { Subject } from "rxjs";
 import { StateDB } from "../hooks/useDBRaw";
+import { Observable, firstValueFrom, Subject } from "rxjs";
+import { first } from "rxjs/operators";
 import {
   accountToWalletAPIAccount,
   currencyToWalletAPICurrency,
-  setWalletApiIdForAccountId,
+  getAccountIdFromWalletAccountId,
 } from "./converters";
 import { isWalletAPISupportedCurrency } from "./helpers";
 import { WalletAPICurrency, AppManifest, WalletAPIAccount, WalletAPICustomHandlers } from "./types";
+
 import { getMainAccount, getParentAccount } from "../account";
-import { listSupportedCurrencies } from "../currencies";
-import { getCryptoAssetsStore } from "../bridge/crypto-assets";
+import { listCurrencies, findCryptoCurrencyById, getCryptoCurrencyById } from "../currencies";
+import { getCryptoAssetsStore } from "../bridge/crypto-assets/index";
 import { TrackingAPI } from "./tracking";
 import {
   bitcoinFamilyAccountGetXPubLogic,
@@ -49,8 +37,10 @@ import {
   signRawTransactionLogic,
 } from "./logic";
 import { getAccountBridge } from "../bridge";
+import { getEnv } from "@ledgerhq/live-env";
 import openTransportAsSubject, { BidirectionalEvent } from "../hw/openTransportAsSubject";
 import { AppResult } from "../hw/actions/app";
+import { UserRefusedOnDevice } from "@ledgerhq/errors";
 import { Transaction } from "../generated/types";
 import {
   DISCOVER_INITIAL_CATEGORY,
@@ -59,8 +49,8 @@ import {
 } from "./constants";
 import { DiscoverDB } from "./types";
 import { LiveAppManifest } from "../platform/types";
+import { WalletState } from "@ledgerhq/live-wallet/store";
 import { ModularDrawerConfiguration } from "./ModularDrawer/types";
-import { useCurrenciesUnderFeatureFlag } from "../modularDrawer/hooks/useCurrenciesUnderFeatureFlag";
 
 export function safeGetRefValue<T>(ref: RefObject<T>): NonNullable<T> {
   if (!ref.current) {
@@ -69,27 +59,75 @@ export function safeGetRefValue<T>(ref: RefObject<T>): NonNullable<T> {
   return ref.current;
 }
 
-export function useSetWalletAPIAccounts(accounts: AccountLike[]): void {
-  useEffect(() => {
-    accounts.forEach(account => {
-      setWalletApiIdForAccountId(account.id);
+export function useWalletAPIAccounts(
+  walletState: WalletState,
+  accounts: AccountLike[],
+): WalletAPIAccount[] {
+  return useMemo(() => {
+    return accounts.map(account => {
+      const parentAccount = getParentAccount(account, accounts);
+
+      return accountToWalletAPIAccount(walletState, account, parentAccount);
     });
-  }, [accounts]);
+  }, [walletState, accounts]);
 }
 
-export function useDAppManifestCurrencyIds(manifest: AppManifest) {
+export function useWalletAPICurrencies(): WalletAPICurrency[] {
+  return useMemo(() => {
+    return listCurrencies(true).reduce<WalletAPICurrency[]>((filtered, currency) => {
+      if (isWalletAPISupportedCurrency(currency)) {
+        filtered.push(currencyToWalletAPICurrency(currency));
+      }
+      return filtered;
+    }, []);
+  }, []);
+}
+
+export function useManifestCurrencies(manifest: AppManifest) {
   return useMemo(() => {
     return (
       manifest.dapp?.networks.map(network => {
-        return network.currency;
+        return getCryptoCurrencyById(network.currency);
       }) ?? []
     );
   }, [manifest.dapp?.networks]);
 }
 
+export function useGetAccountIds(
+  accounts$: Observable<WalletAPIAccount[]> | undefined,
+): Map<string, boolean> | undefined {
+  const [accounts, setAccounts] = useState<WalletAPIAccount[]>([]);
+
+  useEffect(() => {
+    if (!accounts$) {
+      return undefined;
+    }
+
+    const subscription = accounts$.subscribe(walletAccounts => {
+      setAccounts(walletAccounts);
+    });
+
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [accounts$]);
+
+  return useMemo(() => {
+    if (!accounts$) {
+      return undefined;
+    }
+
+    return accounts.reduce((accountIds, account) => {
+      accountIds.set(getAccountIdFromWalletAccountId(account.id), true);
+      return accountIds;
+    }, new Map());
+  }, [accounts, accounts$]);
+}
+
 export interface UiHook {
   "account.request": (params: {
-    currencyIds?: string[];
+    accounts$?: Observable<WalletAPIAccount[]>;
+    currencies: CryptoOrTokenCurrency[];
     areCurrenciesFiltered?: boolean;
     useCase?: string;
     drawerConfiguration?: ModularDrawerConfiguration;
@@ -162,10 +200,11 @@ export interface UiHook {
   }) => void;
 }
 
-export function usePermission(manifest: AppManifest): Omit<Permission, "currencyIds"> {
+export function usePermission(manifest: AppManifest): Permission {
   return useMemo(
     () => ({
-      methodIds: manifest.permissions,
+      currencyIds: manifest.currencies === "*" ? ["**"] : manifest.currencies,
+      methodIds: manifest.permissions as unknown as string[], // TODO remove when using the correct manifest type
     }),
     [manifest],
   );
@@ -195,7 +234,7 @@ export function useConfig({
       wallet,
       mevProtected,
     }),
-    [appId, mevProtected, tracking, userId, wallet],
+    [appId, tracking, userId, wallet],
   );
 }
 
@@ -303,19 +342,18 @@ export function useWalletAPIServer({
   onLoadError: () => void;
   widgetLoaded: boolean;
 } {
-  const dispatch = useDispatch<ThunkDispatch<any, any, UnknownAction>>();
-  const { deactivatedCurrencyIds } = useCurrenciesUnderFeatureFlag();
   const permission = usePermission(manifest);
   const transport = useTransport(webviewHook.postMessage);
   const [widgetLoaded, setWidgetLoaded] = useState(false);
 
-  // We need to set the wallet API account IDs mapping upfront
-  // If we don't want the map to be empty when requesting an account
-  useSetWalletAPIAccounts(accounts);
+  const walletAPIAccounts = useWalletAPIAccounts(walletState, accounts);
+  const walletAPICurrencies = useWalletAPICurrencies();
 
   const { server, onMessage } = useWalletAPIServerRaw({
     transport,
     config,
+    accounts: walletAPIAccounts,
+    currencies: walletAPICurrencies,
     permission,
     customHandlers,
   });
@@ -324,259 +362,52 @@ export function useWalletAPIServer({
     tracking.load(manifest);
   }, [tracking, manifest]);
 
-  // TODO: refactor each handler into its own logic function for clarity
-  useEffect(() => {
-    server.setHandler("currency.list", async ({ currencyIds }) => {
-      tracking.currencyListRequested(manifest);
-
-      try {
-        // 1. Parse manifest currency patterns to determine what to include
-        const manifestCurrencyIds = manifest.currencies === "*" ? ["**"] : manifest.currencies;
-
-        // 2. Apply query filter early - intersect with manifest patterns
-        const queryCurrencyIdsSet = currencyIds ? new Set(currencyIds) : undefined;
-        let effectiveCurrencyIds = manifestCurrencyIds;
-
-        if (queryCurrencyIdsSet) {
-          // If we have a query filter, narrow down what we need to fetch
-          effectiveCurrencyIds = manifestCurrencyIds.flatMap(manifestId => {
-            if (manifestId === "**") {
-              // Query can ask for anything, so use the query list
-              return [...queryCurrencyIdsSet];
-            } else if (manifestId.endsWith("/**")) {
-              // Pattern like "ethereum/**" - keep tokens from query that match this family
-              const family = manifestId.slice(0, -3);
-              return [...queryCurrencyIdsSet].filter(qId => qId.startsWith(`${family}/`));
-            } else if (queryCurrencyIdsSet.has(manifestId)) {
-              // Specific currency/token that's in the query
-              return [manifestId];
-            }
-            // Not in query, skip it
-            return [];
-          });
-        }
-
-        // 3. Parse effective currency IDs to determine what to fetch
-        const includeAllCurrencies = effectiveCurrencyIds.includes("**");
-        const specificCurrencies = new Set<string>();
-        const tokenFamilies = new Set<string>();
-        const specificTokenIds = new Set<string>();
-
-        for (const id of effectiveCurrencyIds) {
-          if (id === "**") {
-            // Already handled above
-            continue;
-          } else if (id.endsWith("/**")) {
-            // Pattern like "ethereum/**" or "solana/**" - include tokens for this family
-            const family = id.slice(0, -3);
-            tokenFamilies.add(family);
-            // Additionally include the parent currency itself
-            specificCurrencies.add(family);
-          } else if (id.includes("/")) {
-            // Specific token ID like "ethereum/erc20/usd__coin"
-            specificTokenIds.add(id);
-          } else {
-            // Specific currency like "bitcoin" or "ethereum"
-            specificCurrencies.add(id);
-          }
-        }
-
-        // 4. Gather all supported parent currencies
-        const allCurrencies = listSupportedCurrencies().reduce<WalletAPICurrency[]>((acc, c) => {
-          if (isWalletAPISupportedCurrency(c) && !deactivatedCurrencyIds.has(c.id))
-            acc.push(currencyToWalletAPICurrency(c));
-          return acc;
-        }, []);
-
-        // 5. Determine which currencies to include based on patterns
-        let includedCurrencies: WalletAPICurrency[] = [];
-        if (includeAllCurrencies) {
-          includedCurrencies = allCurrencies;
-        } else {
-          includedCurrencies = allCurrencies.filter(c => specificCurrencies.has(c.id));
-        }
-
-        // 6. Fetch specific tokens by ID if any
-        const specificTokens: WalletAPICurrency[] = [];
-        if (specificTokenIds.size > 0) {
-          const tokenPromises = [...specificTokenIds].map(async tokenId => {
-            const token = await getCryptoAssetsStore().findTokenById(tokenId);
-            return token ? currencyToWalletAPICurrency(token) : null;
-          });
-          const resolvedTokens = await Promise.all(tokenPromises);
-          specificTokens.push(...resolvedTokens.filter((t): t is WalletAPICurrency => t !== null));
-        }
-
-        // 7. Determine which token families to fetch (only if not already fetched as specific tokens)
-        const familiesToFetch = new Set<string>();
-        if (includeAllCurrencies) {
-          // Fetch tokens for all currency families
-          allCurrencies.forEach(c => {
-            if (c.type === "CryptoCurrency") familiesToFetch.add(c.family);
-          });
-        } else if (tokenFamilies.size > 0) {
-          // Only fetch tokens for families explicitly marked with /**
-          tokenFamilies.forEach(family => familiesToFetch.add(family));
-        }
-
-        // 8. Fetch tokens for relevant families
-        const fetchAllPagesForFamily = async (family: string) => {
-          const args = { networkFamily: family, pageSize: 1000 };
-          let hasNextPage = true;
-          let data: InfiniteData<TokensDataWithPagination, PageParam> | undefined;
-
-          while (hasNextPage) {
-            const querySub = dispatch(
-              calEndpoints.getTokensData.initiate(
-                args,
-                data ? { direction: "forward" } : undefined,
-              ),
-            );
-
-            try {
-              const result = await querySub;
-              data = result.data;
-              hasNextPage = result.hasNextPage;
-              if (result.error) throw result.error;
-            } finally {
-              querySub.unsubscribe();
-            }
-          }
-
-          return (data?.pages ?? []).flatMap(p => p.tokens);
-        };
-
-        const tokensByFamily = await Promise.all(
-          [...familiesToFetch].map(f => fetchAllPagesForFamily(f)),
-        );
-
-        // 9. Combine all results (no additional filter needed since we pre-filtered)
-        const result = tokensByFamily.reduce<WalletAPICurrency[]>(
-          (acc, tokens) => [...acc, ...tokens.map(t => currencyToWalletAPICurrency(t))],
-          [...includedCurrencies, ...specificTokens],
-        );
-
-        tracking.currencyListSuccess(manifest);
-        return result;
-      } catch (err) {
-        tracking.currencyListFail(manifest);
-        throw err;
-      }
-    });
-  }, [walletState, manifest, server, tracking, dispatch, deactivatedCurrencyIds]);
-
-  useEffect(() => {
-    server.setHandler("account.list", ({ currencyIds }) => {
-      tracking.accountListRequested(manifest);
-
-      try {
-        // 1. Parse manifest currency patterns to determine what to include
-        const manifestCurrencyIds = manifest.currencies === "*" ? ["**"] : manifest.currencies;
-
-        // 2. Apply query filter early - intersect with manifest patterns
-        const queryCurrencyIdsSet = currencyIds ? new Set(currencyIds) : undefined;
-        let effectiveCurrencyIds = manifestCurrencyIds;
-
-        if (queryCurrencyIdsSet) {
-          // If we have a query filter, narrow down what we need to check
-          effectiveCurrencyIds = manifestCurrencyIds.flatMap(manifestId => {
-            if (manifestId === "**") {
-              // Query can ask for anything, so use the query list
-              return [...queryCurrencyIdsSet];
-            } else if (manifestId.endsWith("/**")) {
-              // Pattern like "ethereum/**" - keep tokens from query that match this family
-              const family = manifestId.slice(0, -3);
-              return [...queryCurrencyIdsSet].filter(qId => qId.startsWith(`${family}/`));
-            } else if (queryCurrencyIdsSet.has(manifestId)) {
-              // Specific currency/token that's in the query
-              return [manifestId];
-            }
-            // Not in query, skip it
-            return [];
-          });
-        }
-
-        // 3. Build a set of allowed currency IDs based on effective patterns
-        const allowedCurrencyIds = new Set<string>();
-        const includeAllCurrencies = effectiveCurrencyIds.includes("**");
-        const tokenFamilyPrefixes = new Set<string>();
-
-        for (const id of effectiveCurrencyIds) {
-          if (id === "**") {
-            // Will match all currencies
-            continue;
-          } else if (id.endsWith("/**")) {
-            // Pattern like "ethereum/**" - store prefix for matching
-            const family = id.slice(0, -3);
-            tokenFamilyPrefixes.add(family);
-          } else {
-            // Specific currency/token ID
-            allowedCurrencyIds.add(id);
-          }
-        }
-
-        // 4. Filter accounts based on effective currency IDs
-        const wapiAccounts = accounts.reduce<WalletAPIAccount[]>((acc, account) => {
-          const parentAccount = getParentAccount(account, accounts);
-          const accountCurrencyId =
-            account.type === "TokenAccount" ? account.token.id : account.currency.id;
-          const parentCurrencyId =
-            account.type === "TokenAccount" ? account.token.parentCurrency.id : account.currency.id;
-
-          // Check if account currency ID matches the effective patterns
-          const isAllowed =
-            includeAllCurrencies ||
-            allowedCurrencyIds.has(accountCurrencyId) ||
-            tokenFamilyPrefixes.has(parentCurrencyId);
-
-          if (isAllowed) {
-            acc.push(accountToWalletAPIAccount(walletState, account, parentAccount));
-          }
-
-          return acc;
-        }, []);
-
-        tracking.accountListSuccess(manifest);
-        return wapiAccounts;
-      } catch (err) {
-        tracking.accountListFail(manifest);
-        throw err;
-      }
-    });
-  }, [walletState, manifest, server, tracking, uiAccountRequest, accounts]);
-
   useEffect(() => {
     if (!uiAccountRequest) return;
 
     server.setHandler(
       "account.request",
-      async ({ currencyIds, drawerConfiguration, areCurrenciesFiltered, useCase }) => {
+      async ({ accounts$, currencies$, drawerConfiguration, areCurrenciesFiltered, useCase }) => {
         tracking.requestAccountRequested(manifest);
+        const currencies = await firstValueFrom(currencies$);
+
         return new Promise((resolve, reject) => {
-          let done = false;
-          try {
-            uiAccountRequest({
-              currencyIds,
-              drawerConfiguration,
-              areCurrenciesFiltered,
-              useCase,
-              onSuccess: (account: AccountLike, parentAccount: Account | undefined) => {
-                if (done) return;
-                done = true;
-                tracking.requestAccountSuccess(manifest);
-                resolve(accountToWalletAPIAccount(walletState, account, parentAccount));
-              },
-              onCancel: () => {
-                if (done) return;
-                done = true;
-                tracking.requestAccountFail(manifest);
-                reject(new Error("Canceled by user"));
-              },
-            });
-          } catch (error) {
-            tracking.requestAccountFail(manifest);
-            reject(error);
-          }
+          (async () => {
+            try {
+              // handle no curencies selected case
+              const currencyList: CryptoOrTokenCurrency[] = [];
+              for (const { id } of currencies) {
+                const currency =
+                  findCryptoCurrencyById(id) || (await getCryptoAssetsStore().findTokenById(id));
+                if (currency) {
+                  currencyList.push(currency);
+                }
+              }
+
+              let done = false;
+              uiAccountRequest({
+                accounts$,
+                currencies: currencyList,
+                drawerConfiguration,
+                areCurrenciesFiltered,
+                useCase,
+                onSuccess: (account: AccountLike, parentAccount: Account | undefined) => {
+                  if (done) return;
+                  done = true;
+                  tracking.requestAccountSuccess(manifest);
+                  resolve(accountToWalletAPIAccount(walletState, account, parentAccount));
+                },
+                onCancel: () => {
+                  if (done) return;
+                  done = true;
+                  tracking.requestAccountFail(manifest);
+                  reject(new Error("Canceled by user"));
+                },
+              });
+            } catch (error) {
+              reject(error);
+            }
+          })();
         });
       },
     );
@@ -585,11 +416,11 @@ export function useWalletAPIServer({
   useEffect(() => {
     if (!uiAccountReceive) return;
 
-    server.setHandler("account.receive", ({ accountId, tokenCurrency }) =>
+    server.setHandler("account.receive", ({ account, tokenCurrency }) =>
       receiveOnAccountLogic(
         walletState,
         { manifest, accounts, tracking },
-        accountId,
+        account.id,
         (account, parentAccount, accountAddress) =>
           new Promise((resolve, reject) => {
             let done = false;
@@ -625,10 +456,10 @@ export function useWalletAPIServer({
   useEffect(() => {
     if (!uiMessageSign) return;
 
-    server.setHandler("message.sign", ({ accountId, message, options }) =>
+    server.setHandler("message.sign", ({ account, message, options }) =>
       signMessageLogic(
         { manifest, accounts, tracking },
-        accountId,
+        account.id,
         message.toString("hex"),
         (account: AccountLike, message: AnyMessage) =>
           new Promise((resolve, reject) => {
@@ -682,18 +513,13 @@ export function useWalletAPIServer({
 
     server.setHandler(
       "transaction.sign",
-      async ({ accountId, tokenCurrency, transaction, options }) => {
-        let currency: string | undefined;
+      async ({ account, tokenCurrency, transaction, options }) => {
         const signedOperation = await signTransactionLogic(
           { manifest, accounts, tracking },
-          accountId,
+          account.id,
           transaction,
-          (account, parentAccount, signFlowInfos) => {
-            currency =
-              account.type === "TokenAccount"
-                ? account.token.parentCurrency.id
-                : account.currency.id;
-            return new Promise((resolve, reject) => {
+          (account, parentAccount, signFlowInfos) =>
+            new Promise((resolve, reject) => {
               let done = false;
               return uiTxSign({
                 account,
@@ -713,12 +539,11 @@ export function useWalletAPIServer({
                   reject(error);
                 },
               });
-            });
-          },
+            }),
           tokenCurrency,
         );
 
-        return currency === "solana"
+        return account.currency === "solana"
           ? Buffer.from(signedOperation.signature, "hex")
           : Buffer.from(signedOperation.signature);
       },
@@ -730,10 +555,10 @@ export function useWalletAPIServer({
 
     server.setHandler(
       "transaction.signRaw",
-      async ({ accountId, transaction, broadcast, options }) => {
+      async ({ account, transaction, broadcast, options }) => {
         const signedOperation = await signRawTransactionLogic(
           { manifest, accounts, tracking },
-          accountId,
+          account.id,
           transaction,
           (account, parentAccount, tx) =>
             new Promise((resolve, reject) => {
@@ -763,7 +588,7 @@ export function useWalletAPIServer({
         if (broadcast) {
           hash = await broadcastTransactionLogic(
             { manifest, accounts, tracking },
-            accountId,
+            account.id,
             signedOperation,
             async (account, parentAccount, signedOperation) => {
               const bridge = getAccountBridge(account, parentAccount);
@@ -806,12 +631,12 @@ export function useWalletAPIServer({
 
     server.setHandler(
       "transaction.signAndBroadcast",
-      async ({ accountId, tokenCurrency, transaction, options }) => {
+      async ({ account, tokenCurrency, transaction, options }) => {
         const sponsored = transaction.family === "ethereum" && transaction.sponsored;
 
         const signedTransaction = await signTransactionLogic(
           { manifest, accounts, tracking },
-          accountId,
+          account.id,
           transaction,
           (account, parentAccount, signFlowInfos) =>
             new Promise((resolve, reject) => {
@@ -840,7 +665,7 @@ export function useWalletAPIServer({
 
         return broadcastTransactionLogic(
           { manifest, accounts, tracking },
-          accountId,
+          account.id,
           signedTransaction,
           async (account, parentAccount, signedOperation) => {
             const bridge = getAccountBridge(account, parentAccount);
@@ -1104,8 +929,8 @@ export function useWalletAPIServer({
       // retrofit of the exchange params to fit the old platform spec
       const request: CompleteExchangeRequest = {
         provider: params.provider,
-        fromAccountId: params.fromAccountId,
-        toAccountId: params.exchangeType === "SWAP" ? params.toAccountId : undefined,
+        fromAccountId: params.fromAccount.id,
+        toAccountId: params.exchangeType === "SWAP" ? params.toAccount.id : undefined,
         transaction: params.transaction,
         binaryPayload: params.binaryPayload.toString("hex"),
         signature: params.signature.toString("hex"),
@@ -1143,7 +968,7 @@ export function useWalletAPIServer({
   }, [uiExchangeComplete, accounts, manifest, server, tracking]);
 
   return {
-    widgetLoaded: widgetLoaded,
+    widgetLoaded,
     onMessage,
     onLoad,
     onReload,
@@ -1346,9 +1171,9 @@ export function useRecentlyUsed(
                 ...res,
                 usedAt: calculateTimeDiff(recentlyUsed.usedAt),
               }
-            : undefined;
+            : res;
         })
-        .filter((manifest): manifest is RecentlyUsedManifest => manifest !== undefined),
+        .filter(manifest => manifest !== undefined) as RecentlyUsedManifest[],
     [recentlyUsedManifestsDb, manifests],
   );
   const append = useCallback(

package/src/wallet-api/tracking.ts

@@ -241,28 +241,6 @@ export default function trackingWrapper(trackCall: TrackWalletAPI) {
       track("WalletAPI bitcoin family account xpub success", getEventData(manifest));
     },
 
-    // currency.list handler tracking
-    currencyListRequested: (manifest: AppManifest) => {
-      track("WalletAPI CurrencyList requested", getEventData(manifest));
-    },
-    currencyListSuccess: (manifest: AppManifest) => {
-      track("WalletAPI CurrencyList success", getEventData(manifest));
-    },
-    currencyListFail: (manifest: AppManifest) => {
-      track("WalletAPI CurrencyList fail", getEventData(manifest));
-    },
-
-    // account.list handler tracking
-    accountListRequested: (manifest: AppManifest) => {
-      track("WalletAPI AccountList requested", getEventData(manifest));
-    },
-    accountListSuccess: (manifest: AppManifest) => {
-      track("WalletAPI AccountList success", getEventData(manifest));
-    },
-    accountListFail: (manifest: AppManifest) => {
-      track("WalletAPI AccountList fail", getEventData(manifest));
-    },
-
     dappSendTransactionRequested: (manifest: AppManifest, trackingData: DAppTrackingData) => {
       track("dApp SendTransaction requested", { ...getEventData(manifest), ...trackingData });
     },

package/src/wallet-api/types.ts

@@ -83,8 +83,3 @@ export type DAppTrackingData = {
   currency: string;
   network: CryptoCurrency["id"];
 };
-
-export type AccountIdFormat = "uuid" | "encoded";
-
-/** @developer note uuid = wallet API id format, encoded = ledger wallet default format */
-export type AccountIdFormatsResponse = Record<string, AccountIdFormat>;