@ledgerhq/coin-framework 0.0.2

package/src/account/helpers.ts

@@ -0,0 +1,380 @@
+import { BigNumber } from "bignumber.js";
+import invariant from "invariant";
+import { getEnv } from "../env";
+import { encodeTokenAccountId } from "./accountId";
+import { emptyHistoryCache } from "./balanceHistoryCache";
+import type {
+  Account,
+  AccountLike,
+  AccountLikeArray,
+  SubAccount,
+  TokenAccount,
+  ChildAccount,
+} from "@ledgerhq/types-live";
+import {
+  CryptoCurrency,
+  TokenCurrency,
+  Unit,
+} from "@ledgerhq/types-cryptoassets";
+
+// by convention, a main account is the top level account
+// in case of an Account is the account itself
+// in case of a TokenAccount it's the parentAccount
+export const getMainAccount = (
+  account: AccountLike,
+  parentAccount?: Account | null | undefined
+): Account => {
+  const mainAccount = account.type === "Account" ? account : parentAccount;
+  invariant(mainAccount, "an account is expected");
+  return mainAccount as Account;
+};
+
+export const getAccountCurrency = (
+  account?: AccountLike
+): TokenCurrency | CryptoCurrency => {
+  switch (account?.type) {
+    case "Account":
+    case "ChildAccount":
+      return account.currency;
+
+    case "TokenAccount":
+      return account.token;
+
+    default:
+      throw new Error(
+        "invalid account.type=" + (account as unknown as { type: string })?.type
+      );
+  }
+};
+
+export const getAccountUnit = (account: AccountLike): Unit => {
+  switch (account.type) {
+    case "Account":
+      return account.unit;
+
+    case "TokenAccount":
+      return account.token.units[0];
+
+    case "ChildAccount":
+      return account.currency.units[0];
+
+    default:
+      throw new Error("invalid account.type=" + (account as AccountLike).type);
+  }
+};
+
+export const getAccountName = (account: AccountLike): string => {
+  switch (account.type) {
+    case "Account":
+    case "ChildAccount":
+      return account.name;
+
+    case "TokenAccount":
+      return account.token.name;
+
+    default:
+      throw new Error("invalid account.type=" + (account as AccountLike).type);
+  }
+};
+
+export const getAccountSpendableBalance = (account: AccountLike): BigNumber => {
+  switch (account.type) {
+    case "Account":
+    case "TokenAccount":
+      return account.spendableBalance;
+
+    case "ChildAccount":
+      return account.balance;
+
+    default:
+      throw new Error("invalid account.type=" + (account as AccountLike).type);
+  }
+};
+
+export const isAccountEmpty = (a: AccountLike): boolean => {
+  const hasSubAccounts =
+    a.type === "Account" && a.subAccounts && a.subAccounts.length;
+  return a.operationsCount === 0 && a.balance.isZero() && !hasSubAccounts;
+};
+
+export function areAllOperationsLoaded(account: AccountLike): boolean {
+  if (account.operationsCount !== account.operations.length) {
+    return false;
+  }
+
+  if (account.type === "Account" && account.subAccounts) {
+    return account.subAccounts.every(areAllOperationsLoaded);
+  }
+
+  return true;
+}
+
+export const isAccountBalanceSignificant = (a: AccountLike): boolean =>
+  a.balance.gt(100);
+
+// in future, could be a per currency thing
+// clear account to a bare minimal version that can be restored via sync
+// will preserve the balance to avoid user panic
+export function clearAccount<T extends AccountLike>(
+  account: T,
+  familyClean?: (account: Account) => void
+): T {
+  if (account.type === "TokenAccount") {
+    return {
+      ...account,
+      balanceHistoryCache: emptyHistoryCache,
+      operations: [],
+      pendingOperations: [],
+    };
+  }
+
+  if (account.type === "ChildAccount") {
+    return {
+      ...account,
+      balanceHistoryCache: emptyHistoryCache,
+      operations: [],
+      pendingOperations: [],
+    };
+  }
+
+  const copy: Account = {
+    ...account,
+    balanceHistoryCache: emptyHistoryCache,
+    lastSyncDate: new Date(0),
+    operations: [],
+    pendingOperations: [],
+    subAccounts:
+      (account as Account).subAccounts &&
+      (account as Account).subAccounts?.map((acc) =>
+        clearAccount(acc, familyClean)
+      ),
+  };
+
+  familyClean?.(copy);
+
+  delete copy.nfts;
+  return copy as T;
+}
+
+export function findSubAccountById(
+  account: Account,
+  id: string
+): SubAccount | null | undefined {
+  return (account.subAccounts || []).find((a) => a.id === id);
+}
+
+// get the token accounts of an account, ignoring those that are zero IF user don't want them
+export function listSubAccounts(account: Account): SubAccount[] {
+  const accounts = account.subAccounts || [];
+
+  if (getEnv("HIDE_EMPTY_TOKEN_ACCOUNTS")) {
+    return accounts.filter((a) => !a.balance.isZero());
+  }
+
+  return accounts;
+}
+
+export type FlattenAccountsOptions = {
+  enforceHideEmptySubAccounts?: boolean;
+};
+
+export function flattenAccounts(
+  topAccounts: AccountLikeArray,
+  o: FlattenAccountsOptions = {}
+): AccountLike[] {
+  const accounts: AccountLike[] = [];
+
+  for (let i = 0; i < topAccounts.length; i++) {
+    const account = topAccounts[i];
+    accounts.push(account);
+
+    if (account.type === "Account") {
+      const subAccounts = o.enforceHideEmptySubAccounts
+        ? listSubAccounts(account)
+        : account.subAccounts || [];
+
+      for (let j = 0; j < subAccounts.length; j++) {
+        accounts.push(subAccounts[j]);
+      }
+    }
+  }
+
+  return accounts;
+}
+
+export const shortAddressPreview = (addr: string, target = 20): string => {
+  const slice = Math.floor((target - 3) / 2);
+  return addr.length < target - 3
+    ? addr
+    : `${addr.slice(0, slice)}...${addr.slice(addr.length - slice)}`;
+};
+
+export const isAccountBalanceUnconfirmed = (account: AccountLike): boolean =>
+  account.pendingOperations.some(
+    (op) => !account.operations.find((o) => o.hash === op.hash)
+  ) || account.operations.some((op) => !op.blockHeight);
+
+export const isUpToDateAccount = (account: Account | null | undefined) => {
+  if (!account) return true;
+  const { lastSyncDate, currency } = account;
+  const { blockAvgTime } = currency;
+  if (!blockAvgTime) return true;
+  const outdated =
+    // FIXME: same here, we need to use valueOf for typescript to compare dates
+    Date.now().valueOf() - (lastSyncDate.valueOf() || 0) >
+    blockAvgTime * 1000 + getEnv("SYNC_OUTDATED_CONSIDERED_DELAY");
+  return !outdated;
+};
+
+export const makeEmptyTokenAccount = (
+  account: Account,
+  token: TokenCurrency
+): TokenAccount => ({
+  type: "TokenAccount",
+  id: account.id + "+" + token.contractAddress,
+  parentId: account.id,
+  token,
+  balance: new BigNumber(0),
+  spendableBalance: new BigNumber(0),
+  operationsCount: 0,
+  creationDate: new Date(),
+  operations: [],
+  pendingOperations: [],
+  starred: false,
+  swapHistory: [],
+  balanceHistoryCache: emptyHistoryCache,
+});
+
+/**
+ * Enhance an account to force token accounts presence
+ */
+export const accountWithMandatoryTokens = (
+  account: Account,
+  tokenCurrencies: TokenCurrency[]
+): Account => {
+  const { subAccounts } = account;
+  if (!subAccounts) return account;
+  const existingTokens = subAccounts
+    .map((a) => a.type === "TokenAccount" && a.token)
+    .filter(Boolean);
+  const addition = tokenCurrencies
+    .filter(
+      (
+        t // token of the same currency
+      ) => t.parentCurrency === account.currency && !existingTokens.includes(t) // not yet in the sub accounts
+    )
+    .map<TokenAccount>((token) => ({
+      type: "TokenAccount",
+      id: encodeTokenAccountId(account.id, token),
+      parentId: account.id,
+      token,
+      balance: new BigNumber(0),
+      spendableBalance: new BigNumber(0),
+      operationsCount: 0,
+      creationDate: new Date(),
+      operations: [],
+      pendingOperations: [],
+      starred: false,
+      swapHistory: [],
+      balanceHistoryCache: emptyHistoryCache,
+    }));
+  if (addition.length === 0) return account;
+  return { ...account, subAccounts: subAccounts.concat(addition) };
+};
+
+/**
+ * Patch account to enforce the removal of a blacklisted token
+ */
+export const withoutToken = (account: Account, tokenId: string): Account => {
+  const { subAccounts } = account;
+  if (!subAccounts) return account;
+  const tokenAccount = subAccounts.find(
+    (a) => a.type === "TokenAccount" && a.token.id === tokenId
+  );
+  if (!tokenAccount) return account;
+  return {
+    ...account,
+    subAccounts: subAccounts.filter((sa) => sa.id !== tokenAccount.id),
+  };
+};
+
+/**
+ * Find matching pair of subAccount/parentAccount for a given token curency
+ * if no subAccount found will return parentAccount or null if no matches found
+ */
+export const findTokenAccountByCurrency = (
+  tokenCurrency: TokenCurrency,
+  accounts: Account[]
+):
+  | {
+      account?: SubAccount;
+      parentAccount: Account;
+    }
+  | null
+  | undefined => {
+  const parentCurrency = tokenCurrency.parentCurrency;
+
+  for (const parentAccount of accounts) {
+    if (parentAccount.subAccounts && parentAccount.subAccounts.length > 0) {
+      for (const account of parentAccount.subAccounts) {
+        const c = getAccountCurrency(account);
+
+        if (c.id === tokenCurrency.id) {
+          // if token currency matches subAccount return couple account/parentAccount
+          return {
+            account,
+            parentAccount,
+          };
+        }
+      }
+    }
+
+    const parentC = getAccountCurrency(parentAccount);
+
+    if (parentC.id === parentCurrency.id) {
+      // if no token currency matches but parent matches return parentAccount
+      return {
+        parentAccount,
+      };
+    }
+  }
+
+  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";
+}
+
+export function isChildAccount(account?: AccountLike): account is ChildAccount {
+  return account?.type === "ChildAccount";
+}
+
+export function isSubAccount(account?: AccountLike): account is SubAccount {
+  return isTokenAccount(account) || isChildAccount(account);
+}
+
+export function getParentAccount(
+  account: AccountLike,
+  accounts: AccountLike[]
+): Account {
+  switch (account.type) {
+    case "Account":
+      return account;
+    case "TokenAccount":
+    case "ChildAccount": {
+      const parentAccount = accounts.find((a) => a.id == account.parentId);
+      if (!parentAccount) {
+        throw new Error(
+          "No 'parentAccount' account provided for token account"
+        );
+      }
+
+      return parentAccount as Account;
+    }
+  }
+}

