@ledgerhq/live-common 34.51.0-nightly.9 → 34.51.0

package/src/bridge/generic-alpaca/tests/prepareTransaction.test.ts

@@ -1,254 +1,172 @@
 import { genericPrepareTransaction } from "../prepareTransaction";
 import { getAlpacaApi } from "../alpaca";
+import { transactionToIntent } from "../utils";
 import BigNumber from "bignumber.js";
-import * as accountModule from "@ledgerhq/coin-framework/account/index";
-import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { Account } from "@ledgerhq/types-live";
 
 jest.mock("../alpaca", () => ({
   getAlpacaApi: jest.fn(),
 }));
 
+jest.mock("../utils", () => ({
+  transactionToIntent: jest.fn(),
+}));
+
 describe("genericPrepareTransaction", () => {
   const network = "testnet";
   const kind = "local";
 
+  const account = {
+    id: "test-account",
+    address: "0xabc",
+    currency: { id: "ethereum" },
+  } as any;
+
+  const baseTransaction = {
+    amount: new BigNumber(100_000),
+    fees: new BigNumber(500),
+    recipient: "0xrecipient",
+    family: "family",
+  };
+
+  const txIntent = { mock: "intent" };
+
   beforeEach(() => {
     jest.clearAllMocks();
+    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
   });
 
-  it("embeds assets info, if existing", async () => {
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 500n }),
-      getAssetFromToken: jest.fn().mockImplementation((token, owner) => {
-        return {
-          assetOwner: owner,
-          assetReference: token.contractAddress,
-        };
-      }),
-    });
-    jest.spyOn(accountModule, "decodeTokenAccountId").mockImplementation(accountId => {
-      const token =
-        accountId === "ethereum_usdc_sub_account"
-          ? ({ contractAddress: "usdc_contract" } as TokenCurrency)
-          : undefined;
+  it("updates fees if they differ", async () => {
+    const newFee = new BigNumber(700);
 
-      return { accountId, token };
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
     });
 
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const resultUsdcToken = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] }, freshAddress: "0xabc" } as Account,
-      {
-        amount: new BigNumber(100_000),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-        subAccountId: "ethereum_usdc_sub_account",
-      },
-    );
+    const result = await prepareTransaction(account, { ...baseTransaction });
 
-    expect(resultUsdcToken).toEqual({
-      amount: new BigNumber(100_000),
-      fees: new BigNumber(500),
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "usdc_contract",
-      assetOwner: "0xabc",
-      subAccountId: "ethereum_usdc_sub_account",
-    });
-
-    const resultUnknownToken = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] } } as Account,
-      {
-        amount: new BigNumber(100_000),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-        subAccountId: "ethereum_unknown_sub_account",
-      },
+    expect((result as any).fees.toString()).toBe(newFee.toString());
+    expect(transactionToIntent).toHaveBeenCalledWith(
+      account,
+      expect.objectContaining(baseTransaction),
+      undefined,
     );
-
-    expect(resultUnknownToken).toEqual({
-      amount: new BigNumber(100_000),
-      fees: new BigNumber(500),
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "",
-      assetOwner: "",
-      subAccountId: "ethereum_unknown_sub_account",
-    });
   });
 
-  it.each([
-    ["all native amount", { useAllAmount: true }, new BigNumber(42)],
-    ["all native amount on staking scenarios", { mode: "stake" }, new BigNumber(42)],
-    ["all native amount on unstaking scenarios", { mode: "unstake" }, new BigNumber(42)],
-    [
-      "all token amount",
-      { subAccountId: "ethereum_usdc_sub_account", useAllAmount: true },
-      new BigNumber(5),
-    ],
-    [
-      "all token amount on staking scenarios",
-      { subAccountId: "ethereum_usdc_sub_account", mode: "stake" },
-      new BigNumber(5),
-    ],
-    [
-      "all token amount on unstaking scenarios",
-      { subAccountId: "ethereum_usdc_sub_account", mode: "unstake" },
-      new BigNumber(5),
-    ],
-  ] as const)("uses %s, updating the amount", async (_s, partialTransaction, expectedAmount) => {
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 8n }),
-      getAssetFromToken: jest.fn().mockImplementation((token, owner) => {
-        return {
-          assetOwner: owner,
-          assetReference: token.contractAddress,
-        };
-      }),
-    });
-    jest.spyOn(accountModule, "decodeTokenAccountId").mockImplementation(accountId => {
-      const token =
-        accountId === "ethereum_usdc_sub_account"
-          ? ({ contractAddress: "usdc_contract" } as TokenCurrency)
-          : undefined;
+  it("returns original transaction if fees are the same", async () => {
+    const sameFee = baseTransaction.fees;
 
-      return { accountId, token };
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: sameFee }),
     });
 
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(
-      {
-        currency: { id: "ethereum", units: [{}] },
-        spendableBalance: new BigNumber(50),
-        subAccounts: [{ id: "ethereum_usdc_sub_account", spendableBalance: new BigNumber(5) }],
-      } as Account,
-      {
-        amount: new BigNumber(0),
-        recipient: "0xrecipient",
-        family: "family",
-        ...partialTransaction,
-      },
-    );
+    const result = await prepareTransaction(account, baseTransaction);
 
