@ocap/util 1.16.16 → 1.17.1

package/lib/index.js

@@ -1,48 +1,65 @@
-/* eslint-disable max-len */
-/* eslint-disable no-bitwise */
-/* eslint-disable implicit-arrow-linebreak */
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTxType = exports.toDid = exports.toAddress = exports.fromBase64 = exports.toBase64 = exports.fromBase58 = exports.toBase58 = exports.toBuffer = exports.toUint8Array = exports.isUUID = exports.UUID = exports.isUint8Array = exports.fromTokenToUnit = exports.fromUnitToToken = exports.numberToString = exports.toHex = exports.hexToBytes = exports.bytesToHex = exports.numberToHex = exports.hexToNumber = exports.hexToUtf8 = exports.utf8ToHex = exports.toBN = exports.isHex = exports.isHexStrict = exports.isBigNumber = exports.isBN = exports.stripHexPrefix = exports.isHexPrefixed = exports.numberToBN = exports.rightPad = exports.leftPad = exports.BN = void 0;
+/* eslint-disable @typescript-eslint/no-use-before-define */
 /* eslint-disable no-param-reassign */
-/**
- * @fileOverview Contains utility functions to help developers manipulate blockchain related encoding/decoding/formatting
- * @module @ocap/util
- * @example
- * yarn add @ocap/util
- *
- * const Util = require('@ocap/util');
- * console.log(Util.fromTokenToUnit(100)); // 100_0000_0000_0000_0000
- * console.log(Util.fromUnitToToken('1000000000000000000')); // 100
- * console.log(Util.isStrictHex('0x123abc')); // true
- */
-const isBoolean = require('lodash/isBoolean');
-const isString = require('lodash/isString');
-const isNumber = require('lodash/isNumber');
-const isObject = require('lodash/isObject');
-const upperFirst = require('lodash/upperFirst');
-const camelCase = require('lodash/camelCase');
-const isNull = require('lodash/isNull');
-const rightPad = require('lodash/padEnd');
-const leftPad = require('lodash/padStart');
-const base58 = require('bs58');
-const utf8 = require('utf8');
-const base64 = require('base64-url');
-const BN = require('bn.js');
-
+/* eslint-disable no-bitwise */
+const isBoolean_1 = __importDefault(require("lodash/isBoolean"));
+const isString_1 = __importDefault(require("lodash/isString"));
+const isNumber_1 = __importDefault(require("lodash/isNumber"));
+const isObject_1 = __importDefault(require("lodash/isObject"));
+const upperFirst_1 = __importDefault(require("lodash/upperFirst"));
+const camelCase_1 = __importDefault(require("lodash/camelCase"));
+const isNull_1 = __importDefault(require("lodash/isNull"));
+const padEnd_1 = __importDefault(require("lodash/padEnd"));
+exports.rightPad = padEnd_1.default;
+const padStart_1 = __importDefault(require("lodash/padStart"));
+exports.leftPad = padStart_1.default;
+const bs58_1 = __importDefault(require("bs58"));
+const base64_url_1 = __importDefault(require("base64-url"));
+const bn_js_1 = __importDefault(require("bn.js"));
+exports.BN = bn_js_1.default;
+const utf8 = __importStar(require("utf8"));
 const DID_PREFIX = 'did:abt:';
-const zero = new BN(0);
-const negative1 = new BN(-1);
-
+const zero = new bn_js_1.default(0);
+const negative1 = new bn_js_1.default(-1);
 const base58btc = {
-  encode: (v) => `z${base58.encode(v)}`,
-  decode: (v) => base58.decode(v.slice(1)),
+    encode: (v) => `z${bs58_1.default.encode(v)}`,
+    decode: (v) => bs58_1.default.decode(v.slice(1)),
 };
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const isBase58btc = (data) => {
-  if (typeof data !== 'string') {
-    return false;
-  }
-
-  return data[0] === 'z';
+    if (typeof data !== 'string') {
+        return false;
+    }
+    return data[0] === 'z';
 };
