@ledgerhq/live-countervalues 0.1.0

package/src/api/api.mock.ts

@@ -0,0 +1,117 @@
+import type { CounterValuesAPI, RateGranularity } from "../types";
+import { getEnv } from "@ledgerhq/live-env";
+import { getBTCValues, BTCtoUSD, referenceSnapshotDate } from "../mock";
+import { formatPerGranularity } from "../helpers";
+import Prando from "prando";
+import { findCurrencyByTicker } from "@ledgerhq/coin-framework/currencies/index";
+
+const DAY = 24 * 60 * 60 * 1000;
+
+function btcTrend(t: number) {
+  const daysSinceGenesis = (t - 1230937200000) / DAY;
+  return Math.pow(daysSinceGenesis / 693, 5.526);
+}
+
+const randomCache: Record<string, number> = {};
+
+function fromToRandom(id: string) {
+  if (randomCache[id]) return randomCache[id];
+  return (randomCache[id] = new Prando(getEnv("MOCK") + id).next());
+}
+
+function temporalFactor(from: string, to: string, maybeDate: Date | undefined) {
+  const t = (maybeDate || new Date()).getTime();
+  const r = fromToRandom(from); // make it varies between rates...
+
+  const wave1 = Math.cos(r * 0.5 + t / (200 * DAY * (0.5 + 0.5 * r)));
+  // long term wave
+  const wave2 = Math.sin(r + t / (30 * DAY)); // short term wave
+
+  const wave3 = // random market perturbation
+    Math.max(0, Math.sin(t / (66 * DAY))) *
+    Math.cos(wave2 + Math.cos(r) + t / (3 * DAY * (1 - 0.1 * r)));
+
+  // This is essentially randomness!
+  if (maybeDate && Math.cos(7 * r + t * 0.1) > 0.9 + 0.1 * r) {
+    return 0; // intentionally set a GAP into the data
+  }
+
+  const res =
+    (0.2 - 0.2 * r * r) * wave1 +
+    (0.1 + 0.05 * Math.sin(r)) * wave2 +
+    0.05 * wave3 +
+    btcTrend(t) / btcTrend(referenceSnapshotDate.getTime());
+  return Math.max(0, res);
+}
+
+function rate(from: string, to: string, date?: Date): number | undefined {
+  const asBTC = getBTCValues()[from];
+  if (!asBTC) return;
+
+  if (to === "BTC") {
+    return asBTC * temporalFactor(from, to, date);
+  }
+
+  if (to === "USD") {
+    return asBTC * BTCtoUSD * temporalFactor(from, to, date);
+  }
+
+  if (from === "BTC") {
+    const r = rate(to, from, date);
+    if (!r) return;
+    return 1 / r;
+  }
+
+  const btcTO = rate("BTC", to, date);
+
+  if (btcTO) {
+    return asBTC * btcTO * temporalFactor(from, to, date);
+  }
+}
+
+const increment = {
+  daily: DAY,
+  hourly: 60 * 60 * 1000,
+};
+
+function getIds(): string[] {
+  const ids: string[] = [];
+  for (const k in getBTCValues()) {
+    const c = findCurrencyByTicker(k);
+    if (c && (c.type == "CryptoCurrency" || c.type == "TokenCurrency")) {
+      ids.push(c.id);
+    }
+  }
+  return ids;
+}
+
+function getDates(granularity: RateGranularity, start: Date): Date[] {
+  const array: Date[] = [];
+  const f = formatPerGranularity[granularity];
+  const incr = increment[granularity];
+  const initial = new Date(f(start || new Date())).getTime();
+  const now = Date.now();
+
+  for (let t = initial; t < now; t += incr) {
+    array.push(new Date(t));
+  }
+
+  return array;
+}
+
+const api: CounterValuesAPI = {
+  fetchHistorical: (granularity, { from, to, startDate }) => {
+    const r: Record<string, number> = {};
+    const f = formatPerGranularity[granularity];
+    getDates(granularity, startDate).forEach(date => {
+      const v = rate(from.ticker, to.ticker, date);
+      if (v) {
+        r[f(date)] = v;
+      }
+    });
+    return Promise.resolve(r);
+  },
+  fetchLatest: pairs => Promise.resolve(pairs.map(({ from, to }) => rate(from.ticker, to.ticker))),
+  fetchIdsSortedByMarketcap: () => Promise.resolve(getIds()),
+};
+export default api;

package/src/api/api.ts