-    expect(result).toMatchObject({
-      amount: expectedAmount,
-      fees: new BigNumber(8),
-      recipient: "0xrecipient",
-      family: "family",
-    });
+    expect(result).toBe(baseTransaction);
   });
 
-  it("updates fees from the estimation", async () => {
+  it("sets fee if original fees are undefined", async () => {
+    const newFee = new BigNumber(1234);
     (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 700n }),
+      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
     });
 
+    const txWithoutFees = { ...baseTransaction, fees: undefined as any };
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] } } as Account,
-      {
-        amount: new BigNumber(100_000),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-      },
-    );
+    const result = await prepareTransaction(account, txWithoutFees);
 
-    expect(result).toEqual({
-      amount: new BigNumber(100_000),
-      fees: new BigNumber(700),
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "",
-      assetOwner: "",
-    });
+    expect((result as any).fees.toString()).toBe(newFee.toString());
+    expect(result).not.toBe(txWithoutFees);
   });
 
-  it("updates fees from the existing custom", async () => {
+  it("returns original if fees are BigNumber-equal but different instance", async () => {
+    const sameValue = new BigNumber(baseTransaction.fees.toString()); // different instance
     (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 700n }),
+      estimateFees: jest.fn().mockResolvedValue({ value: sameValue }),
     });
 
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] } } as Account,
-      {
-        amount: new BigNumber(100_000),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-        customFees: { parameters: { fees: new BigNumber(600) } },
-      },
-    );
+    const result = await prepareTransaction(account, baseTransaction);
 
-    expect(result).toEqual({
-      amount: new BigNumber(100_000),
-      fees: new BigNumber(600),
-      customFees: { parameters: { fees: new BigNumber(600) } },
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "",
-      assetOwner: "",
-    });
+    expect(result).toBe(baseTransaction); // still same reference
   });
 
-  it("propagates estimated 'storageLimit'", async () => {
+  it("propagates storageLimit from second estimation", async () => {
+    const estimatedFee = new BigNumber(491);
+
+    const estimateFeesFirstCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 300 },
+    });
+
+    const estimateFeesSecondCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 0 },
+    });
+
     (getAlpacaApi as jest.Mock).mockReturnValue({
       estimateFees: jest
         .fn()
-        .mockResolvedValue({ value: 700n, parameters: { storageLimit: 277n } }),
+        .mockImplementationOnce(() => estimateFeesFirstCall())
+        .mockImplementationOnce(() => estimateFeesSecondCall()),
     });
 
+    const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] } } as Account,
-      {
-        amount: new BigNumber(100_000),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-      },
+    const result = await prepareTransaction(account, txWithoutCustomFees);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        fees: estimatedFee,
+        storageLimit: new BigNumber(0),
+        customFees: {
+          parameters: {
+            fees: undefined,
+          },
+        },
+      }),
     );
 
-    expect(result).toEqual({
-      amount: new BigNumber(100_000),
-      fees: new BigNumber(700),
-      storageLimit: new BigNumber(277),
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "",
-      assetOwner: "",
-    });
+    expect((getAlpacaApi as jest.Mock)().estimateFees).toHaveBeenCalledTimes(2);
   });
 
-  it("keeps the amount used during the estimation when using all native amount", async () => {
+  it("propagates storageLimit showing new account scenario", async () => {
+    const estimatedFee = new BigNumber(491);
+
+    const estimateFeesFirstCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 300 },
+    });
+
+    const estimateFeesSecondCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 277 },
+    });
+
     (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 700n, parameters: { amount: 1000n } }),
+      estimateFees: jest
+        .fn()
+        .mockImplementationOnce(() => estimateFeesFirstCall())
+        .mockImplementationOnce(() => estimateFeesSecondCall()),
     });
 
