@ledgerhq/live-common 34.51.0-nightly.0 → 34.51.0-nightly.10

package/src/hw/actions/rawTransaction.ts

@@ -0,0 +1,190 @@
+import { of, Observable } from "rxjs";
+import { scan, catchError, tap } from "rxjs/operators";
+import { useEffect, useState } from "react";
+import { log } from "@ledgerhq/logs";
+import { TransportStatusError } from "@ledgerhq/errors";
+import { TransactionRefusedOnDevice } from "../../errors";
+import { getMainAccount } from "../../account";
+import { getAccountBridge } from "../../bridge";
+import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
+import type { Action, Device } from "./types";
+import type { AppRequest, AppState } from "./app";
+import { createAction as createAppAction } from "./app";
+import type {
+  Account,
+  AccountLike,
+  SignedOperation,
+  SignOperationEvent,
+} from "@ledgerhq/types-live";
+
+type State = {
+  signedOperation: SignedOperation | null | undefined;
+  deviceSignatureRequested: boolean;
+  deviceStreamingProgress: number | null | undefined;
+  transactionSignError: Error | null | undefined;
+  transactionChecksOptInTriggered: boolean;
+  transactionChecksOptIn: boolean | null;
+  manifestId?: string;
+  manifestName?: string;
+};
+type RawTransactionState = AppState & State;
+type RawTransactionRequest = {
+  parentAccount: Account | null | undefined;
+  account: AccountLike;
+  transaction: string;
+  appName?: string;
+  dependencies?: AppRequest[];
+  requireLatestFirmware?: boolean;
+  manifestId?: string;
+  manifestName?: string;
+};
+export type RawTransactionResult =
+  | {
+      signedOperation: SignedOperation;
+      device: Device;
+      swapId?: string;
+    }
+  | {
+      transactionSignError: Error;
+    };
+type TransactionAction = Action<RawTransactionRequest, RawTransactionState, RawTransactionResult>;
+
+const mapResult = ({
+  device,
+  signedOperation,
+  transactionSignError,
+}: RawTransactionState): RawTransactionResult | null | undefined =>
+  signedOperation && device
+    ? {
+        signedOperation,
+        device,
+      }
+    : transactionSignError
+      ? {
+          transactionSignError,
+        }
+      : null;
+
+type Event =
+  | SignOperationEvent
+  | {
+      type: "error";
+      error: Error;
+    };
+const initialState = {
+  signedOperation: null,
+  deviceSignatureRequested: false,
+  deviceStreamingProgress: null,
+  transactionSignError: null,
+  transactionChecksOptInTriggered: false,
+  transactionChecksOptIn: null,
+};
+
+const reducer = (state: State, e: Event): State => {
+  switch (e.type) {
+    case "error": {
+      const { error } = e;
+      const transactionSignError =
+        error instanceof TransportStatusError && error.statusCode === 0x6985
+          ? new TransactionRefusedOnDevice()
+          : error;
+      return { ...initialState, transactionSignError };
+    }
+
+    case "signed":
+      return { ...state, signedOperation: e.signedOperation };
+
+    case "device-signature-requested":
+      return { ...state, deviceSignatureRequested: true };
+
+    case "device-signature-granted":
+      return { ...state, deviceSignatureRequested: false };
+
+    case "device-streaming":
+      return { ...state, deviceStreamingProgress: e.progress };
+
+    case "transaction-checks-opt-in-triggered":
+      return { ...state, transactionChecksOptInTriggered: true };
+
+    case "transaction-checks-opt-in":
+      return { ...state, transactionChecksOptIn: true };
+
+    case "transaction-checks-opt-out":
+      return { ...state, transactionChecksOptIn: false };
+
+    default:
+      return state;
+  }
+};
+
+export const createAction = (
+  connectAppExec: (arg0: ConnectAppInput) => Observable<ConnectAppEvent>,
+): TransactionAction => {
+  const useHook = (
+    reduxDevice: Device | null | undefined,
+    {
+      account,
+      parentAccount,
+      transaction,
+      appName,
+      dependencies,
+      requireLatestFirmware,
+      manifestId,
+      manifestName,
+    }: RawTransactionRequest,
+  ): RawTransactionState => {
+    const mainAccount = getMainAccount(account, parentAccount);
+    const appState = createAppAction(connectAppExec).useHook(reduxDevice, {
+      account: mainAccount,
+      appName,
+      dependencies,
+      requireLatestFirmware,
+    });
+    const { device, opened, inWrongDeviceForAccount, error } = appState;
+    const [state, setState] = useState(initialState);
+    useEffect(() => {
+      if (!device || !opened || inWrongDeviceForAccount || error) {
+        setState(initialState);
+        return;
+      }
+
+      const bridge = getAccountBridge(mainAccount);
+      const sub = bridge
+        .signRawOperation({
+          account: mainAccount,
+          transaction,
+          deviceId: device.deviceId,
+          deviceModelId: device.modelId,
+        })
+        .pipe(
+          catchError(error =>
+            of<{ type: "error"; error: Error }>({
+              type: "error",
+              error,
+            }),
+          ),
+          tap((e: Event) => log("actions-transaction-event", e.type, e)),
+          scan(reducer, initialState),
+        )
+        .subscribe((x: any) => setState(x));
+      return () => {
+        sub.unsubscribe();
+      };
+    }, [device, mainAccount, transaction, opened, inWrongDeviceForAccount, error]);
+    return {
+      ...appState,
+      ...state,
+      manifestId,
+      manifestName,
+      deviceStreamingProgress:
+        state.signedOperation || state.transactionSignError
+          ? null // when good app is opened, we start the progress so it doesn't "blink"
+          : state.deviceStreamingProgress || (appState.opened ? 0 : null),
+    };
+  };
+
+  return {
+    useHook,
+    mapResult,
+  };
+};