package/src/account/index.ts

@@ -0,0 +1,10 @@
+export * from "./accountId";
+export * from "./accountName";
+export * from "./addAccounts";
+export * from "./balanceHistoryCache";
+export * from "./groupOperations";
+export * from "./helpers";
+export * from "./ordering";
+export * from "./pending";
+export * from "./serialization";
+export * from "./support";

package/src/account/ordering.ts

@@ -0,0 +1,109 @@
+import { BigNumber } from "bignumber.js";
+import { flattenAccounts, getAccountCurrency } from "./helpers";
+import type { FlattenAccountsOptions } from "./helpers";
+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) {
+    case "Account":
+      return a.name;
+
+    case "TokenAccount":
+      return a.token.name;
+
+    case "ChildAccount":
+      return a.currency.name;
+
+    default:
+      return "";
+  }
+};
+
+export const sortAccountsComparatorFromOrder = (
+  orderAccounts: string,
+  calculateCountervalue: (
+    currency: TokenCurrency | CryptoCurrency,
+    value: BigNumber
+  ) => BigNumber | null | undefined
+): AccountComparator => {
+  const [order, sort] = orderAccounts.split("|");
+  const ascValue = sort === "desc" ? -1 : 1;
+
+  if (order === "name") {
+    return (a, b) =>
+      ascValue *
+      sortNameLense(a).localeCompare(sortNameLense(b), undefined, {
+        numeric: true,
+      });
+  }
+
+  const cvCaches: Record<string, BigNumber> = {};
+
+  const lazyCalcCV = (a: AccountLike) => {
+    if (a.id in cvCaches) return cvCaches[a.id];
+    const v =
+      calculateCountervalue(getAccountCurrency(a), a.balance) ||
+      new BigNumber(-1);
+    cvCaches[a.id] = v;
+    return v;
+  };
+
+  return (a, b) => {
+    const diff = ascValue * lazyCalcCV(a).minus(lazyCalcCV(b)).toNumber();
+    if (diff === 0) return sortNameLense(a).localeCompare(sortNameLense(b));
+    return diff;
+  };
+};
+export const comparatorSortAccounts = <TA extends AccountLike>(
+  accounts: TA[],
+  comparator: AccountComparator
+): TA[] => {
+  const meta = accounts
+    .map((ta, index) => ({
+      account: ta,
+      index,
+    }))
+    .sort((a, b) => comparator(a.account, b.account));
+
+  if (meta.every((m, i) => m.index === i)) {
+    // account ordering is preserved, we keep the same array reference (this should happen most of the time)
+    return accounts;
+  }
+
+  // otherwise, need to reorder
+  return meta.map((m) => accounts[m.index]);
+};
+// flatten accounts and sort between them (used for grid mode)
+export const flattenSortAccounts = (
+  accounts: Account[],
+  comparator: AccountComparator,
+  o?: FlattenAccountsOptions
+): AccountLike[] => {
+  return comparatorSortAccounts(flattenAccounts(accounts, o), comparator);
+};
+// sort top level accounts and the inner sub accounts if necessary (used for lists)
+export const nestedSortAccounts = (
+  topAccounts: Account[],
+  comparator: AccountComparator
+): Account[] => {
+  let oneAccountHaveChanged = false;
+  // first of all we sort the inner token accounts
+  const accounts = topAccounts.map((a) => {
+    if (!a.subAccounts) return a;
+    const subAccounts = comparatorSortAccounts(a.subAccounts, comparator);
+    if (subAccounts === a.subAccounts) return a;
+    oneAccountHaveChanged = true;
+    return { ...a, subAccounts };
+  });
+  // then we sort again between them
+  return comparatorSortAccounts(
+    oneAccountHaveChanged ? accounts : topAccounts,
+    comparator
+  );
+};

