@ledgerhq/coin-framework 0.0.2-next.0

package/src/cross.test.ts

@@ -0,0 +1,112 @@
+import { genAccount } from "./mocks/account";
+import { getDerivationModesForCurrency } from "./derivation";
+import { listCryptoCurrencies, setSupportedCurrencies } from "./currencies";
+import {
+  accountDataToAccount,
+  accountToAccountData,
+  encode,
+  decode,
+} from "./cross";
+import { Account } from "@ledgerhq/types-live";
+
+setSupportedCurrencies(["ethereum", "ethereum_classic"]);
+
+test("accountDataToAccount / accountToAccountData", () => {
+  listCryptoCurrencies().forEach((currency) => {
+    getDerivationModesForCurrency(currency).forEach((derivationMode) => {
+      const account = genAccount(`${currency.id}_${derivationMode}`, {
+        currency,
+      });
+      const data = accountToAccountData(account);
+      expect(accountToAccountData(accountDataToAccount(data))).toMatchObject(
+        data
+      );
+    });
+  });
+});
+test("encode/decode", () => {
+  const accounts = listCryptoCurrencies().reduce(
+    (acc: Account[], currency) =>
+      acc.concat(
+        getDerivationModesForCurrency(currency).map((derivationMode) => {
+          const account = genAccount(`${currency.id}_${derivationMode}`, {
+            currency,
+          });
+          return account;
+        })
+      ),
+    <Account[]>[]
+  );
+  const data = {
+    accounts,
+    settings: {
+      currenciesSettings: {},
+      pairExchanges: {},
+    },
+    exporterName: "test你好👋",
+    exporterVersion: "0.0.0",
+  };
+  const exp = decode(encode(data));
+  expect(exp.meta.exporterName).toEqual(data.exporterName);
+  expect(exp.accounts.length).toEqual(data.accounts.length);
+  expect(exp.accounts).toMatchObject(data.accounts.map(accountToAccountData));
+});
+test("encode/decode", () => {
+  const accounts = Array(3)
+    .fill(null)
+    .map((_, i) => genAccount("export_" + i));
+  const arg = {
+    accounts,
+    settings: {
+      counterValue: "USD",
+      pairExchanges: {
+        BTC_USD: "KRAKEN",
+      },
+      currenciesSettings: {
+        bitcoin: {
+          confirmationsNb: 3,
+        },
+      },
+      blacklistedTokenIds: ["tokenid1", "tokenid2"],
+    },
+    exporterName: "test",
+    exporterVersion: "0.0.0",
+    chunkSize: 100,
+  };
+  const data = encode(arg);
+  const res = decode(data);
+  expect(res.accounts).toMatchObject(
+    accounts.map((a) => ({
+      balance: a.balance.toString(),
+      currencyId: a.currency.id,
+      id: a.id,
+      name: a.name,
+      index: a.index,
+    }))
+  );
+  expect(res.settings).toMatchObject({
+    counterValue: "USD",
+    pairExchanges: {
+      BTC_USD: "KRAKEN",
+    },
+    currenciesSettings: {
+      bitcoin: {
+        confirmationsNb: 3,
+      },
+    },
+    blacklistedTokenIds: ["tokenid1", "tokenid2"],
+  });
+  expect(res.settings).not.toMatchObject({
+    counterValue: "USD",
+    pairExchanges: {
+      BTC_USD: "KRAKEN",
+    },
+    currenciesSettings: {
+      bitcoin: {
+        confirmationsNb: 3,
+      },
+    },
+    blacklistedTokenIds: ["tokenid3"],
+  });
+  expect(res).toMatchSnapshot();
+});

package/src/cross.ts

