@ledgerhq/coin-framework 0.0.2-next.0

package/src/currencies/CurrencyURIScheme.ts

@@ -0,0 +1,114 @@
+import querystring from "querystring";
+import { BigNumber } from "bignumber.js";
+import { findCryptoCurrencyByScheme } from "@ledgerhq/cryptoassets";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+// see https://github.com/bitcoin/bips/blob/master/bip-0021.mediawiki
+type Data = {
+  address: string;
+  currency?: CryptoCurrency;
+  amount?: BigNumber;
+  // IN SATOSHI !! not in actual 'real' value
+  // ... any other field specific to a coin that will be put in query
+  userGasLimit?: BigNumber;
+  gasPrice?: BigNumber;
+};
+export function encodeURIScheme(data: Data): string {
+  const { currency, address, amount, ...specificFields } = data;
+  const query: Record<string, any> = { ...specificFields };
+  if (!currency) return address;
+
+  if (amount) {
+    const { magnitude } = currency.units[0];
+    query.amount = amount.div(new BigNumber(10).pow(magnitude)).toNumber();
+  }
+
+  const queryStr = querystring.stringify(query);
+  return currency.scheme + ":" + address + (queryStr ? "?" + queryStr : "");
+}
+
+const convertedValue = (value: any, currency: CryptoCurrency) => {
+  const float = new BigNumber(value);
+
+  if (!float.isNaN() && float.gt(0)) {
+    const { magnitude } = currency.units[0];
+    return float.times(new BigNumber(10).pow(magnitude));
+  }
+};
+
+export function decodeURIScheme(str: string): Data {
+  const m = str.match(/(([a-zA-Z]+):)?([^?]+)(\?(.+))?/);
+
+  if (!m) {
+    // as a fallback we'll fallback str to be an address
+    return {
+      address: str,
+    };
+  }
+
+  const [, , scheme, address, , queryStr] = m;
+  const query: Record<string, any> = queryStr
+    ? querystring.parse(queryStr)
+    : {};
+  const currency = findCryptoCurrencyByScheme(scheme);
+
+  if (!currency) {
+    return {
+      address,
+    };
+  }
+
+  const data: Data = {
+    currency,
+    address,
+  };
+  const { amount, ...specificFields } = { ...query } as Partial<{
+    amount: any;
+    value: any;
+    gas: any;
+    gasPrice: any;
+  }>;
+
+  if (currency.id === "ethereum") {
+    if (specificFields.value) {
+      data.amount = new BigNumber(specificFields.value);
+
+      if (data.amount.isNegative()) {
+        data.amount = new BigNumber(0);
+      }
+
+      delete specificFields.value;
+    }
+
+    if (specificFields.gas) {
+      data.userGasLimit = new BigNumber(specificFields.gas);
+
+      if (data.userGasLimit.isNegative()) {
+        data.userGasLimit = new BigNumber(0);
+      }
+
+      delete specificFields.gas;
+    }
+
+    if (specificFields.gasPrice) {
+      data.gasPrice = new BigNumber(specificFields.gasPrice);
+
+      if (data.gasPrice.isNegative()) {
+        data.gasPrice = new BigNumber(0);
+      }
+
+      delete specificFields.gasPrice;
+    }
+  }
+
+  Object.assign(data, specificFields);
+
+  if (amount) {
+    const cValue = convertedValue(amount, currency);
+
+    if (cValue) {
+      data.amount = cValue;
+    }
+  }
+
+  return data;
+}

package/src/currencies/chopCurrencyUnitDecimals.ts

@@ -0,0 +1,34 @@
+// remove the extra decimals that can't be represented in unit
+// this function will preserve the string characters
+// for instance EUR 1230.00234 will be transformed to EUR 1230.00
+// NB this function parse a subset of formats because it it locale independent.
+// make sure you have at least following options set on the formatter:
+
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+
+// - useGrouping: true
+export const chopCurrencyUnitDecimals = (
+  unit: Unit,
+  valueString: string
+): string => {
+  let str = "";
+  let decimals = -1;
+
+  for (let i = 0; i < valueString.length; i++) {
+    const c = valueString[i];
+
+    if (decimals >= 0 && /[0-9]/.test(c)) {
+      decimals++;
+
+      if (decimals > unit.magnitude) {
+        continue;
+      }
+    } else if (c === "," || c === ".") {
+      decimals = 0;
+    }
+
+    str += c;
+  }
+
+  return str;
+};

