@talismn/util 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @talismn/util
 
+## 0.1.7
+
+### Patch Changes
+
+- c651551c: build: move `@polkadot` dependencies to `peerDependencies`
+
+## 0.1.6
+
+### Patch Changes
+
+- 8adc7f06: feat: switched build tool to preconstruct
+
 ## 0.1.5
 
 ### Patch Changes

package/dist/declarations/src/FunctionPropertyNames.d.ts

@@ -0,0 +1,8 @@
+export type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+export type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;
+export type NonFunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;

package/dist/declarations/src/classNames.d.ts

@@ -0,0 +1,3 @@
+type ClassName = string | false | undefined | null;
+export declare const classNames: (...args: ClassName[]) => string | undefined;
+export {};

package/dist/{index.d.ts → declarations/src/index.d.ts}

@@ -1,9 +1,10 @@
 export * from "./BigMath";
+export * from "./FunctionPropertyNames";
 export * from "./blake2Concat";
+export * from "./classNames";
 export * from "./decodeAnyAddress";
 export * from "./encodeAnyAddress";
 export * from "./formatDecimals";
-export * from "./FunctionPropertyNames";
 export * from "./getBase64ImageUrl";
 export * from "./hasOwnProperty";
 export * from "./isArrayOf";

package/dist/talismn-util.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./declarations/src/index";

package/dist/talismn-util.cjs.dev.js