-
 /**
  * Returns a BN object, converts a number value to a BN
  * @param {String|Number|Object} `arg` input a string number, hex string number, number, BigNumber or BN object
@@ -50,41 +67,31 @@ const isBase58btc = (data) => {
  * @throws if the argument is not an array, object that isn't a bignumber, not a string number or number
  */
 const numberToBN = (arg) => {
-  if (typeof arg === 'string' || typeof arg === 'number') {
-    let multiplier = new BN(1); // eslint-disable-line
-    const formattedString = String(arg).toLowerCase().trim();
-    const isHexPrefixed = formattedString.substr(0, 2) === '0x' || formattedString.substr(0, 3) === '-0x';
-    let stringArg = stripHexPrefix(formattedString); // eslint-disable-line
-    if (stringArg.substr(0, 1) === '-') {
-      stringArg = stripHexPrefix(stringArg.slice(1));
-      multiplier = new BN(-1, 10);
-    }
-    stringArg = stringArg === '' ? '0' : stringArg;
-
-    if (
-      (!stringArg.match(/^-?[0-9]+$/) && stringArg.match(/^[0-9A-Fa-f]+$/)) ||
-      stringArg.match(/^[a-fA-F]+$/) ||
-      (isHexPrefixed === true && stringArg.match(/^[0-9A-Fa-f]+$/))
-    ) {
-      return new BN(stringArg, 16).mul(multiplier);
-    }
-
-    if ((stringArg.match(/^-?[0-9]+$/) || stringArg === '') && isHexPrefixed === false) {
-      return new BN(stringArg, 10).mul(multiplier);
-    }
-  } else if (typeof arg === 'object' && arg.toString && !arg.pop && !arg.push) {
-    if (arg.toString(10).match(/^-?[0-9]+$/) && (arg.mul || arg.dividedToIntegerBy)) {
-      return new BN(arg.toString(10), 10);
-    }
-  }
-
-  throw new Error(
-    `[number-to-bn] while converting number ${JSON.stringify(
-      arg
-    )} to BN.js instance, error: invalid number value. Value must be an integer, hex string, BN or BigNumber instance. Note, decimals are not supported.`
-  );
+    if (typeof arg === 'string' || typeof arg === 'number') {
+        let multiplier = new bn_js_1.default(1); // eslint-disable-line
+        const formattedString = String(arg).toLowerCase().trim();
+        const isHexPrefixed = formattedString.substr(0, 2) === '0x' || formattedString.substr(0, 3) === '-0x';
+        let stringArg = (0, exports.stripHexPrefix)(formattedString); // eslint-disable-line
+        if (stringArg.substr(0, 1) === '-') {
+            stringArg = (0, exports.stripHexPrefix)(stringArg.slice(1));
+            multiplier = new bn_js_1.default(-1, 10);
+        }
+        stringArg = stringArg === '' ? '0' : stringArg;
+        if ((!stringArg.match(/^-?[0-9]+$/) && stringArg.match(/^[0-9A-Fa-f]+$/)) ||
+            stringArg.match(/^[a-fA-F]+$/) ||
+            (isHexPrefixed === true && stringArg.match(/^[0-9A-Fa-f]+$/))) {
+            return new bn_js_1.default(stringArg, 16).mul(multiplier);
+        }
+        if ((stringArg.match(/^-?[0-9]+$/) || stringArg === '') && isHexPrefixed === false) {
+            return new bn_js_1.default(stringArg, 10).mul(multiplier);
+        }
+    }
+    if ((0, exports.isBN)(arg)) {
+        return new bn_js_1.default(arg.toString(10), 10);
+    }
+    throw new Error(`[number-to-bn] while converting number ${JSON.stringify(arg)} to BN.js instance, error: invalid number value. Value must be an integer, hex string, BN or BigNumber instance. Note, decimals are not supported.`);
 };
-
+exports.numberToBN = numberToBN;
 /**
  * Returns a `boolean` on whether or not the `string` starts with '0x'
  *
@@ -95,13 +102,12 @@ const numberToBN = (arg) => {
  * @throws if the str input is not a string
  */
 const isHexPrefixed = (str) => {
-  if (typeof str !== 'string') {
-    throw new Error('[is-hex-prefixed] value must be type string');
-  }
-
-  return str.slice(0, 2).toLowerCase() === '0x';
+    if (typeof str !== 'string') {
+        throw new Error('[is-hex-prefixed] value must be type string');
+    }
+    return str.slice(0, 2).toLowerCase() === '0x';
 };
-
+exports.isHexPrefixed = isHexPrefixed;
 /**
  * Removes '0x' from a given `String` if present
  *
@@ -111,13 +117,12 @@ const isHexPrefixed = (str) => {
  * @return {String|Optional} a string by pass if necessary
  */
 const stripHexPrefix = (str) => {
-  if (typeof str !== 'string') {
-    return str;
-  }
-
-  return isHexPrefixed(str) ? str.slice(2) : str;
+    if (typeof str !== 'string') {
+        return str;
+    }
+    return (0, exports.isHexPrefixed)(str) ? str.slice(2) : str;
 };
-
+exports.stripHexPrefix = stripHexPrefix;
 /**
  * Returns true if object is BN, otherwise false
  *
@@ -127,8 +132,8 @@ const stripHexPrefix = (str) => {
  * @param {Object} object
  * @returns {Boolean}
  */