package/src/account/pending.ts

@@ -0,0 +1,66 @@
+import type { Account, Operation, SubAccount } from "@ledgerhq/types-live";
+import { getEnv } from "../env";
+export function shouldRetainPendingOperation(
+  account: Account,
+  op: Operation
+): boolean {
+  // FIXME: valueOf to compare dates in typescript
+  const delay = new Date().valueOf() - op.date.valueOf();
+  const last = account.operations[0];
+
+  if (
+    last &&
+    last.transactionSequenceNumber &&
+    op.transactionSequenceNumber &&
+    op.transactionSequenceNumber <= last.transactionSequenceNumber
+  ) {
+    return false;
+  }
+
+  return delay < getEnv("OPERATION_OPTIMISTIC_RETENTION");
+}
+
+const appendPendingOp = (ops: Operation[], op: Operation) => {
+  const filtered: Operation[] = ops.filter(
+    (o) => o.transactionSequenceNumber !== op.transactionSequenceNumber
+  );
+  filtered.unshift(op);
+  return filtered;
+};
+
+export const addPendingOperation = (account: Account, operation: Operation) => {
+  const accountCopy = { ...account };
+  const { subOperations } = operation;
+  const { subAccounts } = account;
+
+  function addInSubAccount(subaccounts: SubAccount[], op: Operation) {
+    const acc = subaccounts.find((sub) => sub.id === op.accountId);
+
+    if (acc) {
+      const copy: SubAccount = { ...acc };
+      copy.pendingOperations = appendPendingOp(acc.pendingOperations, op);
+      subaccounts[subaccounts.indexOf(acc)] = copy;
+    }
+  }
+
+  if (subOperations && subAccounts) {
+    const taCopy: SubAccount[] = subAccounts.slice(0);
+    subOperations.forEach((op) => {
+      addInSubAccount(taCopy, op);
+    });
+    accountCopy.subAccounts = taCopy;
+  }
+
+  if (accountCopy.id === operation.accountId) {
+    accountCopy.pendingOperations = appendPendingOp(
+      accountCopy.pendingOperations,
+      operation
+    );
+  } else if (subAccounts) {
+    const taCopy: SubAccount[] = subAccounts.slice(0);
+    addInSubAccount(taCopy, operation);
+    accountCopy.subAccounts = taCopy;
+  }
+
+  return accountCopy;
+};