@@ -0,0 +1,176 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('@polkadot/util');
+var utilCrypto = require('@polkadot/util-crypto');
+var keyring = require('@polkadot/keyring');
+var BigNumber = require('bignumber.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var BigNumber__default = /*#__PURE__*/_interopDefault(BigNumber);
+
+/**
+ * Javascript's `Math` library for `BigInt`.
+ * Taken from https://stackoverflow.com/questions/51867270/is-there-a-library-similar-to-math-that-supports-javascript-bigint/64953280#64953280
+ */
+const BigMath = {
+  abs(x) {
+    return x < BigInt("0") ? -x : x;
+  },
+  sign(x) {
+    if (x === BigInt("0")) return BigInt("0");
+    return x < BigInt("0") ? BigInt("-1") : BigInt("1");
+  },
+  // TODO: Improve our babel/tsc config to let us use the `**` operator on bigint values.
+  // Error thrown: Exponentiation cannot be performed on 'bigint' values unless the 'target' option is set to 'es2016' or later. ts(2791)
+  // pow(base: bigint, exponent: bigint) {
+  //   return base ** exponent
+  // },
+  min(value, ...values) {
+    for (const v of values) if (v < value) value = v;
+    return value;
+  },
+  max(value, ...values) {
+    for (const v of values) if (v > value) value = v;
+    return value;
+  }
+};
+
+const bitLength$1 = 128;
+function blake2Concat(input) {
+  return util.u8aToHex(util.u8aConcat(utilCrypto.blake2AsU8a(input, bitLength$1), util.u8aToU8a(input)));
+}
+
+const classNames = (...args) => {
+  return args.filter(Boolean).join(" ") || undefined;
+};
+
+function decodeAnyAddress(encoded, ignoreChecksum, ss58Format) {
+  try {
+    return keyring.decodeAddress(encoded, ignoreChecksum, ss58Format);
+  } catch (error) {
+    if (typeof encoded !== "string") throw error;
+    if (!utilCrypto.isEthereumAddress(encoded)) throw error;
+    return util.hexToU8a(encoded.slice("0x".length));
+  }
+}
+
+function encodeAnyAddress(key, ss58Format) {
+  try {
+    return keyring.encodeAddress(key, ss58Format);
+  } catch (error) {
+    if (typeof key !== "string") throw error;
+    if (!utilCrypto.isEthereumAddress(key)) throw error;
+    return utilCrypto.ethereumEncode(key);
+  }
+}
+
+const MIN_DIGITS = 4; // less truncates more than what compact formating is
+const MAX_DECIMALS_FORMAT = 12;
+
+/**
+ * Custom decimal number formatting for Talisman
+ * note that the NumberFormat().format() call is the ressource heavy part, it's not worth trying to optimize other parts
+ * @param num input number
+ * @param digits number of significant digits to display
+ * @param locale locale used to format the number
+ * @param options formatting options
+ * @returns the formatted value
+ */
+const formatDecimals = (num, digits = MIN_DIGITS, options = {}, locale = "en-US") => {
+  if (num === null || num === undefined) return "";
+  if (digits < MIN_DIGITS) digits = MIN_DIGITS;
+  const value = new BigNumber__default["default"](num);
+  // very small numbers should display "< 0.0001"
+  const minDisplayVal = 1 / Math.pow(10, digits);
+  if (value.gt(0) && value.lt(minDisplayVal)) return `< ${formatDecimals(minDisplayVal)}`;
+
+  // count digits
+  const flooredValue = value.integerValue();
+  const intDigits = flooredValue.isEqualTo(0) ? 0 : flooredValue.toString().length;
+
+  // we never want to display a rounded up value
+  // to prevent JS default rounding, we will remove/truncate insignificant digits ourselves before formatting
+  let truncatedValue = value;
+  //remove insignificant fraction digits
+  const excessFractionDigitsPow10 = new BigNumber__default["default"](10).pow(digits > intDigits ? digits - intDigits : 0);
+  truncatedValue = truncatedValue.multipliedBy(excessFractionDigitsPow10).integerValue().dividedBy(excessFractionDigitsPow10);
+
+  //remove insignificant integer digits
+  const excessIntegerDigits = new BigNumber__default["default"](intDigits > digits ? intDigits - digits : 0);
+  const excessIntegerDigitsPow10 = new BigNumber__default["default"](10).pow(excessIntegerDigits);
+  if (excessIntegerDigits.gt(0)) truncatedValue = truncatedValue.dividedBy(excessIntegerDigitsPow10).integerValue().multipliedBy(excessIntegerDigitsPow10);
+
+  // format
+
+  return Intl.NumberFormat(locale, {
+    //compact notation (K, M, B) if above 9999
+    notation: truncatedValue.gt(9999) ? "compact" : "standard",
+    maximumSignificantDigits: digits + (truncatedValue.lt(1) ? 1 : 0),
+    ...options
+  }).format(truncatedValue.toNumber());
+};
+
+const getBase64ImageUrl = base64 => {
+  const match = /^data:([^;]*?);base64,(.*?)$/.exec(base64);
+  if (!match) return null;
+  const buffer = Buffer.from(match[2], "base64");
+  const blob = new Blob([new Uint8Array(buffer, 0, buffer.length)], {
+    type: match[1]
+  });
+  return URL.createObjectURL(blob);
+};
+
+function hasOwnProperty(obj, prop) {
+  if (typeof obj !== "object") return false;
+  if (obj === null) return false;
+  return prop in obj;
+}
+
+function isArrayOf(array, func) {
+  if (array.length > 0 && array[0] instanceof func) return true;
+  return false;
+}
+
+function planckToTokens(planck, tokenDecimals) {
+  if (typeof planck !== "string" || typeof tokenDecimals !== "number") return;
+  const base = new BigNumber__default["default"](10);
+  const exponent = new BigNumber__default["default"](tokenDecimals).negated();
+  const multiplier = base.pow(exponent);
+  return new BigNumber__default["default"](planck).multipliedBy(multiplier).toString(10);
+}
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const throwAfter = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(reason), ms));
+
+function tokensToPlanck(tokens, tokenDecimals) {
+  if (typeof tokens !== "string" || typeof tokenDecimals !== "number") return;
+  const base = new BigNumber__default["default"](10);
+  const exponent = new BigNumber__default["default"](tokenDecimals);
+  const multiplier = base.pow(exponent);
+  return new BigNumber__default["default"](tokens).multipliedBy(multiplier).toString(10);
+}
+
+const bitLength = 64;
+function twox64Concat(input) {
+  return util.u8aToHex(util.u8aConcat(utilCrypto.xxhashAsU8a(input, bitLength), util.u8aToU8a(input)));
+}
+
+exports.BigMath = BigMath;
+exports.MAX_DECIMALS_FORMAT = MAX_DECIMALS_FORMAT;
+exports.blake2Concat = blake2Concat;
+exports.classNames = classNames;
+exports.decodeAnyAddress = decodeAnyAddress;
+exports.encodeAnyAddress = encodeAnyAddress;
+exports.formatDecimals = formatDecimals;
+exports.getBase64ImageUrl = getBase64ImageUrl;
+exports.hasOwnProperty = hasOwnProperty;
+exports.isArrayOf = isArrayOf;
+exports.planckToTokens = planckToTokens;
+exports.sleep = sleep;
+exports.throwAfter = throwAfter;
+exports.tokensToPlanck = tokensToPlanck;
+exports.twox64Concat = twox64Concat;

