@ocap/util 1.18.165 → 1.19.0

package/esm/constant.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_TOKEN_DECIMAL = 18;

package/esm/constant.js

@@ -0,0 +1 @@
+export const DEFAULT_TOKEN_DECIMAL = 18;

package/esm/create-sorted-list.d.ts

@@ -0,0 +1 @@
+export declare const createSortedList: (list: $TSFixMe) => any;

package/esm/create-sorted-list.js

@@ -0,0 +1,3 @@
+import uniq from 'lodash/uniq';
+import flatten from 'lodash/flatten';
+export const createSortedList = (list) => uniq(flatten(list)).filter(Boolean).sort();

package/esm/error.d.ts

@@ -0,0 +1,11 @@
+export declare class CustomError extends Error {
+    code: string;
+    props: {
+        persist: boolean;
+        [prop: string]: $TSFixMe;
+    };
+    constructor(code: string, message: string, props?: {});
+}
+export declare class PersistError extends CustomError {
+    constructor(code: string, message: string, props?: {});
+}

package/esm/error.js

@@ -0,0 +1,17 @@
+/* eslint-disable max-classes-per-file */
+export class CustomError extends Error {
+    constructor(code, message, props = {}) {
+        super(message);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, CustomError);
+        }
+        this.code = code;
+        this.props = { persist: false, ...props };
+    }
+}
+export class PersistError extends CustomError {
+    constructor(code, message, props = {}) {
+        super(code, message);
+        this.props = { persist: true, ...props };
+    }
+}

package/esm/get-list-field.d.ts

@@ -0,0 +1 @@
+export declare const getListField: (obj: $TSFixMe, key: string) => any;

package/esm/get-list-field.js

@@ -0,0 +1,2 @@
+import get from 'lodash/get';
+export const getListField = (obj, key) => get(obj, `${key}List`) || get(obj, key) || [];

package/esm/get-related-addr.d.ts

@@ -0,0 +1 @@
+export declare const getRelatedAddresses: (state: $TSFixMe) => any[];

package/esm/get-related-addr.js

@@ -0,0 +1 @@
+export const getRelatedAddresses = (state) => [state.address].concat(state.migratedFrom || []).filter(Boolean);

package/esm/index.d.ts

