@ledgerhq/coin-framework 0.0.2-next.0

package/src/account/groupOperations.ts

@@ -0,0 +1,164 @@
+import { flattenAccounts } from "./helpers";
+import { flattenOperationWithInternalsAndNfts } from "../operation";
+import type {
+  AccountLike,
+  AccountLikeArray,
+  DailyOperations,
+  Operation,
+} from "@ledgerhq/types-live";
+
+function startOfDay(t: Date) {
+  return new Date(t.getFullYear(), t.getMonth(), t.getDate());
+}
+
+const emptyDailyOperations = {
+  sections: [],
+  completed: true,
+};
+type GroupOpsByDayOpts = {
+  count: number;
+  withSubAccounts?: boolean;
+  filterOperation?: (arg0: Operation, arg1: AccountLike) => boolean;
+};
+
+const hasStableOperation = (account: AccountLike, hash: string) =>
+  account.operations.some((op) => op.hash === hash);
+
+/**
+ * @memberof account
+ */
+export function groupAccountsOperationsByDay(
+  inputAccounts: AccountLikeArray,
+  { count, withSubAccounts, filterOperation }: GroupOpsByDayOpts
+): DailyOperations {
+  const accounts = withSubAccounts
+    ? flattenAccounts(inputAccounts)
+    : inputAccounts;
+  // Track indexes of account.operations[] for each account
+  const indexes: number[] = Array(accounts.length).fill(0);
+  // Track indexes of account.pendingOperations[] for each account
+  const indexesPending: number[] = Array(accounts.length).fill(0);
+
+  // Returns the next most recent operation from the account with current indexes
+  function getNext():
+    | {
+        ops: Operation[];
+        date: Date;
+      }
+    | null
+    | undefined {
+    let bestOp: Operation | null | undefined;
+    let bestOpInfo = {
+      accountI: 0,
+      fromPending: false,
+    };
+
+    for (let i = 0; i < accounts.length; i++) {
+      const account = accounts[i];
+      // look in operations
+      let op = account.operations[indexes[i]];
+
+      if (filterOperation) {
+        // skip operation we want to filter out
+        while (op && !filterOperation(op, account)) {
+          op = account.operations[++indexes[i]];
+        }
+      }
+
+      if (op && (!bestOp || op.date > bestOp.date)) {
+        bestOp = op;
+        bestOpInfo = {
+          accountI: i,
+          fromPending: false,
+        };
+      }
+
+      // look in pending operations
+      let opP = account.pendingOperations[indexesPending[i]];
+
+      while (
+        opP && // skip all pending operations that are already in operations
+        (hasStableOperation(account, opP.hash) || // but also if we want to filter it
+          (filterOperation && !filterOperation(opP, account)))
+      ) {
+        opP = account.pendingOperations[++indexesPending[i]];
+      }
+
+      if (opP && (!bestOp || opP.date > bestOp.date)) {
+        bestOp = opP;
+        bestOpInfo = {
+          accountI: i,
+          fromPending: true,
+        };
+      }
+    }
+
+    if (bestOp) {
+      if (bestOpInfo.fromPending) {
+        indexesPending[bestOpInfo.accountI]++;
+      } else {
+        indexes[bestOpInfo.accountI]++;
+      }
+
+      const ops = flattenOperationWithInternalsAndNfts(bestOp);
+      return {
+        ops,
+        date: bestOp.date,
+      };
+    }
+  }
+
+  let next = getNext();
+  if (!next) return emptyDailyOperations;
+  const sections: Array<{
+    day: Date;
+    data: Operation[];
+  }> = [];
+  let totalOperations = 0;
+  let day = startOfDay(next.date);
+  let data: Operation[] = [];
+
+  while (totalOperations < count && next) {
+    if (next.date < day) {
+      if (data.length > 0) {
+        const slicedData = data.slice(0, count - totalOperations);
+        sections.push({
+          day,
+          data: slicedData,
+        });
+        totalOperations += slicedData.length;
+      }
+
+      day = startOfDay(next.date);
+      data = next.ops;
+    } else {
+      data = data.concat(next.ops);
+    }
+
+    next = getNext();
+  }
+
+  if (data.length > 0 && totalOperations < count) {
+    sections.push({
+      day,
+      data,
+    });
+  }
+
+  return {
+    sections,
+    completed: !next,
+  };
+}
+
+/**
+ * Return a list of `{count}` operations grouped by day.
+ * @memberof account
+ */
+export function groupAccountOperationsByDay(
+  account: AccountLike,
+  arg: GroupOpsByDayOpts
+): DailyOperations {
+  const accounts: AccountLike[] = [account];
+  return groupAccountsOperationsByDay(accounts, arg);
+}

package/src/account/helpers.test.ts

@@ -0,0 +1,441 @@
+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 {
+  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 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);
+    });
+  });
+});