package/dist/talismn-util.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./talismn-util.cjs.prod.js");
+} else {
+  module.exports = require("./talismn-util.cjs.dev.js");
+}

package/dist/talismn-util.cjs.prod.js

@@ -0,0 +1,176 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('@polkadot/util');
+var utilCrypto = require('@polkadot/util-crypto');
+var keyring = require('@polkadot/keyring');
+var BigNumber = require('bignumber.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var BigNumber__default = /*#__PURE__*/_interopDefault(BigNumber);
+
+/**
+ * Javascript's `Math` library for `BigInt`.
+ * Taken from https://stackoverflow.com/questions/51867270/is-there-a-library-similar-to-math-that-supports-javascript-bigint/64953280#64953280
+ */
+const BigMath = {
+  abs(x) {
+    return x < BigInt("0") ? -x : x;
+  },
+  sign(x) {
+    if (x === BigInt("0")) return BigInt("0");
+    return x < BigInt("0") ? BigInt("-1") : BigInt("1");
+  },
+  // TODO: Improve our babel/tsc config to let us use the `**` operator on bigint values.
+  // Error thrown: Exponentiation cannot be performed on 'bigint' values unless the 'target' option is set to 'es2016' or later. ts(2791)
+  // pow(base: bigint, exponent: bigint) {
+  //   return base ** exponent
+  // },
+  min(value, ...values) {
+    for (const v of values) if (v < value) value = v;
+    return value;
+  },
+  max(value, ...values) {
+    for (const v of values) if (v > value) value = v;
+    return value;
+  }
+};
+
+const bitLength$1 = 128;
+function blake2Concat(input) {
+  return util.u8aToHex(util.u8aConcat(utilCrypto.blake2AsU8a(input, bitLength$1), util.u8aToU8a(input)));
+}
+
+const classNames = (...args) => {
+  return args.filter(Boolean).join(" ") || undefined;
+};
+
+function decodeAnyAddress(encoded, ignoreChecksum, ss58Format) {
+  try {
+    return keyring.decodeAddress(encoded, ignoreChecksum, ss58Format);
+  } catch (error) {
+    if (typeof encoded !== "string") throw error;
+    if (!utilCrypto.isEthereumAddress(encoded)) throw error;
+    return util.hexToU8a(encoded.slice("0x".length));
+  }
+}
+
+function encodeAnyAddress(key, ss58Format) {
+  try {
+    return keyring.encodeAddress(key, ss58Format);
+  } catch (error) {
+    if (typeof key !== "string") throw error;
+    if (!utilCrypto.isEthereumAddress(key)) throw error;
+    return utilCrypto.ethereumEncode(key);
+  }
+}
+
+const MIN_DIGITS = 4; // less truncates more than what compact formating is
+const MAX_DECIMALS_FORMAT = 12;
+
+/**
+ * Custom decimal number formatting for Talisman
+ * note that the NumberFormat().format() call is the ressource heavy part, it's not worth trying to optimize other parts
+ * @param num input number
+ * @param digits number of significant digits to display
+ * @param locale locale used to format the number
+ * @param options formatting options
+ * @returns the formatted value
+ */
+const formatDecimals = (num, digits = MIN_DIGITS, options = {}, locale = "en-US") => {
+  if (num === null || num === undefined) return "";
+  if (digits < MIN_DIGITS) digits = MIN_DIGITS;
+  const value = new BigNumber__default["default"](num);
+  // very small numbers should display "< 0.0001"
+  const minDisplayVal = 1 / Math.pow(10, digits);
+  if (value.gt(0) && value.lt(minDisplayVal)) return `< ${formatDecimals(minDisplayVal)}`;
+
+  // count digits
+  const flooredValue = value.integerValue();
+  const intDigits = flooredValue.isEqualTo(0) ? 0 : flooredValue.toString().length;
+
+  // we never want to display a rounded up value
+  // to prevent JS default rounding, we will remove/truncate insignificant digits ourselves before formatting
+  let truncatedValue = value;
+  //remove insignificant fraction digits
+  const excessFractionDigitsPow10 = new BigNumber__default["default"](10).pow(digits > intDigits ? digits - intDigits : 0);
+  truncatedValue = truncatedValue.multipliedBy(excessFractionDigitsPow10).integerValue().dividedBy(excessFractionDigitsPow10);
+
+  //remove insignificant integer digits
+  const excessIntegerDigits = new BigNumber__default["default"](intDigits > digits ? intDigits - digits : 0);
+  const excessIntegerDigitsPow10 = new BigNumber__default["default"](10).pow(excessIntegerDigits);
+  if (excessIntegerDigits.gt(0)) truncatedValue = truncatedValue.dividedBy(excessIntegerDigitsPow10).integerValue().multipliedBy(excessIntegerDigitsPow10);
+
+  // format
+
+  return Intl.NumberFormat(locale, {
+    //compact notation (K, M, B) if above 9999
+    notation: truncatedValue.gt(9999) ? "compact" : "standard",
+    maximumSignificantDigits: digits + (truncatedValue.lt(1) ? 1 : 0),
+    ...options
+  }).format(truncatedValue.toNumber());
+};
+
+const getBase64ImageUrl = base64 => {
+  const match = /^data:([^;]*?);base64,(.*?)$/.exec(base64);
+  if (!match) return null;
+  const buffer = Buffer.from(match[2], "base64");
+  const blob = new Blob([new Uint8Array(buffer, 0, buffer.length)], {
+    type: match[1]
+  });
+  return URL.createObjectURL(blob);
+};
+
+function hasOwnProperty(obj, prop) {
+  if (typeof obj !== "object") return false;
+  if (obj === null) return false;
+  return prop in obj;
+}
+
+function isArrayOf(array, func) {
+  if (array.length > 0 && array[0] instanceof func) return true;
+  return false;
+}
+
+function planckToTokens(planck, tokenDecimals) {
+  if (typeof planck !== "string" || typeof tokenDecimals !== "number") return;
+  const base = new BigNumber__default["default"](10);
+  const exponent = new BigNumber__default["default"](tokenDecimals).negated();
+  const multiplier = base.pow(exponent);
+  return new BigNumber__default["default"](planck).multipliedBy(multiplier).toString(10);
+}
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const throwAfter = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(reason), ms));
+
+function tokensToPlanck(tokens, tokenDecimals) {
+  if (typeof tokens !== "string" || typeof tokenDecimals !== "number") return;
+  const base = new BigNumber__default["default"](10);
+  const exponent = new BigNumber__default["default"](tokenDecimals);
+  const multiplier = base.pow(exponent);
+  return new BigNumber__default["default"](tokens).multipliedBy(multiplier).toString(10);
+}
+
+const bitLength = 64;
+function twox64Concat(input) {
+  return util.u8aToHex(util.u8aConcat(utilCrypto.xxhashAsU8a(input, bitLength), util.u8aToU8a(input)));
+}
+
+exports.BigMath = BigMath;
+exports.MAX_DECIMALS_FORMAT = MAX_DECIMALS_FORMAT;
+exports.blake2Concat = blake2Concat;
+exports.classNames = classNames;
+exports.decodeAnyAddress = decodeAnyAddress;
+exports.encodeAnyAddress = encodeAnyAddress;
+exports.formatDecimals = formatDecimals;
+exports.getBase64ImageUrl = getBase64ImageUrl;
+exports.hasOwnProperty = hasOwnProperty;
+exports.isArrayOf = isArrayOf;
+exports.planckToTokens = planckToTokens;
+exports.sleep = sleep;
+exports.throwAfter = throwAfter;
+exports.tokensToPlanck = tokensToPlanck;
+exports.twox64Concat = twox64Concat;