@@ -0,0 +1,219 @@
+import type { LiteralUnion } from 'type-fest';
+import rightPad from 'lodash/padEnd';
+import leftPad from 'lodash/padStart';
+import BN from 'bn.js';
+export declare const isBase58btc: (data: any) => boolean;
+export type BytesType = string | Buffer | Uint8Array;
+export type EncodingType = LiteralUnion<'hex' | 'base16' | 'base58' | 'base64' | 'Uint8Array' | 'buffer', string>;
+export type KeyPairType = {
+    publicKey: BytesType;
+    secretKey: BytesType;
+};
+export { BN, leftPad, rightPad };
+/**
+ * Returns a BN object, converts a number value to a BN
+ * @param {string|number|BN} `arg` input a string number, hex string number, number, BigNumber or BN object
+ * @return {BN} `output` BN object of the number
+ * @throws if the argument is not an array, object that isn't a bignumber, not a string number or number
+ */
+export declare const numberToBN: (arg: string | number | BN) => BN;
+/**
+ * Returns a `boolean` on whether or not the `string` starts with '0x'
+ *
+ * @public
+ * @static
+ * @param {String} str the string input value
+ * @return {Boolean} a boolean if it is or is not hex prefixed
+ * @throws if the str input is not a string
+ */
+export declare const isHexPrefixed: (str: string) => boolean;
+/**
+ * Removes '0x' from a given `String` if present
+ *
+ * @public
+ * @static
+ */
+export declare const stripHexPrefix: (str: string | any) => any;
+/**
+ * Returns true if object is BN, otherwise false
+ *
+ * @public
+ * @static
+ * @method isBN
+ * @param {Object} object
+ * @returns {Boolean}
+ */
+export declare const isBN: (object: $TSFixMe) => boolean;
+/**
+ * Returns true if object is BigNumber, otherwise false
+ *
+ * @public
+ * @static
+ * @method isBigNumber
+ * @param {Object} object
+ * @returns {Boolean}
+ */
+export declare const isBigNumber: (object: $TSFixMe) => boolean;
+/**
+ * Check if string is HEX, requires a 0x in front
+ *
+ * @public
+ * @static
+ * @method isHexStrict
+ * @param {String} hex to be checked
+ * @returns {Boolean}
+ */
+export declare const isHexStrict: (hex: string) => boolean;
+/**
+ * Check if string is HEX
+ *
+ * @public
+ * @static
+ * @method isHex
+ * @param {String} hex to be checked
+ * @returns {Boolean}
+ */
+export declare const isHex: (hex: string) => boolean;
+/**
+ * Takes an input and transforms it into an BN
+ *
+ * @public
+ * @static
+ * @method toBN
+ * @param {Number|String|BN} num, string, HEX string or BN
+ * @returns {BN} BN
+ */
+export declare const toBN: (num: number | string | BN, base?: number | "hex") => BN;
+/**
+ * Should be called to get hex representation (prefixed by 0x) of utf8 string
+ *
+ * @public
+ * @static
+ * @method utf8ToHex
+ * @param {String} str
+ * @returns {String} hex representation of input string
+ */
+export declare const utf8ToHex: (str: string) => string;
+/**
+ * Should be called to get utf8 from it's hex representation
+ *
+ * @public
+ * @static
+ * @method hexToUtf8
+ * @param {String} hex
+ * @returns {String} ascii string representation of hex value
+ */
+export declare const hexToUtf8: (hex: string) => string;
+/**
+ * Converts value to number representation
+ *
+ * @public
+ * @static
+ * @method hexToNumber
+ * @param {String|Number|BN} value
+ * @returns {Number}
+ */
+export declare const hexToNumber: (value: string | number | BN) => number;
+/**
+ * Converts value to hex representation
+ *
+ * @public
+ * @static
+ * @method numberToHex
+ * @param {String|Number|BN} value
+ * @returns {String}
+ */
+export declare const numberToHex: (value: $TSFixMe) => string;
+/**
+ * Convert a byte array to a hex string
+ * Note: Implementation from crypto-js
+ *
+ * @public
+ * @static
+ * @method bytesToHex
+ * @param {Array} bytes
+ * @returns {String} the hex string
+ */
+export declare const bytesToHex: (bytes: $TSFixMe) => string;
+/**
+ * Convert a hex string to a byte array
+ * Note: Implementation from crypto-js
+ *
+ * @public
+ * @static
+ * @method hexToBytes
+ * @param {String} hex
+ * @returns {Array} the byte array
+ */
+export declare const hexToBytes: (hex: $TSFixMe) => Array<any>;
+/**
+ * Auto converts any given value into it's hex representation.
+ * And even stringify objects before.
+ *
+ * @public
+ * @static
+ * @method toHex
+ * @param {String|Number|BN|Object|TypedArray|Buffer} value
+ * @param {Boolean} returnType
+ * @returns {String}
+ */
+export declare const toHex: (value: string | number | boolean | BN | Uint8Array | Buffer | (number | {
+    test: string;
+})[] | {
+    test: string;
+}, returnType?: boolean) => string;
+export declare const numberToString: (arg: $TSFixMe) => any;
+/**
+ * Format a big number to human readable number, such as 1_0000_0000_0000_000 => 1 Token
+ */
+export declare const fromUnitToToken: (input: string | number | BN, decimal?: number, optionsInput?: $TSFixMe) => string;
+/**
+ * Convert human readable token number to big number instance
+ */
+export declare const fromTokenToUnit: (input: string | number, decimal?: number) => BN;
+/**
+ * Validates if a value is an Uint8Array.
+ */
+export declare function isUint8Array(value: $TSFixMe): boolean;
+/**
+ * Generate a random UUID
+ */
+export declare function UUID(): string;
+/**
+ * Check if a string is valid UUID
+ */
+export declare function isUUID(str: string): boolean;
+/**
+ * Convert input to Uint8Array on best effort, base64 node supported
+ */
+export declare function toUint8Array(v: any): Uint8Array;
+/**
+ * Convert input to Buffer on best effort, base64 not supported
+ */
+export declare function toBuffer(v: any): Buffer;
+/**
+ * Convert input to base58btc format on best effort
+ */
+export declare function toBase58(v: any): string;
+/**
+ * Decode base58 string
+ */
+export declare function fromBase58(v: string): Buffer;
+/**
+ * Convert input to base64 format
+ */
+export declare function toBase64(v: any, escape?: boolean): string;
+/**
+ * Decode base64(base64_url) string to buffer
+ */
+export declare function fromBase64(v: string): Buffer;
+/**
+ * Convert did to address: remove `did:abt:` prefix
+ */
+export declare function toAddress(did: string): string;
+/**
+ * Convert address to did: prepend `did:abt:` prefix
+ */
+export declare function toDid(address: string): string;
+export declare function isSameDid(a: string, b: string): boolean;
+export declare function formatTxType(type: string): any;