-const isBN = (object) => object instanceof BN || (object && object.constructor && object.constructor.name === 'BN');
-
+const isBN = (object) => object instanceof bn_js_1.default || (object && object.constructor && object.constructor.name === 'BN');
+exports.isBN = isBN;
 /**
  * Returns true if object is BigNumber, otherwise false
  *
@@ -139,7 +144,7 @@ const isBN = (object) => object instanceof BN || (object && object.constructor &
  * @returns {Boolean}
  */
 const isBigNumber = (object) => object && object.constructor && object.constructor.name === 'BigNumber';
-
+exports.isBigNumber = isBigNumber;
 /**
  * Check if string is HEX, requires a 0x in front
  *
@@ -149,8 +154,8 @@ const isBigNumber = (object) => object && object.constructor && object.construct
  * @param {String} hex to be checked
  * @returns {Boolean}
  */
-const isHexStrict = (hex) => (isString(hex) || isNumber(hex)) && /^(-)?0x[0-9a-f]*$/i.test(hex);
-
+const isHexStrict = (hex) => ((0, isString_1.default)(hex) || (0, isNumber_1.default)(hex)) && /^(-)?0x[0-9a-f]*$/i.test(hex);
+exports.isHexStrict = isHexStrict;
 /**
  * Check if string is HEX
  *
@@ -160,29 +165,30 @@ const isHexStrict = (hex) => (isString(hex) || isNumber(hex)) && /^(-)?0x[0-9a-f
  * @param {String} hex to be checked
  * @returns {Boolean}
  */
-const isHex = (hex) => (isString(hex) || isNumber(hex)) && /^(-0x|0x|0X|-0X)?[0-9a-f]*$/i.test(hex);
-
+const isHex = (hex) => ((0, isString_1.default)(hex) || (0, isNumber_1.default)(hex)) && /^(-0x|0x|0X|-0X)?[0-9a-f]*$/i.test(hex);
+exports.isHex = isHex;
 /**
  * Takes an input and transforms it into an BN
  *
  * @public
  * @static
  * @method toBN
- * @param {Number|String|BN} number, string, HEX string or BN
+ * @param {Number|String|BN} num, string, HEX string or BN
  * @returns {BN} BN
  */
-const toBN = (number) => {
-  try {
-    if (typeof number === 'number' && number > 0) {
-      const numStr = Number(number).toLocaleString('fullwide', { useGrouping: false });
-      return new BN(numStr, 10);
-    }
-    return numberToBN(number);
-  } catch (error) {
-    throw new Error(`${error} Given value: "${number}"`);
-  }
+const toBN = (num, base = 10) => {
+    try {
+        if (typeof num === 'number' && num > 0) {
+            const numStr = Number(num).toLocaleString('fullwide', { useGrouping: false });
+            return new bn_js_1.default(numStr, base);
+        }
+        return (0, exports.numberToBN)(num);
+    }
+    catch (error) {
+        throw new Error(`${error} Given value: "${num}"`);
+    }
 };
-
+exports.toBN = toBN;
 /**
  * Should be called to get hex representation (prefixed by 0x) of utf8 string
  *
@@ -193,28 +199,23 @@ const toBN = (number) => {
  * @returns {String} hex representation of input string
  */
 const utf8ToHex = (str) => {
-  str = utf8.encode(str);
-  let hex = '';
-
-  /* eslint-disable no-control-regex */
-  // remove \u0000 padding from either side
-  str = str.replace(/^(?:\u0000)*/, '');
-  str = str.split('').reverse().join('');
-  str = str.replace(/^(?:\u0000)*/, '');
-  str = str.split('').reverse().join('');
-  /* eslint-enable no-control-regex */
-
-  for (let i = 0; i < str.length; i++) {
-    const code = str.charCodeAt(i);
-    // if (code !== 0) {
-    const n = code.toString(16);
-    hex += n.length < 2 ? `0${n}` : n;
-    // }
-  }
-
-  return `0x${hex}`;
+    str = utf8.encode(str);
+    let hex = '';
+    /* eslint-disable no-control-regex */
+    // remove \u0000 padding from either side
+    str = str.replace(/^(?:\u0000)*/, '');
+    str = str.split('').reverse().join('');
+    str = str.replace(/^(?:\u0000)*/, '');
+    str = str.split('').reverse().join('');
+    /* eslint-enable no-control-regex */
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        const n = code.toString(16);
+        hex += n.length < 2 ? `0${n}` : n;
+    }
+    return `0x${hex}`;
 };