package/dist/talismn-util.esm.js

@@ -0,0 +1,154 @@
+import { u8aToHex, u8aConcat, u8aToU8a, hexToU8a } from '@polkadot/util';
+import { blake2AsU8a, isEthereumAddress, ethereumEncode, xxhashAsU8a } from '@polkadot/util-crypto';
+import { decodeAddress, encodeAddress } from '@polkadot/keyring';
+import BigNumber from 'bignumber.js';
+
+/**
+ * Javascript's `Math` library for `BigInt`.
+ * Taken from https://stackoverflow.com/questions/51867270/is-there-a-library-similar-to-math-that-supports-javascript-bigint/64953280#64953280
+ */
+const BigMath = {
+  abs(x) {
+    return x < BigInt("0") ? -x : x;
+  },
+  sign(x) {
+    if (x === BigInt("0")) return BigInt("0");
+    return x < BigInt("0") ? BigInt("-1") : BigInt("1");
+  },
+  // TODO: Improve our babel/tsc config to let us use the `**` operator on bigint values.
+  // Error thrown: Exponentiation cannot be performed on 'bigint' values unless the 'target' option is set to 'es2016' or later. ts(2791)
+  // pow(base: bigint, exponent: bigint) {
+  //   return base ** exponent
+  // },
+  min(value, ...values) {
+    for (const v of values) if (v < value) value = v;
+    return value;
+  },
+  max(value, ...values) {
+    for (const v of values) if (v > value) value = v;
+    return value;
+  }
+};
+
+const bitLength$1 = 128;
+function blake2Concat(input) {
+  return u8aToHex(u8aConcat(blake2AsU8a(input, bitLength$1), u8aToU8a(input)));
+}
+
+const classNames = (...args) => {
+  return args.filter(Boolean).join(" ") || undefined;
+};
+
+function decodeAnyAddress(encoded, ignoreChecksum, ss58Format) {
+  try {
+    return decodeAddress(encoded, ignoreChecksum, ss58Format);
+  } catch (error) {
+    if (typeof encoded !== "string") throw error;
+    if (!isEthereumAddress(encoded)) throw error;
+    return hexToU8a(encoded.slice("0x".length));
+  }
+}
+
+function encodeAnyAddress(key, ss58Format) {
+  try {
+    return encodeAddress(key, ss58Format);
+  } catch (error) {
+    if (typeof key !== "string") throw error;
+    if (!isEthereumAddress(key)) throw error;
+    return ethereumEncode(key);
+  }
+}
+
+const MIN_DIGITS = 4; // less truncates more than what compact formating is
+const MAX_DECIMALS_FORMAT = 12;
+
+/**
+ * Custom decimal number formatting for Talisman
+ * note that the NumberFormat().format() call is the ressource heavy part, it's not worth trying to optimize other parts
+ * @param num input number
+ * @param digits number of significant digits to display
+ * @param locale locale used to format the number
+ * @param options formatting options
+ * @returns the formatted value
+ */
+const formatDecimals = (num, digits = MIN_DIGITS, options = {}, locale = "en-US") => {
+  if (num === null || num === undefined) return "";
+  if (digits < MIN_DIGITS) digits = MIN_DIGITS;
+  const value = new BigNumber(num);
+  // very small numbers should display "< 0.0001"
+  const minDisplayVal = 1 / Math.pow(10, digits);
+  if (value.gt(0) && value.lt(minDisplayVal)) return `< ${formatDecimals(minDisplayVal)}`;
+
+  // count digits
+  const flooredValue = value.integerValue();
+  const intDigits = flooredValue.isEqualTo(0) ? 0 : flooredValue.toString().length;
+
+  // we never want to display a rounded up value
+  // to prevent JS default rounding, we will remove/truncate insignificant digits ourselves before formatting
+  let truncatedValue = value;
+  //remove insignificant fraction digits
+  const excessFractionDigitsPow10 = new BigNumber(10).pow(digits > intDigits ? digits - intDigits : 0);
+  truncatedValue = truncatedValue.multipliedBy(excessFractionDigitsPow10).integerValue().dividedBy(excessFractionDigitsPow10);
+
+  //remove insignificant integer digits
+  const excessIntegerDigits = new BigNumber(intDigits > digits ? intDigits - digits : 0);
+  const excessIntegerDigitsPow10 = new BigNumber(10).pow(excessIntegerDigits);
+  if (excessIntegerDigits.gt(0)) truncatedValue = truncatedValue.dividedBy(excessIntegerDigitsPow10).integerValue().multipliedBy(excessIntegerDigitsPow10);
+
+  // format
+
+  return Intl.NumberFormat(locale, {
+    //compact notation (K, M, B) if above 9999
+    notation: truncatedValue.gt(9999) ? "compact" : "standard",
+    maximumSignificantDigits: digits + (truncatedValue.lt(1) ? 1 : 0),
+    ...options
+  }).format(truncatedValue.toNumber());
+};
+
+const getBase64ImageUrl = base64 => {
+  const match = /^data:([^;]*?);base64,(.*?)$/.exec(base64);
+  if (!match) return null;
+  const buffer = Buffer.from(match[2], "base64");
+  const blob = new Blob([new Uint8Array(buffer, 0, buffer.length)], {
+    type: match[1]
+  });
+  return URL.createObjectURL(blob);
+};
+
+function hasOwnProperty(obj, prop) {
+  if (typeof obj !== "object") return false;
+  if (obj === null) return false;
+  return prop in obj;
+}
+
+function isArrayOf(array, func) {
+  if (array.length > 0 && array[0] instanceof func) return true;
+  return false;
+}
+
+function planckToTokens(planck, tokenDecimals) {
+  if (typeof planck !== "string" || typeof tokenDecimals !== "number") return;
+  const base = new BigNumber(10);
+  const exponent = new BigNumber(tokenDecimals).negated();
+  const multiplier = base.pow(exponent);
+  return new BigNumber(planck).multipliedBy(multiplier).toString(10);
+}
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const throwAfter = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(reason), ms));
+
+function tokensToPlanck(tokens, tokenDecimals) {
+  if (typeof tokens !== "string" || typeof tokenDecimals !== "number") return;
+  const base = new BigNumber(10);
+  const exponent = new BigNumber(tokenDecimals);
+  const multiplier = base.pow(exponent);
+  return new BigNumber(tokens).multipliedBy(multiplier).toString(10);
+}
+
+const bitLength = 64;
+function twox64Concat(input) {
+  return u8aToHex(u8aConcat(xxhashAsU8a(input, bitLength), u8aToU8a(input)));
+}
+
+export { BigMath, MAX_DECIMALS_FORMAT, blake2Concat, classNames, decodeAnyAddress, encodeAnyAddress, formatDecimals, getBase64ImageUrl, hasOwnProperty, isArrayOf, planckToTokens, sleep, throwAfter, tokensToPlanck, twox64Concat };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/util",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "UNLICENSED",
@@ -12,8 +12,8 @@
     "type": "git",
     "url": "https://github.com/talismansociety/talisman.git"
   },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/talismn-util.cjs.js",