@@ -0,0 +1,366 @@
+// cross helps dealing with cross-project feature like export/import & cross project conversions
+import { BigNumber } from "bignumber.js";
+import compressjs from "@ledgerhq/compressjs";
+import {
+  runDerivationScheme,
+  getDerivationScheme,
+  asDerivationMode,
+} from "./derivation";
+import { decodeAccountId, emptyHistoryCache } from "./account";
+import { getCryptoCurrencyById } from "./currencies";
+import type { Account, CryptoCurrencyIds } from "@ledgerhq/types-live";
+
+export type AccountData = {
+  id: string;
+  currencyId: string;
+  freshAddress?: string;
+  seedIdentifier: string;
+  derivationMode: string;
+  // we are unsafe at this stage, validation is done later
+  name: string;
+  index: number;
+  balance: string;
+};
+
+export type CryptoSettings = {
+  confirmationsNb?: number;
+};
+
+export type Settings = {
+  counterValue?: string;
+  currenciesSettings: Record<CryptoCurrencyIds, CryptoSettings>;
+  pairExchanges: Record<string, string | null | undefined>;
+  blacklistedTokenIds?: string[];
+  hideEmptyTokenAccounts?: boolean;
+};
+
+export type DataIn = {
+  // accounts to export (filter them to only be the visible ones)
+  accounts: Account[];
+  // settings
+  settings: Settings;
+  // the name of the exporter. e.g. "desktop" for the desktop app
+  exporterName: string;
+  // the version of the exporter. e.g. the desktop app version
+  exporterVersion: string;
+};
+
+type Meta = {
+  exporterName: string;
+  exporterVersion: string;
+};
+
+export type Result = {
+  accounts: AccountData[];
+  settings: Settings;
+  meta: Meta;
+};
+
+export function encode({
+  accounts,
+  settings,
+  exporterName,
+  exporterVersion,
+}: DataIn): string {
+  return Buffer.from(
+    compressjs.Bzip2.compressFile(
+      Buffer.from(
+        JSON.stringify({
+          meta: {
+            exporterName,
+            exporterVersion,
+          },
+          accounts: accounts.map(accountToAccountData),
+          settings,
+        })
+      )
+    )
+  ).toString("binary");
+}
+
+const asResultMeta = (unsafe: Record<string, any>): Meta => {
+  if (typeof unsafe !== "object" || !unsafe) {
+    throw new Error("invalid meta data");
+  }
+
+  const { exporterName, exporterVersion } = unsafe;
+
+  if (typeof exporterName !== "string") {
+    throw new Error("invalid meta.exporterName");
+  }
+
+  if (typeof exporterVersion !== "string") {
+    throw new Error("invalid meta.exporterVersion");
+  }
+
+  return {
+    exporterName,
+    exporterVersion,
+  };
+};
+
+const asResultAccount = (unsafe: Record<string, any>): AccountData => {
+  if (typeof unsafe !== "object" || !unsafe) {
+    throw new Error("invalid account data");
+  }
+
+  const {
+    id,
+    currencyId,
+    freshAddress,
+    seedIdentifier,
+    derivationMode,
+    name,
+    index,
+    balance,
+  } = unsafe;
+
+  if (typeof id !== "string") {
+    throw new Error("invalid account.id");
+  }
+
+  if (typeof currencyId !== "string") {
+    throw new Error("invalid account.currencyId");
+  }
+
+  if (typeof seedIdentifier !== "string") {
+    throw new Error("invalid account.seedIdentifier");
+  }
+
+  if (typeof derivationMode !== "string") {
+    throw new Error("invalid account.derivationMode");
+  }
+
+  if (typeof name !== "string") {
+    throw new Error("invalid account.name");
+  }
+
+  if (typeof index !== "number") {
+    throw new Error("invalid account.index");
+  }
+
+  if (typeof balance !== "string") {
+    throw new Error("invalid account.balance");
+  }
+
+  const o: AccountData = {
+    id,
+    currencyId,
+    seedIdentifier,
+    derivationMode,
+    name,
+    index,
+    balance,
+  };
+
+  if (typeof freshAddress === "string" && freshAddress) {
+    o.freshAddress = freshAddress;
+  }
+
+  return o;
+};
+
+const asResultAccounts = (unsafe: unknown): AccountData[] => {
+  if (typeof unsafe !== "object" || !unsafe || !Array.isArray(unsafe)) {
+    throw new Error("invalid accounts data");
+  }
+
+  return unsafe.map(asResultAccount);
+};
+
+const asCryptoSettings = (unsafe: Record<string, any>): CryptoSettings => {
+  if (typeof unsafe !== "object" || !unsafe) {
+    throw new Error("invalid currency settings data");
+  }
+
+  const { confirmationsNb } = unsafe;
+
+  if (typeof confirmationsNb === "number") {
+    return {
+      confirmationsNb,
+    };
+  }
+
+  return {};
+};
+
+const asResultSettings = (unsafe: Record<string, any>): Settings => {
+  if (typeof unsafe !== "object" || !unsafe) {
+    throw new Error("invalid settings data");
+  }
+
+  const {
+    counterValue,
+    currenciesSettings,
+    pairExchanges,
+    blacklistedTokenIds,
+    hideEmptyTokenAccounts,
+  } = unsafe;
+  const currenciesSettingsSafe: Record<CryptoCurrencyIds, CryptoSettings> = {};
+
+  if (currenciesSettings && typeof currenciesSettings === "object") {
+    for (const k in currenciesSettings) {
+      currenciesSettingsSafe[k] = asCryptoSettings(currenciesSettings[k]);
+    }
+  }
+
+  const pairExchangesSafe: Record<string, string> = {};
+
+  if (pairExchanges && typeof pairExchanges === "object") {
+    for (const k in pairExchanges) {
+      const v = pairExchanges[k];
+
+      if (v && typeof v === "string") {
+        pairExchangesSafe[k] = v;
+      }
+    }
+  }
+
+  const res: Settings = {
+    currenciesSettings: currenciesSettingsSafe,
+    pairExchanges: pairExchangesSafe,
+  };
+
+  if (counterValue && typeof counterValue === "string") {
+    res.counterValue = counterValue;
+  }
+
+  if (hideEmptyTokenAccounts && typeof hideEmptyTokenAccounts === "boolean") {
+    res.hideEmptyTokenAccounts = hideEmptyTokenAccounts;
+  }
+
+  const blacklistedTokenIdsSafe: string[] = [];
+
+  if (blacklistedTokenIds && Array.isArray(blacklistedTokenIds)) {
+    for (const b of blacklistedTokenIds) {
+      if (typeof b === "string") {
+        blacklistedTokenIdsSafe.push(b);
+      }
+    }
+
+    res.blacklistedTokenIds = blacklistedTokenIdsSafe;
+  }
+
+  return res;
+};
+
+export function decode(bytes: string): Result {
+  const unsafe: Record<string, any> = JSON.parse(
+    Buffer.from(
+      compressjs.Bzip2.decompressFile(Buffer.from(bytes, "binary"))
+    ).toString()
+  );
+
+  if (typeof unsafe !== "object" || !unsafe) {
+    throw new Error("invalid data");
+  }
+
+  return {
+    meta: asResultMeta(unsafe.meta),
+    accounts: asResultAccounts(unsafe.accounts),
+    settings: asResultSettings(unsafe.settings),
+  };
+}
+export function accountToAccountData({
+  id,
+  name,
+  seedIdentifier,
+  derivationMode,
+  freshAddress,
+  currency,
+  index,
+  balance,
+}: Account): AccountData {
+  const res: AccountData = {
+    id,
+    name,
+    seedIdentifier,
+    derivationMode,
+    freshAddress,
+    currencyId: currency.id,
+    index,
+    balance: balance.toString(),
+  };
+
+  return res;
+}
+// reverse the account data to an account.
+// this restore the essential data of an account and the result of the fields
+// are assumed to be restored during first sync
+export const accountDataToAccount = ({
+  id,
+  currencyId,
+  freshAddress: inputFreshAddress,
+  name,
+  index,
+  balance,
+  derivationMode: derivationModeStr,
+  seedIdentifier,
+}: AccountData): Account => {
+  const { xpubOrAddress } = decodeAccountId(id); // TODO rename in AccountId xpubOrAddress
+
+  const derivationMode = asDerivationMode(derivationModeStr);
+  const currency = getCryptoCurrencyById(currencyId);
+  let xpub = "";
+  let freshAddress = inputFreshAddress || "";
+  let freshAddressPath = "";
+
+  if (
+    // FIXME Dirty hack, since we have no way here to know if "xpubOrAddress" is one or the other.
+    // Proposed fix: https://ledgerhq.atlassian.net/browse/LL-7437
+    currency.family === "bitcoin" ||
+    currency.family === "cardano"
+  ) {
+    // In bitcoin implementation, xpubOrAddress field always go in the xpub
+    xpub = xpubOrAddress;
+  } else {
+    if (currency.family === "tezos") {
+      xpub = xpubOrAddress;
+    } else if (!freshAddress) {
+      // otherwise, it's the freshAddress
+      freshAddress = xpubOrAddress;
+    }
+
+    freshAddressPath = runDerivationScheme(
+      getDerivationScheme({
+        currency,
+        derivationMode,
+      }),
+      currency,
+      {
+        account: index,
+      }
+    );
+  }
+
+  const balanceBN = new BigNumber(balance);
+  const account: Account = {
+    type: "Account",
+    id,
+    derivationMode,
+    seedIdentifier,
+    xpub,
+    name,
+    starred: false,
+    used: false,
+    currency,
+    index,
+    freshAddress,
+    freshAddressPath,
+    swapHistory: [],
+    // these fields will be completed as we will sync
+    freshAddresses: [],
+    blockHeight: 0,
+    balance: balanceBN,
+    spendableBalance: balanceBN,
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    unit: currency.units[0],
+    lastSyncDate: new Date(0),
+    creationDate: new Date(),
+    balanceHistoryCache: emptyHistoryCache,
+  };
+
+  return account;
+};