@@ -0,0 +1,79 @@
+import network from "@ledgerhq/live-network/network";
+import URL from "url";
+import { getEnv } from "@ledgerhq/live-env";
+import { promiseAllBatched } from "@ledgerhq/live-promise";
+import { formatPerGranularity, inferCurrencyAPIID } from "../helpers";
+import type { CounterValuesAPI, TrackingPair } from "../types";
+import type { Currency } from "@ledgerhq/types-cryptoassets";
+
+const baseURL = () => getEnv("LEDGER_COUNTERVALUES_API");
+
+const LATEST_CHUNK = 50;
+
+const api: CounterValuesAPI = {
+  fetchHistorical: async (granularity, { from, to, startDate }) => {
+    const format = formatPerGranularity[granularity];
+    const url = URL.format({
+      pathname: `${baseURL()}/v3/historical/${granularity}/simple`,
+      query: {
+        from: inferCurrencyAPIID(from),
+        to: inferCurrencyAPIID(to),
+        start: format(startDate),
+        end: format(new Date()),
+      },
+    });
+    const { data } = await network({ method: "GET", url });
+    return data;
+  },
+
+  fetchLatest: async (pairs: TrackingPair[]): Promise<number[]> => {
+    if (pairs.length === 0) return [];
+
+    // we group the pairs into chunks (of max LATEST_CHUNK) of the same "to" currency
+    // the batches preserve the ordering of "pairs" so the output returns the result in same orders
+    // we essentially assume that pairs' to's field are not changing / are sorted
+    const batches: Array<[Currency[], Currency]> = []; // array of [froms, to]
+    const first = pairs[0];
+    let batch: [Currency[], Currency] = [[first.from], first.to];
+    for (let i = 1; i < pairs.length; i++) {
+      const pair = pairs[i];
+      if (pair.to !== batch[1] || batch[0].length >= LATEST_CHUNK) {
+        batches.push(batch);
+        batch = [[pair.from], pair.to];
+      } else {
+        batch[0].push(pair.from);
+      }
+    }
+    batches.push(batch);
+
+    const all = await promiseAllBatched(4, batches, async ([froms, to]): Promise<number[]> => {
+      const fromIds = froms.map(inferCurrencyAPIID);
+      const url = URL.format({
+        pathname: `${baseURL()}/v3/spot/simple`,
+        query: {
+          to: inferCurrencyAPIID(to),
+          froms: fromIds.join(","),
+        },
+      });
+
+      const { data } = await network({ method: "GET", url });
+
+      // backend returns an object with keys being the froms
+      return fromIds.map(id => data[id] || 0);
+    });
+
+    const data = all.flat();
+
+    return data;
+  },
+
+  fetchIdsSortedByMarketcap: async () => {
+    const { data } = await network({
+      method: "GET",
+      url: `${baseURL()}/v3/currencies/supported`,
+    });
+    return data;
+  },
+};
+
+export default api;

package/src/api/index.ts

@@ -0,0 +1,19 @@
+import { getEnv } from "@ledgerhq/live-env";
+import type { CounterValuesAPI } from "../types";
+import prodAPI from "./api";
+import mockAPI from "./api.mock";
+
+const api: CounterValuesAPI = {
+  fetchHistorical: (granularity, pair) =>
+    getEnv("MOCK_COUNTERVALUES")
+      ? mockAPI.fetchHistorical(granularity, pair)
+      : prodAPI.fetchHistorical(granularity, pair),
+  fetchLatest: pairs =>
+    getEnv("MOCK_COUNTERVALUES") ? mockAPI.fetchLatest(pairs) : prodAPI.fetchLatest(pairs),
+  fetchIdsSortedByMarketcap: () =>
+    getEnv("MOCK_COUNTERVALUES")
+      ? mockAPI.fetchIdsSortedByMarketcap()
+      : prodAPI.fetchIdsSortedByMarketcap(),
+};
+
+export default api;

package/src/helpers.ts