-
+exports.utf8ToHex = utf8ToHex;
 /**
  * Should be called to get utf8 from it's hex representation
  *
@@ -225,30 +226,26 @@ const utf8ToHex = (str) => {
  * @returns {String} ascii string representation of hex value
  */
 const hexToUtf8 = (hex) => {
-  if (!isHexStrict(hex)) throw new Error(`The parameter "${hex}" must be a valid HEX string.`);
-
-  let str = '';
-  let code = 0;
-  hex = hex.replace(/^0x/i, '');
-
-  // remove 00 padding from either side
-  hex = hex.replace(/^(?:00)*/, '');
-  hex = hex.split('').reverse().join('');
-  hex = hex.replace(/^(?:00)*/, '');
-  hex = hex.split('').reverse().join('');
-
-  const l = hex.length;
-
-  for (let i = 0; i < l; i += 2) {
-    code = parseInt(hex.substr(i, 2), 16);
-    // if (code !== 0) {
-    str += String.fromCharCode(code);
-    // }
-  }
-
-  return utf8.decode(str);
+    if (!(0, exports.isHexStrict)(hex))
+        throw new Error(`The parameter "${hex}" must be a valid HEX string.`);
+    let str = '';
+    let code = 0;
+    hex = hex.replace(/^0x/i, '');
+    // remove 00 padding from either side
+    hex = hex.replace(/^(?:00)*/, '');
+    hex = hex.split('').reverse().join('');
+    hex = hex.replace(/^(?:00)*/, '');
+    hex = hex.split('').reverse().join('');
+    const l = hex.length;
+    for (let i = 0; i < l; i += 2) {
+        code = parseInt(hex.substr(i, 2), 16);
+        // if (code !== 0) {
+        str += String.fromCharCode(code);
+        // }
+    }
+    return utf8.decode(str);
 };
-
+exports.hexToUtf8 = hexToUtf8;
 /**
  * Converts value to number representation
  *
@@ -259,13 +256,12 @@ const hexToUtf8 = (hex) => {
  * @returns {Number}
  */
 const hexToNumber = (value) => {
-  if (!value) {
-    return value;
-  }
-
-  return toBN(value).toNumber();
+    if (!value) {
+        return value;
+    }
+    return (0, exports.toBN)(value).toNumber();
 };
-
+exports.hexToNumber = hexToNumber;
 /**
  * Converts value to hex representation
  *
@@ -276,21 +272,18 @@ const hexToNumber = (value) => {
  * @returns {String}
  */
 const numberToHex = (value) => {
-  if (isNull(value) || typeof value === 'undefined') {
-    return value;
-  }
-
-  // eslint-disable-next-line no-restricted-globals
-  if (!isFinite(value) && !isHex(value)) {
-    throw new Error(`Given input "${value}" is not a number.`);
-  }
-
-  const number = toBN(value);
-  const result = number.toString(16);
-
-  return number.lt(new BN(0)) ? `-0x${result.substr(1)}` : `0x${result}`;
+    if ((0, isNull_1.default)(value) || typeof value === 'undefined') {
+        return value;
+    }
+    // eslint-disable-next-line no-restricted-globals
+    if (!isFinite(value) && !(0, exports.isHex)(value)) {
+        throw new Error(`Given input "${value}" is not a number.`);
+    }
+    const num = (0, exports.toBN)(value);
+    const result = num.toString(16);
+    return num.lt(new bn_js_1.default(0)) ? `-0x${result.substr(1)}` : `0x${result}`;
 };
-
+exports.numberToHex = numberToHex;
 /**
  * Convert a byte array to a hex string
  * Note: Implementation from crypto-js
@@ -302,16 +295,14 @@ const numberToHex = (value) => {
  * @returns {String} the hex string
  */
 const bytesToHex = (bytes) => {
-  const hex = [];
-
-  for (let i = 0; i < bytes.length; i++) {
-    hex.push((bytes[i] >>> 4).toString(16));
-    hex.push((bytes[i] & 0xf).toString(16));
-  }
-
-  return `0x${hex.join('')}`;
+    const hex = [];
+    for (let i = 0; i < bytes.length; i++) {
+        hex.push((bytes[i] >>> 4).toString(16));
+        hex.push((bytes[i] & 0xf).toString(16));
+    }
+    return `0x${hex.join('')}`;
 };