package/src/currencies/formatCurrencyUnit.ts

@@ -0,0 +1,167 @@
+import { BigNumber } from "bignumber.js";
+import { prefixFormat, suffixFormat } from "./localeUtility";
+import { toLocaleString } from "./BigNumberToLocaleString";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+const nonBreakableSpace = " ";
+const defaultFormatOptions = {
+  locale: "en-EN",
+  // show the currency code
+  showCode: false,
+  // always show the sign, even if it's a positive value
+  alwaysShowSign: false,
+  // override showAllDigits of the unit
+  showAllDigits: false,
+  // disable the feature that only show significant digits
+  // and removes the negligible extra digits.
+  // (rounding is dynamically applied based on the value. higher value means more rounding)
+  disableRounding: false,
+  // enable or not the thousands grouping (e.g; 1,234.00)
+  useGrouping: true,
+  // this allow to increase the number of digits displayed
+  // even if the currency don't allow more than this (sub-cent)
+  // a value of 1 can display USD 0.006 for instance. 2 can display USD 0.0065
+  // NB even if you set 3, USD 4.50 will be display as USD 4.50 , not 4.5000 (extra zeros are not displayed)
+  subMagnitude: 0,
+  // discrete mode will hide amounts
+  discreet: false,
+  joinFragmentsSeparator: "",
+  // Increase the significant digits. Ex: For a value of 1.121212 BTC, dynamicSignificantDigits of 4 => 1.121 / dynamicSignificantDigits of 6 => 1.12121
+  dynamicSignificantDigits: 6,
+  staticSignificantDigits: 8,
+};
+
+export type formatCurrencyUnitOptions = Partial<typeof defaultFormatOptions>;
+
+type FormatFragment =
+  | {
+      kind: "value";
+      value: string;
+    }
+  | {
+      kind: "sign";
+      value: string;
+    }
+  | {
+      kind: "code";
+      value: string;
+    }
+  | {
+      kind: "separator";
+      value: string;
+    };
+type FormatFragmentTypes = "value" | "sign" | "code" | "separator";
+export function formatCurrencyUnitFragment(
+  unit: Unit,
+  value: BigNumber,
+  _options?: formatCurrencyUnitOptions
+): FormatFragment[] {
+  if (!BigNumber.isBigNumber(value)) {
+    console.warn("formatCurrencyUnit called with value=", value);
+    return [];
+  }
+
+  if (value.isNaN()) {
+    console.warn("formatCurrencyUnit called with NaN value!");
+    return [];
+  }
+
+  if (!value.isFinite()) {
+    console.warn("formatCurrencyUnit called with infinite value=", value);
+    return [];
+  }
+
+  const options: Record<
+    string,
+    formatCurrencyUnitOptions[keyof formatCurrencyUnitOptions]
+  > = {};
+
+  if (_options) {
+    let k: keyof formatCurrencyUnitOptions;
+    for (k in _options) {
+      // sanitize the undefined value
+      const value = _options[k];
+      if (value !== undefined) {
+        options[k] = value;
+      }
+    }
+  }
+
+  const {
+    showCode,
+    alwaysShowSign,
+    showAllDigits,
+    locale,
+    disableRounding,
+    useGrouping,
+    subMagnitude,
+    discreet,
+    dynamicSignificantDigits,
+    staticSignificantDigits,
+  } = { ...defaultFormatOptions, ...unit, ...options };
+  const { magnitude, code } = unit;
+  const floatValue = value.div(new BigNumber(10).pow(magnitude));
+  const floatValueAbs = floatValue.abs();
+  const minimumFractionDigits = showAllDigits ? magnitude : 0;
+  const maximumFractionDigits = disableRounding
+    ? magnitude + subMagnitude
+    : Math.max(
+        minimumFractionDigits,
+        Math.max(
+          0, // dynamic max number of digits based on the value itself. to only show significant part
+          Math.min(
+            dynamicSignificantDigits -
+              Math.ceil(Math.log10(floatValueAbs.toNumber())),
+            magnitude + subMagnitude,
+            staticSignificantDigits
+          )
+        )
+      );
+  const fragValueByKind = {
+    sign:
+      alwaysShowSign || floatValue.isNegative()
+        ? floatValue.isNegative()
+          ? "-"
+          : "+"
+        : null,
+    code: showCode ? code : null,
+    value: discreet
+      ? "***"
+      : toLocaleString(floatValueAbs, locale, {
+          maximumFractionDigits,
+          minimumFractionDigits,
+          useGrouping,
+        }),
+    separator: nonBreakableSpace,
+  };
+  const frags: FormatFragment[] = [];
+  let nonSepIndex = -1;
+  let sepConsumed = true;
+  (unit.prefixCode ? prefixFormat : suffixFormat).forEach((kind) => {
+    const v = fragValueByKind[kind];
+    if (!v) return;
+    const isSep = kind === "separator";
+    if (sepConsumed && isSep) return;
+    sepConsumed = isSep;
+    if (!isSep) nonSepIndex = frags.length;
+    frags.push({
+      kind: kind as FormatFragmentTypes,
+      value: v,
+    });
+  });
+  frags.splice(nonSepIndex + 1); // remove extra space at the end
+
+  return frags;
+}
+// simplification of formatCurrencyUnitFragment if no fragmented styles is needed
+export function formatCurrencyUnit(
+  unit: Unit,
+  value: BigNumber,
+  options?: formatCurrencyUnitOptions
+): string {
+  const joinFragmentsSeparator =
+    (options && options.joinFragmentsSeparator) ||
+    defaultFormatOptions.joinFragmentsSeparator;
+  return formatCurrencyUnitFragment(unit, value, options)
+    .map((f) => f.value)
+    .join(joinFragmentsSeparator);
+}

