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

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

@@ -134,6 +134,7 @@ export function transactionToIntent(
   const res: TransactionIntent & { memo?: { type: string; value?: string } } & {
     data?: { type: string; value?: unknown };
   } = {
+    intentType: isStaking ? "staking" : "transaction",
     type: intentType,
     sender: account.freshAddress,
     recipient: transaction.recipient,

package/src/bridge/mockHelpers.ts

@@ -183,3 +183,60 @@ export const makeAccountBridgeReceive: () => (
     path: account.freshAddressPath,
     publicKey: "mockPublickKey", // We could probably keep the publicKey in `account.freshPublicKey`
   });
+
+export const signRawOperation: AccountBridge<any>["signRawOperation"] = ({ account }) =>
+  new Observable(o => {
+    let cancelled = false;
+
+    async function main() {
+      await delay(1000);
+      if (cancelled) return;
+
+      for (let i = 0; i <= 1; i += 0.1) {
+        o.next({
+          type: "device-streaming",
+          progress: i,
+          index: i,
+          total: 10,
+        });
+        await delay(300);
+      }
+
+      o.next({
+        type: "device-signature-requested",
+      });
+      await delay(2000);
+      if (cancelled) return;
+      o.next({
+        type: "device-signature-granted",
+      });
+      const rng = new Prando("");
+      const op = genOperation(account, account, account.operations, rng);
+      op.type = "OUT";
+      op.value = new BigNumber(0);
+      op.blockHash = null;
+      op.blockHeight = null;
+      op.senders = [account.freshAddress];
+      op.recipients = [];
+      op.blockHeight = account.blockHeight;
+      op.date = new Date();
+      await delay(1000);
+      if (cancelled) return;
+      broadcasted[account.id] = (broadcasted[account.id] || []).concat(op);
+      o.next({
+        type: "signed",
+        signedOperation: {
+          operation: { ...op },
+          signature: "",
+        },
+      });
+    }
+
+    main().then(
+      () => o.complete(),
+      e => o.error(e),
+    );
+    return () => {
+      cancelled = true;
+    };
+  });

package/src/bridge/react/BridgeSync.test.tsx

@@ -2,13 +2,19 @@
  * @jest-environment jsdom
  */
 import "../../__tests__/test-helpers/dom-polyfill";
-import React from "react";
+import React, { useEffect } from "react";
 import { render, screen } from "@testing-library/react";
+import type { Account } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { Observable } from "rxjs";
+import type { Observer } from "rxjs";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 import { genAccount } from "../../mock/account";
-import { BridgeSync } from "./BridgeSync";
+import { BridgeSync, resetStates } from "./BridgeSync";
 import { setSupportedCurrencies } from "../../currencies";
-import { getAccountBridge } from "..";
+import * as Bridge from "..";
+import { useBridgeSync, useBridgeSyncState } from "./context";
+import type { Sync, BridgeSyncState } from "./types";
 
 jest.setTimeout(30000);
 
@@ -24,96 +30,521 @@ const defaultsBridgeSyncOpts = {
 
 setSupportedCurrencies(["bitcoin", "ethereum"]);
 
+const bitcoin = getCryptoCurrencyById("bitcoin");
+const ethereum = getCryptoCurrencyById("ethereum");
+
+const createAccount = (
+  id: string,
+  currency: CryptoCurrency,
+  options: Parameters<typeof genAccount>[1] = {},
+) => genAccount(id, { ...options, currency });
+
+type BridgeSyncRenderProps = Partial<Omit<React.ComponentProps<typeof BridgeSync>, "children">>;
+
+const renderBridgeSync = (props: BridgeSyncRenderProps = {}, children: React.ReactNode = null) =>
+  render(
+    <BridgeSync {...defaultsBridgeSyncOpts} {...props}>
+      {children}
+    </BridgeSync>,
+  );
+
+type AccountUpdater = (arg0: Account) => Account;
+
+const baseGetAccountBridge = Bridge.getAccountBridge;
+
+const withMockedAccountBridge = (
+  account: Account,
+  syncFactory: () => Observable<AccountUpdater>,
+) => {
+  const originalBridge = baseGetAccountBridge(account);
+  const mockBridge = {
+    ...originalBridge,
+    sync: syncFactory,
+  };
+  return jest.spyOn(Bridge, "getAccountBridge").mockImplementation(acc => {
+    if (acc.id === account.id) {
+      return mockBridge;
+    }
+    return baseGetAccountBridge(acc);
+  });
+};
+
+const mockBridgeSync = (
+  account: Account,
+  producer: (observer: Observer<AccountUpdater>) => void | (() => void),
+) =>
+  withMockedAccountBridge(
+    account,
+    () =>
+      new Observable<AccountUpdater>(observer => {
+        const cleanup = producer(observer);
+        return typeof cleanup === "function" ? cleanup : undefined;
+      }),
+  );
+
 describe("BridgeSync", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+    resetStates();
+  });
+
   test("initialize without an error", async () => {
-    render(<BridgeSync {...defaultsBridgeSyncOpts}>LOADED</BridgeSync>);
+    renderBridgeSync({}, "LOADED");
     expect(screen.getByText("LOADED")).not.toBeNull();
   });
 
-  test("executes a sync at start tracked as reason=initial", async () => {
-    await new Promise(resolve => {
-      const BTC = getCryptoCurrencyById("bitcoin");
-      const account = genAccount("btc1", { currency: BTC });
-      const futureOpLength = account.operations.length;
-      // we remove the first operation to feed it back as a broadcasted one, the mock impl will make it go back to operations
-      const lastOp = account.operations.splice(0, 1)[0];
-      getAccountBridge(account).broadcast({
-        account,
-        signedOperation: {
-          operation: lastOp,
-          signature: "",
-        },
-      });
-      const accounts = [account];
-      expect(accounts[0].operations.length).toBe(futureOpLength - 1);
-
-      function track(type, opts) {
-        if (type === "SyncSuccess") {
-          expect(opts).toMatchObject({
-            reason: "initial",
-            currencyName: "Bitcoin",
-            operationsLength: futureOpLength,
-          });
-          resolve(null);
-        }
+  test("executes a sync at start tracked as reason=initial", done => {
+    const account = createAccount("btc1", bitcoin);
+    const futureOpLength = account.operations.length;
+    // we remove the first operation to feed it back as a broadcasted one, the mock impl will make it go back to operations
+    const lastOp = account.operations.splice(0, 1)[0];
+    Bridge.getAccountBridge(account).broadcast({
+      account,
+      signedOperation: {
+        operation: lastOp,
+        signature: "",
+      },
+    });
+    const accounts = [account];
+    expect(accounts[0].operations.length).toBe(futureOpLength - 1);
+
+    function track(type, opts) {
+      if (type === "SyncSuccess") {
+        expect(opts).toMatchObject({
+          reason: "initial",
+          currencyName: "Bitcoin",
+          operationsLength: futureOpLength,
+        });
+        done();
       }
-      render(
-        <BridgeSync {...defaultsBridgeSyncOpts} accounts={accounts} trackAnalytics={track}>
-          {null}
-        </BridgeSync>,
-      );
+    }
+    renderBridgeSync({ accounts, trackAnalytics: track });
+  });
+
+  test("sync all accounts in parallel at start tracked as reason=initial", done => {
+    const accounts = [
+      createAccount("2btc1", bitcoin),
+      createAccount("2btc2", bitcoin),
+      createAccount("2eth1", ethereum),
+    ];
+    const synced: Array<Record<string, unknown>> = [];
+    let resolveFirst;
+    function prepareCurrency() {
+      if (!resolveFirst) {
+        return new Promise((resolve, reject) => {
+          resolveFirst = resolve;
+          setTimeout(
+            reject,
+            5000,
+            new Error("prepareCurrency doesn't seem to be called in parallel"),
+          );
+        });
+      }
+      // if we reach here, it means, we managed to have
+      // a SECOND sync that need to prepare currency
+      // so it's a proof that sync correctly runs in parallel
+      // otherwise it would timeout
+      resolveFirst();
+      return Promise.resolve();
+    }
+    function track(type, opts) {
+      expect(type).not.toEqual("SyncError");
+      if (type === "SyncSuccess") {
+        synced.push(opts);
+        expect(opts).toMatchObject({
+          reason: "initial",
+        });
+        if (synced.length === accounts.length) done();
+      }
+    }
+    renderBridgeSync({
+      accounts,
+      prepareCurrency,
+      trackAnalytics: track,
     });
   });
 
-  test("sync all accounts in parallel at start tracked as reason=initial", async () => {
-    await new Promise(resolve => {
-      const BTC = getCryptoCurrencyById("bitcoin");
-      const ETH = getCryptoCurrencyById("ethereum");
-      const accounts = [
-        genAccount("2btc1", { currency: BTC }),
-        genAccount("2btc2", { currency: BTC }),
-        genAccount("2eth1", { currency: ETH }),
-      ];
-      const synced: Array<any> = [];
-      let resolveFirst;
-      function prepareCurrency() {
-        if (!resolveFirst) {
-          return new Promise((resolve, reject) => {
-            resolveFirst = resolve;
-            setTimeout(
-              reject,
-              5000,
-              new Error("prepareCurrency doesn't seem to be called in parallel"),
-            );
-          });
+  test("provides context values correctly", () => {
+    const account = createAccount("btc1", bitcoin);
+    const accounts = [account];
+
+    let syncFunction: Sync | undefined;
+    let syncState: BridgeSyncState | undefined;
+
+    function TestComponent() {
+      syncFunction = useBridgeSync();
+      syncState = useBridgeSyncState();
+      return <div data-testid="test-component">Test</div>;
+    }
+
+    renderBridgeSync({ accounts }, <TestComponent />);
+
+    expect(syncFunction).toBeDefined();
+    expect(typeof syncFunction).toBe("function");
+    expect(syncState).toBeDefined();
+    expect(typeof syncState).toBe("object");
+  });
+
+  test("handles sync errors with recoverError function", done => {
+    const account = createAccount("btc1", bitcoin);
+    const accounts = [account];
+
+    const mockError = new Error("Sync failed");
+    const recoverError = jest.fn((error: Error) => {
+      expect(error.message).toBe("Sync failed");
+      return error; // Return error to treat as actual error
+    });
+
+    // Mock the account bridge to return an Observable that emits an error
+    mockBridgeSync(account, observer => {
+      const timeout = setTimeout(() => observer.error(mockError), 100);
+      return () => clearTimeout(timeout);
+    });
+
+    let syncStateChecked = false;
+    let syncStateRef: BridgeSyncState;
+    function TestComponent() {
+      const syncState = useBridgeSyncState();
+      syncStateRef = syncState;
+
+      // After the error is silenced, the sync state should show no error
+      setTimeout(() => {
+        if (!syncStateChecked && syncStateRef[account.id]) {
+          syncStateChecked = true;
+          expect(syncStateRef[account.id].error).toBe(mockError);
+          expect(recoverError).toHaveBeenCalledWith(mockError);
+          done();
         }
-        // if we reach here, it means, we managed to have
-        // a SECOND sync that need to prepare currency
-        // so it's a proof that sync correctly runs in parallel
-        // otherwise it would timeout
-        resolveFirst();
-        return Promise.resolve();
-      }
-      function track(type, opts) {
-        expect(type).not.toEqual("SyncError");
-        if (type === "SyncSuccess") {
-          synced.push(opts);
-          expect(opts).toMatchObject({
-            reason: "initial",
-          });
-          if (synced.length === accounts.length) resolve(null);
+      }, 200);
+
+      return <div>Test</div>;
+    }
+
+    renderBridgeSync({ accounts, recoverError }, <TestComponent />);
+  });
+
+  test("silences errors when recoverError returns null", done => {
+    const account = createAccount("btc1", bitcoin);
+    const accounts = [account];
+
+    const mockError = new Error("Sync failed but should be silenced");
+    const recoverError = jest.fn(() => null); // Return null to silence the error
+
+    // Mock the account bridge to return an Observable that emits an error
+    mockBridgeSync(account, observer => {
+      const timeout = setTimeout(() => observer.error(mockError), 100);
+      return () => clearTimeout(timeout);
+    });
+
+    let syncStateChecked = false;
+    let syncStateRef: BridgeSyncState;
+    function TestComponent() {
+      const syncState = useBridgeSyncState();
+      syncStateRef = syncState;
+
+      // After the error is silenced, the sync state should show no error
+      setTimeout(() => {
+        if (!syncStateChecked && syncStateRef[account.id]) {
+          syncStateChecked = true;
+          expect(syncStateRef[account.id].error).toBeNull();
+          expect(recoverError).toHaveBeenCalledWith(mockError);
+          done();
         }
-      }
-      render(
-        <BridgeSync
-          {...defaultsBridgeSyncOpts}
-          prepareCurrency={prepareCurrency}
-          accounts={accounts}
-          trackAnalytics={track}
-        >
-          {null}
-        </BridgeSync>,
-      );
+      }, 200);
+
+      return <div>Test</div>;
+    }
+
+    renderBridgeSync({ accounts, recoverError }, <TestComponent />);
+  });
+
+  test("handles blacklisted token IDs in sync config", () => {
+    const account = createAccount("btc1", bitcoin);
+    const blacklistedTokenIds = ["token1", "token2"];
+
+    renderBridgeSync({ accounts: [account], blacklistedTokenIds });
+
+    // Test passes if component renders without errors with blacklisted tokens
+    expect(blacklistedTokenIds).toHaveLength(2);
+  });
+
+  test("handles sync actions correctly", () => {
+    const account1 = createAccount("btc1", bitcoin);
+    const account2 = createAccount("eth1", ethereum);
+    const accounts = [account1, account2];
+
+    let sync: Sync | undefined;
+
+    function TestComponent() {
+      sync = useBridgeSync();
+      return <div>Test</div>;
+    }
+
+    renderBridgeSync({ accounts }, <TestComponent />);
+
+    expect(sync).toBeDefined();
+
+    // Test different sync actions
+    expect(() => {
+      sync?.({ type: "SYNC_ALL_ACCOUNTS", priority: 1, reason: "manual" });
+    }).not.toThrow();
+
+    expect(() => {
+      sync?.({ type: "SYNC_ONE_ACCOUNT", accountId: account1.id, priority: 1, reason: "manual" });
+    }).not.toThrow();
+
+    expect(() => {
+      sync?.({
+        type: "SYNC_SOME_ACCOUNTS",
+        accountIds: [account1.id],
+        priority: 1,
+        reason: "manual",
+      });
+    }).not.toThrow();
+
+    expect(() => {
+      sync?.({ type: "SET_SKIP_UNDER_PRIORITY", priority: 5 });
+    }).not.toThrow();
+
+    expect(() => {
+      sync?.({ type: "BACKGROUND_TICK", reason: "background" });
+    }).not.toThrow();
+  });
+
+  test("handles pending operations sync", () => {
+    const account = createAccount("btc1", bitcoin);
+
+    // Create account with pending operations
+    const accountWithPending = {
+      ...account,
+      pendingOperations: [
+        {
+          id: "pending1",
+          hash: "hash1",
+          type: "OUT" as const,
+          value: account.balance,
+          fee: account.balance.dividedBy(10),
+          blockHash: null,
+          blockHeight: null,
+          senders: [account.freshAddress],
+          recipients: ["recipient1"],
+          accountId: account.id,
+          date: new Date(),
+          extra: {},
+        },
+      ],
+    };
+
+    const accounts = [accountWithPending];
+
+    let sync: Sync | undefined;
+
+    function TestComponent() {
+      sync = useBridgeSync();
+      return <div>Test</div>;
+    }
+
+    renderBridgeSync({ accounts }, <TestComponent />);
+
+    expect(sync).toBeDefined();
+
+    // The component should automatically sync accounts with pending operations
+    // This is tested by checking that the component renders without errors
+    // and that pending operations are handled properly
+    expect(accountWithPending.pendingOperations.length).toBeGreaterThan(0);
+  });
+
+  test("hydrates currencies only once", async () => {
+    const account1 = createAccount("btc1", bitcoin);
+    const account2 = createAccount("btc2", bitcoin); // Same currency
+    const account3 = createAccount("eth1", ethereum);
+    const accounts = [account1, account2, account3];
+
+    const hydrateCurrency = jest.fn(() => Promise.resolve());
+
+    renderBridgeSync({ accounts, hydrateCurrency });
+
+    // Wait for hydration to complete
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    // Should only hydrate each currency once, not once per account
+    expect(hydrateCurrency).toHaveBeenCalledTimes(2); // BTC and ETH
+    expect(hydrateCurrency).toHaveBeenCalledWith(bitcoin);
+    expect(hydrateCurrency).toHaveBeenCalledWith(ethereum);
+  });
+
+  test("handles different sync actions", () => {
+    const account = createAccount("btc1", bitcoin);
+    const accounts = [account];
+
+    let sync: Sync | undefined;
+
+    function TestComponent() {
+      sync = useBridgeSync();
+      return <div>Test</div>;
+    }
+
+    renderBridgeSync({ accounts }, <TestComponent />);
+
+    expect(sync).toBeDefined();
+
+    // Test that sync actions can be called without throwing
+    expect(sync).toBeDefined();
+    const syncFn = sync!; // Assert non-null since we just checked
+
+    expect(() =>
+      syncFn({ type: "SYNC_ALL_ACCOUNTS", priority: 1, reason: "manual" }),
+    ).not.toThrow();
+    expect(() =>
+      syncFn({ type: "SYNC_ONE_ACCOUNT", accountId: account.id, priority: 1, reason: "manual" }),
+    ).not.toThrow();
+    expect(() => syncFn({ type: "SET_SKIP_UNDER_PRIORITY", priority: 5 })).not.toThrow();
+    expect(() => syncFn({ type: "BACKGROUND_TICK", reason: "background" })).not.toThrow();
+  });
+
+  test("tracks session analytics when all accounts complete", async () => {
+    const account1 = createAccount("btc1", bitcoin, { operationsSize: 3 });
+    const account2 = createAccount("eth1", ethereum, { operationsSize: 5 });
+    const accounts = [account1, account2];
+
+    const trackAnalytics = jest.fn();
+
+    renderBridgeSync({ accounts, trackAnalytics });
+
+    // Wait for potential analytics calls
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    // The component should not throw when tracking analytics
+    expect(accounts).toHaveLength(2);
+  });
+
+  test("handles non-existent account sync gracefully", () => {
+    const account = createAccount("btc1", bitcoin);
+    const accounts = [account];
+
+    let sync: Sync | undefined;
+
+    function TestComponent() {
+      sync = useBridgeSync();
+      return <div>Test</div>;
+    }
+
+    renderBridgeSync({ accounts }, <TestComponent />);
+
+    // Try to sync an account that doesn't exist - should not throw
+    expect(sync).toBeDefined();
+    const syncFn = sync!;
+
+    expect(() => {
+      syncFn({
+        type: "SYNC_ONE_ACCOUNT",
+        accountId: "non-existent-account",
+        priority: 1,
+        reason: "manual",
+      });
+    }).not.toThrow();
+  });
+
+  test("does not send analytics for background sync reason", done => {
+    const account = createAccount("btc1", bitcoin);
+    const accounts = [account];
+
+    const trackAnalytics = jest.fn();
+
+    // Mock the account bridge to complete successfully
+    mockBridgeSync(account, observer => {
+      observer.next((acc: typeof account) => acc);
+      observer.complete();
+    });
+
+    function TestComponent() {
+      const sync = useBridgeSync();
+
+      useEffect(() => {
+        // Trigger a background sync
+        sync({
+          type: "SYNC_ONE_ACCOUNT",
+          accountId: account.id,
+          priority: 1,
+          reason: "background",
+        });
+      }, [sync]);
+      return <div>Test</div>;
+    }
+
+    renderBridgeSync({ accounts, trackAnalytics }, <TestComponent />);
+
+    // Wait for sync to complete and verify no analytics were sent
+    setTimeout(() => {
+      // Should not have called trackAnalytics with SyncSuccess for background syncs
+      const syncSuccessCalls = trackAnalytics.mock.calls.filter(call => call[0] === "SyncSuccess");
+      expect(syncSuccessCalls).toHaveLength(0);
+
+      // Verify trackAnalytics was not called at all with SyncSuccess
+      expect(trackAnalytics).not.toHaveBeenCalledWith("SyncSuccess", expect.anything());
+
+      done();
+    }, 200);
+  });
+
+  test("sends analytics for non-background sync reason", done => {
+    const account = createAccount("btc1", bitcoin);
+    const accounts = [account];
+
+    const trackAnalytics = jest.fn();
+
+    // Mock the account bridge to complete successfully
+    mockBridgeSync(account, observer => {
+      observer.next((acc: typeof account) => acc);
+      observer.complete();
     });
+
+    function TestComponent() {
+      const sync = useBridgeSync();
+
+      useEffect(() => {
+        // Trigger a manual (non-background) sync
+        sync({
+          type: "SYNC_ONE_ACCOUNT",
+          accountId: account.id,
+          priority: 1,
+          reason: "manual",
+        });
+      }, [sync]);
+      return <div>Test</div>;
+    }
+
+    renderBridgeSync({ accounts, trackAnalytics }, <TestComponent />);
+
+    // Wait for sync to complete and verify analytics were sent
+    setTimeout(() => {
+      // Should have called trackAnalytics with SyncSuccess for manual syncs
+      expect(trackAnalytics).toHaveBeenCalledWith(
+        "SyncSuccess",
+        expect.objectContaining({
+          reason: "manual",
+          currencyName: account.currency.name,
+        }),
+      );
+
+      done();
+    }, 400);
+  });
+
+  test("provides sync state context", () => {
+    const account = createAccount("btc1", bitcoin);
+    const accounts = [account];
+
+    let syncState: BridgeSyncState | undefined;
+
+    function TestComponent() {
+      syncState = useBridgeSyncState();
+      return <div>Test</div>;
+    }
+
+    renderBridgeSync({ accounts }, <TestComponent />);
+
+    expect(syncState).toBeDefined();
+    expect(typeof syncState).toBe("object");
   });
 });