+    const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] } } as Account,
-      {
-        amount: new BigNumber(0),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-        useAllAmount: true,
-      },
+    const result = await prepareTransaction(account, txWithoutCustomFees);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        fees: estimatedFee,
+        storageLimit: new BigNumber(277),
+        customFees: {
+          parameters: {
+            fees: undefined,
+          },
+        },
+      }),
     );
 
-    expect(result).toEqual({
-      amount: new BigNumber(1000),
-      fees: new BigNumber(700),
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "",
-      assetOwner: "",
-      useAllAmount: true,
-    });
+    expect((getAlpacaApi as jest.Mock)().estimateFees).toHaveBeenCalledTimes(2);
   });
 });

package/src/bridge/generic-alpaca/utils.test.ts

@@ -197,18 +197,21 @@ describe("Alpaca utils", () => {
       });
     });
 
-    it("handles FEES operation where value = value + fees", () => {
-      const op = {
-        ...baseOp,
-        type: "FEES",
-        value: BigInt(5),
-        tx: { ...baseOp.tx, fees: BigInt(2) },
-      };
-
-      const result = adaptCoreOperationToLiveOperation(accountId, op);
-
-      expect(result.value.toString()).toEqual("7");
-    });
+    it.each([["FEES"], ["DELEGATE"], ["UNDELEGATE"]])(
+      "handles %s operation where value = value + fees",
+      operationType => {
+        const op = {
+          ...baseOp,
+          type: operationType,
+          value: BigInt(5),
+          tx: { ...baseOp.tx, fees: BigInt(2) },
+        };
+
+        const result = adaptCoreOperationToLiveOperation(accountId, op);
+
+        expect(result.value.toString()).toEqual("7");
+      },
+    );
 
     it("handles non-FEES/OUT operation where value = value only", () => {
       const op = {

package/src/bridge/generic-alpaca/utils.ts

@@ -61,7 +61,7 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
     accountId,
     type: opType,
     value:
-      op.asset.type === "native" && ["OUT", "FEES"].includes(opType)
+      op.asset.type === "native" && ["OUT", "FEES", "DELEGATE", "UNDELEGATE"].includes(opType)
         ? new BigNumber(op.value.toString()).plus(bnFees)
         : new BigNumber(op.value.toString()),
     fee: bnFees,

package/src/dada-client/MIGRATION_GUIDE.md

@@ -6,46 +6,7 @@ Migrate from `listTokens()` and `listTokensForCryptoCurrency()` to the DaDa Clie
 
 > **Remove CAL Initiative ([LIVE-21487](https://ledgerhq.atlassian.net/browse/LIVE-21487))**: Replace static token lists with dynamic, server-managed asset data. Beware there are many usages of listTokens that actually are going to get dropped or moved to simpler solution than even using DaDa. This guide is for the usecases we still need to list tokens.
 
-### useAssetsData
-
-```typescript
-const { data, isLoading, isSuccess, isError, loadNext, error, refetch } = useAssetsData({
-  product: "lld" | "llm", // app identifier
-  version: string, // app version
-  search?: string, // server-side search query
-  currencyIds?: string[], // filter by parent currencies
-  areCurrenciesFiltered?: boolean, // required when using currencyIds
-  useCase?: string, // optimize server response
-  isStaging?: boolean, // use staging API
-});
-```
-
-## Integration on LLD
-
-**Configuration:**
-
-```typescript
-product: "lld";
-version: __APP_VERSION__;
-```
-
-**Pagination:** Use `react-window`'s `InfiniteLoader` + `FixedSizeList` with `loadMoreItems` callback, or implement scroll detection to call `loadNext`
-
-## Integration on LLM
-
-**Configuration:**
-
-```typescript
-import { VersionNumber } from "react-native-version-number";
-
-product: "llm";
-version: VersionNumber.appVersion;
-```
-
-**Pagination:** Use `BottomSheetVirtualizedList` or `FlatList` with `onEndReached={loadNext}`
-
-
-## Migration Examples
+## Migration Scenarios
 
 ### 1. Basic Token Lists
 
@@ -81,7 +42,7 @@ function TokenList() {
     .filter(currency => currency.type === "TokenCurrency");
 
   return (
-    <SomethingThatManagesInfiniteScrollList
+    <InfiniteScrollList
       data={tokens}
       renderItem={(token, index) => (
         <div key={token.id}>{token.name}</div>
@@ -177,7 +138,7 @@ function SearchableTokens({ searchQuery }) {
     .filter(currency => currency.type === "TokenCurrency");
 
   return (
-    <SomethingThatManagesInfiniteScrollList
+    <InfiniteScrollList
       data={tokens}
       renderItem={(token) => <div key={token.id}>{token.name}</div>}
       onScrollEnd={loadNext}
@@ -185,3 +146,70 @@ function SearchableTokens({ searchQuery }) {
   );
 }
 ```
+
+## Setup
+
+Add DaDa Client to your Redux store:
+
+```typescript
+import { configureStore } from "@reduxjs/toolkit";
+import { assetsDataApi } from "@ledgerhq/live-common/dada-client/state-manager/api";
+
+const store = configureStore({
+  reducer: {
+    [assetsDataApi.reducerPath]: assetsDataApi.reducer,
+  },
+  middleware: getDefaultMiddleware => getDefaultMiddleware().concat(assetsDataApi.middleware),
+});
+```
+
+## Configuration
+
+**Desktop (LLD):**
+
+```typescript
+product: "lld";
+version: __APP_VERSION__;
+```
+
+**Mobile (LLM):**
+
+```typescript
+import { VersionNumber } from "react-native-version-number";
+
+product: "llm";
+version: VersionNumber.appVersion;
+```
+
+## Pagination Components
+
+**Desktop (LLD):** Use `InfiniteScrollList` with `onScrollEnd={loadNext}`
+
+**Mobile (LLM):** Use `BottomSheetVirtualizedList` or `FlatList` with `onEndReached={loadNext}`
+
+## API Reference
+
+### useAssetsData (Paginated)
+
+```typescript
+const { data, isLoading, loadNext, error, refetch } = useAssetsData({
+  product: "lld" | "llm", // app identifier
+  version: string, // app version
+  search?: string, // server-side search query
+  currencyIds?: string[], // filter by parent currencies
+  areCurrenciesFiltered?: boolean, // required when using currencyIds
+  useCase?: string, // optimize server response
+  isStaging?: boolean, // use staging API
+});
+```
+
+### useAssetData (Single Page)
+
+```typescript
+const { data, isLoading, error, refetch } = useAssetData({
+  product: "lld" | "llm", // app identifier
+  version: string, // app version
+  currencyIds?: string[], // filter by parent currencies
+  isStaging?: boolean, // use staging API
+});
+```

package/src/dada-client/state-manager/api.ts

@@ -41,20 +41,18 @@ export const assetsDataApi = createApi({
           ...(pageParam?.cursor && { cursor: pageParam.cursor }),
           ...(queryArg?.useCase && { transaction: queryArg.useCase }),
           ...(queryArg?.currencyIds &&
-            queryArg?.currencyIds.length > 0 && { currencyIds: queryArg.currencyIds }),
+            queryArg?.currencyIds.length > 0 &&
+            !queryArg?.useCase && { currencyIds: queryArg.currencyIds }),
           ...(queryArg?.search && { search: queryArg.search }),
           product: queryArg.product,
           minVersion: queryArg.version,
-          additionalData: queryArg.additionalData || [
-            AssetsAdditionalData.Apy,
-            AssetsAdditionalData.MarketTrend,
-          ],
+          additionalData: [AssetsAdditionalData.Apy, AssetsAdditionalData.MarketTrend],
         };
 
         const baseUrl = queryArg.isStaging ? getEnv("DADA_API_STAGING") : getEnv("DADA_API_PROD");
 
         return {
-          url: `${baseUrl}/assets`,
+          url: `${baseUrl}assets`,
           params,
         };
       },
@@ -83,10 +81,7 @@ export const assetsDataApi = createApi({
             queryArg?.currencyIds.length > 0 && { currencyIds: queryArg.currencyIds }),
           product: queryArg.product,
           minVersion: queryArg.version,
-          additionalData: queryArg.additionalData || [
-            AssetsAdditionalData.Apy,
-            AssetsAdditionalData.MarketTrend,
-          ],
+          additionalData: [AssetsAdditionalData.Apy, AssetsAdditionalData.MarketTrend],
         };
 
         const baseUrl = queryArg.isStaging ? getEnv("DADA_API_STAGING") : getEnv("DADA_API_PROD");

package/src/dada-client/state-manager/types.ts

@@ -16,7 +16,6 @@ export interface GetAssetsDataParams {
   product: "llm" | "lld";
   version: string;
   isStaging?: boolean;
-  additionalData?: AssetsAdditionalData[];
 }
 
 export interface PageParam {

package/src/deposit/useGroupedCurrenciesByProvider.hook.ts

@@ -3,7 +3,7 @@ import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { useEffect, useMemo, useState } from "react";
 import { isCurrencySupported, listSupportedCurrencies, listTokens } from "../currencies";
 import { loadCurrenciesByProvider } from "./helper";
-import { useAcceptedCurrency } from "../modularDrawer/hooks/useAcceptedCurrency";
+import { useCurrenciesUnderFeatureFlag } from "../modularDrawer/hooks/useCurrenciesUnderFeatureFlag";
 
 // FIXME(LIVE-10505): bad performane & shared utility to move to coin-framework
 const listSupportedTokens = () => listTokens().filter(t => isCurrencySupported(t.parentCurrency));
@@ -17,15 +17,16 @@ export const useGroupedCurrenciesByProvider = (
   withLoading?: boolean,
 ): GroupedCurrencies | LoadingBasedGroupedCurrencies => {
   const [result, setResult] = useState(initialResult);
-  const isAcceptedCurrency = useAcceptedCurrency();
+  // the import is from MAD but as this hook will be removed, it's fine to keep it here
+  const { deactivatedCurrencyIds } = useCurrenciesUnderFeatureFlag();
 
   const [loadingStatus, setLoadingStatus] = useState<LoadingStatus>(LoadingStatus.Idle);
   const coinsAndTokensSupported = useMemo(
     () =>
       (listSupportedCurrencies() as CryptoOrTokenCurrency[])
         .concat(listSupportedTokens())
-        .filter(isAcceptedCurrency),
-    [isAcceptedCurrency],
+        .filter(c => !deactivatedCurrencyIds.has(c.id)),
+    [deactivatedCurrencyIds],
   );
 
   // Get mapped assets filtered by supported & sorted currencies, grouped by provider id

package/src/e2e/data/deviceLabelsData.ts

@@ -65,7 +65,7 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.ETHEREUM.name]: DeviceLabels.VERIFY_ETHEREUM,
       [AppInfos.POLKADOT.name]: DeviceLabels.PLEASE_REVIEW,
       [AppInfos.POLYGON.name]: DeviceLabels.VERIFY_POLYGON,
-      [AppInfos.SOLANA.name]: DeviceLabels.PUBKEY,
+      [AppInfos.SOLANA.name]: DeviceLabels.VERIFY_SOLANA_ADDRESS,
       default: DeviceLabels.ADDRESS,
     },
     receiveConfirm: {
@@ -75,13 +75,14 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.ETHEREUM.name]: DeviceLabels.CONFIRM,
       [AppInfos.POLKADOT.name]: DeviceLabels.CAPS_APPROVE,
       [AppInfos.POLYGON.name]: DeviceLabels.CONFIRM,
+      [AppInfos.SOLANA.name]: DeviceLabels.CONFIRM,
       default: DeviceLabels.APPROVE,
     },
     delegateVerify: {
       [AppInfos.COSMOS.name]: DeviceLabels.PLEASE_REVIEW,
       [AppInfos.MULTIVERS_X.name]: DeviceLabels.RECEIVER,
       [AppInfos.NEAR.name]: DeviceLabels.VIEW_HEADER,
-      [AppInfos.SOLANA.name]: DeviceLabels.DELEGATE_FROM,
+      [AppInfos.SOLANA.name]: DeviceLabels.REVIEW_TRANSACTION,
       default: DeviceLabels.REVIEW_OPERATION,
     },
     delegateConfirm: {
@@ -91,6 +92,7 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.INJECTIVE.name]: DeviceLabels.CAPS_APPROVE,
       [AppInfos.MULTIVERS_X.name]: DeviceLabels.SIGN,
       [AppInfos.NEAR.name]: DeviceLabels.CONTINUE_TO_ACTION,
+      [AppInfos.SOLANA.name]: DeviceLabels.SIGN_TRANSACTION,
       [AppInfos.OSMOSIS.name]: DeviceLabels.CAPS_APPROVE,
       default: DeviceLabels.APPROVE,
     },

package/src/e2e/enum/Device.ts

@@ -1,10 +1,7 @@
 export class Device {
-  constructor(
-    public readonly name: string,
-    public readonly targetId: number,
-  ) {}
+  constructor(public readonly name: string) {}
 
-  static readonly LNS = new Device("nanoS", 823132164);
-  static readonly LNX = new Device("nanoX", 855638020);
-  static readonly LNSP = new Device("nanoSP", 856686596);
+  static readonly LNS = "nanoS";
+  static readonly LNX = "nanoX";
+  static readonly LNSP = "nanoSP";
 }