@ledgerhq/live-common 23.1.0 → 24.0.0-next.0

package/src/portfolio/index.ts

@@ -1,505 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import memoize from "lodash/memoize";
-import last from "lodash/last";
-import find from "lodash/find";
-import type {
-  AccountLikeArray,
-  AccountLike,
-  Account,
-  BalanceHistory,
-  AccountPortfolio,
-  CurrencyPortfolio,
-  PortfolioRange,
-  BalanceHistoryWithCountervalue,
-  Portfolio,
-  AssetsDistribution,
-  TokenCurrency,
-  CryptoCurrency,
-} from "../types";
-import { getOperationAmountNumberWithInternals } from "../operation";
-import { flattenAccounts, getAccountCurrency } from "../account/helpers";
-import { getEnv } from "../env";
-import { getPortfolioRangeConfig, getDates } from "./range";
-
-export * from "./range";
-
-type GetBalanceHistory = (
-  account: AccountLike,
-  r: PortfolioRange
-) => BalanceHistory;
-
-/**
- * generate an array of {daysCount} datapoints, one per day,
- * for the balance history of an account.
- * The last item of the array is the balance available right now.
- * @memberof account
- */
-const getBalanceHistoryImpl: GetBalanceHistory = (account, r) => {
-  const conf = getPortfolioRangeConfig(r);
-  const history: Array<{ date: Date; value: BigNumber }> = [];
-  let { balance } = account;
-  const operationsLength = account.operations.length;
-  let i = 0; // index of operation
-
-  let t = new Date();
-  history.unshift({
-    date: t,
-    value: balance,
-  });
-  t = new Date((conf.startOf(t) as any) - 1); // end of yesterday
-
-  for (let d = conf.count - 1; d > 0; d--) {
-    // accumulate operations after time t
-    while (i < operationsLength && account.operations[i].date > t) {
-      balance = balance.minus(
-        getOperationAmountNumberWithInternals(account.operations[i])
-      );
-      i++;
-    }
-
-    if (i === operationsLength) {
-      // When there is no more operation, we consider we reached ZERO to avoid invalid assumption that balance was already available.
-      balance = new BigNumber(0);
-    }
-
-    history.unshift({
-      date: t,
-      value: BigNumber.max(balance, 0),
-    });
-    t = new Date((t as any) - conf.increment);
-  }
-
-  return history;
-};
-
-const accountRateHash = (account, r) =>
-  `${r}_${account.id}_${account.balance.toString()}_${
-    account.operations[0] ? account.operations[0].id : ""
-  }`;
-
-export const getBalanceHistoryJS: GetBalanceHistory = memoize(
-  getBalanceHistoryImpl,
-  accountRateHash
-);
-export const getBalanceHistory: GetBalanceHistory = (account, r) => {
-  // try to find it in the account object
-  const balanceHistory = account.balanceHistory;
-
-  if (
-    balanceHistory &&
-    balanceHistory[r] &&
-    (<BalanceHistory>balanceHistory[r]).length > 1
-  ) {
-    return <BalanceHistory>balanceHistory[r];
-  }
-
-  // fallback on JS implementation
-  return getBalanceHistoryJS(account, r);
-};
-type GetBalanceHistoryWithCountervalue = (
-  account: AccountLike,
-  r: PortfolioRange,
-  calculateAccountCounterValue: (
-    arg0: TokenCurrency | CryptoCurrency,
-    arg1: BigNumber,
-    arg2: Date
-  ) => BigNumber | null | undefined,
-  useEffectiveFrom?: boolean
-) => AccountPortfolio;
-
-// hash the "stable" part of the histo
-// only the latest datapoint is "unstable" meaning it always changes because it's the current date.
-const accountRateHashCVStable = (account, r, cvRef, useEffectiveFrom) =>
-  `${accountRateHash(account, r)}_${cvRef ? cvRef.toString() : "none"}_${
-    useEffectiveFrom ? "withEffectiveFrom" : ""
-  }`;
-
-const accountCVstableCache = {};
-const ZERO = new BigNumber(0);
-const percentageHighThreshold = 100000;
-
-const meaningfulPercentage = (
-  deltaChange: BigNumber | null | undefined,
-  balanceDivider: BigNumber | null | undefined
-): BigNumber | null | undefined => {
-  if (deltaChange && balanceDivider && !balanceDivider.isZero()) {
-    const percent = deltaChange.div(balanceDivider);
-
-    if (percent.lt(percentageHighThreshold)) {
-      return percent;
-    }
-  }
-};
-
-export const getBalanceHistoryWithCountervalue: GetBalanceHistoryWithCountervalue =
-  (account, r, calc, useEffectiveFrom = true) => {
-    const history = getBalanceHistory(account, r);
-    const cur = getAccountCurrency(account);
-    // a high enough value so we can compare if something changes
-    const cacheReferenceValue = new BigNumber("10").pow(
-      3 + cur.units[0].magnitude
-    );
-    // pick a stable countervalue point in time to hash for the cache
-    const cvRef = calc(cur, cacheReferenceValue, history[0].date);
-
-    const mapFn = (p) => ({
-      ...p,
-      countervalue: (cvRef && calc(cur, p.value, p.date)) || ZERO,
-    });
-
-    const stableHash = accountRateHashCVStable(
-      account,
-      r,
-      cvRef,
-      useEffectiveFrom
-    );
-    let stable = accountCVstableCache[stableHash];
-    const lastPoint = mapFn(history[history.length - 1]);
-
-    const calcChanges = (h: BalanceHistoryWithCountervalue) => {
-      // previous existing implementation here
-      const from = h[0];
-      const to = h[h.length - 1];
-      const fromEffective = useEffectiveFrom
-        ? find(h, (record) => record.value.isGreaterThan(0)) || from
-        : from;
-      return {
-        countervalueReceiveSum: new BigNumber(0),
-        // not available here
-        countervalueSendSum: new BigNumber(0),
-        cryptoChange: {
-          value: to.value.minus(fromEffective.value),
-          percentage: null,
-        },
-        countervalueChange: {
-          value: (to.countervalue || ZERO).minus(
-            fromEffective.countervalue || ZERO
-          ),
-          percentage: meaningfulPercentage(
-            (to.countervalue || ZERO).minus(fromEffective.countervalue || ZERO),
-            fromEffective.countervalue
-          ),
-        },
-      };
-    };
-
-    if (!stable) {
-      const h = history.map(mapFn);
-      stable = {
-        history: h,
-        countervalueAvailable: !!cvRef,
-        ...calcChanges(h),
-      };
-      accountCVstableCache[stableHash] = stable;
-      return stable;
-    }
-
-    const lastStable: any = last(stable.history);
-
-    if (lastPoint.countervalue.eq(lastStable.countervalue)) {
-      return stable;
-    }
-
-    const h = stable.history.slice(0, -1).concat(lastPoint);
-    const copy = { ...stable, history: h, ...calcChanges(h) };
-    accountCVstableCache[stableHash] = copy;
-    return copy;
-  };
-
-/**
- * calculate the total balance history for all accounts in a reference fiat unit
- * and using a CalculateCounterValue function (see countervalue helper)
- * NB the last item of the array is actually the current total balance.
- * @memberof account
- */
-export function getPortfolio(
-  topAccounts: Account[],
-  range: PortfolioRange,
-  calc: (
-    arg0: TokenCurrency | CryptoCurrency,
-    arg1: BigNumber,
-    arg2: Date
-  ) => BigNumber | null | undefined
-): Portfolio {
-  const accounts: AccountLike[] = flattenAccounts(topAccounts);
-  const availableAccounts: AccountLike[] = [];
-  const unavailableAccounts: AccountLike[] = [];
-  const histories: BalanceHistoryWithCountervalue[] = [];
-  const changes: BigNumber[] = [];
-  const countervalueReceiveSums: BigNumber[] = [];
-  const countervalueSendSums: BigNumber[] = [];
-
-  for (let i = 0; i < accounts.length; i++) {
-    const account = accounts[i];
-    const r = getBalanceHistoryWithCountervalue(account, range, calc, false);
-
-    if (r.countervalueAvailable) {
-      availableAccounts.push(account);
-      histories.push(r.history);
-      changes.push(r.countervalueChange.value);
-      countervalueReceiveSums.push(r.countervalueReceiveSum);
-      countervalueSendSums.push(r.countervalueSendSum);
-    } else {
-      unavailableAccounts.push(account);
-    }
-  }
-
-  const unavailableCurrencies: any[] = [
-    ...new Set(unavailableAccounts.map(getAccountCurrency)),
-  ];
-  const balanceAvailable =
-    accounts.length === 0 || availableAccounts.length > 0;
-  const balanceHistory = getDates(range).map((date) => ({
-    date,
-    value: ZERO,
-  }));
-
-  for (let i = 0; i < histories.length; i++) {
-    const history = histories[i];
-
-    for (let j = 0; j < history.length; j++) {
-      const res = balanceHistory[j];
-
-      if (res) {
-        res.value = res.value.plus(history[j].countervalue);
-      }
-    }
-  }
-
-  const countervalueChangeValue: BigNumber = changes.reduce(
-    (sum, v) => sum.plus(v),
-    new BigNumber(0)
-  );
-  const countervalueReceiveSum: BigNumber = countervalueReceiveSums.reduce(
-    (sum, v) => sum.plus(v),
-    new BigNumber(0)
-  );
-  const countervalueSendSum: BigNumber = countervalueSendSums.reduce(
-    (sum, v) => sum.plus(v),
-    new BigNumber(0)
-  );
-  // in case there were no receive, we just track the market change
-  // weighted by the current balances
-  let countervalueChangePercentage;
-
-  if (getEnv("EXPERIMENTAL_ROI_CALCULATION")) {
-    if (countervalueReceiveSum.isZero()) {
-      countervalueChangePercentage = meaningfulPercentage(
-        countervalueChangeValue,
-        balanceHistory[0].value.plus(countervalueSendSum)
-      );
-    } else {
-      countervalueChangePercentage = meaningfulPercentage(
-        countervalueChangeValue,
-        countervalueReceiveSum
-      );
-    }
-  } else {
-    countervalueChangePercentage = meaningfulPercentage(
-      countervalueChangeValue, // in non experimental mode, we were dividing by first point
-      balanceHistory[0].value
-    );
-  }
-
-  const ret = {
-    balanceHistory,
-    balanceAvailable,
-    availableAccounts,
-    unavailableCurrencies,
-    accounts,
-    range,
-    histories,
-    countervalueReceiveSum,
-    countervalueSendSum,
-    countervalueChange: {
-      percentage: countervalueChangePercentage,
-      value: countervalueChangeValue,
-    },
-  };
-  return ret;
-}
-
-/**
- * calculate the total balance history for all accounts in a reference fiat unit
- * and using a CalculateCounterValue function (see countervalue helper)
- * NB the last item of the array is actually the current total balance.
- * @memberof account
- */
-export function getCurrencyPortfolio(
-  accounts: AccountLikeArray,
-  range: PortfolioRange,
-  calc: (
-    arg0: TokenCurrency | CryptoCurrency,
-    arg1: BigNumber,
-    arg2: Date
-  ) => BigNumber | null | undefined
-): CurrencyPortfolio {
-  const histories: BalanceHistoryWithCountervalue[] = [];
-  let countervalueAvailable = false;
-
-  for (let i = 0; i < accounts.length; i++) {
-    const account = accounts[i];
-    const r = getBalanceHistoryWithCountervalue(account, range, calc);
-    histories.push(r.history);
-    countervalueAvailable = r.countervalueAvailable;
-  }
-
-  const history = getDates(range).map((date) => ({
-    date,
-    value: ZERO,
-    countervalue: ZERO,
-  }));
-
-  for (let i = 0; i < histories.length; i++) {
-    const h = histories[i];
-
-    for (let j = 0; j < h.length; j++) {
-      const res = history[j];
-      res.value = res.value.plus(h[j].value);
-      res.countervalue = res.countervalue.plus(h[j].countervalue);
-    }
-  }
-
-  // previous existing implementation here
-  const from = history[0];
-  const to = history[history.length - 1];
-  const fromEffective =
-    (find(history, (record) => record.value.isGreaterThan(0)) as {
-      date: Date;
-      value: any;
-      countervalue: any;
-    }) || from;
-  const cryptoChange = {
-    value: to.value.minus(from.value),
-    percentage: null,
-  };
-  const countervalueChange = {
-    value: (to.countervalue || ZERO).minus(fromEffective.countervalue || ZERO),
-    percentage: meaningfulPercentage(
-      (to.countervalue || ZERO).minus(fromEffective.countervalue || ZERO),
-      fromEffective.countervalue
-    ),
-  };
-  const ret = {
-    history,
-    countervalueAvailable,
-    accounts,
-    range,
-    histories,
-    cryptoChange,
-    countervalueChange,
-  };
-  return ret;
-}
-export const defaultAssetsDistribution = {
-  minShowFirst: 1,
-  maxShowFirst: 6,
-  showFirstThreshold: 0.95,
-};
-export type AssetsDistributionOpts = typeof defaultAssetsDistribution;
-const assetsDistributionNotAvailable: AssetsDistribution = {
-  isAvailable: false,
-  list: [],
-  showFirst: 0,
-  sum: new BigNumber(0),
-};
-const previousDistributionCache = {
-  hash: "",
-  data: assetsDistributionNotAvailable,
-};
-export function getAssetsDistribution(
-  topAccounts: Account[],
-  calculateCountervalue: (
-    currency: TokenCurrency | CryptoCurrency,
-    value: BigNumber
-  ) => BigNumber | null | undefined,
-  opts?: AssetsDistributionOpts
-): AssetsDistribution {
-  const { minShowFirst, maxShowFirst, showFirstThreshold } = {
-    ...defaultAssetsDistribution,
-    ...opts,
-  };
-  let sum = new BigNumber(0);
-  const idBalances = {};
-  const idCurrencies = {};
-  const accounts = flattenAccounts(topAccounts);
-
-  for (let i = 0; i < accounts.length; i++) {
-    const account = accounts[i];
-    const cur = getAccountCurrency(account);
-    const id = cur.id;
-
-    if (account.balance.isGreaterThan(0)) {
-      idCurrencies[id] = cur;
-      idBalances[id] = (idBalances[id] || new BigNumber(0)).plus(
-        account.balance
-      );
-    }
-  }
-
-  const idCountervalues = {};
-
-  for (const id in idBalances) {
-    const countervalue = calculateCountervalue(
-      idCurrencies[id],
-      idBalances[id]
-    );
-
-    if (countervalue) {
-      idCountervalues[id] = countervalue;
-      sum = sum.plus(countervalue);
-    }
-  }
-
-  const idCurrenciesKeys = Object.keys(idCurrencies);
-
-  if (idCurrenciesKeys.length === 0) {
-    return assetsDistributionNotAvailable;
-  }
-
-  const isAvailable = !sum.isZero();
-  const hash = `${idCurrenciesKeys.length}_${sum.toString()}`;
-
-  if (hash === previousDistributionCache.hash) {
-    return previousDistributionCache.data;
-  }
-
-  const list = idCurrenciesKeys
-    .map((id) => {
-      const currency = idCurrencies[id];
-      const amount = idBalances[id];
-      const countervalue = idCountervalues[id] || new BigNumber(0);
-      return {
-        currency,
-        countervalue,
-        amount,
-        distribution: isAvailable ? countervalue.div(sum).toNumber() : 0,
-      };
-    })
-    .sort((a, b) => {
-      const diff = b.countervalue.minus(a.countervalue).toNumber();
-      if (diff === 0) return a.currency.name.localeCompare(b.currency.name);
-      return diff;
-    });
-  let i;
-  let acc = 0;
-
-  for (i = 0; i < maxShowFirst && i < list.length; i++) {
-    if (acc > showFirstThreshold) {
-      break;
-    }
-
-    acc += list[i].distribution;
-  }
-
-  const showFirst = Math.max(minShowFirst, i);
-  const data = {
-    isAvailable,
-    list,
-    showFirst,
-    sum,
-  };
-  previousDistributionCache.hash = hash;
-  previousDistributionCache.data = data;
-  return data;
-}