package/src/currencies/formatShort.ts

@@ -0,0 +1,24 @@
+import numeral from "numeral";
+import { BigNumber } from "bignumber.js";
+import { formatCurrencyUnit } from "./formatCurrencyUnit";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+
+/**
+ * This will format in a very concise way a valid, typically to be used on axis.
+ * For instance 15k 20k ,...
+ */
+export function formatShort(unit: Unit, value: BigNumber): string {
+  const { magnitude } = unit;
+  const floatValue = value.div(new BigNumber(10).pow(magnitude));
+
+  if (floatValue.isZero()) {
+    return "0";
+  }
+
+  if (new BigNumber(-1).isLessThan(floatValue) && floatValue.isLessThan(1)) {
+    // numeral have issues with low values, fallback on formatCurrencyUnit
+    return formatCurrencyUnit(unit, value);
+  }
+
+  return numeral(floatValue.toNumber()).format("0[.]0a");
+}

package/src/currencies/index.ts

@@ -0,0 +1,78 @@
+import { encodeURIScheme, decodeURIScheme } from "./CurrencyURIScheme";
+import { sanitizeValueString } from "./sanitizeValueString";
+import {
+  listFiatCurrencies,
+  findFiatCurrencyByTicker,
+  getFiatCurrencyByTicker,
+  hasFiatCurrencyTicker,
+  listCryptoCurrencies,
+  getCryptoCurrencyById,
+  hasCryptoCurrencyId,
+  findCryptoCurrency,
+  findCryptoCurrencyById,
+  findCryptoCurrencyByScheme,
+  findCryptoCurrencyByKeyword,
+  findCryptoCurrencyByTicker,
+  listTokens,
+  listTokensForCryptoCurrency,
+  listTokenTypesForCryptoCurrency,
+  findTokenByTicker,
+  findTokenById,
+  findTokenByAddress,
+  hasTokenId,
+  findCompoundToken,
+  getAbandonSeedAddress,
+  getTokenById,
+  addTokens,
+} from "@ledgerhq/cryptoassets";
+export * from "./support";
+import { parseCurrencyUnit } from "./parseCurrencyUnit";
+import { chopCurrencyUnitDecimals } from "./chopCurrencyUnitDecimals";
+import {
+  formatCurrencyUnit,
+  formatCurrencyUnitFragment,
+} from "./formatCurrencyUnit";
+import { formatShort } from "./formatShort";
+import { valueFromUnit } from "./valueFromUnit";
+import type { Currency } from "@ledgerhq/types-cryptoassets";
+
+const findCurrencyByTicker = (ticker: string): Currency | null | undefined =>
+  findCryptoCurrencyByTicker(ticker) ||
+  findFiatCurrencyByTicker(ticker) ||
+  findTokenByTicker(ticker);
+
+export {
+  listFiatCurrencies,
+  listCryptoCurrencies,
+  getFiatCurrencyByTicker,
+  findCurrencyByTicker,
+  findCryptoCurrency,
+  findCryptoCurrencyById,
+  findCryptoCurrencyByTicker,
+  findCryptoCurrencyByScheme,
+  findCryptoCurrencyByKeyword,
+  findFiatCurrencyByTicker,
+  hasFiatCurrencyTicker,
+  listTokensForCryptoCurrency,
+  listTokenTypesForCryptoCurrency,
+  findTokenByAddress,
+  findTokenByTicker,
+  findTokenById,
+  hasTokenId,
+  getTokenById,
+  getAbandonSeedAddress,
+  parseCurrencyUnit,
+  chopCurrencyUnitDecimals,
+  formatCurrencyUnit,
+  formatCurrencyUnitFragment,
+  formatShort,
+  getCryptoCurrencyById,
+  hasCryptoCurrencyId,
+  encodeURIScheme,
+  decodeURIScheme,
+  valueFromUnit,
+  sanitizeValueString,
+  findCompoundToken,
+  listTokens,
+  addTokens,
+};