@@ -0,0 +1,82 @@
+import { Currency } from "@ledgerhq/types-cryptoassets";
+import type { RateGranularity } from "./types";
+
+export const inferCurrencyAPIID = (currency: Currency): string => {
+  switch (currency.type) {
+    case "FiatCurrency": {
+      return currency.ticker;
+    }
+    case "CryptoCurrency":
+    case "TokenCurrency": {
+      return currency.id;
+    }
+  }
+};
+
+const HOUR = 60 * 60 * 1000;
+const DAY = 24 * HOUR;
+
+export const incrementPerGranularity: Record<RateGranularity, number> = {
+  daily: DAY,
+  hourly: HOUR,
+};
+
+export const datapointLimits: Record<RateGranularity, number> = {
+  daily: 9999 * DAY,
+  hourly: 7 * DAY, // we fetch at MOST a week of hourly. after that there are too much data...
+};
+
+/**
+ * efficient implementation of YYYY-MM-DD formatter
+ * @memberof countervalue
+ */
+export const formatCounterValueDay = (d: Date): string => d.toISOString().slice(0, 10);
+
+/**
+ * efficient implementation of YYYY-MM-DDTHH formatter
+ * @memberof countervalue
+ */
+export const formatCounterValueHour = (d: Date): string => d.toISOString().slice(0, 13);
+
+/**
+ * full version of formatCounterValue*
+ */
+export const formatCounterValueHashes = (d: Date): { iso: string; day: string; hour: string } => {
+  const iso = d.toISOString();
+  return {
+    iso,
+    day: iso.slice(0, 10),
+    hour: iso.slice(0, 13),
+  };
+};
+
+export const parseFormattedDate = (str: string): Date => {
+  let full = str;
+
+  switch (str.length) {
+    case 10:
+      full += "T00:00";
+      break;
+
+    case 13:
+      full += ":00";
+      break;
+  }
+
+  full += ":00.000Z";
+  return new Date(full);
+};
+
+export const formatPerGranularity: Record<RateGranularity, (arg0: Date) => string> = {
+  daily: formatCounterValueDay,
+  hourly: formatCounterValueHour,
+};
+
+// a hash function used to identify a pair of currencies, internal use only (not used for the API)
+export function pairId({ from, to }: { from: Currency; to: Currency }): string {
+  return `${inferCurrencyAPIID(to)} ${inferCurrencyAPIID(from)}`;
+}
+
+export function magFromTo(from: Currency, to: Currency): number {
+  return 10 ** (to.units[0].magnitude - from.units[0].magnitude);
+}

package/src/logic.integration.test.ts

@@ -0,0 +1,209 @@
+import {
+  initialState,
+  loadCountervalues,
+  calculate,
+  exportCountervalues,
+  importCountervalues,
+} from "./logic";
+import { findCurrencyByTicker } from "@ledgerhq/coin-framework/currencies/index";
+import {
+  getFiatCurrencyByTicker,
+  getCryptoCurrencyById,
+  getTokenById,
+} from "@ledgerhq/cryptoassets";
+import { getBTCValues } from "./mock";
+import { Currency } from "@ledgerhq/types-cryptoassets";
+import Prando from "prando";
+import api from "./api";
+import { setEnv } from "@ledgerhq/live-env";
+
+const value = "ll-ci/0.0.0";
+setEnv("LEDGER_CLIENT_VERSION", value);
+
+const ethereum = getCryptoCurrencyById("ethereum");
+const bitcoin = getCryptoCurrencyById("bitcoin");
+const usd = getFiatCurrencyByTicker("USD");
+const now = Date.now();
+
+const DAY = 24 * 60 * 60 * 1000;
+
+jest.setTimeout(60000);
+
+describe("API sanity", () => {
+  test("recent days have rate for BTC USD", async () => {
+    const state = await loadCountervalues(initialState, {
+      trackingPairs: [
+        {
+          from: bitcoin,
+          to: usd,
+          startDate: new Date(now - 200 * DAY),
+        },
+      ],
+      autofillGaps: false,
+      disableAutoRecoverErrors: true,
+    });
+
+    for (let i = 0; i < 7; i++) {
+      const value = calculate(state, {
+        date: new Date(now - i * DAY),
+        disableRounding: true,
+        from: bitcoin,
+        to: usd,
+        value: 1000000,
+      });
+      expect(value).toBeDefined();
+    }
+  });
+  test("recent days have different rates for BTC USD", async () => {
+    const state = await loadCountervalues(initialState, {
+      trackingPairs: [
+        {
+          from: bitcoin,
+          to: usd,
+          startDate: new Date(now - 200 * DAY),
+        },
+      ],
+      autofillGaps: true,
+      disableAutoRecoverErrors: true,
+    });
+    const currentValue = calculate(state, {
+      disableRounding: true,
+      from: bitcoin,
+      to: usd,
+      value: 1000000,
+    });
+
+    for (let i = 1; i < 7; i++) {
+      const value = calculate(state, {
+        date: new Date(now - i * DAY),
+        disableRounding: true,
+        from: bitcoin,
+        to: usd,
+        value: 1000000,
+      });
+      expect(value).not.toEqual(currentValue);
+    }
+  });
+});
+
+describe("extreme cases", () => {
+  const universe = Object.keys(getBTCValues())
+    .filter(t => t !== "USD")
+    .map(findCurrencyByTicker)
+    .filter(Boolean) as Currency[];
+  universe.sort((a, b) => a.ticker.localeCompare(b.ticker));
+  const prando = new Prando("orderingrng");
+  const sampleCount = Math.min(120, universe.length);
+  const i = prando.nextInt(0, universe.length - sampleCount);
+  const currencies = universe.slice(i, i + sampleCount);
+
+  test("all tickers against USD", async () => {
+    const state = await loadCountervalues(initialState, {
+      trackingPairs: currencies.map(from => ({
+        from,
+        to: usd,
+        startDate: new Date(),
+      })),
+      autofillGaps: true,
+      disableAutoRecoverErrors: true,
+    });
+
+    const currenciesWithCVs = currencies
+      .map(from =>
+        calculate(state, {
+          date: new Date(),
+          from,
+          to: usd,
+          value: 1000000,
+        }),
+      )
+      .filter(v => v && v > 0);
+
+    expect(currenciesWithCVs.length).toBeGreaterThan(0);
+  });
+
+  test("all tickers against BTC", async () => {
+    const state = await loadCountervalues(initialState, {
+      trackingPairs: currencies.map(from => ({
+        from,
+        to: bitcoin,
+        startDate: new Date(),
+      })),
+      autofillGaps: true,
+      disableAutoRecoverErrors: true,
+    });
+
+    const currenciesWithCVs = currencies
+      .map(from =>
+        calculate(state, {
+          date: new Date(),
+          from,
+          to: bitcoin,
+          value: 1000000,
+        }),
+      )
+      .filter(v => v && v > 0);
+
+    expect(currenciesWithCVs.length).toBeGreaterThan(0);
+  });
+});
+
+describe("WETH rules", () => {
+  // this test is created to confirm the recent removal of weth/eth specific management is still functional in v3 context
+  test("ethereum WETH have countervalues", async () => {
+    const weth = getTokenById("ethereum/erc20/weth");
+    const state = await loadCountervalues(initialState, {
+      trackingPairs: [
+        {
+          from: weth,
+          to: usd,
+          startDate: new Date(now - 10 * DAY),
+        },
+      ],
+      autofillGaps: true,
+      disableAutoRecoverErrors: true,
+    });
+    const value = calculate(state, {
+      disableRounding: true,
+      from: weth,
+      to: usd,
+      value: 1000000,
+    });
+    expect(value).toBeGreaterThan(0);
+  });
+});
+
+test("fetchIdsSortedByMarketcap", async () => {
+  const ids = await api.fetchIdsSortedByMarketcap();
+  expect(ids).toContain("bitcoin");
+});
+
+test("export and import it back", async () => {
+  const settings = {
+    trackingPairs: [
+      {
+        from: bitcoin,
+        to: usd,
+        startDate: new Date(now - 10 * DAY),
+      },
+      {
+        from: ethereum,
+        to: usd,
+        startDate: new Date(now - 100 * DAY),
+      },
+    ],
+    autofillGaps: true,
+    disableAutoRecoverErrors: true,
+  };
+  const state = await loadCountervalues(initialState, settings);
+  const exported = exportCountervalues(state);
+  const imported = importCountervalues(exported, settings);
+  expect(imported).toEqual(state);
+});
+
+describe("API specific unit tests", () => {
+  test("fetchLatest with empty pairs", async () => {
+    const rates = await api.fetchLatest([]);
+    expect(rates).toEqual([]);
+  });
+});

