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

package/src/account/groupOperations.ts

@@ -1,16 +1,11 @@
-import type { AccountLikeArray, AccountLike, Operation } from "../types";
 import { flattenAccounts } from "./helpers";
 import { flattenOperationWithInternalsAndNfts } from "../operation";
-export type DailyOperationsSection = {
-  day: Date;
-  data: Operation[];
-};
-export type DailyOperations = {
-  // operations grouped by day
-  sections: DailyOperationsSection[];
-  // Is the sections complete? means there is no more operations to pull
-  completed: boolean;
-};
+import type {
+  AccountLike,
+  AccountLikeArray,
+  DailyOperations,
+  Operation,
+} from "@ledgerhq/types-live";
 
 function startOfDay(t) {
   return new Date(t.getFullYear(), t.getMonth(), t.getDate());

package/src/account/helpers.test.ts

@@ -0,0 +1,513 @@
+import {
+  CryptoCurrency,
+  TokenCurrency,
+  Unit,
+} from "@ledgerhq/types-cryptoassets";
+import {
+  Account,
+  ChildAccount,
+  Operation,
+  SubAccount,
+  TokenAccount,
+} from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import {
+  areAllOperationsLoaded,
+  emptyHistoryCache,
+  getAccountCurrency,
+  getAccountName,
+  getAccountSpendableBalance,
+  getAccountUnit,
+} from ".";
+import { BitcoinAccount } from "../families/bitcoin/types";
+import {
+  BandwidthInfo,
+  TronAccount,
+  TronResources,
+} from "../families/tron/types";
+import {
+  isAccountEmpty,
+  isAccountBalanceSignificant,
+  clearAccount,
+} from "./helpers";
+
+const mockAccount = {} as Account;
+const childAccount = {
+  ...mockAccount,
+  type: "ChildAccount",
+  parentId: "sampleId",
+  address: "sampleAddress",
+} as ChildAccount;
+const tokenAccount = {
+  ...mockAccount,
+  type: "TokenAccount",
+  token: {} as TokenCurrency,
+  parentId: "sampleId",
+} as TokenAccount;
+
+describe(getAccountCurrency.name, () => {
+  describe("given an Account", () => {
+    beforeEach(() => {
+      mockAccount.type = "Account";
+    });
+    it("should return the currency", () => {
+      const sampleCurrency = { family: "bitcoin" } as CryptoCurrency;
+      mockAccount.currency = sampleCurrency;
+      expect(getAccountCurrency(mockAccount)).toEqual(sampleCurrency);
+    });
+  });
+
+  describe("given a ChildAccount", () => {
+    it("should return the currency", () => {
+      const sampleCurrency = { family: "bitcoin" } as CryptoCurrency;
+      childAccount.currency = sampleCurrency;
+      expect(getAccountCurrency(childAccount)).toEqual(sampleCurrency);
+    });
+  });
+
+  describe("given a TokenAccount", () => {
+    it("should return the token currency", () => {
+      const sampleToken = { id: "tokenId" } as TokenCurrency;
+      tokenAccount.token = sampleToken;
+      expect(getAccountCurrency(tokenAccount)).toEqual(sampleToken);
+    });
+  });
+
+  describe("given an unknown type Account", () => {
+    beforeEach(() => {
+      (mockAccount as any).type = "DefinitelyNotAStandardAccount";
+    });
+
+    it("should throw an error", () => {
+      expect(() => getAccountCurrency(mockAccount)).toThrow(Error);
+    });
+
+    it("should display the account type in the error message", () => {
+      expect.assertions(1);
+      try {
+        getAccountCurrency(mockAccount);
+      } catch (e: unknown) {
+        expect((e as Error).message.includes(mockAccount.type)).toEqual(true);
+      }
+    });
+  });
+});
+
+describe(getAccountUnit.name, () => {
+  describe("given an Account", () => {
+    beforeEach(() => {
+      mockAccount.type = "Account";
+    });
+    it("should return the unit", () => {
+      const sampleUnit = { name: "unit" } as Unit;
+      mockAccount.unit = sampleUnit;
+      expect(getAccountUnit(mockAccount)).toEqual(sampleUnit);
+    });
+  });
+
+  describe("given a ChildAccount", () => {
+    it("should return the currency unit", () => {
+      const sampleUnit = { name: "unit" } as Unit;
+      childAccount.currency = { units: [sampleUnit] } as CryptoCurrency;
+      expect(getAccountUnit(childAccount)).toEqual(sampleUnit);
+    });
+  });
+
+  describe("given a TokenAccount", () => {
+    it("should return the token unit", () => {
+      const sampleUnit = { name: "unit" } as Unit;
+      tokenAccount.token = { units: [sampleUnit] } as TokenCurrency;
+      expect(getAccountUnit(tokenAccount)).toEqual(sampleUnit);
+    });
+  });
+
+  describe("given an unknown type Account", () => {
+    beforeEach(() => {
+      (mockAccount as any).type = "DefinitelyNotAStandardAccount";
+    });
+
+    it("should throw an error", () => {
+      expect(() => getAccountUnit(mockAccount)).toThrow(Error);
+    });
+
+    it("should display the account type in the error message", () => {
+      expect.assertions(1);
+      try {
+        getAccountUnit(mockAccount);
+      } catch (e: unknown) {
+        expect((e as Error).message.includes(mockAccount.type)).toEqual(true);
+      }
+    });
+  });
+});
+
+describe(getAccountName.name, () => {
+  describe("given an Account", () => {
+    beforeEach(() => {
+      mockAccount.type = "Account";
+    });
+    it("should return the account name", () => {
+      const sampleAccountName = "SampleAccountName";
+      mockAccount.name = sampleAccountName;
+      expect(getAccountName(mockAccount)).toEqual(sampleAccountName);
+    });
+  });
+
+  describe("given a ChildAccount", () => {
+    it("should return the account name", () => {
+      const sampleAccountName = "SampleAccountName";
+      childAccount.name = sampleAccountName;
+      expect(getAccountName(childAccount)).toEqual(sampleAccountName);
+    });
+  });
+
+  describe("given a TokenAccount", () => {
+    it("should return the token account name", () => {
+      const sampleAccountName = "SampleAccountName";
+      tokenAccount.token = { name: sampleAccountName } as TokenCurrency;
+      expect(getAccountName(tokenAccount)).toEqual(sampleAccountName);
+    });
+  });
+
+  describe("given an unknown type Account", () => {
+    beforeEach(() => {
+      (mockAccount as any).type = "DefinitelyNotAStandardAccount";
+    });
+
+    it("should throw an error", () => {
+      expect(() => getAccountName(mockAccount)).toThrow(Error);
+    });
+
+    it("should display the account type in the error message", () => {
+      expect.assertions(1);
+      try {
+        getAccountName(mockAccount);
+      } catch (e: unknown) {
+        expect((e as Error).message.includes(mockAccount.type)).toEqual(true);
+      }
+    });
+  });
+});
+
+describe(getAccountSpendableBalance.name, () => {
+  describe("given an Account", () => {
+    beforeEach(() => {
+      mockAccount.type = "Account";
+    });
+    it("should return the account spendable balance", () => {
+      const sampleAccountBalance = new BigNumber(10);
+      mockAccount.spendableBalance = sampleAccountBalance;
+      expect(getAccountSpendableBalance(mockAccount)).toEqual(
+        sampleAccountBalance
+      );
+    });
+  });
+
+  describe("given a ChildAccount", () => {
+    it("should return the account balance", () => {
+      const sampleAccountBalance = new BigNumber(10);
+      childAccount.balance = sampleAccountBalance;
+      expect(getAccountSpendableBalance(childAccount)).toEqual(
+        sampleAccountBalance
+      );
+    });
+  });
+
+  describe("given a TokenAccount", () => {
+    it("should return the token account spendable balance", () => {
+      const sampleAccountBalance = new BigNumber(10);
+      tokenAccount.spendableBalance = sampleAccountBalance;
+      expect(getAccountSpendableBalance(tokenAccount)).toEqual(
+        sampleAccountBalance
+      );
+    });
+  });
+
+  describe("given an unknown type Account", () => {
+    beforeEach(() => {
+      (mockAccount as any).type = "DefinitelyNotAStandardAccount";
+    });
+
+    it("should throw an error", () => {
+      expect(() => getAccountSpendableBalance(mockAccount)).toThrow(Error);
+    });
+
+    it("should display the account type in the error message", () => {
+      expect.assertions(1);
+      try {
+        getAccountSpendableBalance(mockAccount);
+      } catch (e: unknown) {
+        expect((e as Error).message.includes(mockAccount.type)).toEqual(true);
+      }
+    });
+  });
+});
+
+describe(isAccountEmpty.name, () => {
+  describe("given a Tron account", () => {
+    let tronAccount: TronAccount;
+    beforeEach(() => {
+      tronAccount = mockAccount as TronAccount;
+      tronAccount.type = "Account";
+      tronAccount.currency = { family: "tron" } as CryptoCurrency;
+    });
+    describe("when account as no ressources", () => {
+      beforeEach(() => {
+        tronAccount.tronResources = {
+          bandwidth: {
+            freeLimit: new BigNumber(0),
+          } as BandwidthInfo,
+        } as TronResources;
+      });
+
+      it("should return true", () => {
+        expect(isAccountEmpty(tronAccount)).toEqual(true);
+      });
+    });
+    describe("when account has resources", () => {
+      beforeEach(() => {
+        tronAccount.tronResources = {
+          bandwidth: {
+            freeLimit: new BigNumber(42),
+          } as BandwidthInfo,
+        } as TronResources;
+      });
+
+      it("should return false", () => {
+        expect(isAccountEmpty(tronAccount)).toEqual(false);
+      });
+    });
+  });
+
+  describe("given an account", () => {
+    beforeEach(() => {
+      mockAccount.type = "Account";
+      mockAccount.currency = { family: "ethereum" } as CryptoCurrency;
+    });
+    describe("when account has no subaccounts", () => {
+      beforeEach(() => {
+        mockAccount.subAccounts = [];
+      });
+
+      describe("and balance is zero", () => {
+        beforeEach(() => {
+          mockAccount.balance = new BigNumber(0);
+        });
+        it("should return true if operationsCount is 0", () => {
+          mockAccount.operationsCount = 0;
+          expect(isAccountEmpty(mockAccount)).toEqual(true);
+        });
+        it("should return false if operationsCount is higher than 0", () => {
+          mockAccount.operationsCount = 1;
+          expect(isAccountEmpty(mockAccount)).toEqual(false);
+        });
+      });
+
+      describe("and balance is higher than 0", () => {
+        beforeEach(() => {
+          mockAccount.balance = new BigNumber(42);
+        });
+        it("should return false if operationsCount is 0", () => {
+          mockAccount.operationsCount = 0;
+          expect(isAccountEmpty(mockAccount)).toEqual(false);
+        });
+        it("should return false if operationsCount is higher than 0", () => {
+          mockAccount.operationsCount = 1;
+          expect(isAccountEmpty(mockAccount)).toEqual(false);
+        });
+      });
+    });
+    describe("when account has subaccounts", () => {
+      beforeEach(() => {
+        mockAccount.subAccounts = [{} as SubAccount];
+      });
+
+      it("should return false", () => {
+        expect(isAccountEmpty(mockAccount)).toEqual(false);
+      });
+    });
+  });
+});
+
+describe(areAllOperationsLoaded.name, () => {
+  describe("given an account with subAccounts", () => {
+    beforeEach(() => {
+      mockAccount.type = "Account";
+      mockAccount.operations = [];
+      mockAccount.operationsCount = 0;
+      mockAccount.subAccounts = [
+        {
+          operations: [],
+          operationsCount: 0,
+        },
+        {
+          operations: [{} as Operation],
+          operationsCount: 1,
+        },
+      ] as SubAccount[];
+    });
+    describe("when sub account operation aren't loaded", () => {
+      beforeEach(() => {
+        (mockAccount.subAccounts as SubAccount[])[1].operations = [];
+      });
+      it("should return false", () => {
+        expect(areAllOperationsLoaded(mockAccount)).toEqual(false);
+      });
+    });
+
+    describe("when sub account operation are loaded", () => {
+      it("should return true", () => {
+        expect(areAllOperationsLoaded(mockAccount)).toEqual(true);
+      });
+    });
+  });
+  describe("given an account without subAccounts", () => {
+    describe("when operations count is different from operations length", () => {
+      beforeEach(() => {
+        childAccount.operationsCount = 2;
+        childAccount.operations = [{} as Operation];
+      });
+      it("should return false", () => {
+        expect(areAllOperationsLoaded(childAccount)).toEqual(false);
+      });
+    });
+
+    describe("when operations count is same as operations length", () => {
+      beforeEach(() => {
+        childAccount.operationsCount = 1;
+        childAccount.operations = [{} as Operation];
+      });
+      it("should return true", () => {
+        expect(areAllOperationsLoaded(childAccount)).toEqual(true);
+      });
+    });
+  });
+});
+
+describe(isAccountBalanceSignificant.name, () => {
+  describe("when balance is low", () => {
+    beforeEach(() => {
+      mockAccount.balance = new BigNumber(10);
+    });
+    it("should return false", () => {
+      expect(isAccountBalanceSignificant(mockAccount)).toEqual(false);
+    });
+  });
+  describe("when balance is high", () => {
+    beforeEach(() => {
+      mockAccount.balance = new BigNumber(101);
+    });
+    it("should return true", () => {
+      expect(isAccountBalanceSignificant(mockAccount)).toEqual(true);
+    });
+  });
+});
+
+describe(clearAccount.name, () => {
+  describe("given a TokenAccount", () => {
+    const tokenAccount = {
+      ...mockAccount,
+      token: {} as TokenCurrency,
+      parentId: "sampleId",
+      type: "TokenAccount",
+    } as TokenAccount;
+
+    it("should clear operations", () => {
+      const clearedAccount = clearAccount(tokenAccount);
+      expect(clearedAccount.operations.length).toEqual(0);
+      expect(clearedAccount.pendingOperations.length).toEqual(0);
+    });
+
+    it("should clear balanceHistory", () => {
+      const clearedAccount = clearAccount(tokenAccount);
+      expect(clearedAccount.balanceHistoryCache).toEqual(emptyHistoryCache);
+    });
+  });
+
+  describe("given a ChildAccount", () => {
+    const childAccount = {
+      ...mockAccount,
+      type: "ChildAccount",
+      parentId: "sampleId",
+      address: "sampleAddress",
+    } as ChildAccount;
+
+    it("should clear operations", () => {
+      const clearedAccount = clearAccount(childAccount);
+      expect(clearedAccount.operations.length).toEqual(0);
+      expect(clearedAccount.pendingOperations.length).toEqual(0);
+    });
+
+    it("should clear balanceHistory", () => {
+      const clearedAccount = clearAccount(childAccount);
+      expect(clearedAccount.balanceHistoryCache).toEqual(emptyHistoryCache);
+    });
+  });
+
+  describe("given an Account", () => {
+    const ethereumCurrency = {
+      family: "ethereum",
+    } as CryptoCurrency;
+    const withSubAccounts = {
+      ...mockAccount,
+      subAccounts: [
+        {
+          currency: ethereumCurrency,
+        } as SubAccount,
+      ],
+      currency: ethereumCurrency,
+    };
+    it("should clear operations", () => {
+      const clearedAccount = clearAccount(withSubAccounts);
+      expect(clearedAccount.operations.length).toEqual(0);
+      expect(clearedAccount.pendingOperations.length).toEqual(0);
+    });
+
+    it("should clear balanceHistory", () => {
+      const clearedAccount = clearAccount(withSubAccounts);
+      expect(clearedAccount.balanceHistoryCache).toEqual(emptyHistoryCache);
+    });
+
+    it("should reset lastSyncDate", () => {
+      const clearedAccount = clearAccount(withSubAccounts);
+      expect(clearedAccount.lastSyncDate).toEqual(new Date(0));
+    });
+
+    it("should delete nfts attribute", () => {
+      withSubAccounts.nfts = [];
+      const clearedAccount = clearAccount(withSubAccounts);
+      expect(Object.keys(clearedAccount).indexOf("nfts")).toEqual(-1);
+    });
+
+    describe("when it is a tron account", () => {
+      beforeEach(() => {
+        const tronCurrency = {
+          family: "tron",
+        } as CryptoCurrency;
+        withSubAccounts.currency = tronCurrency;
+      });
+
+      it("should reset tronResources cache", () => {
+        const clearedAccount = clearAccount(withSubAccounts) as TronAccount;
+        expect(
+          Object.keys(clearedAccount.tronResources.cacheTransactionInfoById)
+            .length
+        ).toEqual(0);
+      });
+    });
+
+    describe("when it is a bitcoin account", () => {
+      beforeEach(() => {
+        const btcCurrency = {
+          family: "bitcoin",
+        } as CryptoCurrency;
+        withSubAccounts.currency = btcCurrency;
+      });
+
+      it("should reset bitcoinResources", () => {
+        const clearedAccount = clearAccount(withSubAccounts) as BitcoinAccount;
+        expect(clearedAccount.bitcoinResources.utxos.length).toEqual(0);
+      });
+    });
+  });
+});

package/src/account/helpers.ts

@@ -1,20 +1,24 @@
 import { BigNumber } from "bignumber.js";
 import invariant from "invariant";
+import { getEnv } from "../env";
+import { encodeTokenAccountId } from "./accountId";
+import { emptyHistoryCache } from "./balanceHistoryCache";
+import { isAccountDelegating } from "../families/tezos/bakers";
+import {
+  BitcoinAccount,
+  initialBitcoinResourcesValue,
+} from "../families/bitcoin/types";
 import type {
+  Account,
   AccountLike,
   AccountLikeArray,
-  Account,
-  Unit,
   SubAccount,
-  TokenCurrency,
   TokenAccount,
   ChildAccount,
-} from "../types";
-import { getEnv } from "../env";
-import { encodeTokenAccountId } from "./accountId";
-import { emptyHistoryCache } from "./balanceHistoryCache";
-import { isAccountDelegating } from "../families/tezos/bakers";
-import { initialBitcoinResourcesValue } from "../families/bitcoin/types";
+} from "@ledgerhq/types-live";
+import { TokenCurrency, Unit } from "@ledgerhq/types-cryptoassets";
+import { TronAccount } from "../families/tron/types";
+import { CosmosAccount } from "../families/cosmos/types";
 
 // by convention, a main account is the top level account
 // in case of an Account is the account itself