package/src/load/speculos.ts

@@ -128,6 +128,7 @@ export const findLatestAppCandidate = (
   appCandidates: AppCandidate[],
   search: AppSearch,
 ): AppCandidate | null => {
+  search.firmware = process.env.SPECULOS_FIRMWARE_VERSION;
   let apps = appCandidates.filter(c => appCandidatesMatches(c, search));
   if (apps.length === 0) {
     return null;

package/src/market/utils/index.ts

@@ -1,6 +1,9 @@
 import { PortfolioRange } from "@ledgerhq/types-live";
 import { Order } from "./types";
 
+// Export all types from types.ts
+export * from "./types";
+
 export function getRange(range: PortfolioRange | string) {
   switch (range) {
     case "day":

package/src/modularDrawer/hooks/__test__/useAssetAccountCounts.test.ts

@@ -0,0 +1,40 @@
+import { genAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
+import { useNetworkAccountCounts } from "../useNetworkAccountCounts";
+import { createFixtureCryptoCurrency } from "../../../mock/fixtures/cryptoCurrencies";
+
+const ethereumCurrency = createFixtureCryptoCurrency("ethereum");
+const ethereumAccountHigh = genAccount("ethereum-account-high", {
+  currency: ethereumCurrency,
+});
+
+describe("useNetworkAccountCounts", () => {
+  it("should return the count for one account", () => {
+    const assetAccountCounts = useNetworkAccountCounts({
+      networks: [ethereumCurrency],
+      nestedAccounts: [ethereumAccountHigh],
+      accountIds: new Map([[ethereumAccountHigh.id, true]]),
+      formatLabel: (count: number) => `${count}`,
+    });
+
+    expect(assetAccountCounts[0].count).toBe(1);
+    expect(assetAccountCounts[0].label).toBe("1");
+  });
+
+  it("should return the count for two accounts on ethereum", () => {
+    const ethereumAccountLow = genAccount("ethereum-account-low", {
+      currency: ethereumCurrency,
+    });
+    const assetAccountCounts = useNetworkAccountCounts({
+      networks: [ethereumCurrency],
+      nestedAccounts: [ethereumAccountHigh, ethereumAccountLow],
+      accountIds: new Map([
+        [ethereumAccountHigh.id, true],
+        [ethereumAccountLow.id, true],
+      ]),
+      formatLabel: (count: number) => `${count}`,
+    });
+
+    expect(assetAccountCounts[0].count).toBe(2);
+    expect(assetAccountCounts[0].label).toBe("2");
+  });
+});

package/src/modularDrawer/hooks/__test__/useCurrenciesUnderFeatureFlag.test.ts

@@ -0,0 +1,59 @@
+/**
+ * @jest-environment jsdom
+ */
+import { renderHook } from "@testing-library/react";
+import { useCurrenciesUnderFeatureFlag } from "../useCurrenciesUnderFeatureFlag";
+import { useFeature } from "../../../featureFlags";
+import useEnv from "../../../hooks/useEnv";
+
+jest.mock("../../../featureFlags", () => ({ useFeature: jest.fn() }));
+jest.mock("../../../hooks/useEnv", () => jest.fn());
+
+const mockUseFeature = jest.mocked(useFeature);
+const mockedEnvironment = jest.mocked(useEnv);
+
+describe("useCurrenciesUnderFeatureFlag", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return empty deactivatedCurrencyIds when all features are enabled", () => {
+    mockedEnvironment.mockReturnValue(false);
+    mockUseFeature.mockReturnValue({ enabled: true });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    expect(result.current.deactivatedCurrencyIds.size).toEqual(0);
+    expect(result.current.featureFlaggedCurrencies).toBeDefined();
+  });
+
+  it("should include disabled currencies in deactivatedCurrencyIds", () => {
+    mockedEnvironment.mockReturnValue(false);
+    mockUseFeature.mockReturnValue({ enabled: false });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    expect(result.current.deactivatedCurrencyIds.size).toBeGreaterThan(0);
+  });
+
+  it("should return empty deactivatedCurrencyIds when MOCK is true", () => {
+    mockedEnvironment.mockReturnValue(true);
+    mockUseFeature.mockReturnValue({ enabled: false });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    expect(result.current.deactivatedCurrencyIds.size).toBe(0);
+  });
+
+  it("should contain currency mappings", () => {
+    mockedEnvironment.mockReturnValue(false);
+    mockUseFeature.mockReturnValue({ enabled: true });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    const currencies = result.current.featureFlaggedCurrencies;
+    expect(currencies).toHaveProperty("aptos");
+    expect(currencies).toHaveProperty("stacks");
+    expect(currencies).toHaveProperty("optimism");
+  });
+});