@ledgerhq/coin-framework 2.5.0 → 2.6.0-next.0

package/src/bridge/jsHelpers.test.ts

@@ -1,138 +1,435 @@
+import { getCryptoCurrencyById, listCryptoCurrencies } from "@ledgerhq/cryptoassets/currencies";
+import type {
+  Account,
+  Operation,
+  SyncConfig,
+  TokenAccount,
+  TransactionCommon,
+} from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { firstValueFrom } from "rxjs";
-import type { Account, SyncConfig, TransactionCommon } from "@ledgerhq/types-live";
-import { listCryptoCurrencies } from "@ledgerhq/cryptoassets/currencies";
-import { AccountShapeInfo, updateTransaction, makeSync, bip32asBuffer } from "./jsHelpers";
-
-describe("jsHelpers", () => {
-  describe("updateTransaction", () => {
-    it("should not update the transaction object", () => {
-      const transaction: TransactionCommon = {
-        recipient: "0x17733CAb76d9A2112576443F21735789733B1ca3",
-        amount: new BigNumber("10000000000000"),
-      };
+import {
+  AccountShapeInfo,
+  bip32asBuffer,
+  makeScanAccounts,
+  makeSync,
+  updateTransaction,
+} from "./jsHelpers";
+import { createEmptyHistoryCache } from "../account/balanceHistoryCache";
 
-      const updatedTransaction = updateTransaction(transaction, {
-        recipient: "0x17733CAb76d9A2112576443F21735789733B1ca3",
-        amount: new BigNumber("10000000000000"),
-      });
+describe("updateTransaction", () => {
+  it("should not update the transaction object", () => {
+    const transaction: TransactionCommon = {
+      recipient: "0x17733CAb76d9A2112576443F21735789733B1ca3",
+      amount: new BigNumber("10000000000000"),
+    };
 
-      expect(transaction).toBe(updatedTransaction);
+    const updatedTransaction = updateTransaction(transaction, {
+      recipient: "0x17733CAb76d9A2112576443F21735789733B1ca3",
+      amount: new BigNumber("10000000000000"),
     });
 
-    it("should update the transaction object", () => {
-      const transaction: TransactionCommon = {
-        recipient: "0x17733CAb76d9A2112576443F21735789733B1ca3",
-        amount: new BigNumber("10000000000000"),
-      };
+    expect(transaction).toBe(updatedTransaction);
+  });
 
-      const updatedTransaction = updateTransaction(transaction, {
-        recipient: "0x17733CAb76d9A2112576443F21735789733B1ca3",
-        amount: new BigNumber("20000000000000"),
-      });
+  it("should update the transaction object", () => {
+    const transaction: TransactionCommon = {
+      recipient: "0x17733CAb76d9A2112576443F21735789733B1ca3",
+      amount: new BigNumber("10000000000000"),
+    };
+
+    const updatedTransaction = updateTransaction(transaction, {
+      recipient: "0x17733CAb76d9A2112576443F21735789733B1ca3",
+      amount: new BigNumber("20000000000000"),
+    });
 
-      expect(transaction).not.toBe(updatedTransaction);
+    expect(transaction).not.toBe(updatedTransaction);
 
-      expect(updatedTransaction).toEqual({
-        ...transaction,
-        amount: new BigNumber("20000000000000"),
-      });
+    expect(updatedTransaction).toEqual({
+      ...transaction,
+      amount: new BigNumber("20000000000000"),
     });
   });
+});
 
-  describe("makeSync", () => {
-    it("returns a function to update account that give a new instance of account", async () => {
-      // Given
-      const account = createAccount({
-        id: "12",
-        creationDate: new Date("2024-05-12T17:04:12"),
-        lastSyncDate: new Date("2024-05-12T17:04:12"),
-      });
+describe("makeSync", () => {
+  it("returns a function to update account that give a new instance of account", async () => {
+    // Given
+    const account = createAccount({
+      id: "12",
+      creationDate: new Date("2024-05-12T17:04:12"),
+      lastSyncDate: new Date("2024-05-12T17:04:12"),
+    });
 
-      // When
-      const accountUpdater = makeSync({
-        getAccountShape: (_accountShape: AccountShapeInfo) => Promise.resolve({} as Account),
-      })(account, {} as SyncConfig);
-      const updater = await firstValueFrom(accountUpdater);
-      const newAccount = updater(account);
+    // When
+    const accountUpdater = makeSync({
+      getAccountShape: (_accountShape: AccountShapeInfo) => Promise.resolve({} as Account),
+    })(account, {} as SyncConfig);
+    const updater = await firstValueFrom(accountUpdater);
+    const newAccount = updater(account);
 
-      // Then
-      const nonUpdatedFields = {
-        ...account,
-        id: expect.any(String),
+    // Then
+    const nonUpdatedFields = {
+      ...account,
+      id: expect.any(String),
+      creationDate: expect.any(Date),
+      lastSyncDate: expect.any(Date),
+      subAccounts: [],
+    };
+    expect(newAccount).toEqual(nonUpdatedFields);
+    expect(newAccount.id).not.toEqual(account.id);
+    expect(newAccount.creationDate).not.toEqual(account.creationDate);
+    expect(newAccount.lastSyncDate).not.toEqual(account.lastSyncDate);
+  });
+
+  it("returns a account with a corrected formatted id", async () => {
+    // Given
+    const account = createAccount({
+      id: "12",
+      creationDate: new Date("2024-05-12T17:04:12"),
+      lastSyncDate: new Date("2024-05-12T17:04:12"),
+    });
+
+    // When
+    const accountUpdater = makeSync({
+      getAccountShape: (_accountShape: AccountShapeInfo) => Promise.resolve({} as Account),
+    })(account, {} as SyncConfig);
+    const updater = await firstValueFrom(accountUpdater);
+    const newAccount = updater(account);
+
+    // Then
+    const expectedAccount = {
+      ...account,
+      id: "js:2:bitcoin::",
+      subAccounts: undefined,
+    };
+    expect(newAccount.id).toEqual(expectedAccount.id);
+  });
+});
+
+describe("makeScanAccounts", () => {
+  it("returns the first account found when there is no one used previously", async () => {
+    // Given
+    const addressResolver = {
+      address: "address",
+      path: "path",
+      publicKey: "publicKey",
+    };
+    const syncConfig = {
+      paginationConfig: {},
+    };
+    const deviceId = "deviceId";
+    const currency = getCryptoCurrencyById("algorand");
+
+    // When
+    const scanAccounts = makeScanAccounts({
+      getAccountShape: (accountShape, config) => {
+        expect(config).toBe(syncConfig);
+        expect(accountShape.currency).toBe(currency);
+        expect(accountShape.address).toBe(addressResolver.address);
+        expect(accountShape.derivationPath).toBe(addressResolver.path);
+        expect(accountShape.deviceId).toBe(deviceId);
+        return Promise.resolve({
+          id: "1234",
+          balanceHistoryCache: createEmptyHistoryCache(),
+        });
+      },
+      getAddressFn: (_deviceId, _addressOpt) => Promise.resolve(addressResolver),
+    });
+
+    // Then
+    const result = await firstValueFrom(
+      scanAccounts({
+        currency,
+        deviceId,
+        syncConfig,
+      }),
+    );
+
+    expect(result).toEqual({
+      account: {
+        id: "1234",
+        balance: new BigNumber("0"),
+        balanceHistoryCache: createEmptyHistoryCache(),
+        blockHeight: 0,
         creationDate: expect.any(Date),
+        currency,
+        derivationMode: "",
+        freshAddress: addressResolver.address,
+        freshAddressPath: addressResolver.path,
+        index: 0,
         lastSyncDate: expect.any(Date),
-        subAccounts: [],
-      };
-      expect(newAccount).toEqual(nonUpdatedFields);
-      expect(newAccount.id).not.toEqual(account.id);
-      expect(newAccount.creationDate).not.toEqual(account.creationDate);
-      expect(newAccount.lastSyncDate).not.toEqual(account.lastSyncDate);
+        operations: [],
+        operationsCount: 0,
+        pendingOperations: [],
+        seedIdentifier: addressResolver.publicKey,
+        spendableBalance: new BigNumber("0"),
+        swapHistory: [],
+        type: "Account",
+        used: false,
+      },
+      type: "discovered",
+    });
+  });
+
+  it("throws an error when the GetAccountShape does not return an id", async () => {
+    // Given
+    const addressResolver = {
+      address: "address",
+      path: "path",
+      publicKey: "publicKey",
+    };
+
+    // When
+    const scanAccounts = makeScanAccounts({
+      getAccountShape: () =>
+        Promise.resolve({
+          balanceHistoryCache: createEmptyHistoryCache(),
+        }),
+      getAddressFn: (_deviceId, _addressOpt) => Promise.resolve(addressResolver),
+    });
+
+    // Then
+    expect(
+      firstValueFrom(
+        scanAccounts({
+          currency: getCryptoCurrencyById("algorand"),
+          deviceId: "deviceId",
+          syncConfig: {
+            paginationConfig: {},
+          },
+        }),
+      ),
+    ).rejects.toThrow("account ID must be provided");
+  });
+
+  it("throws an error when the GetAccountShape returns an incorrect balance", async () => {
+    // Given
+    const addressResolver = {
+      address: "address",
+      path: "path",
+      publicKey: "publicKey",
+    };
+
+    // When
+    const scanAccounts = makeScanAccounts({
+      getAccountShape: () =>
+        Promise.resolve({
+          id: "1234",
+          balance: new BigNumber("NULL"),
+          balanceHistoryCache: createEmptyHistoryCache(),
+        }),
+      getAddressFn: (_deviceId, _addressOpt) => Promise.resolve(addressResolver),
+    });
+
+    // Then
+    expect(
+      firstValueFrom(
+        scanAccounts({
+          currency: getCryptoCurrencyById("algorand"),
+          deviceId: "deviceId",
+          syncConfig: {
+            paginationConfig: {},
+          },
+        }),
+      ),
+    ).rejects.toThrow("invalid balance NaN");
+  });
+
+  it.each([
+    {
+      balance: new BigNumber(1_000_000),
+      operationsCount: 0,
+    },
+    {
+      balance: new BigNumber(0),
+      operationsCount: 1,
+    },
+    {
+      balance: new BigNumber(0),
+      operations: [{}] as Operation[],
+    },
+    {
+      balance: new BigNumber(0),
+      operationsCount: 0,
+      subAccounts: [{}] as TokenAccount[],
+    },
+  ])("returns an account flag as used", async account => {
+    // Given
+    const addressResolver = {
+      address: "address",
+      path: "path",
+      publicKey: "publicKey",
+    };
+    const currency = getCryptoCurrencyById("algorand");
+
+    // When
+    const scanAccounts = makeScanAccounts({
+      getAccountShape: () =>
+        Promise.resolve({
+          ...account,
+          id: "1234",
+          balanceHistoryCache: createEmptyHistoryCache(),
+        }),
+      getAddressFn: (_deviceId, _addressOpt) => Promise.resolve(addressResolver),
     });
 
-    it("returns a account with a corrected formatted id", async () => {
+    // Then
+    const result = await firstValueFrom(
+      scanAccounts({
+        currency,
+        deviceId: "deviceId",
+        syncConfig: {
+          paginationConfig: {},
+        },
+      }),
+    );
+
+    expect(result.account.used).toBe(true);
+  });
+
+  it.each([
+    {
+      account: {
+        balance: new BigNumber(0),
+      },
+      expectedUsed: false,
+    },
+    {
+      account: {
+        balance: new BigNumber(0),
+        used: true,
+      },
+      expectedUsed: true,
+    },
+    {
+      account: {
+        balance: new BigNumber(1_000_000),
+        used: false,
+      },
+      expectedUsed: false,
+    },
+    {
+      account: {
+        balance: new BigNumber(1_000_000),
+      },
+      expectedUsed: true,
+    },
+  ])(
+    "overrides the used flag only if not returned by the getAccountShape",
+    async ({ account, expectedUsed }) => {
       // Given
-      const account = createAccount({
-        id: "12",
-        creationDate: new Date("2024-05-12T17:04:12"),
-        lastSyncDate: new Date("2024-05-12T17:04:12"),
-      });
+      const addressResolver = {
+        address: "address",
+        path: "path",
+        publicKey: "publicKey",
+      };
+      const currency = getCryptoCurrencyById("algorand");
 
       // When
-      const accountUpdater = makeSync({
-        getAccountShape: (_accountShape: AccountShapeInfo) => Promise.resolve({} as Account),
-      })(account, {} as SyncConfig);
-      const updater = await firstValueFrom(accountUpdater);
-      const newAccount = updater(account);
+      const scanAccounts = makeScanAccounts({
+        getAccountShape: () =>
+          Promise.resolve({
+            ...account,
+            id: "1234",
+            balanceHistoryCache: createEmptyHistoryCache(),
+          }),
+        getAddressFn: (_deviceId, _addressOpt) => Promise.resolve(addressResolver),
+      });
 
       // Then
-      const expectedAccount = {
-        ...account,
-        id: "js:2:bitcoin::",
-        subAccounts: undefined,
-      };
-      expect(newAccount.id).toEqual(expectedAccount.id);
+      const result = await firstValueFrom(
+        scanAccounts({
+          currency,
+          deviceId: "deviceId",
+          syncConfig: {
+            paginationConfig: {},
+          },
+        }),
+      );
+
+      expect(result.account.used).toEqual(expectedUsed);
+    },
+  );
+
+  it("returns all accounts found until the first not used yet", done => {
+    // Given
+    const addressResolver = {
+      address: "address",
+      path: "path",
+      publicKey: "publicKey",
+    };
+
+    const USED_ACCOUNT_NUMN = 2;
+    let scanCall = 0;
+    const scanAccounts = makeScanAccounts({
+      getAccountShape: () => {
+        scanCall++;
+        const used = scanCall > USED_ACCOUNT_NUMN ? false : true;
+        return Promise.resolve({
+          used,
+          id: `1234${scanCall}`,
+          balanceHistoryCache: createEmptyHistoryCache(),
+        });
+      },
+      getAddressFn: (_deviceId, _addressOpt) => Promise.resolve(addressResolver),
     });
-  });
 
-  describe("bip32asBuffer", () => {
-    it.each([
-      {
-        name: "Simple",
-        derivationPath: "m/44'/1/1/0",
-        expectedResult: "048000002c000000010000000100000000",
+    // When
+    let subscribeCalled = 0;
+    scanAccounts({
+      currency: getCryptoCurrencyById("algorand"),
+      deviceId: "deviceId",
+      syncConfig: {
+        paginationConfig: {},
       },
-      {
-        name: "Hardened coin type",
-        derivationPath: "m/44'/1'/1/0",
-        expectedResult: "048000002c800000010000000100000000",
+    }).subscribe({
+      // Then
+      next: ({ account, type }) => {
+        subscribeCalled++;
+        expect(type).toEqual("discovered");
+        expect(["12341", "12342", "12343"]).toContain(account.id);
+        if (account.id === "12343") {
+          expect(account.used).toBeFalsy();
+        } else {
+          expect(account.used).toBeTruthy();
+        }
       },
-      {
-        name: "Hardened account",
-        derivationPath: "m/44'/1'/1'/0",
-        expectedResult: "048000002c800000018000000100000000",
+      complete: () => {
+        try {
+          // Expect that the 3 account have been found, 2 existing one + the usuned one
+          expect(subscribeCalled).toEqual(USED_ACCOUNT_NUMN + 1);
+          done();
+        } catch (e) {
+          done(e);
+        }
       },
-    ])("converts path for AppCoins with $name case", ({ derivationPath, expectedResult }) => {
-      const path = bip32asBuffer(derivationPath);
-      expect(path).toEqual(Buffer.from(expectedResult, "hex"));
     });
   });
 });
 
-const emptyHistoryCache = {
-  HOUR: {
-    latestDate: null,
-    balances: [],
-  },
-  DAY: {
-    latestDate: null,
-    balances: [],
-  },
-  WEEK: {
-    latestDate: null,
-    balances: [],
-  },
-};
+describe("bip32asBuffer", () => {
+  it.each([
+    {
+      name: "Simple",
+      derivationPath: "m/44'/1/1/0",
+      expectedResult: "048000002c000000010000000100000000",
+    },
+    {
+      name: "Hardened coin type",
+      derivationPath: "m/44'/1'/1/0",
+      expectedResult: "048000002c800000010000000100000000",
+    },
+    {
+      name: "Hardened account",
+      derivationPath: "m/44'/1'/1'/0",
+      expectedResult: "048000002c800000018000000100000000",
+    },
+  ])("converts path for AppCoins with $name case", ({ derivationPath, expectedResult }) => {
+    const path = bip32asBuffer(derivationPath);
+    expect(path).toEqual(Buffer.from(expectedResult, "hex"));
+  });
+});
 
 // Call once for all tests the currencies. Relies on real implementation to check also consistency.
 const bitcoinCurrency = listCryptoCurrencies(true).find(c => c.id === "bitcoin")!;
@@ -158,7 +455,7 @@ function createAccount(init: Partial<Account>): Account {
     pendingOperations: [],
     lastSyncDate: new Date(),
     // subAccounts: [],
-    balanceHistoryCache: emptyHistoryCache,
+    balanceHistoryCache: createEmptyHistoryCache(),
     swapHistory: [],
   };
 }

package/src/bridge/jsHelpers.ts

@@ -180,6 +180,7 @@ export const makeSync =
     T extends TransactionCommon = TransactionCommon,
     A extends Account = Account,
     U extends TransactionStatusCommon = TransactionStatusCommon,
+    O extends Operation = Operation,
     R extends AccountRaw = AccountRaw,
   >({
     getAccountShape,
@@ -189,7 +190,7 @@ export const makeSync =
     getAccountShape: GetAccountShape<A>;
     postSync?: (initial: A, synced: A) => A;
     shouldMergeOps?: boolean;
-  }): AccountBridge<T, A, U, R>["sync"] =>
+  }): AccountBridge<T, A, U, O, R>["sync"] =>
   (initial, syncConfig): Observable<AccountUpdater<A>> =>
     new Observable((o: Observer<(acc: A) => A>) => {
       async function main() {
@@ -384,7 +385,7 @@ export const makeScanAccounts =
           account.balanceHistoryCache = generateHistoryFromOperations(account);
         }
 
-        if (!account.used) {
+        if (accountShape.used === undefined) {
           account.used = !isAccountEmpty(account);
         }