+  "module": "dist/talismn-util.esm.js",
   "files": [
     "/dist"
   ],
@@ -21,33 +21,34 @@
     "node": ">=14"
   },
   "scripts": {
-    "dev": "tsc --watch --declarationMap",
-    "build": "tsc --declarationMap",
-    "build:packages:prod": "rm -rf dist && tsc",
-    "prepack": "yarn build:packages:prod",
     "test": "jest",
     "lint": "eslint . --max-warnings 0",
     "clean": "rm -rf dist && rm -rf .turbo rm -rf node_modules"
   },
   "dependencies": {
-    "@polkadot/keyring": "^10.1.7",
-    "@polkadot/util": "^10.1.7",
-    "@polkadot/util-crypto": "^10.1.7",
     "bignumber.js": "^9.1.0"
   },
   "devDependencies": {
-    "@talismn/eslint-config": "^0.0.0",
-    "@talismn/tsconfig": "^0.0.1",
+    "@polkadot/keyring": "^10.1.7",
+    "@polkadot/util": "^10.1.7",
+    "@polkadot/util-crypto": "^10.1.7",
+    "@talismn/eslint-config": "^0.0.1",
+    "@talismn/tsconfig": "^0.0.2",
     "@types/jest": "^27.5.1",
     "eslint": "^8.4.0",
     "jest": "^28.1.0",
     "ts-jest": "^28.0.2",
     "typescript": "^4.6.4"
   },