package/src/logic.test.ts

@@ -0,0 +1,30 @@
+import { genAccount } from "@ledgerhq/coin-framework/mocks/account";
+import { getCryptoCurrencyById, getFiatCurrencyByTicker } from "@ledgerhq/cryptoassets";
+import { inferTrackingPairForAccounts } from "./logic";
+
+describe("inferTrackingPairForAccounts", () => {
+  const accounts = Array(20)
+    .fill(null)
+    .map((_, i) => genAccount("test" + i));
+  const usd = getFiatCurrencyByTicker("USD");
+
+  test("trackingPairs have a deterministic order regardless of accounts order", () => {
+    const trackingPairs = inferTrackingPairForAccounts(accounts, usd);
+    const accounts2 = accounts.slice(10).concat(accounts.slice(0, 10));
+    const trackingPairs2 = inferTrackingPairForAccounts(accounts2, usd);
+    expect(trackingPairs).toEqual(trackingPairs2);
+  });
+
+  test("trackingPairs with same from and to are filtered out", () => {
+    const first = genAccount("test1", { currency: getCryptoCurrencyById("bitcoin") });
+    const trackingPairs = inferTrackingPairForAccounts([first], first.currency);
+    expect(trackingPairs).toEqual([]);
+  });
+
+  test("trackingPairs with 2 accounts of same coin yield one tracking pair", () => {
+    const first = genAccount("test1", { currency: getCryptoCurrencyById("bitcoin") });
+    const second = genAccount("test2", { currency: getCryptoCurrencyById("bitcoin") });
+    const trackingPairs = inferTrackingPairForAccounts([first, second], usd);
+    expect(trackingPairs.length).toBe(1);
+  });
+});