@ledgerhq/live-common 34.51.0-nightly.1 → 34.51.0-nightly.3

package/src/modularDrawer/types/detailedAccount.ts

@@ -0,0 +1,49 @@
+import { Unit } from "@ledgerhq/types-cryptoassets";
+import { AccountLike } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+
+/**
+ * Base raw detailed account with unformatted values for UI formatting
+ * This is the shared interface that both mobile and desktop can extend
+ */
+export interface BaseRawDetailedAccount {
+  id: string;
+  name: string;
+  ticker: string;
+  balance: BigNumber;
+  balanceUnit: Unit;
+  fiatValue: number;
+  address: string;
+  cryptoId: string;
+  parentId?: string;
+}
+
+/**
+ * Extended detailed account that includes the original account references
+ * Used by mobile implementation that needs access to the full account objects
+ */
+export interface ExtendedRawDetailedAccount extends BaseRawDetailedAccount {
+  account: AccountLike;
+  parentAccount?: AccountLike;
+  protocol?: string;
+}
+
+/**
+ * Configuration for formatting detailed accounts
+ */
+export interface DetailedAccountFormatConfig {
+  discreet?: boolean;
+  locale?: string;
+  showCode?: boolean;
+}
+
+/**
+ * Parameters for creating detailed accounts
+ */
+export interface CreateDetailedAccountsParams {
+  asset: any; // CryptoOrTokenCurrency - avoiding import to keep this generic
+  accountTuples: any[]; // AccountTuple[] - avoiding import to keep this generic
+  accountNameMap: Record<string, string>;
+  isTokenCurrency: boolean;
+  formatConfig?: DetailedAccountFormatConfig;
+}

package/src/modularDrawer/types/index.ts

@@ -0,0 +1 @@
+export * from "./detailedAccount";

package/src/modularDrawer/utils/__tests__/sortAccountsByFiatValue.test.ts