+  "peerDependencies": {
+    "@polkadot/keyring": "10.x",
+    "@polkadot/util": "10.x",
+    "@polkadot/util-crypto": "^10.x"
+  },
   "eslintConfig": {
     "root": true,
     "extends": [
-      "@talismn/eslint-config"
+      "@talismn/eslint-config/base"
     ]
   }
 }

package/dist/BigMath.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BigMath = void 0;
-/**
- * Javascript's `Math` library for `BigInt`.
- * Taken from https://stackoverflow.com/questions/51867270/is-there-a-library-similar-to-math-that-supports-javascript-bigint/64953280#64953280
- */
-exports.BigMath = {
-    abs(x) {
-        return x < BigInt("0") ? -x : x;
-    },
-    sign(x) {
-        if (x === BigInt("0"))
-            return BigInt("0");
-        return x < BigInt("0") ? BigInt("-1") : BigInt("1");
-    },
-    // TODO: Improve our babel/tsc config to let us use the `**` operator on bigint values.
-    // Error thrown: Exponentiation cannot be performed on 'bigint' values unless the 'target' option is set to 'es2016' or later. ts(2791)
-    // pow(base: bigint, exponent: bigint) {
-    //   return base ** exponent
-    // },
-    min(value, ...values) {
-        for (const v of values)
-            if (v < value)
-                value = v;
-        return value;
-    },
-    max(value, ...values) {
-        for (const v of values)
-            if (v > value)
-                value = v;
-        return value;
-    },
-};

