@ledgerhq/live-common 34.52.0 → 34.53.0-nightly.20251107095716

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

@@ -1,4 +1,9 @@
-import type { Operation, TransactionCommon } from "@ledgerhq/types-live";
+import type {
+  Operation,
+  OperationRaw,
+  TransactionCommon,
+  TransactionCommonRaw,
+} from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import type { Unit } from "@ledgerhq/types-cryptoassets";
 
@@ -6,6 +11,34 @@ type NetworkInfo = {
   fees: BigNumber;
 };
 
+type NetworkInfoRaw = {
+  fees: string;
+};
+
+type Strategy = "slow" | "medium" | "fast";
+
+export type FeeData = {
+  maxFeePerGas: BigNumber | null;
+  maxPriorityFeePerGas: BigNumber | null;
+  gasPrice: BigNumber | null;
+  nextBaseFee: BigNumber | null;
+};
+
+export type FeeDataRaw = {
+  maxFeePerGas: string | null;
+  maxPriorityFeePerGas: string | null;
+  gasPrice: string | null;
+  nextBaseFee: string | null;
+};
+
+export type GasOptions = {
+  [key in Strategy]: FeeData;
+};
+
+export type GasOptionsRaw = {
+  [key in Strategy]: FeeDataRaw;
+};
+
 export type GenericTransaction = TransactionCommon & {
   family: string;
   fees?: BigNumber | null;
@@ -14,6 +47,7 @@ export type GenericTransaction = TransactionCommon & {
     parameters: { fees?: BigNumber | null };
   };
   tag?: number | null | undefined;
+  nonce?: BigNumber | null | undefined;
   feeCustomUnit?: Unit | null | undefined;
   memoType?: string | null;
   memoValue?: string | null;
@@ -27,12 +61,56 @@ export type GenericTransaction = TransactionCommon & {
     | "stake"
     | "undelegate"
     | "unstake";
-  type?: number;
+  type?: number | null;
   assetReference?: string;
   assetOwner?: string;
   networkInfo?: NetworkInfo | null;
+  chainId?: number | null;
+  gasLimit?: BigNumber | null;
+  gasPrice?: BigNumber | null;
+  maxFeePerGas?: BigNumber | null;
+  maxPriorityFeePerGas?: BigNumber | null;
+  gasOptions?: GasOptions;
+};
+
+export type GenericTransactionRaw = TransactionCommonRaw & {
+  family: string;
+  fees?: string | null;
+  storageLimit?: string | null;
+  customFees?: {
+    parameters: { fees?: string | null };
+  };
+  tag?: number | null | undefined;
+  nonce?: string | null | undefined;
+  feeCustomUnit?: Unit | null | undefined;
+  memoType?: string | null;
+  memoValue?: string | null;
+  data?: string;
+  mode?:
+    | "send"
+    | "changeTrust"
+    | "send-legacy"
+    | "send-eip1559"
+    | "delegate"
+    | "stake"
+    | "undelegate"
+    | "unstake";
+  type?: number | null;
+  assetReference?: string | null;
+  assetOwner?: string | null;
+  networkInfo?: NetworkInfoRaw | null;
+  chainId?: number | null;
+  gasLimit?: string | null;
+  gasPrice?: string | null;
+  maxFeePerGas?: string | null;
+  maxPriorityFeePerGas?: string | null;
+  gasOptions?: GasOptionsRaw;
 };
 
 export interface OperationCommon extends Operation {
   extra: Record<string, any>;
 }
+
+export interface OperationCommonRaw extends OperationRaw {
+  extra: Record<string, any>;
+}

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

@@ -22,6 +22,7 @@ describe("Alpaca utils", () => {
           parentType: "OPT_IN",
           subType: undefined,
           parentValue: new BigNumber(50),
+          parentRecipient: "recipient-address",
         },
       ],
       [
@@ -32,6 +33,7 @@ describe("Alpaca utils", () => {
           parentType: "DELEGATE",
           subType: undefined,
           parentValue: new BigNumber(50),
+          parentRecipient: "recipient-address",
         },
       ],
       [
@@ -42,6 +44,7 @@ describe("Alpaca utils", () => {
           parentType: "DELEGATE",
           subType: undefined,
           parentValue: new BigNumber(50),
+          parentRecipient: "recipient-address",
         },
       ],
       [
@@ -52,6 +55,7 @@ describe("Alpaca utils", () => {
           parentType: "UNDELEGATE",
           subType: undefined,
           parentValue: new BigNumber(50),
+          parentRecipient: "recipient-address",
         },
       ],
       [
@@ -62,6 +66,7 @@ describe("Alpaca utils", () => {
           parentType: "UNDELEGATE",
           subType: undefined,
           parentValue: new BigNumber(50),
+          parentRecipient: "recipient-address",
         },
       ],
       [
@@ -72,6 +77,7 @@ describe("Alpaca utils", () => {
           parentType: "OUT",
           subType: undefined,
           parentValue: new BigNumber(50),
+          parentRecipient: "recipient-address",
         },
       ],
       [
@@ -82,6 +88,7 @@ describe("Alpaca utils", () => {
           parentType: "FEES",
           subType: "OPT_IN",
           parentValue: new BigNumber(12),
+          parentRecipient: "contract-address",
         },
       ],
       [
@@ -92,6 +99,7 @@ describe("Alpaca utils", () => {
           parentType: "FEES",
           subType: "DELEGATE",
           parentValue: new BigNumber(12),
+          parentRecipient: "contract-address",
         },
       ],
       [
@@ -102,6 +110,7 @@ describe("Alpaca utils", () => {
           parentType: "FEES",
           subType: "DELEGATE",
           parentValue: new BigNumber(12),
+          parentRecipient: "contract-address",
         },
       ],
       [
@@ -112,6 +121,7 @@ describe("Alpaca utils", () => {
           parentType: "FEES",
           subType: "UNDELEGATE",
           parentValue: new BigNumber(12),
+          parentRecipient: "contract-address",
         },
       ],
       [
@@ -122,26 +132,38 @@ describe("Alpaca utils", () => {
           parentType: "FEES",
           subType: "UNDELEGATE",
           parentValue: new BigNumber(12),
+          parentRecipient: "contract-address",
         },
       ],
       [
         "token",
         "send",
         { subAccountId: "sub-account-id" },
-        { parentType: "FEES", subType: "OUT", parentValue: new BigNumber(12) },
+        {
+          parentType: "FEES",
+          subType: "OUT",
+          parentValue: new BigNumber(12),
+          parentRecipient: "contract-address",
+        },
       ],
     ])("builds an optimistic %s operation with %s mode ", (_s, mode, params, expected) => {
       const operation = buildOptimisticOperation(
         {
           id: "parent-account-id",
           freshAddress: "account-address",
-          subAccounts: [{ id: "sub-account-id" }],
+          subAccounts: [{ id: "sub-account-id", token: { contractAddress: "contract-address" } }],
         } as Account,
         {
           mode,
           amount: new BigNumber(50),
           fees: new BigNumber(12),
           recipient: "recipient-address",
+          recipientDomain: {
+            registry: "ens",
+            domain: "recipient.eth",
+            address: "recipient-address",
+            type: "forward",
+          },
           ...params,
         } as GenericTransaction,
       );
@@ -156,6 +178,17 @@ describe("Alpaca utils", () => {
         fee: new BigNumber(12),
         blockHash: null,
         blockHeight: null,
+        transactionRaw: {
+          amount: expected.subType ? "0" : expected.parentValue.toFixed(),
+          fees: "12",
+          recipient: expected.parentRecipient,
+          recipientDomain: {
+            registry: "ens",
+            domain: "recipient.eth",
+            address: "recipient-address",
+            type: "forward",
+          },
+        },
         ...(expected.subType
           ? {
               subOperations: [
@@ -168,6 +201,11 @@ describe("Alpaca utils", () => {
                   value: new BigNumber(50),
                   blockHash: null,
                   blockHeight: null,
+                  transactionRaw: {
+                    amount: "50",
+                    fees: "12",
+                    recipient: "recipient-address",
+                  },
                 },
               ],
             }
@@ -420,5 +458,23 @@ describe("Alpaca utils", () => {
 
       expect(result.value.toString()).toEqual("50");
     });
+
+    it("shows fees in value when transaction has failed", () => {
+      const failedOp = {
+        ...baseOp,
+        type: "OUT",
+        value: BigInt(100),
+        tx: { ...baseOp.tx, fees: BigInt(25) },
+        details: { status: "failed" },
+      };
+
+      const result = adaptCoreOperationToLiveOperation(accountId, failedOp);
+
+      expect(result).toMatchObject({
+        hasFailed: true,
+        value: new BigNumber(25),
+        fee: new BigNumber(25),
+      });
+    });
   });
 });

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

@@ -9,7 +9,15 @@ import {
 } from "@ledgerhq/coin-framework/api/types";
 import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { GenericTransaction, OperationCommon } from "./types";
+import {
+  FeeData,
+  FeeDataRaw,
+  GasOptions,
+  GasOptionsRaw,
+  GenericTransaction,
+  GenericTransactionRaw,
+  OperationCommon,
+} from "./types";
 
 export function findCryptoCurrencyByNetwork(network: string): CryptoCurrency | undefined {
   const networksRemap = {
@@ -99,23 +107,36 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
     extra.memo = op.details.memo as string;
   }
   const bnFees = new BigNumber(op.tx.fees.toString());
+  const hasFailed = op.details?.status === "failed";
+
+  let value: BigNumber;
+  if (hasFailed) {
+    value = bnFees;
+  } else if (
+    op.asset.type === "native" &&
+    ["OUT", "FEES", "DELEGATE", "UNDELEGATE"].includes(opType)
+  ) {
+    value = new BigNumber(op.value.toString()).plus(bnFees);
+  } else {
+    value = new BigNumber(op.value.toString());
+  }
+
   const res = {
     id: encodeOperationId(accountId, op.tx.hash, op.type),
     hash: op.tx.hash,
     accountId,
     type: opType,
-    value:
-      op.asset.type === "native" && ["OUT", "FEES", "DELEGATE", "UNDELEGATE"].includes(opType)
-        ? new BigNumber(op.value.toString()).plus(bnFees)
-        : new BigNumber(op.value.toString()),
+    value,
     fee: bnFees,
     blockHash: op.tx.block.hash,
     blockHeight: op.tx.block.height,
     senders: extra.parentSenders ?? op.senders,
     recipients: extra.parentRecipients ?? op.recipients,
     date: op.tx.date,
-    transactionSequenceNumber: op.details?.sequence as number,
-    hasFailed: op.details?.status === "failed",
+    transactionSequenceNumber: op.details?.sequence
+      ? new BigNumber(op.details?.sequence.toString())
+      : undefined,
+    hasFailed,
     extra,
   };
 
@@ -189,6 +210,10 @@ export function transactionToIntent(
     data: Buffer.isBuffer(transaction.data)
       ? { type: "buffer", value: transaction.data }
       : { type: "none" },
+    sequence:
+      transaction.nonce !== null && transaction.nonce !== undefined
+        ? BigInt(transaction.nonce.toString())
+        : undefined,
   };
   if (transaction.assetReference && transaction.assetOwner) {
     const { subAccountId } = transaction;
@@ -216,10 +241,114 @@ export function transactionToIntent(
   return res;
 }
 
+function toFeeDataRaw(data: FeeData): FeeDataRaw {
+  return {
+    gasPrice: data.gasPrice?.toFixed() ?? null,
+    maxFeePerGas: data.maxFeePerGas?.toFixed() ?? null,
+    maxPriorityFeePerGas: data.maxPriorityFeePerGas?.toFixed() ?? null,
+    nextBaseFee: data.nextBaseFee?.toFixed() ?? null,
+  };
+}
+
+function toGasOptionRaw(options: GasOptions): GasOptionsRaw {
+  return {
+    fast: toFeeDataRaw(options.fast),
+    medium: toFeeDataRaw(options.medium),
+    slow: toFeeDataRaw(options.slow),
+  };
+}
+
+function toGenericTransactionRaw(transaction: GenericTransaction): GenericTransactionRaw {
+  const raw: GenericTransactionRaw = {
+    amount: transaction.amount.toString(),
+    recipient: transaction.recipient,
+    family: transaction.family,
+  };
+
+  if ("useAllAmount" in transaction) {
+    raw.useAllAmount = transaction.useAllAmount;
+  }
+
+  const stringFieldsToPropagate = [
+    "memoType",
+    "memoValue",
+    "assetReference",
+    "assetOwner",
+  ] as const;
+  for (const field of stringFieldsToPropagate) {
+    if (field in transaction) {
+      raw[field] = transaction[field];
+    }
+  }
+
+  const numberFieldsToPropagate = ["tag", "type", "chainId"] as const;
+  for (const field of numberFieldsToPropagate) {
+    if (field in transaction) {
+      raw[field] = transaction[field];
+    }
+  }
+
+  const bigNumberFieldsToPropagate = [
+    "fees",
+    "storageLimit",
+    "nonce",
+    "gasLimit",
+    "gasPrice",
+    "maxFeePerGas",
+    "maxPriorityFeePerGas",
+  ] as const;
+  for (const field of bigNumberFieldsToPropagate) {
+    if (field in transaction) {
+      raw[field] = transaction[field]?.toFixed();
+    }
+  }
+
+  if ("customFees" in transaction) {
+    raw.customFees =
+      transaction.customFees && "fees" in transaction.customFees.parameters
+        ? {
+            parameters: { fees: transaction.customFees.parameters.fees?.toFixed() },
+          }
+        : { parameters: {} };
+  }
+
+  if ("feesStrategy" in transaction) {
+    raw.feesStrategy = transaction.feesStrategy;
+  }
+
+  if ("mode" in transaction) {
+    raw.mode = transaction.mode;
+  }
+
+  if ("feeCustomUnit" in transaction) {
+    raw.feeCustomUnit = transaction.feeCustomUnit;
+  }
+
+  if ("data" in transaction) {
+    raw.data = transaction.data?.toString("hex");
+  }
+
+  if ("networkInfo" in transaction) {
+    raw.networkInfo = transaction.networkInfo && {
+      fees: transaction.networkInfo.fees.toFixed(),
+    };
+  }
+
+  if ("gasOptions" in transaction) {
+    raw.gasOptions = transaction.gasOptions && toGasOptionRaw(transaction.gasOptions);
+  }
+
+  if ("recipientDomain" in transaction) {
+    raw.recipientDomain = transaction.recipientDomain;
+  }
+
+  return raw;
+}
+
 export const buildOptimisticOperation = (
   account: Account,
   transaction: GenericTransaction,
-  sequenceNumber?: number,
+  sequenceNumber?: bigint,
 ): Operation => {
   let type: OperationType;
   switch (transaction.mode) {
@@ -242,6 +371,7 @@ export const buildOptimisticOperation = (
   const { subAccountId } = transaction;
   const { subAccounts } = account;
   const parentType = subAccountId ? "FEES" : type;
+  const tokenAccount = subAccountId ? subAccounts?.find(ta => ta.id === subAccountId) : null;
 
   const operation: Operation = {
     id: encodeOperationId(account.id, "", parentType),
@@ -253,9 +383,16 @@ export const buildOptimisticOperation = (
     blockHeight: null,
     senders: [account.freshAddress.toString()],
     recipients: [transaction.recipient],
-    transactionSequenceNumber: sequenceNumber ?? 0,
+    transactionSequenceNumber: new BigNumber(sequenceNumber?.toString() ?? 0),
     accountId: account.id,
     date: new Date(),
+    transactionRaw: toGenericTransactionRaw({
+      ...transaction,
+      nonce: sequenceNumber !== undefined ? new BigNumber(sequenceNumber.toString()) : undefined,
+      ...(tokenAccount
+        ? { recipient: tokenAccount.token.contractAddress, amount: new BigNumber(0) }
+        : {}),
+    }),
     extra: {
       ledgerOpType: type,
       blockTime: new Date(),
@@ -263,7 +400,6 @@ export const buildOptimisticOperation = (
     },
   };
 
-  const tokenAccount = subAccountId ? subAccounts?.find(ta => ta.id === subAccountId) : null;
   if (tokenAccount && subAccountId) {
     operation.subOperations = [
       {
@@ -278,6 +414,11 @@ export const buildOptimisticOperation = (
         recipients: [transaction.recipient],
         accountId: subAccountId,
         date: new Date(),
+        transactionRaw: toGenericTransactionRaw({
+          ...transaction,
+          nonce:
+            sequenceNumber !== undefined ? new BigNumber(sequenceNumber.toString()) : undefined,
+        }),
         extra: {
           ledgerOpType: type,
         },

package/src/bridge/index.ts

@@ -2,12 +2,12 @@ import type { ScanAccountEvent, ScanAccountEventRaw } from "@ledgerhq/types-live
 import { fromAccountRaw, toAccountRaw } from "../account";
 export { getCurrencyBridge, getAccountBridge } from "./impl";
 
-export function fromScanAccountEventRaw(raw: ScanAccountEventRaw): ScanAccountEvent {
+export async function fromScanAccountEventRaw(raw: ScanAccountEventRaw): Promise<ScanAccountEvent> {
   switch (raw.type) {
     case "discovered":
       return {
         type: raw.type,
-        account: fromAccountRaw(raw.account),
+        account: await fromAccountRaw(raw.account),
       };
 
     default:

package/src/bridge/useBridgeTransaction.test.ts

@@ -31,12 +31,15 @@ describe("useBridgeTransaction", () => {
     const mainAccount = genAccount("mocked-account-1", { currency: BTC });
     const { result } = renderHook(() => useBridgeTransaction(() => ({ account: mainAccount })));
 
-    await waitFor(() => {
-      expect(result.current.bridgePending).toBeFalsy();
-      expect(result.current.bridgeError).toBeFalsy();
-      expect(result.current.transaction).not.toBeFalsy();
-      expect(result.current.account).not.toBeFalsy();
-    });
+    await waitFor(
+      () => {
+        expect(result.current.bridgePending).toBeFalsy();
+        expect(result.current.bridgeError).toBeFalsy();
+        expect(result.current.transaction).not.toBeFalsy();
+        expect(result.current.account).not.toBeFalsy();
+      },
+      { timeout: 10000 },
+    );
   });
 
   test("bridgeError go through", async () => {

package/src/currencies/cryptoIcons.test.ts

@@ -1,6 +1,12 @@
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
+import { addTokens as addTokensLegacy } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
 import { inferCryptoCurrencyIcon } from "./cryptoIcons";
-import { findTokenById } from "@ledgerhq/cryptoassets/tokens";
+import { getCryptoAssetsStore } from "../bridge/crypto-assets/index";
+
+beforeAll(() => {
+  initializeLegacyTokens(addTokensLegacy);
+});
 
 describe("inferCryptoCurrencyIcon", () => {
   const registryMock = {
@@ -22,9 +28,8 @@ describe("inferCryptoCurrencyIcon", () => {
     expect(inferCryptoCurrencyIcon(registryMock, getCryptoCurrencyById("arbitrum"))).toBe(3);
   });
 
-  test("USDT is inferred properly", () => {
-    const usdt = findTokenById("ethereum/erc20/usd_tether__erc20_");
-    if (!usdt) throw new Error("USDT token not found");
-    expect(inferCryptoCurrencyIcon(registryMock, usdt)).toBe(4);
+  test("USDT is inferred properly", async () => {
+    const token = await getCryptoAssetsStore().findTokenById("ethereum/erc20/usd_tether__erc20_");
+    expect(inferCryptoCurrencyIcon(registryMock, token!)).toBe(4);
   });
 });

package/src/currencies/index.ts

@@ -14,10 +14,7 @@ export {
   listTokens,
   listTokensForCryptoCurrency,
   listTokenTypesForCryptoCurrency,
-  findTokenById,
-  findTokenByAddressInCurrency,
   getAbandonSeedAddress,
-  addTokens,
 } from "@ledgerhq/cryptoassets";
 export {
   encodeURIScheme,

package/src/currencies/sortByMarketcap.test.ts

@@ -4,9 +4,12 @@ import { getBTCValues } from "@ledgerhq/live-countervalues/mock";
 import { CURRENCIES_LIST, IDS } from "./mock";
 import { findCryptoCurrencyByTicker, findFiatCurrencyByTicker } from "@ledgerhq/cryptoassets/index";
 import { getCryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/index";
-import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/tokens";
+import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/legacy/legacy-store";
+import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
+import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
 import { setup } from "../bridge/impl";
 
+initializeLegacyTokens(addTokens);
 setup(legacyCryptoAssetsStore);
 
 test("sortCurrenciesByIds snapshot", async () => {

package/src/dada-client/README.md

@@ -24,6 +24,14 @@ const { data, isLoading, error } = useAssetsData({
   search: "bitcoin",
 });
 
+// You can control the fetching with the skip parameter
+const { data, isLoading, error } = useAssetsData({
+  product: "llm",
+  version: "1.0.0",
+  search: "bitcoin",
+  skip: true, // true: no fetch
+});
+
 // Get interest rates for currencies
 const currencies = [bitcoinCurrency, ethereumCurrency];
 const interestRates = useInterestRatesByCurrencies(currencies);
@@ -79,6 +87,35 @@ const MarketComponent = () => {
 };
 ```
 
+### Lazy Currency Fetching
+
+```typescript
+import { useLazyLedgerCurrency } from '@ledgerhq/live-common/dada-client/hooks/useLazyLedgerCurrency';
+
+const CurrencyComponent = ({ currency }) => {
+  const { getLedgerCurrency } = useLazyLedgerCurrency(
+    {
+      product: 'lld',
+      version: '2.0.0',
+    },
+    currency
+  );
+
+  const handleFetchCurrency = async () => {
+    const ledgerCurrency = await getLedgerCurrency();
+    if (ledgerCurrency) {
+      console.log('Ledger currency data:', ledgerCurrency);
+    }
+  };
+
+  return (
+    <button onClick={handleFetchCurrency}>
+      Fetch Currency Data
+    </button>
+  );
+};
+```
+
 ## API Reference
 
 ### Hooks
@@ -87,6 +124,7 @@ const MarketComponent = () => {
 - `useAssetData()` - Fetch specific asset data
 - `useInterestRatesByCurrencies()` - Get interest rates for currencies
 - `useMarketByCurrencies()` - Get market data for currencies
+- `useLazyLedgerCurrency()` - Lazy hook to fetch ledger currency data on demand
 
 ## Integration