package/src/currencies/localeUtility.ts

@@ -0,0 +1,50 @@
+import memoize from "lodash/memoize";
+const options = {
+  style: "currency",
+  currency: "USD",
+};
+const localeNotAvailable = (1.2).toLocaleString("en", options) !== "$1.20";
+
+const getFallback = (locale: string) =>
+  staticFallback[Object.keys(staticFallback).includes(locale) ? locale : "en"];
+
+const staticFallback: Record<string, [string, string]> = {
+  en: ["-$1.00", "10,000.2"],
+  es: ["-1,00 US$", "10.000,2"],
+  fr: ["-1,00 $US", "10 000,2"],
+  ja: ["-US$1.00", "10,000.2"],
+  ko: ["-US$1.00", "10,000.2"],
+  ru: ["-1,00 $", "10 000,2"],
+  zh: ["-US$1.00", "10,000.2"],
+};
+export const prefixFormat = ["sign", "code", "value"] as const;
+export const suffixFormat = ["sign", "value", "separator", "code"] as const;
+// returns decimal and thousands separator
+// FIXME: rename thousands to group
+export type GetSeparators = (locale: string) => {
+  decimal: string | null | undefined;
+  thousands: string | null | undefined;
+};
+export const getSeparators: GetSeparators = memoize((locale) => {
+  const res = localeNotAvailable
+    ? getFallback(locale)[1]
+    : (10000.2).toLocaleString(locale);
+  let decimal;
+  let thousands;
+
+  for (let i = 0; i < res.length; i++) {
+    const c = res[i];
+    if (/[0-9]/.test(c)) continue;
+
+    if (!thousands) {
+      thousands = c;
+    } else {
+      decimal = c;
+    }
+  }
+
+  return {
+    decimal,
+    thousands,
+  };
+});

package/src/currencies/parseCurrencyUnit.ts

@@ -0,0 +1,16 @@
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+import { BigNumber } from "bignumber.js";
+// parse a value that was formatted with formatCurrencyUnit
+// NB this function parse a subset of formats because it it locale independant.
+// make sure you have at least following options set on the formatter:
+// - useGrouping: true
+// - showCode: false
+export const parseCurrencyUnit = (
+  unit: Unit,
+  valueString: string
+): BigNumber => {
+  const str = valueString.replace(/,/g, ".");
+  const value = new BigNumber(str);
+  if (value.isNaN()) return new BigNumber(0);
+  return value.times(new BigNumber(10).pow(unit.magnitude)).integerValue();
+};

package/src/currencies/sanitizeValueString.ts

@@ -0,0 +1,58 @@
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+import { getSeparators } from "./localeUtility";
+const numbers = "0123456789";
+export const sanitizeValueString = (
+  unit: Unit,
+  valueString: string,
+  locale?: string
+): {
+  display: string;
+  value: string;
+} => {
+  const s = getSeparators(locale || "en-US");
+  const dot = s.decimal || ".";
+  let display = "";
+  let value = "";
+  let decimals = -1;
+
+  for (let i = 0; i < valueString.length; i++) {
+    const c = valueString[i];
+
+    if (numbers.indexOf(c) !== -1) {
+      if (decimals >= 0) {
+        decimals++;
+        if (decimals > unit.magnitude) break;
+        value = value === "0" ? c : value + c;
+        display += c;
+      } else if (value !== "0") {
+        value += c;
+        display += c;
+      } else {
+        value = c;
+        display = c;
+      }
+    } else if (decimals === -1 && (c === "," || c === ".")) {
+      if (unit.magnitude === 0) {
+        // in this specific case, we will never allow commas
+        return {
+          display,
+          value,
+        };
+      }
+
+      if (i === 0) display = "0";
+      decimals = 0;
+      display += dot;
+    }
+  }
+
+  for (let i = Math.max(0, decimals); i < unit.magnitude; ++i) {
+    value += "0";
+  }
+
+  if (!value) value = "0";
+  return {
+    display,
+    value,
+  };
+};