package/dist/FunctionPropertyNames.d.ts

@@ -1,8 +0,0 @@
-export declare type FunctionPropertyNames<T> = {
-    [K in keyof T]: T[K] extends Function ? K : never;
-}[keyof T];
-export declare type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;
-export declare type NonFunctionPropertyNames<T> = {
-    [K in keyof T]: T[K] extends Function ? never : K;
-}[keyof T];
-export declare type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;

package/dist/FunctionPropertyNames.js

@@ -1,4 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/ban-types */
-// Some handy types from https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/blake2Concat.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.blake2Concat = void 0;
-const util_1 = require("@polkadot/util");
-const util_crypto_1 = require("@polkadot/util-crypto");
-const bitLength = 128;
-function blake2Concat(input) {
-    return (0, util_1.u8aToHex)((0, util_1.u8aConcat)((0, util_crypto_1.blake2AsU8a)(input, bitLength), (0, util_1.u8aToU8a)(input)));
-}
-exports.blake2Concat = blake2Concat;

package/dist/decodeAnyAddress.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeAnyAddress = void 0;
-const keyring_1 = require("@polkadot/keyring");
-const util_1 = require("@polkadot/util");
-const util_crypto_1 = require("@polkadot/util-crypto");
-function decodeAnyAddress(encoded, ignoreChecksum, ss58Format) {
-    try {
-        return (0, keyring_1.decodeAddress)(encoded, ignoreChecksum, ss58Format);
-    }
-    catch (error) {
-        if (typeof encoded !== "string")
-            throw error;
-        if (!(0, util_crypto_1.isEthereumAddress)(encoded))
-            throw error;
-        return (0, util_1.hexToU8a)(encoded.slice("0x".length));
-    }
-}
-exports.decodeAnyAddress = decodeAnyAddress;

package/dist/encodeAnyAddress.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeAnyAddress = void 0;
-const keyring_1 = require("@polkadot/keyring");
-const util_crypto_1 = require("@polkadot/util-crypto");
-function encodeAnyAddress(key, ss58Format) {
-    try {
-        return (0, keyring_1.encodeAddress)(key, ss58Format);
-    }
-    catch (error) {
-        if (typeof key !== "string")
-            throw error;
-        if (!(0, util_crypto_1.isEthereumAddress)(key))
-            throw error;
-        return (0, util_crypto_1.ethereumEncode)(key);
-    }
-}
-exports.encodeAnyAddress = encodeAnyAddress;

package/dist/formatDecimals.js

@@ -1,57 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatDecimals = exports.MAX_DECIMALS_FORMAT = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const MIN_DIGITS = 4; // less truncates more than what compact formating is
-exports.MAX_DECIMALS_FORMAT = 12;
-/**
- * Custom decimal number formatting for Talisman
- * note that the NumberFormat().format() call is the ressource heavy part, it's not worth trying to optimize other parts
- * @param num input number
- * @param digits number of significant digits to display
- * @param locale locale used to format the number
- * @param options formatting options
- * @returns the formatted value
- */
-const formatDecimals = (num, digits = MIN_DIGITS, options = {}, locale = "en-US") => {
-    if (num === null || num === undefined)
-        return "";
-    if (digits < MIN_DIGITS)
-        digits = MIN_DIGITS;
-    const value = new bignumber_js_1.default(num);
-    // very small numbers should display "< 0.0001"
-    const minDisplayVal = 1 / Math.pow(10, digits);
-    if (value.gt(0) && value.lt(minDisplayVal))
-        return `< ${(0, exports.formatDecimals)(minDisplayVal)}`;
-    // count digits
-    const flooredValue = value.integerValue();
-    const intDigits = flooredValue.isEqualTo(0) ? 0 : flooredValue.toString().length;
-    // we never want to display a rounded up value
-    // to prevent JS default rounding, we will remove/truncate insignificant digits ourselves before formatting
-    let truncatedValue = value;
-    //remove insignificant fraction digits
-    const excessFractionDigitsPow10 = new bignumber_js_1.default(10).pow(digits > intDigits ? digits - intDigits : 0);
-    truncatedValue = truncatedValue
-        .multipliedBy(excessFractionDigitsPow10)
-        .integerValue()
-        .dividedBy(excessFractionDigitsPow10);
-    //remove insignificant integer digits
-    const excessIntegerDigits = new bignumber_js_1.default(intDigits > digits ? intDigits - digits : 0);
-    const excessIntegerDigitsPow10 = new bignumber_js_1.default(10).pow(excessIntegerDigits);
-    if (excessIntegerDigits.gt(0))
-        truncatedValue = truncatedValue
-            .dividedBy(excessIntegerDigitsPow10)
-            .integerValue()
-            .multipliedBy(excessIntegerDigitsPow10);
-    // format
-    return Intl.NumberFormat(locale, {
-        //compact notation (K, M, B) if above 9999
-        notation: truncatedValue.gt(9999) ? "compact" : "standard",
-        maximumSignificantDigits: digits + (truncatedValue.lt(1) ? 1 : 0),
-        ...options,
-    }).format(truncatedValue.toNumber());
-};
-exports.formatDecimals = formatDecimals;