-
+exports.bytesToHex = bytesToHex;
 /**
  * Convert a hex string to a byte array
  * Note: Implementation from crypto-js
@@ -323,23 +314,19 @@ const bytesToHex = (bytes) => {
  * @returns {Array} the byte array
  */
 const hexToBytes = (hex) => {
-  hex = hex.toString(16);
-
-  if (!isHex(hex)) {
-    throw new Error(`Given value "${hex}" is not a valid hex string.`);
-  }
-
-  hex = hex.replace(/^0x/i, '');
-  hex = hex.length % 2 ? `0${hex}` : hex;
-
-  const bytes = [];
-  for (let c = 0; c < hex.length; c += 2) {
-    bytes.push(parseInt(hex.substr(c, 2), 16));
-  }
-
-  return bytes;
+    hex = hex.toString(16);
+    if (!(0, exports.isHex)(hex)) {
+        throw new Error(`Given value "${hex}" is not a valid hex string.`);
+    }
+    hex = hex.replace(/^0x/i, '');
+    hex = hex.length % 2 ? `0${hex}` : hex;
+    const bytes = [];
+    for (let c = 0; c < hex.length; c += 2) {
+        bytes.push(parseInt(hex.substr(c, 2), 16));
+    }
+    return bytes;
 };
-
+exports.hexToBytes = hexToBytes;
 /**
  * Auto converts any given value into it's hex representation.
  * And even stringify objects before.
@@ -351,66 +338,57 @@ const hexToBytes = (hex) => {
  * @param {Boolean} returnType
  * @returns {String}
  */