package/src/portfolio/range.ts

@@ -1,71 +0,0 @@
-import type { PortfolioRange, PortfolioRangeConfig } from "../types";
-export const hourIncrement = 60 * 60 * 1000;
-export const dayIncrement = 24 * hourIncrement;
-export const weekIncrement = 7 * dayIncrement;
-export function startOfHour(t: Date) {
-  return new Date(t.getFullYear(), t.getMonth(), t.getDate(), t.getHours());
-}
-export function startOfMonth(t: Date) {
-  return new Date(t.getFullYear(), t.getMonth(), 1);
-}
-export function startOfDay(t: Date) {
-  return new Date(t.getFullYear(), t.getMonth(), t.getDate());
-}
-export function startOfWeek(t: Date) {
-  const d = startOfDay(t);
-  return new Date(d.getTime() - d.getDay() * dayIncrement);
-}
-const ranges: Record<PortfolioRange, PortfolioRangeConfig> = {
-  year: {
-    count: 52,
-    increment: weekIncrement,
-    startOf: startOfWeek,
-    granularityId: "WEEK",
-  },
-  month: {
-    count: 30,
-    increment: dayIncrement,
-    startOf: startOfDay,
-    granularityId: "DAY",
-  },
-  week: {
-    count: 7 * 24,
-    increment: hourIncrement,
-    startOf: startOfHour,
-    granularityId: "HOUR",
-  },
-  day: {
-    count: 24,
-    increment: hourIncrement,
-    startOf: startOfHour,
-    granularityId: "HOUR",
-  },
-};
-
-const getPerPortfolioRanges = (): Record<
-  PortfolioRange,
-  PortfolioRangeConfig
-> => {
-  return ranges;
-};
-
-export function getPortfolioRangeConfig(
-  r: PortfolioRange
-): PortfolioRangeConfig {
-  return getPerPortfolioRanges()[r];
-}
-export const getRanges = (): PortfolioRange[] =>
-  Object.keys(getPerPortfolioRanges()) as PortfolioRange[];
-export function getDates(r: PortfolioRange): Date[] {
-  const conf = getPortfolioRangeConfig(r);
-  let t = new Date();
-  const array = [t];
-  t = new Date(conf.startOf(t).valueOf() - 1); // end of yesterday
-
-  for (let d = conf.count - 1; d > 0; d--) {
-    array.unshift(t);
-    t = new Date(t.valueOf() - conf.increment);
-  }
-
-  return array;
-}