package/dist/getBase64ImageUrl.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBase64ImageUrl = void 0;
-const getBase64ImageUrl = (base64) => {
-    const match = /^data:([^;]*?);base64,(.*?)$/.exec(base64);
-    if (!match)
-        return null;
-    const buffer = Buffer.from(match[2], "base64");
-    const blob = new Blob([new Uint8Array(buffer, 0, buffer.length)], { type: match[1] });
-    return URL.createObjectURL(blob);
-};
-exports.getBase64ImageUrl = getBase64ImageUrl;

package/dist/hasOwnProperty.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasOwnProperty = void 0;
-function hasOwnProperty(obj, prop) {
-    return prop in obj;
-}
-exports.hasOwnProperty = hasOwnProperty;

package/dist/index.js

@@ -1,30 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./BigMath"), exports);
-__exportStar(require("./blake2Concat"), exports);
-__exportStar(require("./decodeAnyAddress"), exports);
-__exportStar(require("./encodeAnyAddress"), exports);
-__exportStar(require("./formatDecimals"), exports);
-__exportStar(require("./FunctionPropertyNames"), exports);
-__exportStar(require("./getBase64ImageUrl"), exports);
-__exportStar(require("./hasOwnProperty"), exports);
-__exportStar(require("./isArrayOf"), exports);
-__exportStar(require("./planckToTokens"), exports);
-__exportStar(require("./sleep"), exports);
-__exportStar(require("./throwAfter"), exports);
-__exportStar(require("./tokensToPlanck"), exports);
-__exportStar(require("./twox64Concat"), exports);

package/dist/isArrayOf.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isArrayOf = void 0;
-function isArrayOf(array, func) {
-    if (array.length > 0 && array[0] instanceof func)
-        return true;
-    return false;
-}
-exports.isArrayOf = isArrayOf;

package/dist/planckToTokens.js

@@ -1,16 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.planckToTokens = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-function planckToTokens(planck, tokenDecimals) {
-    if (typeof planck !== "string" || typeof tokenDecimals !== "number")
-        return;
-    const base = new bignumber_js_1.default(10);
-    const exponent = new bignumber_js_1.default(tokenDecimals).negated();
-    const multiplier = base.pow(exponent);
-    return new bignumber_js_1.default(planck).multipliedBy(multiplier).toString(10);
-}
-exports.planckToTokens = planckToTokens;

package/dist/sleep.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleep = void 0;
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-exports.sleep = sleep;

package/dist/throwAfter.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.throwAfter = void 0;
-const throwAfter = (ms, reason) => new Promise((_, reject) => setTimeout(() => reject(reason), ms));
-exports.throwAfter = throwAfter;

package/dist/tokensToPlanck.js

@@ -1,16 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tokensToPlanck = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-function tokensToPlanck(tokens, tokenDecimals) {
-    if (typeof tokens !== "string" || typeof tokenDecimals !== "number")
-        return;
-    const base = new bignumber_js_1.default(10);
-    const exponent = new bignumber_js_1.default(tokenDecimals);
-    const multiplier = base.pow(exponent);
-    return new bignumber_js_1.default(tokens).multipliedBy(multiplier).toString(10);
-}
-exports.tokensToPlanck = tokensToPlanck;

package/dist/twox64Concat.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.twox64Concat = void 0;
-const util_1 = require("@polkadot/util");
-const util_crypto_1 = require("@polkadot/util-crypto");
-const bitLength = 64;
-function twox64Concat(input) {
-    return (0, util_1.u8aToHex)((0, util_1.u8aConcat)((0, util_crypto_1.xxhashAsU8a)(input, bitLength), (0, util_1.u8aToU8a)(input)));
-}
-exports.twox64Concat = twox64Concat;