-const toHex = (value, returnType) => {
-  if (isUint8Array(value) || Buffer.isBuffer(value)) {
-    return returnType ? 'bytes' : bytesToHex(value);
-  }
-
-  if (isBase58btc(value)) {
-    return returnType ? 'bytes' : bytesToHex(base58btc.decode(value));
-  }
-
-  if (isBoolean(value)) {
+const toHex = (value, returnType = false) => {
+    if (isUint8Array(value) || Buffer.isBuffer(value)) {
+        return returnType ? 'bytes' : (0, exports.bytesToHex)(value);
+    }
+    if (isBase58btc(value)) {
+        return returnType ? 'bytes' : (0, exports.bytesToHex)(base58btc.decode(value));
+    }
+    if ((0, isBoolean_1.default)(value)) {
+        // eslint-disable-next-line no-nested-ternary
+        return returnType ? 'bool' : value ? '0x01' : '0x00';
+    }
+    if ((0, isObject_1.default)(value) && !(0, exports.isBigNumber)(value) && !(0, exports.isBN)(value)) {
+        return returnType ? 'string' : (0, exports.utf8ToHex)(JSON.stringify(value));
+    }
+    // if its a negative number, pass it through numberToHex
+    if ((0, isString_1.default)(value)) {
+        if (value.indexOf('-0x') === 0 || value.indexOf('-0X') === 0) {
+            return returnType ? 'int256' : (0, exports.numberToHex)(value);
+        }
+        if (value.indexOf('0x') === 0 || value.indexOf('0X') === 0) {
+            return returnType ? 'bytes' : value;
+        }
+        // TODO: some edge case may be not properly handled here
+        return returnType ? 'string' : (0, exports.utf8ToHex)(value);
+    }
     // eslint-disable-next-line no-nested-ternary
-    return returnType ? 'bool' : value ? '0x01' : '0x00';
-  }
-
-  if (isObject(value) && !isBigNumber(value) && !isBN(value)) {
-    return returnType ? 'string' : utf8ToHex(JSON.stringify(value));
-  }
-
-  // if its a negative number, pass it through numberToHex
-  if (isString(value)) {
-    if (value.indexOf('-0x') === 0 || value.indexOf('-0X') === 0) {
-      return returnType ? 'int256' : numberToHex(value);
-    }
-    if (value.indexOf('0x') === 0 || value.indexOf('0X') === 0) {
-      return returnType ? 'bytes' : value;
-    }
-
-    // TODO: some edge case may be not properly handled here
-    return returnType ? 'string' : utf8ToHex(value);
-  }
-
-  // eslint-disable-next-line no-nested-ternary
-  return returnType ? (value < 0 ? 'int256' : 'uint256') : numberToHex(value);
+    return returnType ? (value < 0 ? 'int256' : 'uint256') : (0, exports.numberToHex)(value);
 };
-
+exports.toHex = toHex;
 const numberToString = (arg) => {
-  if (typeof arg === 'string') {
-    if (!arg.match(/^-?[0-9.]+$/)) {
-      throw new Error(`Invalid value '${arg}' while converting to string, should be a number matching (^-?[0-9.]+).`);
-    }
-    return arg;
-  }
-  if (typeof arg === 'number') {
-    if (typeof number === 'number' && arg > 0) {
-      return Number(arg).toLocaleString('fullwide', { useGrouping: false });
-    }
-
-    return String(arg);
-  }
-
-  if (typeof arg === 'object' && arg.toString && (arg.toTwos || arg.dividedToIntegerBy)) {
-    if (arg.toPrecision) {
-      return String(arg.toPrecision());
-    }
-    return arg.toString(10);
-  }
-
-  throw new Error(`while converting number to string, invalid number value '${arg}' type ${typeof arg}.`);
+    if (typeof arg === 'string') {
+        if (!arg.match(/^-?[0-9.]+$/)) {
+            throw new Error(`Invalid value '${arg}' while converting to string, should be a number matching (^-?[0-9.]+).`);
+        }
+        return arg;
+    }
+    if (typeof arg === 'number') {
+        if (Number.isInteger(arg) && arg > 0) {
+            return Number(arg).toLocaleString('fullwide', { useGrouping: false });
+        }
+        return String(arg);
+    }
+    if (typeof arg === 'object' && arg.toString && (arg.toTwos || arg.dividedToIntegerBy)) {
+        if (arg.toPrecision) {
+            return String(arg.toPrecision());
+        }
+        return arg.toString(10);
+    }
+    throw new Error(`while converting number to string, invalid number value '${arg}' type ${typeof arg}.`);
 };
-
+exports.numberToString = numberToString;
 /**
  * Format a big number to human readable number, such as 1_0000_0000_0000_000 => 1 Token
  *
@@ -422,40 +400,34 @@ const numberToString = (arg) => {
  * @param {object} [optionsInput=undefined]
  * @returns {string}
  */
-const fromUnitToToken = (input, decimal = 18, optionsInput) => {
-  let unit = toBN(input);
-  const negative = unit.lt(zero);
-  const base = toBN(`1${'0'.repeat(decimal)}`, 10);
-  const baseLength = base.toString(10).length - 1 || 1;
-  const options = optionsInput || {};
-
-  if (negative) {
-    unit = unit.mul(negative1);
-  }
-
-  let fraction = unit.mod(base).toString(10);
-  while (fraction.length < baseLength) {
-    fraction = `0${fraction}`;
-  }
-
-  if (!options.pad) {
-    // eslint-disable-next-line prefer-destructuring
-    fraction = fraction.match(/^([0-9]*[1-9]|0)(0*)/)[1];
-  }
-
-  let whole = unit.div(base).toString(10);
-  if (options.commify) {
-    whole = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
-  }
-
-  let value = `${whole}${fraction === '0' ? '' : `.${fraction}`}`;
-  if (negative) {
-    value = `-${value}`;
-  }
-
-  return value;
+const fromUnitToToken = (input, decimal = 18, optionsInput = {}) => {
+    let unit = (0, exports.toBN)(input);
+    const negative = unit.lt(zero);
+    const base = (0, exports.toBN)(`1${'0'.repeat(decimal)}`, 10);
+    const baseLength = base.toString(10).length - 1 || 1;
+    const options = optionsInput || {};
+    if (negative) {
+        unit = unit.mul(negative1);
+    }
+    let fraction = unit.mod(base).toString(10);
+    while (fraction.length < baseLength) {
+        fraction = `0${fraction}`;
+    }
+    if (!options.pad) {
+        // eslint-disable-next-line prefer-destructuring
+        fraction = fraction.match(/^([0-9]*[1-9]|0)(0*)/)[1];
+    }
+    let whole = unit.div(base).toString(10);
+    if (options.commify) {
+        whole = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+    }
+    let value = `${whole}${fraction === '0' ? '' : `.${fraction}`}`;
+    if (negative) {
+        value = `-${value}`;
+    }
+    return value;
 };
-
+exports.fromUnitToToken = fromUnitToToken;
 /**
  * Convert human readable token number to big number instance
  *
@@ -466,54 +438,45 @@ const fromUnitToToken = (input, decimal = 18, optionsInput) => {
  * @returns {BN}
  */
 const fromTokenToUnit = (input, decimal = 18) => {
-  let token = numberToString(input);
-  const base = toBN(`1${'0'.repeat(decimal)}`, 10);
-  const baseLength = base.toString(10).length - 1 || 1;
-
-  // Is it negative?
-  const negative = token.substring(0, 1) === '-';
-  if (negative) {
-    token = token.substring(1);
-  }
-
-  if (token === '.') {
-    throw new Error(`error converting token ${input} to unit, invalid value`);
-  }
-
-  // Split it into a whole and fractional part
-  const comps = token.split('.');
-  if (comps.length > 2) {
-    throw new Error(`error converting token ${input} to unit, too many decimal points`);
-  }
-
-  let whole = comps[0];
-  let fraction = comps[1];
-
-  if (!whole) {
-    whole = '0';
-  }
-  if (!fraction) {
-    fraction = '0';
-  }
-  if (fraction.length > baseLength) {
-    throw new Error(`error converting token ${input} to unit, too many decimal places`);
-  }
-
-  while (fraction.length < baseLength) {
-    fraction += '0';
-  }
-
-  whole = new BN(whole);
-  fraction = new BN(fraction);
-  let unit = whole.mul(base).add(fraction);
-
-  if (negative) {
-    unit = unit.mul(negative1);
-  }
-
-  return new BN(unit.toString(10), 10);
+    let token = (0, exports.numberToString)(input);
+    const base = (0, exports.toBN)(`1${'0'.repeat(decimal)}`, 10);
+    const baseLength = base.toString(10).length - 1 || 1;
+    // Is it negative?
+    const negative = token.substring(0, 1) === '-';
+    if (negative) {
+        token = token.substring(1);
+    }
+    if (token === '.') {
+        throw new Error(`error converting token ${input} to unit, invalid value`);
+    }
+    // Split it into a whole and fractional part
+    const comps = token.split('.');
+    if (comps.length > 2) {
+        throw new Error(`error converting token ${input} to unit, too many decimal points`);
+    }
+    let whole = comps[0];
+    let fraction = comps[1];
+    if (!whole) {
+        whole = '0';
+    }
+    if (!fraction) {
+        fraction = '0';
+    }
+    if (fraction.length > baseLength) {
+        throw new Error(`error converting token ${input} to unit, too many decimal places`);
+    }
+    while (fraction.length < baseLength) {
+        fraction += '0';
+    }
+    whole = new bn_js_1.default(whole);
+    fraction = new bn_js_1.default(fraction);
+    let unit = whole.mul(base).add(fraction);
+    if (negative) {
+        unit = unit.mul(negative1);
+    }
+    return new bn_js_1.default(unit.toString(10), 10);
 };
-
+exports.fromTokenToUnit = fromTokenToUnit;
 /**
  * Validates if a value is an Uint8Array.
  *
@@ -523,9 +486,9 @@ const fromTokenToUnit = (input, decimal = 18) => {
  * @returns {Boolean} boolean indicating if a value is an Uint8Array
  */
 function isUint8Array(value) {
-  return Object.prototype.toString.call(value) === '[object Uint8Array]';
+    return Object.prototype.toString.call(value) === '[object Uint8Array]';
 }
-
+exports.isUint8Array = isUint8Array;
 /**
  * Generate a random UUID
  *
@@ -534,13 +497,13 @@ function isUint8Array(value) {
  * @returns {string} Generated uuid
  */
 function UUID() {
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-    const r = (Math.random() * 16) | 0;
-    const v = c === 'x' ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-  });
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
 }