package/src/currencies/BigNumberToLocaleString.test.ts

@@ -0,0 +1,155 @@
+import { BigNumber } from "bignumber.js";
+import { toLocaleString } from "./BigNumberToLocaleString";
+test("basic toLocaleString usage", () => {
+  expect(toLocaleString(new BigNumber(0))).toBe("0");
+  expect(toLocaleString(new BigNumber(8))).toBe("8");
+  expect(toLocaleString(new BigNumber(123))).toBe("123");
+  expect(toLocaleString(new BigNumber(0.001))).toBe("0.001");
+  expect(toLocaleString(new BigNumber(13.1))).toBe("13.1");
+  expect(toLocaleString(new BigNumber(123.01))).toBe("123.01");
+  expect(toLocaleString(new BigNumber(123.012))).toBe("123.012");
+  expect(toLocaleString(new BigNumber(1123))).toBe("1,123");
+  expect(toLocaleString(new BigNumber("9999999999999999"))).toBe(
+    "9,999,999,999,999,999"
+  );
+  expect(toLocaleString(new BigNumber("9999999999999.99"))).toBe(
+    "9,999,999,999,999.99"
+  );
+});
+test("toLocaleString to default maximumFractionDigits to 3", () => {
+  expect(toLocaleString(new BigNumber(4.44444))).toBe("4.444");
+  expect(toLocaleString(new BigNumber(444444.444444444))).toBe("444,444.444");
+  expect(toLocaleString(new BigNumber(0.444444444))).toBe("0.444");
+  expect(toLocaleString(new BigNumber(9.99999))).toBe("9.999");
+  expect(toLocaleString(new BigNumber(111111.111111111))).toBe("111,111.111");
+  expect(toLocaleString(new BigNumber(0.999999999))).toBe("0.999");
+  expect(toLocaleString(new BigNumber(9.5))).toBe("9.5");
+  expect(toLocaleString(new BigNumber(9.9))).toBe("9.9");
+  expect(toLocaleString(new BigNumber(99.6))).toBe("99.6");
+  expect(toLocaleString(new BigNumber(99.8))).toBe("99.8");
+  expect(toLocaleString(new BigNumber(999.7))).toBe("999.7");
+  expect(toLocaleString(new BigNumber(999.9))).toBe("999.9");
+  expect(toLocaleString(new BigNumber(999999.7))).toBe("999,999.7");
+  expect(toLocaleString(new BigNumber(999999.9))).toBe("999,999.9");
+});
+test("toLocaleString minimumFractionDigits", () => {
+  expect(
+    toLocaleString(new BigNumber(0), "en", {
+      minimumFractionDigits: 1,
+    })
+  ).toBe("0.0");
+  expect(
+    toLocaleString(new BigNumber(8), "en", {
+      minimumFractionDigits: 1,
+    })
+  ).toBe("8.0");
+  expect(
+    toLocaleString(new BigNumber(123), "en", {
+      minimumFractionDigits: 1,
+    })
+  ).toBe("123.0");
+  expect(
+    toLocaleString(new BigNumber(0.001), "en", {
+      minimumFractionDigits: 1,
+    })
+  ).toBe("0.001");
+  expect(
+    toLocaleString(new BigNumber(9.5), "en", {
+      minimumFractionDigits: 1,
+    })
+  ).toBe("9.5");
+  expect(
+    toLocaleString(new BigNumber(9.6), "en", {
+      minimumFractionDigits: 2,
+    })
+  ).toBe("9.60");
+  expect(
+    toLocaleString(new BigNumber(13.1), "en", {
+      minimumFractionDigits: 3,
+    })
+  ).toBe("13.100");
+  expect(
+    toLocaleString(new BigNumber(123.01), "en", {
+      minimumFractionDigits: 5,
+    })
+  ).toBe("123.01000");
+  expect(
+    toLocaleString(new BigNumber(123.012), "en", {
+      minimumFractionDigits: 10,
+    })
+  ).toBe("123.0120000000");
+  expect(
+    toLocaleString(new BigNumber(1123), "en", {
+      minimumFractionDigits: 1,
+    })
+  ).toBe("1,123.0");
+  expect(
+    toLocaleString(new BigNumber("9999999999999999"), "en", {
+      minimumFractionDigits: 1,
+    })
+  ).toBe("9,999,999,999,999,999.0");
+  expect(
+    toLocaleString(new BigNumber("9999999999999.999"), "en", {
+      minimumFractionDigits: 5,
+    })
+  ).toBe("9,999,999,999,999.99900");
+});
+test("toLocaleString minimumFractionDigits and maximumFractionDigits", () => {
+  expect(
+    toLocaleString(new BigNumber(1), "en", {
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 5,
+    })
+  ).toBe("1.0");
+  expect(
+    toLocaleString(new BigNumber(1.003), "en", {
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 5,
+    })
+  ).toBe("1.003");
+  expect(
+    toLocaleString(new BigNumber(1.000003), "en", {
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 5,
+    })
+  ).toBe("1.0");
+  expect(
+    toLocaleString(new BigNumber(1.333333333333), "en", {
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 5,
+    })
+  ).toBe("1.33333");
+  expect(
+    toLocaleString(new BigNumber(0), "en", {
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 5,
+    })
+  ).toBe("0.0");
+  expect(
+    toLocaleString(new BigNumber(0.003), "en", {
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 5,
+    })
+  ).toBe("0.003");
+  expect(
+    toLocaleString(new BigNumber(0.000003), "en", {
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 5,
+    })
+  ).toBe("0.0");
+  expect(
+    toLocaleString(new BigNumber(9.7), "en", {
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 1,
+    })
+  ).toBe("9.7");
+  expect(
+    toLocaleString(
+      new BigNumber("4.4444444444444444444411111111111111"),
+      "en",
+      {
+        maximumFractionDigits: 20,
+      }
+    )
+  ).toBe("4.44444444444444444444");
+});