@@ -87,14 +91,12 @@ export const getAccountSpendableBalance = (account: AccountLike): BigNumber => {
 };
 
 export const isAccountEmpty = (a: AccountLike): boolean => {
-  if (
-    a.type === "Account" &&
-    a.currency.id === "tron" &&
-    a.tronResources &&
+  if (a.type === "Account" && a.currency.family === "tron") {
+    const tronAcc = a as TronAccount;
     // FIXME: here we compared a BigNumber to a number, would always return false
-    a.tronResources.bandwidth.freeLimit.eq(0)
-  ) {
-    return true;
+    return (
+      tronAcc.tronResources && tronAcc.tronResources.bandwidth.freeLimit.eq(0)
+    );
   }
 
   const hasSubAccounts =
@@ -149,16 +151,17 @@ export function clearAccount<T extends AccountLike>(account: T): T {
       (account as Account).subAccounts &&
       (account as Account).subAccounts?.map(clearAccount),
   };
-  if (copy.tronResources) {
-    copy.tronResources = {
-      ...copy.tronResources,
+
+  if (copy.currency.family === "tron") {
+    const tronAcc = copy as TronAccount;
+    tronAcc.tronResources = {
+      ...tronAcc.tronResources,
       cacheTransactionInfoById: {},
     };
   }
-  if (copy.bitcoinResources) {
-    copy.bitcoinResources = initialBitcoinResourcesValue;
+  if (copy.currency.family === "bitcoin") {
+    (copy as BitcoinAccount).bitcoinResources = initialBitcoinResourcesValue;
   }
-  delete copy.balanceHistory;
   delete copy.nfts;
   return copy as T;
 }
@@ -240,15 +243,18 @@ export const getVotesCount = (
   const mainAccount = getMainAccount(account, parentAccount);
 
   // FIXME find a way to make it per family?
-  if (mainAccount.currency.id === "tezos") {
-    return isAccountDelegating(account) ? 1 : 0;
-  } else if (mainAccount.tronResources) {
-    return mainAccount.tronResources.votes.length;
-  } else if (mainAccount.cosmosResources) {
-    return mainAccount.cosmosResources.delegations.length;
+  switch (mainAccount.currency.family) {
+    case "tezos":
+      return isAccountDelegating(account) ? 1 : 0;
+    case "tron":
+      return (mainAccount as TronAccount)?.tronResources?.votes.length || 0;
+    case "cosmos":
+      return (
+        (mainAccount as CosmosAccount)?.cosmosResources?.delegations.length || 0
+      );
+    default:
+      return 0;
   }
-
-  return 0;
 };
 
 export const makeEmptyTokenAccount = (
@@ -367,6 +373,10 @@ export const findTokenAccountByCurrency = (
   return null; // else return nothing
 };
 
+export function isAccount(account: AccountLike): account is Account {
+  return account.type === "Account";
+}
+
 export function isTokenAccount(account: AccountLike): account is TokenAccount {
   return account.type === "TokenAccount";
 }

package/src/account/importAccounts.ts

@@ -1,10 +1,10 @@
-import type { Account } from "../types";
 import { log } from "@ledgerhq/logs";
 import type { Result } from "../cross";
 import { accountDataToAccount } from "../cross";
 import { findAccountMigration, checkAccountSupported } from "./support";
 import joinSwapHistories from "../exchange/swap/joinSwapHistories";
 import isEqual from "lodash/isEqual";
+import type { Account } from "@ledgerhq/types-live";
 const itemModeDisplaySort = {
   create: 1,
   update: 2,

package/src/account/ordering.ts

@@ -1,13 +1,13 @@
 import { BigNumber } from "bignumber.js";
-import type {
-  AccountLike,
-  Account,
-  TokenCurrency,
-  CryptoCurrency,
-} from "../types";
 import { flattenAccounts, getAccountCurrency } from "./helpers";
 import type { FlattenAccountsOptions } from "./helpers";
-type AccountComparator = (a: AccountLike, b: AccountLike) => number;
+import type { Account, AccountLike } from "@ledgerhq/types-live";
+import type {
+  CryptoCurrency,
+  TokenCurrency,
+} from "@ledgerhq/types-cryptoassets";
+
+export type AccountComparator = (a: AccountLike, b: AccountLike) => number;
 
 const sortNameLense = (a: AccountLike): string => {
   switch (a.type) {

package/src/account/pending.ts

@@ -1,4 +1,4 @@
-import type { Account, Operation, SubAccount } from "../types";
+import type { Account, Operation, SubAccount } from "@ledgerhq/types-live";
 import { getEnv } from "../env";
 export function shouldRetainPendingOperation(
   account: Account,