-
+exports.UUID = UUID;
 /**
  * Check if a string is valid UUID
  *
@@ -550,9 +513,9 @@ function UUID() {
  * @returns {boolean}
  */
 function isUUID(str) {
-  return /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/.test(str);
+    return /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/.test(str);
 }
-
+exports.isUUID = isUUID;
 /**
  * Convert input to Uint8Array on best effort, base64 node supported
  *
@@ -563,28 +526,31 @@ function isUUID(str) {
  * @throws {Error}
  */
 function toUint8Array(v) {
-  let vb = null;
-  if ([null, undefined, ''].includes(v)) {
-    vb = new Uint8Array();
-  } else if (Buffer.isBuffer(v)) {
-    vb = new Uint8Array(v);
-  } else if (isHexStrict(v)) {
-    vb = new Uint8Array(hexToBytes(v));
-  } else if (isUint8Array(v)) {
-    vb = new Uint8Array(v);
-  } else if (isBase58btc(v)) {
-    vb = new Uint8Array(base58btc.decode(v));
-  } else if (typeof v === 'string') {
-    vb = new Uint8Array(hexToBytes(toHex(v)));
-  } else {
-    throw new Error(
-      `Unsupported input type ${typeof v} detected for toBuffer, only Uint8Array/Buffer/Hex/Base58 are supported`
-    );
-  }
-
-  return vb;
+    let vb = null;
+    if ([null, undefined, ''].includes(v)) {
+        vb = new Uint8Array();
+    }
+    else if (Buffer.isBuffer(v)) {
+        vb = new Uint8Array(v);
+    }
+    else if ((0, exports.isHexStrict)(v)) {
+        vb = new Uint8Array((0, exports.hexToBytes)(v));
+    }
+    else if (isUint8Array(v)) {
+        vb = new Uint8Array(v);
+    }
+    else if (isBase58btc(v)) {
+        vb = new Uint8Array(base58btc.decode(v));
+    }
+    else if (typeof v === 'string') {
+        vb = new Uint8Array((0, exports.hexToBytes)((0, exports.toHex)(v)));
+    }
+    else {
+        throw new Error(`Unsupported input type ${typeof v} detected for toBuffer, only Uint8Array/Buffer/Hex/Base58 are supported`);
+    }
+    return vb;
 }