package/src/currencies/BigNumberToLocaleString.ts

@@ -0,0 +1,80 @@
+// Implement a subset of Number#toLocaleString for BigNumber.js
+// https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number/toLocaleString
+import { BigNumber } from "bignumber.js";
+import { getSeparators } from "./localeUtility";
+export type SupportedOptions = {
+  minimumFractionDigits: number;
+  maximumFractionDigits: number;
+  useGrouping: boolean;
+};
+
+// FIXME later, might want to expose this format!
+const getFormatForLocale = (locale: string) => {
+  const { decimal, thousands } = getSeparators(locale);
+  const opts = {
+    decimalSeparator: ".",
+    groupSeparator: ",",
+    groupSize: 3,
+    secondaryGroupSize: 0,
+    fractionGroupSeparator: "\xA0",
+    // non-breaking space
+    fractionGroupSize: 0,
+  };
+  if (typeof decimal === "string") opts.decimalSeparator = decimal;
+  if (typeof thousands === "string") opts.groupSeparator = thousands;
+  return opts;
+};
+
+export const toLocaleString = (
+  n: BigNumber,
+  localeInput?: string,
+  options: Partial<SupportedOptions> = {}
+): string => {
+  let locale = localeInput;
+  if (!locale) locale = "en";
+  const minimumFractionDigits: number =
+    "minimumFractionDigits" in options
+      ? (options.minimumFractionDigits as number)
+      : 0;
+  const maximumFractionDigits: number =
+    "maximumFractionDigits" in options
+      ? (options.maximumFractionDigits as number)
+      : Math.max(minimumFractionDigits, 3);
+  const useGrouping = "useGrouping" in options ? options.useGrouping : true;
+  const format = getFormatForLocale(locale);
+
+  if (!useGrouping) {
+    format.groupSeparator = "";
+  }
+
+  const BN = BigNumber.clone({
+    FORMAT: format,
+  });
+  const bn = new BN(n);
+  const maxDecimals = bn.toFormat(maximumFractionDigits, BigNumber.ROUND_FLOOR);
+
+  if (maximumFractionDigits !== minimumFractionDigits) {
+    const minDecimals = bn.toFormat(
+      minimumFractionDigits,
+      BigNumber.ROUND_FLOOR
+    );
+    let i = maxDecimals.length;
+
+    // cleanup useless '0's from the right until the minimumFractionDigits
+    while (i > minDecimals.length) {
+      if (maxDecimals[i - 1] !== "0") {
+        if (maxDecimals[i - 1] === format.decimalSeparator) {
+          i--;
+        }
+
+        break; // we reach decimal. stop now.
+      }
+
+      i--;
+    }
+
+    return maxDecimals.slice(0, i);
+  }
+
+  return maxDecimals;
+};