package/src/currencies/support.ts

@@ -0,0 +1,107 @@
+import {
+  getFiatCurrencyByTicker,
+  getCryptoCurrencyById,
+  hasCryptoCurrencyId,
+} from "@ledgerhq/cryptoassets";
+import {
+  CryptoCurrency,
+  CryptoCurrencyId,
+  FiatCurrency,
+} from "@ledgerhq/types-cryptoassets";
+import { getEnv } from "../env";
+
+// set by user side effect to precise which currencies are considered supported (typically by live)
+let userSupportedCurrencies: CryptoCurrency[] = [];
+let userSupportedFiats: FiatCurrency[] = [];
+// Current list was established with what our API really supports
+// to update the list,
+// 1. $ ledger-live countervalues --format supportedFiats --fiats
+// 2. copy & paste the output
+setSupportedFiats([
+  "AED",
+  "AUD",
+  "BGN",
+  "BHD",
+  "BRL",
+  "CAD",
+  "CHF",
+  "CLP",
+  "CNY",
+  "CRC",
+  "CZK",
+  "DKK",
+  "EUR",
+  "GBP",
+  "GHS",
+  "HKD",
+  "HRK",
+  "HUF",
+  "IDR",
+  "ILS",
+  "INR",
+  "IRR",
+  "JPY",
+  "KES",
+  "KHR",
+  "KRW",
+  "MUR",
+  "MXN",
+  "MYR",
+  "NGN",
+  "NOK",
+  "NZD",
+  "PHP",
+  "PKR",
+  "PLN",
+  "RON",
+  "RUB",
+  "SEK",
+  "SGD",
+  "THB",
+  "TRY",
+  "TZS",
+  "UAH",
+  "UGX",
+  "USD",
+  "VES",
+  "VND",
+  "VUV",
+  "ZAR",
+]);
+
+export function isFiatSupported(fiat: FiatCurrency) {
+  return userSupportedFiats.includes(fiat);
+}
+export function setSupportedFiats(ids: string[]) {
+  userSupportedFiats = ids.map(getFiatCurrencyByTicker);
+}
+export function listSupportedFiats(): FiatCurrency[] {
+  return userSupportedFiats;
+}
+
+export function setSupportedCurrencies(ids: CryptoCurrencyId[]) {
+  userSupportedCurrencies = Array.from(new Set(ids)) // Make sure to remove duplicates
+    .map((id) => getCryptoCurrencyById(id));
+}
+
+function getExperimentalSupports() {
+  return getEnv("EXPERIMENTAL_CURRENCIES")
+    .split(",")
+    .filter(
+      (id: string) =>
+        hasCryptoCurrencyId(id) &&
+        !userSupportedCurrencies.find((c) => c.id === id)
+    )
+    .map(getCryptoCurrencyById);
+}
+
+export function listSupportedCurrencies(): CryptoCurrency[] {
+  const experimentals = getExperimentalSupports();
+  return experimentals.length === 0
+    ? userSupportedCurrencies
+    : userSupportedCurrencies.concat(experimentals);
+}
+
+export function isCurrencySupported(currency: CryptoCurrency): boolean {
+  return listSupportedCurrencies().includes(currency);
+}

package/src/currencies/valueFromUnit.ts

@@ -0,0 +1,10 @@
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+import { BigNumber } from "bignumber.js";
+
+/**
+ * convert a value in a given unit to a normalized value
+ * For instance, for 1 BTC, valueFromUnit(1, btcUnit) returns 100000000
+ * @memberof countervalue
+ */
+export const valueFromUnit = (valueInUnit: BigNumber, unit: Unit) =>
+  valueInUnit.times(new BigNumber(10).pow(unit.magnitude));