-
+exports.toUint8Array = toUint8Array;
 /**
  * Convert input to Buffer on best effort, base64 not supported
  *
@@ -595,9 +561,9 @@ function toUint8Array(v) {
  * @throws {Error}
  */
 function toBuffer(v) {
-  return Buffer.from(toUint8Array(v));
+    return Buffer.from(toUint8Array(v));
 }
-
+exports.toBuffer = toBuffer;
 /**
  * Convert input to base58btc format on best effort
  *
@@ -608,10 +574,10 @@ function toBuffer(v) {
  * @throws {Error}
  */
 function toBase58(v) {
-  const buf = base58btc.encode(toUint8Array(v));
-  return Buffer.from(buf).toString('utf-8');
+    const buf = base58btc.encode(toUint8Array(v));
+    return Buffer.from(buf).toString('utf-8');
 }
-
+exports.toBase58 = toBase58;
 /**
  * Decode base58 string
  *
@@ -621,13 +587,12 @@ function toBase58(v) {
  * @returns {buffer}
  */
 function fromBase58(v) {
-  if (isBase58btc(v) === false) {
-    throw new Error('fromBase58 expect strict base58 encoded string as input');
-  }
-
-  return Buffer.from(base58btc.decode(v));
+    if (isBase58btc(v) === false) {
+        throw new Error('fromBase58 expect strict base58 encoded string as input');
+    }
+    return Buffer.from(base58btc.decode(v));
 }
-
+exports.fromBase58 = fromBase58;
 /**
  * Convert input to base64 format
  *
@@ -639,10 +604,11 @@ function fromBase58(v) {
  * @throws {Error}
  */
 function toBase64(v, escape = true) {
-  const encoded = base64.encode(toBuffer(v));
-  return escape ? base64.escape(encoded) : encoded;
+    // FIXME: 这个是正确的?
+    const encoded = base64_url_1.default.encode(toBuffer(v));
+    return escape ? base64_url_1.default.escape(encoded) : encoded;
 }
-
+exports.toBase64 = toBase64;
 /**
  * Decode base64(base64_url) string to buffer
  *
@@ -652,12 +618,12 @@ function toBase64(v, escape = true) {
  * @returns {buffer}
  */
 function fromBase64(v) {
-  if (typeof v !== 'string') {
-    throw new Error('fromBase64 requires input to be a string');
-  }
-  return Buffer.from(base64.unescape(v), 'base64');
+    if (typeof v !== 'string') {
+        throw new Error('fromBase64 requires input to be a string');
+    }
+    return Buffer.from(base64_url_1.default.unescape(v), 'base64');
 }
-
+exports.fromBase64 = fromBase64;
 /**
  * Convert did to address: remove `did:abt:` prefix
  *
@@ -667,9 +633,9 @@ function fromBase64(v) {
  * @returns {string}
  */
 function toAddress(did) {
-  return did.replace(DID_PREFIX, '');
+    return did.replace(DID_PREFIX, '');
 }
-
+exports.toAddress = toAddress;
 /**
  * Convert address to did: prepend `did:abt:` prefix
  *
@@ -679,42 +645,8 @@ function toAddress(did) {
  * @returns {string}
  */
 function toDid(address) {
-  return `${DID_PREFIX}${toAddress(address)}`;
+    return `${DID_PREFIX}${toAddress(address)}`;
 }
-
-const formatTxType = (type) => upperFirst(camelCase(type));
-
-module.exports = {
-  BN,
-  isBN,
-  isBigNumber,
-  isHexPrefixed,
-  stripHexPrefix,
-  utf8ToHex,
-  hexToUtf8,
-  numberToHex,
-  hexToNumber,
-  isHex,
-  isHexStrict,
-  isUint8Array,
-  hexToBytes,
-  bytesToHex,
-  toHex,
-  numberToString,
-  fromUnitToToken,
-  fromTokenToUnit,
-  toBN,
-  toUint8Array,
-  toBuffer,
-  toBase58,
-  fromBase58,
-  toBase64,
-  fromBase64,
-  UUID,
-  isUUID,
-  toDid,
-  toAddress,
-  formatTxType,
-  leftPad,
-  rightPad,
-};
+exports.toDid = toDid;
+const formatTxType = (type) => (0, upperFirst_1.default)((0, camelCase_1.default)(type));
+exports.formatTxType = formatTxType;