@@ -0,0 +1,117 @@
+import { sortAccountsByFiatValue } from "../sortAccountsByFiatValue";
+import { BaseRawDetailedAccount } from "../../types/detailedAccount";
+import BigNumber from "bignumber.js";
+
+const mockBalanceUnit = { name: "Ethereum", code: "ETH", magnitude: 18 };
+
+const mockAccounts: BaseRawDetailedAccount[] = [
+  {
+    name: "Ethereum 1",
+    id: "js:2:ethereum:0xaDf49b9f133fb137e82b24F06D23E49c51f586C7:",
+    ticker: "ETH",
+    balance: new BigNumber("1.55699"),
+    balanceUnit: mockBalanceUnit,
+    fiatValue: 4149.62,
+    address: "0xaDf...586C7",
+    cryptoId: "ethereum",
+  },
+  {
+    name: "Ethereum 2",
+    id: "js:2:ethereum:0xd4b6595ff5f3c21E0b00edB8947A31110a9c4B8f:",
+    ticker: "ETH",
+    balance: new BigNumber("0.178403"),
+    balanceUnit: mockBalanceUnit,
+    fiatValue: 475.47,
+    address: "0xd4b...c4B8f",
+    cryptoId: "ethereum",
+  },
+  {
+    name: "Ethereum 3",
+    id: "js:2:ethereum:0x833eBB4bDa11da33a7F1C907C8171e5995Fe33c7:",
+    ticker: "ETH",
+    balance: new BigNumber("5.10589"),
+    balanceUnit: mockBalanceUnit,
+    fiatValue: 13607.93,
+    address: "0x833...e33c7",
+    cryptoId: "ethereum",
+  },
+  {
+    name: "Ethereum 4",
+    id: "js:2:ethereum:0xDbD543b0e80e0E73FbD49FDEe902FC59652753B9:",
+    ticker: "ETH",
+    balance: new BigNumber("0.00148572"),
+    balanceUnit: mockBalanceUnit,
+    fiatValue: 3.96,
+    address: "0xDbD...753B9",
+    cryptoId: "ethereum",
+  },
+];
+
+const expectedSortedAccounts = [
+  mockAccounts[2], // 13607.93
+  mockAccounts[0], // 4149.62
+  mockAccounts[1], // 475.47
+  mockAccounts[3], // 3.96
+];
+
+describe("sortAccountsByFiatValue", () => {
+  it("should sort accounts by fiat value in descending order", () => {
+    const sortedAccounts = sortAccountsByFiatValue(mockAccounts);
+    expect(sortedAccounts).toEqual(expectedSortedAccounts);
+  });
+
+  it("should handle empty accounts array", () => {
+    const sortedAccounts = sortAccountsByFiatValue([]);
+    expect(sortedAccounts).toEqual([]);
+  });
+
+  it("should handle accounts with identical fiat values", () => {
+    const identicalAccounts = [
+      { ...mockAccounts[0], fiatValue: 1000 },
+      { ...mockAccounts[1], fiatValue: 1000 },
+    ];
+    const sortedAccounts = sortAccountsByFiatValue(identicalAccounts);
+    expect(sortedAccounts).toEqual(identicalAccounts);
+  });
+
+  it("should handle accounts with zero fiat value", () => {
+    const zeroBalanceAccounts = [
+      { ...mockAccounts[0], fiatValue: 0 },
+      { ...mockAccounts[1], fiatValue: 10000 },
+    ];
+    const sortedAccounts = sortAccountsByFiatValue(zeroBalanceAccounts);
+    expect(sortedAccounts).toEqual([zeroBalanceAccounts[1], zeroBalanceAccounts[0]]);
+  });
+
+  it("should handle accounts with undefined fiat value", () => {
+    const undefinedFiatAccounts = [
+      { ...mockAccounts[0], fiatValue: undefined as any },
+      { ...mockAccounts[1], fiatValue: 5000 },
+    ];
+    const sortedAccounts = sortAccountsByFiatValue(undefinedFiatAccounts);
+    expect(sortedAccounts).toEqual([undefinedFiatAccounts[1], undefinedFiatAccounts[0]]);
+  });
+
+  it("should not mutate the original array", () => {
+    const originalAccounts = [...mockAccounts];
+    const sortedAccounts = sortAccountsByFiatValue(mockAccounts);
+
+    expect(mockAccounts).toEqual(originalAccounts);
+    expect(sortedAccounts).not.toBe(mockAccounts);
+  });
+
+  it("should work with extended account types", () => {
+    interface ExtendedAccount extends BaseRawDetailedAccount {
+      customField: string;
+    }
+
+    const extendedAccounts: ExtendedAccount[] = [
+      { ...mockAccounts[0], customField: "test1" },
+      { ...mockAccounts[2], customField: "test2" },
+    ];
+
+    const sortedAccounts = sortAccountsByFiatValue(extendedAccounts);
+    expect(sortedAccounts[0].customField).toBe("test2"); // Higher fiat value
+    expect(sortedAccounts[1].customField).toBe("test1"); // Lower fiat value
+  });
+});

package/src/modularDrawer/utils/getBalanceAndFiatValueByAssets.ts

@@ -5,9 +5,9 @@ import { AccountLike } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
 
-interface ExtendedAssetType extends AssetType {
-  currency?: CryptoOrTokenCurrency;
-  balance?: BigNumber;
+export interface ExtendedAssetType extends AssetType {
+  currency: CryptoOrTokenCurrency;
+  balance: BigNumber;
   fiatValue?: number;
 }
 
@@ -30,6 +30,9 @@ export const getBalanceAndFiatValueByAssets = (
       id: asset.id,
       name: asset.name,
       ticker: asset.ticker,
+      currency: asset,
+      balance: new BigNumber(0),
+      fiatValue: 0,
     };
   });
 };

package/src/modularDrawer/utils/index.ts