package/esm/index.js

@@ -0,0 +1,526 @@
+import isBoolean from 'lodash/isBoolean';
+import isString from 'lodash/isString';
+import isNumber from 'lodash/isNumber';
+import isObject from 'lodash/isObject';
+import upperFirst from 'lodash/upperFirst';
+import camelCase from 'lodash/camelCase';
+import isNull from 'lodash/isNull';
+import rightPad from 'lodash/padEnd';
+import leftPad from 'lodash/padStart';
+import base58 from 'bs58';
+import base64 from 'base64-url';
+import BN from 'bn.js';
+import * as utf8 from 'utf8';
+const DID_PREFIX = 'did:abt:';
+const zero = new BN(0);
+const negative1 = new BN(-1);
+const base58btc = {
+    encode: (v) => `z${base58.encode(v)}`,
+    decode: (v) => base58.decode(v.slice(1)),
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isBase58btc = (data) => {
+    if (typeof data !== 'string') {
+        return false;
+    }
+    if (data[0] === 'z') {
+        try {
+            base58btc.decode(data);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    return false;
+};
+export { BN, leftPad, rightPad };
+/**
+ * Returns a BN object, converts a number value to a BN
+ * @param {string|number|BN} `arg` input a string number, hex string number, number, BigNumber or BN object
+ * @return {BN} `output` BN object of the number
+ * @throws if the argument is not an array, object that isn't a bignumber, not a string number or number
+ */
+export 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);
+        }
+    }
+    if (isBN(arg)) {
+        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.`);
+};
+/**
+ * Returns a `boolean` on whether or not the `string` starts with '0x'
+ *
+ * @public
+ * @static
+ * @param {String} str the string input value
+ * @return {Boolean} a boolean if it is or is not hex prefixed
+ * @throws if the str input is not a string
+ */
+export 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';
+};
+/**
+ * Removes '0x' from a given `String` if present
+ *
+ * @public
+ * @static
+ */
+export const stripHexPrefix = (str) => {
+    if (typeof str === 'string') {
+        return isHexPrefixed(str) ? str.slice(2) : str;
+    }
+    return str;
+};
+/**
+ * Returns true if object is BN, otherwise false
+ *
+ * @public
+ * @static
+ * @method isBN
+ * @param {Object} object
+ * @returns {Boolean}
+ */
+export const isBN = (object) => object instanceof BN || (object && object.constructor && object.constructor.name === 'BN');
+/**
+ * Returns true if object is BigNumber, otherwise false
+ *
+ * @public
+ * @static
+ * @method isBigNumber
+ * @param {Object} object
+ * @returns {Boolean}
+ */
+export const isBigNumber = (object) => object && object.constructor && object.constructor.name === 'BigNumber';
+/**
+ * Check if string is HEX, requires a 0x in front
+ *
+ * @public
+ * @static
+ * @method isHexStrict
+ * @param {String} hex to be checked
+ * @returns {Boolean}
+ */
+export const isHexStrict = (hex) => (isString(hex) || isNumber(hex)) && /^(-)?0x[0-9a-f]*$/i.test(hex);
+/**
+ * Check if string is HEX
+ *
+ * @public
+ * @static
+ * @method isHex
+ * @param {String} hex to be checked
+ * @returns {Boolean}
+ */
+export const isHex = (hex) => (isString(hex) || isNumber(hex)) && /^(-0x|0x|0X|-0X)?[0-9a-f]*$/i.test(hex);
+/**
+ * Takes an input and transforms it into an BN
+ *
+ * @public
+ * @static
+ * @method toBN
+ * @param {Number|String|BN} num, string, HEX string or BN
+ * @returns {BN} BN
+ */
+export const toBN = (num, base = 10) => {
+    try {
+        if (typeof num === 'number' && num > 0) {
+            const numStr = Number(num).toLocaleString('fullwide', { useGrouping: false });
+            return new BN(numStr, base);
+        }
+        return numberToBN(num);
+    }
+    catch (error) {
+        throw new Error(`${error} Given value: "${num}"`);
+    }
+};
+/**
+ * Should be called to get hex representation (prefixed by 0x) of utf8 string
+ *
+ * @public
+ * @static
+ * @method utf8ToHex
+ * @param {String} str
+ * @returns {String} hex representation of input string
+ */
+export 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);
+        const n = code.toString(16);
+        hex += n.length < 2 ? `0${n}` : n;
+    }
+    return `0x${hex}`;
+};
+/**
+ * Should be called to get utf8 from it's hex representation
+ *
+ * @public
+ * @static
+ * @method hexToUtf8
+ * @param {String} hex
+ * @returns {String} ascii string representation of hex value
+ */
+export 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);
+};
+/**
+ * Converts value to number representation
+ *
+ * @public
+ * @static
+ * @method hexToNumber
+ * @param {String|Number|BN} value
+ * @returns {Number}
+ */
+export const hexToNumber = (value) => {
+    if (!value) {
+        return 0;
+    }
+    return toBN(value).toNumber();
+};
+/**
+ * Converts value to hex representation
+ *
+ * @public
+ * @static
+ * @method numberToHex
+ * @param {String|Number|BN} value
+ * @returns {String}
+ */
+export 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 num = toBN(value);
+    const result = num.toString(16);
+    return num.lt(new BN(0)) ? `-0x${result.substr(1)}` : `0x${result}`;
+};
+/**
+ * Convert a byte array to a hex string
+ * Note: Implementation from crypto-js
+ *
+ * @public
+ * @static
+ * @method bytesToHex
+ * @param {Array} bytes
+ * @returns {String} the hex string
+ */
+export 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('')}`;
+};
+/**
+ * Convert a hex string to a byte array
+ * Note: Implementation from crypto-js
+ *
+ * @public
+ * @static
+ * @method hexToBytes
+ * @param {String} hex
+ * @returns {Array} the byte array
+ */
+export 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;
+};
+/**
+ * Auto converts any given value into it's hex representation.
+ * And even stringify objects before.
+ *
+ * @public
+ * @static
+ * @method toHex
+ * @param {String|Number|BN|Object|TypedArray|Buffer} value
+ * @param {Boolean} returnType
+ * @returns {String}
+ */
+export const toHex = (value, returnType = false) => {
+    if (isUint8Array(value) || Buffer.isBuffer(value)) {
+        return returnType ? 'bytes' : bytesToHex(value);
+    }
+    if (isBase58btc(value)) {
+        return returnType ? 'bytes' : bytesToHex(base58btc.decode(value));
+    }
+    if (isBoolean(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 (typeof value === 'string') {
+        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);
+};
+export 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 (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}.`);
+};
+/**
+ * Format a big number to human readable number, such as 1_0000_0000_0000_000 => 1 Token
+ */
+export 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;
+};
+/**
+ * Convert human readable token number to big number instance
+ */
+export 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);
+};
+/**
+ * Validates if a value is an Uint8Array.
+ */
+export function isUint8Array(value) {
+    return Object.prototype.toString.call(value) === '[object Uint8Array]';
+}
+/**
+ * Generate a random UUID
+ */
+export 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);
+    });
+}
+/**
+ * Check if a string is valid UUID
+ */
+export 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);
+}
+/**
+ * Convert input to Uint8Array on best effort, base64 node supported
+ */
+export 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;
+}
+/**
+ * Convert input to Buffer on best effort, base64 not supported
+ */
+export function toBuffer(v) {
+    return Buffer.from(toUint8Array(v));
+}
+/**
+ * Convert input to base58btc format on best effort
+ */
+export function toBase58(v) {
+    const buf = base58btc.encode(toUint8Array(v));
+    return Buffer.from(buf).toString('utf-8');
+}
+/**
+ * Decode base58 string
+ */
+export function fromBase58(v) {
+    if (isBase58btc(v) === false) {
+        throw new Error('fromBase58 expect strict base58 encoded string as input');
+    }
+    return Buffer.from(base58btc.decode(v));
+}
+/**
+ * Convert input to base64 format
+ */
+export function toBase64(v, escape = true) {
+    const encoded = base64.encode(toBuffer(v));
+    return escape ? base64.escape(encoded) : encoded;
+}
+/**
+ * Decode base64(base64_url) string to buffer
+ */
+export function fromBase64(v) {
+    if (typeof v !== 'string') {
+        throw new Error('fromBase64 requires input to be a string');
+    }
+    return Buffer.from(base64.unescape(v), 'base64');
+}
+/**
+ * Convert did to address: remove `did:abt:` prefix
+ */
+export function toAddress(did) {
+    return did.replace(DID_PREFIX, '');
+}
+/**
+ * Convert address to did: prepend `did:abt:` prefix
+ */
+export function toDid(address) {
+    return `${DID_PREFIX}${toAddress(address)}`;
+}
+export function isSameDid(a, b) {
+    return toAddress(a).toLowerCase() === toAddress(b).toLowerCase();
+}
+export function formatTxType(type) {
+    return upperFirst(camelCase(type));
+}

package/esm/md5.d.ts

@@ -0,0 +1 @@
+export declare const md5: (x: $TSFixMe) => string;

package/esm/md5.js

@@ -0,0 +1,3 @@
+import crypto from 'crypto';
+// eslint-disable-next-line import/prefer-default-export
+export const md5 = (x) => crypto.createHash('md5').update(x).digest('hex');

package/esm/ready.d.ts

@@ -0,0 +1,10 @@
+import EventEmitter from 'events';
+export declare class Ready extends EventEmitter {
+    emit: $TSFixMe;
+    ready: $TSFixMe;
+    readyCallbacks: $TSFixMe;
+    readyMarks: $TSFixMe;
+    constructor();
+    markReady(mark?: $TSFixMe): void;
+    onReady(cb: $TSFixMe): void;
+}

package/esm/ready.js

@@ -0,0 +1,36 @@
+import EventEmitter from 'events';
+export class Ready extends EventEmitter {
+    constructor() {
+        super();
+        this.ready = false;
+        this.readyCallbacks = [];
+        this.readyMarks = {};
+    }
+    markReady(mark) {
+        if (this.ready) {
+            return;
+        }
+        if (mark === undefined) {
+            this.ready = true;
+            this.readyCallbacks.forEach((x) => x());
+            this.emit('ready');
+        }
+        else {
+            // console.log('Ready.markReady', this.name, mark);
+            this.readyMarks[mark] = true;
+            this.ready = Object.values(this.readyMarks).every((x) => !!x);
+            if (this.ready) {
+                this.readyCallbacks.forEach((cb) => cb());
+                this.emit('ready');
+            }
+        }
+    }
+    onReady(cb) {
+        if (this.ready) {
+            cb();
+        }
+        else {
+            this.readyCallbacks.push(cb);
+        }
+    }
+}

package/lib/index.d.ts

@@ -1,13 +1,11 @@
-/// <reference types="node" />
-/// <reference types="jest" />
 import type { LiteralUnion } from 'type-fest';
 import rightPad from 'lodash/padEnd';
 import leftPad from 'lodash/padStart';
 import BN from 'bn.js';
 export declare const isBase58btc: (data: any) => boolean;
-export declare type BytesType = string | Buffer | Uint8Array;
-export declare type EncodingType = LiteralUnion<'hex' | 'base16' | 'base58' | 'base64' | 'Uint8Array' | 'buffer', string>;
-export declare type KeyPairType = {
+export type BytesType = string | Buffer | Uint8Array;
+export type EncodingType = LiteralUnion<'hex' | 'base16' | 'base58' | 'base64' | 'Uint8Array' | 'buffer', string>;
+export type KeyPairType = {
     publicKey: BytesType;
     secretKey: BytesType;
 };
@@ -85,7 +83,7 @@ export declare const isHex: (hex: string) => boolean;
  * @param {Number|String|BN} num, string, HEX string or BN
  * @returns {BN} BN
  */
-export declare const toBN: (num: number | string | BN, base?: number | 'hex') => BN;
+export declare const toBN: (num: number | string | BN, base?: number | "hex") => BN;
 /**
  * Should be called to get hex representation (prefixed by 0x) of utf8 string
  *

package/lib/index.js

@@ -26,7 +26,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatTxType = exports.isSameDid = 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 = exports.isBase58btc = void 0;
+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 = exports.isBase58btc = void 0;
+exports.isUint8Array = isUint8Array;
+exports.UUID = UUID;
+exports.isUUID = isUUID;
+exports.toUint8Array = toUint8Array;
+exports.toBuffer = toBuffer;
+exports.toBase58 = toBase58;
+exports.fromBase58 = fromBase58;
+exports.toBase64 = toBase64;
+exports.fromBase64 = fromBase64;
+exports.toAddress = toAddress;
+exports.toDid = toDid;
+exports.isSameDid = isSameDid;
+exports.formatTxType = formatTxType;
 const isBoolean_1 = __importDefault(require("lodash/isBoolean"));
 const isString_1 = __importDefault(require("lodash/isString"));
 const isNumber_1 = __importDefault(require("lodash/isNumber"));
@@ -474,7 +487,6 @@ exports.fromTokenToUnit = fromTokenToUnit;
 function isUint8Array(value) {
     return Object.prototype.toString.call(value) === '[object Uint8Array]';
 }
-exports.isUint8Array = isUint8Array;
 /**
  * Generate a random UUID
  */
@@ -485,14 +497,12 @@ function UUID() {
         return v.toString(16);
     });
 }
-exports.UUID = UUID;
 /**
  * Check if a string is valid UUID
  */
 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);
 }
-exports.isUUID = isUUID;
 /**
  * Convert input to Uint8Array on best effort, base64 node supported
  */
@@ -521,14 +531,12 @@ function toUint8Array(v) {
     }
     return vb;
 }
-exports.toUint8Array = toUint8Array;
 /**
  * Convert input to Buffer on best effort, base64 not supported
  */
 function toBuffer(v) {
     return Buffer.from(toUint8Array(v));
 }
-exports.toBuffer = toBuffer;
 /**
  * Convert input to base58btc format on best effort
  */
@@ -536,7 +544,6 @@ function toBase58(v) {
     const buf = base58btc.encode(toUint8Array(v));
     return Buffer.from(buf).toString('utf-8');
 }
-exports.toBase58 = toBase58;
 /**
  * Decode base58 string
  */
@@ -546,7 +553,6 @@ function fromBase58(v) {
     }
     return Buffer.from(base58btc.decode(v));
 }
-exports.fromBase58 = fromBase58;
 /**
  * Convert input to base64 format
  */
@@ -554,7 +560,6 @@ function toBase64(v, escape = true) {
     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
  */
@@ -564,26 +569,21 @@ function fromBase64(v) {
     }
     return Buffer.from(base64_url_1.default.unescape(v), 'base64');
 }
-exports.fromBase64 = fromBase64;
 /**
  * Convert did to address: remove `did:abt:` prefix
  */
 function toAddress(did) {
     return did.replace(DID_PREFIX, '');
 }
-exports.toAddress = toAddress;
 /**
  * Convert address to did: prepend `did:abt:` prefix
  */
 function toDid(address) {
     return `${DID_PREFIX}${toAddress(address)}`;
 }
-exports.toDid = toDid;
 function isSameDid(a, b) {
     return toAddress(a).toLowerCase() === toAddress(b).toLowerCase();
 }
-exports.isSameDid = isSameDid;
 function formatTxType(type) {
     return (0, upperFirst_1.default)((0, camelCase_1.default)(type));
 }
-exports.formatTxType = formatTxType;

package/lib/md5.js

@@ -5,5 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.md5 = void 0;
 const crypto_1 = __importDefault(require("crypto"));
+// eslint-disable-next-line import/prefer-default-export
 const md5 = (x) => crypto_1.default.createHash('md5').update(x).digest('hex');
 exports.md5 = md5;

package/lib/ready.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import EventEmitter from 'events';
 export declare class Ready extends EventEmitter {
     emit: $TSFixMe;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocap/util",
-  "version": "1.18.165",
+  "version": "1.19.0",
   "description": "utils shared across multiple forge js libs, works in both node.js and browser",
   "keywords": [
     "arcblock",
@@ -22,17 +22,17 @@
     "elliptic": "6.5.3"
   },
   "devDependencies": {
-    "@arcblock/eslint-config-ts": "0.2.3",
-    "@types/base64-url": "^2.2.0",
-    "@types/jest": "^29.5.12",
-    "@types/lodash": "^4.17.7",
-    "@types/node": "^17.0.45",
-    "@types/utf8": "^3.0.1",
-    "eslint": "^8.25.0",
+    "@arcblock/eslint-config-ts": "0.3.3",
+    "@types/base64-url": "^2.2.2",
+    "@types/jest": "^29.5.13",
+    "@types/lodash": "^4.17.10",
+    "@types/node": "^22.7.5",
+    "@types/utf8": "^3.0.3",
+    "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "type-fest": "^3.1.0",
-    "typescript": "^4.8.4"
+    "typescript": "^5.6.2"
   },
   "author": {
     "name": "wangshijun",
@@ -44,10 +44,22 @@
   ],
   "homepage": "https://github.com/ArcBlock/blockchain/tree/master/core/forge-util",
   "license": "Apache-2.0",
-  "main": "lib/index.js",
-  "typings": "lib/index.d.ts",
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./lib/index.js",
+      "default": "./esm/index.js"
+    },
+    "./lib/*": {
+      "require": "./lib/*.js"
+    }
+  },
   "files": [
-    "lib"
+    "lib",
+    "esm"
   ],
   "repository": {
     "type": "git",
@@ -58,13 +70,15 @@
     "lint:fix": "npm run lint -- --fix",
     "test": "jest --forceExit --detectOpenHandles",
     "coverage": "npm run test -- --coverage",
-    "clean": "rm -fr lib",
+    "clean": "rm -fr lib esm",
     "prebuild": "npm run clean",
-    "build": "tsc",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build": "npm run build:cjs && npm run build:esm",
     "build:watch": "npm run build -- -w"
   },
   "bugs": {
     "url": "https://github.com/ArcBlock/blockchain/issues"
   },
-  "gitHead": "e1a9e9e807ca049f67ffbb5ac556b014461cb7a1"
+  "gitHead": "1b6fac03988fb18507c8ef4c21de282762005f87"
 }