@ledgerhq/live-common 25.1.0 → 25.2.0-next.0

package/src/hw/signTransaction/tron.ts

@@ -1,6 +1,6 @@
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import Trx from "@ledgerhq/hw-app-trx";
 import Transport from "@ledgerhq/hw-transport";
-import type { CryptoCurrency } from "../../types";
 export default async (
   currency: CryptoCurrency,
   transport: Transport,

package/src/hw/uninstallApp.ts

@@ -2,8 +2,8 @@ import { ignoreElements, catchError } from "rxjs/operators";
 import { Observable, throwError } from "rxjs";
 import { ManagerAppDepUninstallRequired } from "@ledgerhq/errors";
 import Transport from "@ledgerhq/hw-transport";
-import type { App, ApplicationVersion } from "../types/manager";
 import ManagerAPI from "../api/Manager";
+import type { App, ApplicationVersion } from "@ledgerhq/types-live";
 export default function uninstallApp(
   transport: Transport,
   targetId: string | number,

package/src/manager/hooks.ts

@@ -1,10 +1,10 @@
 import { useState, useEffect } from "react";
 import semver from "semver";
-import type { DeviceModelInfo } from "../types/manager";
 import { useEnv } from "../env.react";
 import manager from ".";
 import { getProviderId } from "./provider";
 import ManagerAPI from "../api/Manager";
+import type { DeviceModelInfo } from "@ledgerhq/types-live";
 
 async function hasOudatedApps({
   deviceInfo,

package/src/manager/index.ts

@@ -4,15 +4,15 @@ import semver from "semver";
 import chunk from "lodash/chunk";
 import type { DeviceModelId } from "@ledgerhq/devices";
 import { UnknownMCU } from "@ledgerhq/errors";
+import { listCryptoCurrencies } from "../currencies";
+import ManagerAPI from "../api/Manager";
+import { getProviderId } from "./provider";
 import type {
   ApplicationVersion,
   DeviceInfo,
-  OsuFirmware,
   FirmwareUpdateContext,
-} from "../types/manager";
-import { listCryptoCurrencies } from "../currencies";
-import ManagerAPI from "../api/Manager";
-import { getProviderId } from "./provider";
+  OsuFirmware,
+} from "@ledgerhq/types-live";
 export { getProviderId };
 const ICONS_FALLBACK = {
   bitcoin_testnet: "bitcoin",

package/src/manager/provider.ts

@@ -1,4 +1,4 @@
-import type { DeviceInfo } from "../types/manager";
+import type { DeviceInfo } from "@ledgerhq/types-live";
 import { getEnv } from "../env";
 export const PROVIDERS: Record<string, number> = {
   das: 2,

package/src/market/MarketDataProvider.tsx

@@ -10,7 +10,6 @@ import React, {
 } from "react";
 
 import { useDebounce } from "../hooks/useDebounce";
-import { Currency } from "../types";
 import {
   State,
   MarketDataApi,
@@ -21,6 +20,7 @@ import {
   SupportedCoins,
 } from "./types";
 import defaultFetchApi from "./api/api";
+import type { Currency } from "@ledgerhq/types-cryptoassets";
 type Props = {
   children: React.ReactNode;
   fetchApi?: MarketDataApi;

package/src/market/api/api.ts

@@ -12,7 +12,7 @@ import {
   listSupportedCurrencies,
 } from "../../currencies";
 import { rangeDataTable } from "../utils/rangeDataTable";
-import { CryptoCurrency } from "@ledgerhq/cryptoassets";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { getEnv } from "../../env";
 import network from "../../network";
 

package/src/market/types.ts

@@ -1,5 +1,5 @@
 // @flow
-import { CryptoCurrency } from "../types";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 export type MarketCoin = {
   id: string;

package/src/migrations/accounts-dataset.ts

@@ -1,5 +1,5 @@
 import { fromAccountRaw } from "../account";
-import type { Account, AccountRaw } from "../types";
+import type { Account, AccountRaw } from "@ledgerhq/types-live";
 
 const accounts: Account[] = [
   {

package/src/migrations/accounts.ts

@@ -1,4 +1,4 @@
-import type { Account, AccountLike, SubAccount } from "../types";
+import type { Account, AccountLike, SubAccount } from "@ledgerhq/types-live";
 import type { SwapOperation } from "../exchange/swap/types";
 import {
   encodeTokenAccountId,

package/src/mock/account.ts

@@ -5,14 +5,6 @@ import {
   listTokensForCryptoCurrency,
   findCompoundToken,
 } from "../currencies";
-import type {
-  TokenAccount,
-  Account,
-  AccountLike,
-  Operation,
-  CryptoCurrency,
-  TokenCurrency,
-} from "../types";
 import { getOperationAmountNumber } from "../operation";
 import {
   inferSubOperations,
@@ -23,6 +15,21 @@ import {
 import { getDerivationScheme, runDerivationScheme } from "../derivation";
 import { genHex, genAddress } from "./helpers";
 import perFamilyMock from "../generated/mock";
+import type {
+  Account,
+  AccountLike,
+  Operation,
+  TokenAccount,
+} from "@ledgerhq/types-live";
+import type {
+  CryptoCurrency,
+  TokenCurrency,
+} from "@ledgerhq/types-cryptoassets";
+import { CosmosAccount } from "../families/cosmos/types";
+import { BitcoinAccount } from "../families/bitcoin/types";
+import { AlgorandAccount } from "../families/algorand/types";
+import { PolkadotAccount } from "../families/polkadot/types";
+import { TezosAccount } from "../families/tezos/types";
 
 function ensureNoNegative(operations) {
   let total = new BigNumber(0);
@@ -429,7 +436,7 @@ export function genAccount(
   }
 
   if (currency.id === "cosmos") {
-    account.cosmosResources = {
+    (account as CosmosAccount).cosmosResources = {
       // TODO variation in these
       delegations: [],
       redelegations: [],
@@ -442,21 +449,21 @@ export function genAccount(
   }
 
   if (currency.family === "bitcoin") {
-    account.bitcoinResources = {
+    (account as BitcoinAccount).bitcoinResources = {
       utxos: [],
       walletAccount: undefined,
     };
   }
 
   if (currency.family === "algorand") {
-    account.algorandResources = {
+    (account as AlgorandAccount).algorandResources = {
       rewards: new BigNumber(0),
       nbAssets: account.subAccounts?.length ?? 0,
     };
   }
 
   if (currency.family === "polkadot") {
-    account.polkadotResources = {
+    (account as PolkadotAccount).polkadotResources = {
       stash: null,
       controller: null,
       nonce: 0,
@@ -469,6 +476,13 @@ export function genAccount(
     };
   }
 
+  if (currency.family === "tezos") {
+    (account as TezosAccount).tezosResources = {
+      revealed: true,
+      counter: 0,
+    };
+  }
+
   account.operations = Array(operationsSize)
     .fill(null)
     .reduce((ops: Operation[]) => {

package/src/mock/helpers.ts

@@ -1,5 +1,8 @@
 import Prando from "prando";
-import type { CryptoCurrency, TokenCurrency } from "../types";
+import type {
+  CryptoCurrency,
+  TokenCurrency,
+} from "@ledgerhq/types-cryptoassets";
 
 /**
  * @memberof mock/account

package/src/nft/NftMetadataProvider/index.tsx

@@ -15,7 +15,7 @@ import {
 import { isOutdated } from "./logic";
 import { getCurrencyBridge } from "../../bridge";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-import { NFT, ProtoNFT } from "../../types";
+import type { NFT, ProtoNFT } from "@ledgerhq/types-live";
 
 const NftMetadataContext = createContext<NFTMetadataContextType>({
   cache: {},

package/src/nft/NftMetadataProvider/types.ts

@@ -1,7 +1,7 @@
 import {
   NFTCollectionMetadataResponse,
   NFTMetadataResponse,
-} from "../../types";
+} from "@ledgerhq/types-live";
 
 export type NFTResourceQueued = {
   status: "queued";

package/src/nft/helpers.ts

@@ -9,10 +9,10 @@ import type {
   Operation,
   ProtoNFT,
   NFT,
-  CryptoCurrency,
   NFTCollectionMetadataResponse,
-} from "../types";
+} from "@ledgerhq/types-live";
 import { API, apiForCurrency } from "../api/Ethereum";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 export const nftsFromOperations = (ops: Operation[]): ProtoNFT[] => {
   const nftsMap = ops

package/src/nft/hook.ts

@@ -1,4 +1,5 @@
-import type { ProtoNFT, CryptoCurrency, FloorPrice } from "../types";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import type { FloorPrice, ProtoNFT } from "@ledgerhq/types-live";
 import { getEnv } from "../env";
 import network from "../network";
 

package/src/nft/support.ts

@@ -1,5 +1,7 @@
-import { Transaction, CryptoCurrency, ProtoNFT, NFTStandard } from "../types";
+import { Transaction } from "../generated/types";
 import { getEnv } from "../env";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import type { NFTStandard, ProtoNFT } from "@ledgerhq/types-live";
 
 export const isNftTransaction = (
   transaction: Transaction | undefined | null

package/src/notifications/AnnouncementProvider/types.ts

@@ -1,6 +1,6 @@
 import type { DeviceModelId } from "@ledgerhq/devices";
-import type { DeviceModelInfo } from "../../types/manager";
 export type AnnouncementDeviceModelId = Array<DeviceModelId | "no_nano">;
+import { DeviceModelInfo } from "@ledgerhq/types-live";
 export type AnnouncementDeviceFilter = {
   modelIds?: AnnouncementDeviceModelId;
   versions?: string[];

package/src/onboarding/hooks/useOnboardingStatePolling.test.ts

@@ -8,7 +8,7 @@ import {
   OnboardingState,
   OnboardingStep,
 } from "../../hw/extractOnboardingState";
-import { SeedPhraseType } from "../../types/manager";
+import { SeedPhraseType } from "@ledgerhq/types-live";
 import { getOnboardingStatePolling } from "../../hw/getOnboardingStatePolling";
 
 jest.mock("../../hw/getOnboardingStatePolling");
@@ -59,6 +59,11 @@ describe("useOnboardingStatePolling", () => {
           {
             onboardingState: { ...aSecondOnboardingState },
             allowedError: null,
+          },
+          {
+            // During the third polling, it gets the same onboarding state
+            onboardingState: { ...aSecondOnboardingState },
+            allowedError: null,
           }
         ).pipe(
           delayWhen((_, index) => {
@@ -89,7 +94,7 @@ describe("useOnboardingStatePolling", () => {
       expect(result.current.onboardingState).toEqual(anOnboardingState);
     });
 
-    it("should fetch again the state at a defined frequency and update (if new) the onboarding state returned to the consumer", async () => {
+    it("should fetch again the state at a defined frequency and only update the onboarding state returned to the consumer if it different than the previous one", async () => {
       const device = aDevice;
 
       const { result } = renderHook(() =>
@@ -112,6 +117,19 @@ describe("useOnboardingStatePolling", () => {
       expect(result.current.fatalError).toBeNull();
       expect(result.current.allowedError).toBeNull();
       expect(result.current.onboardingState).toEqual(aSecondOnboardingState);
+      // To compare with the result of the third polling
+      const prevOnboardingState = result.current.onboardingState;
+
+      // Third polling
+      await act(async () => {
+        jest.advanceTimersByTime(pollingPeriodMs);
+      });
+
+      expect(result.current.fatalError).toBeNull();
+      expect(result.current.allowedError).toBeNull();
+      // It should not have been updated
+      // toBe matcher checks referential identity of object instances
+      expect(result.current.onboardingState).toBe(prevOnboardingState);
     });
 
     describe("and when the hook consumer stops the polling", () => {
@@ -164,6 +182,11 @@ describe("useOnboardingStatePolling", () => {
             onboardingState: null,
             allowedError: new DisconnectedDevice("An allowed error"),
           },
+          {
+            onboardingState: null,
+            // During the third polling, it gets the same allowed error
+            allowedError: new DisconnectedDevice("An allowed error"),
+          },
           {
             onboardingState: { ...aSecondOnboardingState },
             allowedError: null,
@@ -176,7 +199,7 @@ describe("useOnboardingStatePolling", () => {
       );
     });
 
-    it("should update the allowed error returned to the consumer, update the fatal error to null and keep the previous onboarding state", async () => {
+    it("should update the allowed error returned to the consumer if different than the previous one, update the fatal error to null and keep the previous onboarding state", async () => {
       const device = aDevice;
 
       const { result } = renderHook(() =>
@@ -199,6 +222,19 @@ describe("useOnboardingStatePolling", () => {
       expect(result.current.allowedError).toBeInstanceOf(DisconnectedDevice);
       expect(result.current.fatalError).toBeNull();
       expect(result.current.onboardingState).toEqual(anOnboardingState);
+      // To compare with the result of the third polling
+      const prevAllowedError = result.current.allowedError;
+
+      // Thirs polling
+      await act(async () => {
+        jest.advanceTimersByTime(pollingPeriodMs);
+      });
+
+      expect(result.current.fatalError).toBeNull();
+      expect(result.current.onboardingState).toEqual(anOnboardingState);
+      // It should not have been updated
+      // toBe matcher checks referential identity of object instances
+      expect(result.current.allowedError).toBe(prevAllowedError);
     });
 
     it("should be able to recover once the allowed error is fixed and the onboarding state is updated", async () => {
@@ -218,7 +254,7 @@ describe("useOnboardingStatePolling", () => {
       expect(result.current.onboardingState).toEqual(anOnboardingState);
 
       await act(async () => {
-        jest.advanceTimersByTime(pollingPeriodMs);
+        jest.advanceTimersByTime(2 * pollingPeriodMs);
       });
 
       // Everything is ok on the next run

package/src/onboarding/hooks/useOnboardingStatePolling.ts

@@ -1,19 +1,39 @@
 import { useState, useEffect } from "react";
 import { Subscription } from "rxjs";
+import { isEqual } from "lodash";
 import type { Device } from "../../hw/actions/types";
 import { DeviceOnboardingStatePollingError } from "@ledgerhq/errors";
 
-import type { OnboardingStatePollingResult } from "../../hw/getOnboardingStatePolling";
-import { getOnboardingStatePolling } from "../../hw/getOnboardingStatePolling";
+import type {
+  OnboardingStatePollingResult,
+  GetOnboardingStatePollingArgs,
+  GetOnboardingStatePollingResult,
+} from "../../hw/getOnboardingStatePolling";
+import { getOnboardingStatePolling as defaultGetOnboardingStatePolling } from "../../hw/getOnboardingStatePolling";
 import { OnboardingState } from "../../hw/extractOnboardingState";
 
 export type UseOnboardingStatePollingResult = OnboardingStatePollingResult & {
   fatalError: Error | null;
 };
 
+export type UseOnboardingStatePollingDependencies = {
+  getOnboardingStatePolling?: (
+    args: GetOnboardingStatePollingArgs
+  ) => GetOnboardingStatePollingResult;
+};
+
+export type UseOnboardingStatePollingArgs =
+  UseOnboardingStatePollingDependencies & {
+    device: Device | null;
+    pollingPeriodMs: number;
+    stopPolling?: boolean;
+  };
+
 /**
  * Polls the current device onboarding state, and notify the hook consumer of
  * any allowed errors and fatal errors
+ * @param getOnboardingStatePolling A polling function, by default set to live-common/hw/getOnboardingStatePolling.
+ * This dependency injection is needed for LLD to have the polling working on the internal thread
  * @param device A Device object
  * @param pollingPeriodMs The period in ms after which the device onboarding state is fetched again
  * @param stopPolling Flag to stop or continue the polling
@@ -23,14 +43,11 @@ export type UseOnboardingStatePollingResult = OnboardingStatePollingResult & {
  * - fatalError: any error that is fatal and stops the polling
  */
 export const useOnboardingStatePolling = ({
+  getOnboardingStatePolling = defaultGetOnboardingStatePolling,
   device,
   pollingPeriodMs,
   stopPolling = false,
-}: {
-  device: Device | null;
-  pollingPeriodMs: number;
-  stopPolling?: boolean;
-}): UseOnboardingStatePollingResult => {
+}: UseOnboardingStatePollingArgs): UseOnboardingStatePollingResult => {
   const [onboardingState, setOnboardingState] =
     useState<OnboardingState | null>(null);
   const [allowedError, setAllowedError] = useState<Error | null>(null);
@@ -49,11 +66,23 @@ export const useOnboardingStatePolling = ({
         next: (onboardingStatePollingResult: OnboardingStatePollingResult) => {
           if (onboardingStatePollingResult) {
             setFatalError(null);
-            setAllowedError(onboardingStatePollingResult.allowedError);
+            // Only updates if the new allowedError is different
+            setAllowedError((prevAllowedError) =>
+              getNewAllowedErrorIfChanged(
+                prevAllowedError,
+                onboardingStatePollingResult.allowedError
+              )
+            );
 
             // Does not update the onboarding state if an allowed error occurred
             if (!onboardingStatePollingResult.allowedError) {
-              setOnboardingState(onboardingStatePollingResult.onboardingState);
+              // Only updates if the new onboardingState is different
+              setOnboardingState((prevOnboardingState) =>
+                getNewOnboardingStateIfChanged(
+                  prevOnboardingState,
+                  onboardingStatePollingResult.onboardingState
+                )
+              );
             }
           }
         },
@@ -80,7 +109,27 @@ export const useOnboardingStatePolling = ({
     setAllowedError,
     setFatalError,
     stopPolling,
+    getOnboardingStatePolling,
   ]);
 
   return { onboardingState, allowedError, fatalError };
 };
+
+const getNewOnboardingStateIfChanged = (
+  prevOnboardingState: OnboardingState | null,
+  newOnboardingState: OnboardingState | null
+): OnboardingState | null => {
+  return isEqual(prevOnboardingState, newOnboardingState)
+    ? prevOnboardingState
+    : newOnboardingState;
+};
+
+const getNewAllowedErrorIfChanged = (
+  prevError: Error | null,
+  newError: Error | null
+): Error | null => {
+  // Only interested if the errors are instances of the same Error class
+  return prevError?.constructor === newError?.constructor
+    ? prevError
+    : newError;
+};

package/src/operation.ts

@@ -1,16 +1,16 @@
+import type {
+  Account,
+  AccountLike,
+  NFTStandard,
+  Operation,
+} from "@ledgerhq/types-live";
 import { BigNumber } from "bignumber.js";
+import { decodeAccountId } from "./account";
 import { encodeNftId } from "./nft";
 import {
   encodeERC1155OperationId,
   encodeERC721OperationId,
 } from "./nft/nftOperationId";
-import {
-  Account,
-  AccountLike,
-  decodeAccountId,
-  NFTStandard,
-  Operation,
-} from "./types";
 
 const nftOperationIdEncoderPerStandard: Record<
   NFTStandard,

package/src/pagination.ts

@@ -1,4 +1,5 @@
-import type { SyncConfig } from "./types";
+import type { SyncConfig } from "@ledgerhq/types-live";
+
 export function getOperationsPageSize(
   accountId: string | null | undefined,
   syncConfig: SyncConfig

package/src/platform/JSONRPCServer.ts

@@ -4,15 +4,16 @@ import {
   JSONRPCServerAndClient,
   JSONRPCClient,
 } from "json-rpc-2.0";
-type LedgerLiveAPIHandlers = Record<string, () => any>;
+type LedgerLiveAPIHandlers = Record<string, (any) => any>;
 type SendFunc = (request: any) => Promise<void>;
 export const useJSONRPCServer = (
   handlers: LedgerLiveAPIHandlers,
   send: SendFunc
-) => {
+): Array<SendFunc> => {
   const serverRef: {
     current: null | JSONRPCServerAndClient;
   } = useRef(null);
+
   useEffect(() => {
     const server = new JSONRPCServerAndClient(
       new JSONRPCServer(),
@@ -29,5 +30,6 @@ export const useJSONRPCServer = (
       await serverRef.current.receiveAndSend(request);
     }
   }, []);
+
   return [receive];
 };

package/src/platform/converters.test.ts

@@ -3,7 +3,7 @@ import BigNumber from "bignumber.js";
 import "../__tests__/test-helpers/setup";
 
 import { getPlatformTransactionSignFlowInfos } from "./converters";
-import type { Transaction } from "../types";
+import type { Transaction } from "../generated/types";
 import type { PlatformTransaction } from "./types";
 
 describe("getPlatformTransactionSignFlowInfos", () => {

package/src/platform/converters.ts

@@ -1,6 +1,7 @@
+import { Account, AccountLike } from "@ledgerhq/types-live";
 import byFamily from "../generated/platformAdapter";
+import type { Transaction } from "../generated/types";
 import { isTokenAccount, isSubAccount } from "../account";
-import { Account, AccountLike, Transaction } from "../types";
 import {
   PlatformAccount,
   PlatformCurrency,

package/src/platform/helpers.ts

@@ -1,5 +1,5 @@
 import { isCryptoCurrency, isTokenCurrency } from "../currencies";
-import { Currency } from "../types";
+import { Currency } from "@ledgerhq/types-cryptoassets";
 import {
   PlatformCurrency,
   PlatformSupportedCurrency,

package/src/platform/rawTypes.ts

@@ -1,4 +1,4 @@
-import type { SignedOperationRaw } from "../types";
+import type { SignedOperationRaw } from "@ledgerhq/types-live";
 
 export type {
   RawAccount as RawPlatformAccount,

package/src/platform/react.ts

@@ -1,5 +1,5 @@
 import { useCallback, useMemo } from "react";
-import { AccountLike } from "../types";
+import { AccountLike } from "@ledgerhq/types-live";
 import {
   accountToPlatformAccount,
   currencyToPlatformCurrency,

package/src/platform/serializers.test.ts

@@ -1,6 +1,6 @@
+import type { SignedOperation, SignedOperationRaw } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 
-import { SignedOperation, SignedOperationRaw } from "../types";
 import "../__tests__/test-helpers/setup";
 
 import {