@@ -1,5 +1,6 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 export { groupCurrenciesByProvider } from "./groupCurrenciesByProvider";
+export { sortAccountsByFiatValue } from "./sortAccountsByFiatValue";
 
 function isCorrespondingCurrency(
   elem: CryptoOrTokenCurrency,

package/src/modularDrawer/utils/sortAccountsByFiatValue.ts

@@ -0,0 +1,14 @@
+import { BaseRawDetailedAccount } from "../types/detailedAccount";
+
+/**
+ * Sorts accounts by their fiat value in descending order
+ * @param accounts - List of accounts with fiat values to sort
+ * @returns Sorted list of accounts by fiat value balance in descending order
+ */
+export function sortAccountsByFiatValue<T extends BaseRawDetailedAccount>(accounts: T[]): T[] {
+  return [...accounts].sort((a, b) => {
+    const fiatValueA = a.fiatValue ?? 0;
+    const fiatValueB = b.fiatValue ?? 0;
+    return fiatValueB - fiatValueA;
+  });
+}

package/src/modularDrawer/utils/type.ts

@@ -42,10 +42,10 @@ export type UseBalanceDeps = () => {
 
 export type BalanceUI = {
   // Raw values
-  balance?: BigNumber;
+  balance: BigNumber;
   fiatValue?: number;
   fiatUnit?: Unit;
-  currency?: CryptoOrTokenCurrency;
+  currency: CryptoOrTokenCurrency;
   // Formatting parameters
   locale?: string;
   discreet?: boolean;
@@ -83,6 +83,7 @@ export type NetworkHookParams = {
   networks: CryptoOrTokenCurrency[];
   accounts$?: Observable<WalletAPIAccount[]>;
 };
+// Network hook type that returns currency properties spread at top level
 export type NetworkHook = (
   params: NetworkHookParams,
 ) => Array<CryptoOrTokenCurrency & Network & { balanceData?: BalanceUI; count?: number }>;

package/src/platform/providers/RemoteLiveAppProvider/api/mock.json

@@ -263,9 +263,9 @@
   {
     "id": "1inch",
     "name": "1inch",
-    "url": "https://dapp-browser.apps.ledger.com/?params=%7B%22dappUrl%22%3A%22https%3A%2F%2Fapp.1inch.io%2F%3FledgerLive%3Dtrue%22%2C%22nanoApp%22%3A%221inch%22%2C%22dappName%22%3A%221inch%22%2C%22networks%22%3A%5B%7B%22currency%22%3A%22ethereum%22%2C%22chainID%22%3A1%2C%22nodeURL%22%3A%22wss%3A%2F%2Feth-mainnet.ws.alchemyapi.io%2Fv2%2F0fyudoTG94QWC0tEtfJViM9v2ZXJuij2%22%7D%2C%7B%22currency%22%3A%22bsc%22%2C%22chainID%22%3A56%2C%22nodeURL%22%3A%22https%3A%2F%2Fbsc-dataseed.binance.org%2F%22%7D%2C%7B%22currency%22%3A%20%22polygon%22%2C%22chainID%22%3A%20137%2C%22nodeURL%22%3A%20%22https%3A%2F%2Fpolygon-mainnet.g.alchemy.com%2Fv2%2FoPIxZM7kXsPVVY1Sk0kOQwkoIOpSu8PE%22%7D%5D%7D",
+    "url": "https://dapp-browser.apps.ledger.com/?params=%7B%22dappUrl%22%3A%22https%3A%2F%2F1inch.com%2Fswap%2F%22%2C%22nanoApp%22%3A%221inch%22%2C%22dappName%22%3A%221inch%22%2C%22networks%22%3A%5B%7B%22currency%22%3A%22ethereum%22%2C%22chainID%22%3A1%2C%22nodeURL%22%3A%22wss%3A%2F%2Feth-mainnet.ws.alchemyapi.io%2Fv2%2F0fyudoTG94QWC0tEtfJViM9v2ZXJuij2%22%7D%2C%7B%22currency%22%3A%22bsc%22%2C%22chainID%22%3A56%2C%22nodeURL%22%3A%22https%3A%2F%2Fbsc-dataseed.binance.org%2F%22%7D%2C%7B%22currency%22%3A%22polygon%22%2C%22chainID%22%3A137%2C%22nodeURL%22%3A%22https%3A%2F%2Fpolygon-mainnet.g.alchemy.com%2Fv2%2FoPIxZM7kXsPVVY1Sk0kOQwkoIOpSu8PE%22%7D%5D%7D",
     "params": {
-      "dappUrl": "https://app.1inch.io/?ledgerLive=true",
+      "dappUrl": "https://1inch.com/swap/",
       "nanoApp": "1inch",
       "dappName": "1inch",
       "networks": [
@@ -286,7 +286,7 @@
         }
       ]
     },
-    "homepageUrl": "https://1inch.io/",
+    "homepageUrl": "https://1inch.com/",
     "icon": "https://cdn.live.ledger.com/icons/platform/1inch.png",
     "platforms": ["ios", "android", "desktop"],
     "apiVersion": "^1.0.0 || ~0.0.1",

package/src/wallet-api/logic.ts

@@ -139,6 +139,41 @@ export function signTransactionLogic(
   });
 }
 
+export function signRawTransactionLogic(
+  { manifest, accounts, tracking }: WalletAPIContext,
+  walletAccountId: string,
+  transaction: string,
+  uiNavigation: (
+    account: AccountLike,
+    parentAccount: Account | undefined,
+    transaction: string,
+  ) => Promise<SignedOperation>,
+): Promise<SignedOperation> {
+  tracking.signRawTransactionRequested(manifest);
+
+  if (!transaction) {
+    tracking.signRawTransactionFail(manifest);
+    return Promise.reject(new Error("Transaction required"));
+  }
+
+  const accountId = getAccountIdFromWalletAccountId(walletAccountId);
+  if (!accountId) {
+    tracking.signRawTransactionFail(manifest);
+    return Promise.reject(new Error(`accountId ${walletAccountId} unknown`));
+  }
+
+  const account = accounts.find(account => account.id === accountId);
+
+  if (!account) {
+    tracking.signRawTransactionFail(manifest);
+    return Promise.reject(new Error("Account required"));
+  }
+
+  const parentAccount = getParentAccount(account, accounts);
+
+  return uiNavigation(account, parentAccount, transaction);
+}
+
 export function broadcastTransactionLogic(
   { manifest, accounts, tracking }: WalletAPIContext,
   walletAccountId: string,

package/src/wallet-api/react.ts

@@ -37,6 +37,7 @@ import {
   signTransactionLogic,
   bitcoinFamilyAccountGetAddressLogic,
   bitcoinFamilyAccountGetPublicKeyLogic,
+  signRawTransactionLogic,
 } from "./logic";
 import { getAccountBridge } from "../bridge";
 import { getEnv } from "@ledgerhq/live-env";
@@ -154,6 +155,14 @@ export interface UiHook {
   }) => void;
   "storage.get": WalletHandlers["storage.get"];
   "storage.set": WalletHandlers["storage.set"];
+  "transaction.signRaw": (params: {
+    account: AccountLike;
+    parentAccount: Account | undefined;
+    transaction: string;
+    options: Parameters<WalletHandlers["transaction.sign"]>[0]["options"];
+    onSuccess: (signedOperation: SignedOperation) => void;
+    onError: (error: Error) => void;
+  }) => void;
   "transaction.sign": (params: {
     account: AccountLike;
     parentAccount: Account | undefined;
@@ -320,6 +329,7 @@ export function useWalletAPIServer({
     "storage.get": uiStorageGet,
     "storage.set": uiStorageSet,
     "transaction.sign": uiTxSign,
+    "transaction.signRaw": uiTxSignRaw,
     "transaction.broadcast": uiTxBroadcast,
     "device.transport": uiDeviceTransport,
     "device.select": uiDeviceSelect,
@@ -536,6 +546,82 @@ export function useWalletAPIServer({
     );
   }, [accounts, manifest, server, tracking, uiTxSign]);
 
+  useEffect(() => {
+    if (!uiTxSignRaw) return;
+
+    server.setHandler(
+      "transaction.signRaw",
+      async ({ account, transaction, broadcast, options }) => {
+        const signedOperation = await signRawTransactionLogic(
+          { manifest, accounts, tracking },
+          account.id,
+          transaction,
+          (account, parentAccount, tx) =>
+            new Promise((resolve, reject) => {
+              let done = false;
+              return uiTxSignRaw({
+                account,
+                parentAccount,
+                transaction: tx,
+                options,
+                onSuccess: signedOperation => {
+                  if (done) return;
+                  done = true;
+                  tracking.signRawTransactionSuccess(manifest);
+                  resolve(signedOperation);
+                },
+                onError: error => {
+                  if (done) return;
+                  done = true;
+                  tracking.signRawTransactionFail(manifest);
+                  reject(error);
+                },
+              });
+            }),
+        );
+
+        let hash: string | undefined;
+        if (broadcast) {
+          hash = await broadcastTransactionLogic(
+            { manifest, accounts, tracking },
+            account.id,
+            signedOperation,
+            async (account, parentAccount, signedOperation) => {
+              const bridge = getAccountBridge(account, parentAccount);
+              const mainAccount = getMainAccount(account, parentAccount);
+
+              let optimisticOperation: Operation = signedOperation.operation;
+
+              if (!getEnv("DISABLE_TRANSACTION_BROADCAST")) {
+                try {
+                  optimisticOperation = await bridge.broadcast({
+                    account: mainAccount,
+                    signedOperation,
+                    broadcastConfig: { mevProtected: !!config.mevProtected },
+                  });
+                  tracking.broadcastSuccess(manifest);
+                } catch (error) {
+                  tracking.broadcastFail(manifest);
+                  throw error;
+                }
+              }
+
+              uiTxBroadcast &&
+                uiTxBroadcast(account, parentAccount, mainAccount, optimisticOperation);
+
+              return optimisticOperation.hash;
+            },
+          );
+        }
+
+        return {
+          signedTransactionHex: signedOperation.signature,
+          transactionHash: hash,
+        };
+      },
+    );
+  }, [accounts, config.mevProtected, manifest, server, tracking, uiTxBroadcast, uiTxSignRaw]);
+
   useEffect(() => {
     if (!uiTxSign) return;
 
@@ -604,7 +690,7 @@ export function useWalletAPIServer({
         );
       },
     );
-  }, [accounts, manifest, server, tracking, uiTxBroadcast, uiTxSign]);
+  }, [accounts, config.mevProtected, manifest, server, tracking, uiTxBroadcast, uiTxSign]);
 
   const onLoad = useCallback(() => {
     tracking.loadSuccess(manifest);

package/src/wallet-api/tracking.ts

@@ -70,6 +70,21 @@ export default function trackingWrapper(trackCall: TrackWalletAPI) {
       track("WalletAPI SignTransaction Success", getEventData(manifest));
     },
 
+    // Sign Raw transaction modal open
+    signRawTransactionRequested: (manifest: AppManifest) => {
+      track("WalletAPI SignRawTransaction", getEventData(manifest));
+    },
+
+    // Failed to sign raw transaction (cancel or error)
+    signRawTransactionFail: (manifest: AppManifest) => {
+      track("WalletAPI SignRawTransaction Fail", getEventData(manifest));
+    },
+
+    // Successfully signed raw transaction
+    signRawTransactionSuccess: (manifest: AppManifest) => {
+      track("WalletAPI SignRawTransaction Success", getEventData(manifest));
+    },
+
     // Select account modal open
     requestAccountRequested: (manifest: AppManifest) => {
       track("WalletAPI RequestAccount", getEventData(manifest));

package/src/wallet-api/useDappLogic.ts

@@ -8,7 +8,7 @@ import { getAccountBridge } from "../bridge";
 import { getEnv } from "@ledgerhq/live-env";
 import network from "@ledgerhq/live-network/network";
 import { getWalletAPITransactionSignFlowInfos } from "./converters";
-import { findTokenByAddress, getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { findTokenByAddressInCurrency, getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
 import { prepareMessageToSign } from "../hw/signMessage/index";
 import { CurrentAccountHistDB, UiHook, usePermission } from "./react";
 import BigNumber from "bignumber.js";
@@ -482,8 +482,6 @@ export function useDappLogic({
 
               const transactionType = getTxType(signFlowInfos.liveTx as EvmTransaction);
 
-              const token = findTokenByAddress(tx.recipient);
-
               const accountCurrencyName =
                 currentAccount.type === "TokenAccount"
                   ? currentAccount.token.name
@@ -494,6 +492,8 @@ export function useDappLogic({
                   ? currentAccount.token.parentCurrency.id
                   : currentAccount.currency.id;
 
+              const token = findTokenByAddressInCurrency(tx.recipient, accountNetwork);
+
               trackingData = {
                 type: transactionType,
                 currency: token ? token.name : accountCurrencyName,