@ocap/util 1.16.16 → 1.17.1

package/lib/constant.d.ts

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

package/lib/constant.js

@@ -1,3 +1,4 @@
-module.exports = Object.freeze({
-  DEFAULT_TOKEN_DECIMAL: 18,
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TOKEN_DECIMAL = void 0;
+exports.DEFAULT_TOKEN_DECIMAL = 18;

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

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

package/lib/create-sorted-list.js

@@ -1,6 +1,10 @@
-const uniq = require('lodash/uniq');
-const flatten = require('lodash/flatten');
-
-const createSortedList = (list) => uniq(flatten(list)).filter(Boolean).sort();
-
-module.exports = createSortedList;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSortedList = void 0;
+const uniq_1 = __importDefault(require("lodash/uniq"));
+const flatten_1 = __importDefault(require("lodash/flatten"));
+const createSortedList = (list) => (0, uniq_1.default)((0, flatten_1.default)(list)).filter(Boolean).sort();
+exports.createSortedList = createSortedList;

package/lib/error.d.ts

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

package/lib/error.js

@@ -1,14 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomError = void 0;
 class CustomError extends Error {
-  constructor(code = 'GENERIC', message, props = {}) {
-    super(message);
-
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, CustomError);
+    constructor(code, message, props = {}) {
+        super(message);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, CustomError);
+        }
+        this.code = code;
+        this.props = Object.assign({ persist: false }, props);
     }
-
-    this.code = code;
-    this.props = { persist: false, ...props };
-  }
 }
-
-module.exports = CustomError;
+exports.CustomError = CustomError;

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

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

package/lib/get-list-field.js

@@ -1,5 +1,9 @@
-const get = require('lodash/get');
-
-const getListField = (obj, key) => get(obj, `${key}List`) || get(obj, key) || [];
-
-module.exports = getListField;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getListField = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+const getListField = (obj, key) => (0, get_1.default)(obj, `${key}List`) || (0, get_1.default)(obj, key) || [];
+exports.getListField = getListField;

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

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

package/lib/get-related-addr.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelatedAddresses = void 0;
 const getRelatedAddresses = (state) => [state.address].concat(state.migratedFrom || []).filter(Boolean);
-
-module.exports = getRelatedAddresses;
+exports.getRelatedAddresses = getRelatedAddresses;

package/lib/index.d.ts

@@ -1,6 +1,192 @@
-// Generate by [js2dts@0.3.3](https://github.com/whxaxes/js2dts#readme)
-
-import * as bnJs from 'bn.js';
+/// <reference types="node" />
+/// <reference types="jest" />
+import rightPad from 'lodash/padEnd';
+import leftPad from 'lodash/padStart';
+import BN from 'bn.js';
+export declare type BytesType = string | Buffer | Uint8Array;
+export declare type EncodingType = 'hex' | 'base16' | 'base58' | 'base64' | 'Uint8Array' | 'buffer';
+export declare type KeyPairType = {
+    publicKey: BytesType;
+    secretKey: BytesType;
+};
+export { BN, leftPad, rightPad };
+/**
+ * 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
+ * @return {Object} `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
+ * @param {String} str the string value
+ * @return {String|Optional} a string by pass if necessary
+ */
+export declare const stripHexPrefix: (str: $TSFixMe) => 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) => string | number | BN;
+/**
+ * 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) => number[];
+/**
+ * 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
+ *
+ * @public
+ * @static
+ * @method fromUnitToToken
+ * @param {string|number} input
+ * @param {number} [decimal=18]
+ * @param {object} [optionsInput=undefined]
+ * @returns {string}
+ */
+export declare const fromUnitToToken: (input: string | number | BN, decimal?: number, optionsInput?: $TSFixMe) => string;
+/**
+ * Convert human readable token number to big number instance
+ *
+ * @public
+ * @static
+ * @param {string} input
+ * @param {number} [decimal=18]
+ * @returns {BN}
+ */
+export declare const fromTokenToUnit: (input: string | number, decimal?: number) => BN;
 /**
  * Validates if a value is an Uint8Array.
  *
@@ -9,7 +195,24 @@ import * as bnJs from 'bn.js';
  * @param {*} value - value to validate
  * @returns {Boolean} boolean indicating if a value is an Uint8Array
  */
-declare function isUint8Array(value: any): boolean;
+export declare function isUint8Array(value: $TSFixMe): boolean;
+/**
+ * Generate a random UUID
+ *
+ * @public
+ * @static
+ * @returns {string} Generated uuid
+ */
+export declare function UUID(): string;
+/**
+ * Check if a string is valid UUID
+ *
+ * @public
+ * @static
+ * @param {string} str
+ * @returns {boolean}
+ */
+export declare function isUUID(str: string): boolean;
 /**
  * Convert input to Uint8Array on best effort, base64 node supported
  *
@@ -19,7 +222,7 @@ declare function isUint8Array(value: any): boolean;
  * @returns {Uint8Array}
  * @throws {Error}
  */
-declare function toUint8Array(v: any): Uint8Array;
+export declare function toUint8Array(v: $TSFixMe): Uint8Array;
 /**
  * Convert input to Buffer on best effort, base64 not supported
  *
@@ -29,7 +232,7 @@ declare function toUint8Array(v: any): Uint8Array;
  * @returns {buffer}
  * @throws {Error}
  */
-declare function toBuffer(v: any): any;
+export declare function toBuffer(v: $TSFixMe): Buffer;
 /**
  * Convert input to base58btc format on best effort
  *
@@ -39,7 +242,7 @@ declare function toBuffer(v: any): any;
  * @returns {string}
  * @throws {Error}
  */
-declare function toBase58(v: any): string;
+export declare function toBase58(v: $TSFixMe): string;
 /**
  * Decode base58 string
  *
@@ -48,7 +251,7 @@ declare function toBase58(v: any): string;
  * @param {string} v
  * @returns {buffer}
  */
-declare function fromBase58(v: string): any;
+export declare function fromBase58(v: string): Buffer;
 /**
  * Convert input to base64 format
  *
@@ -59,7 +262,7 @@ declare function fromBase58(v: string): any;
  * @returns {string}
  * @throws {Error}
  */
-declare function toBase64(v: any, escape?: typeof escape): string;
+export declare function toBase64(v: $TSFixMe, escape?: boolean): string;
 /**
  * Decode base64(base64_url) string to buffer
  *
@@ -68,77 +271,23 @@ declare function toBase64(v: any, escape?: typeof escape): string;
  * @param {string} v
  * @returns {buffer}
  */
-declare function fromBase64(v: string): any;
+export declare function fromBase64(v: string): Buffer;
 /**
- * Generate a random UUID
- *
- * @public
- * @static
- * @returns {string} Generated uuid
- */
-declare function UUID(): string;
-/**
- * Check if a string is valid UUID
- *
- * @public
- * @static
- * @param {string} str
- * @returns {boolean}
- */
-declare function isUUID(str: string): boolean;
-/**
- * Convert address to did: prepend `did:abt:` prefix
+ * Convert did to address: remove `did:abt:` prefix
  *
  * @public
  * @static
  * @param {string} did - address string
  * @returns {string}
  */
-declare function toDid(address: any): string;
+export declare function toAddress(did: string): string;
 /**
- * Convert did to address: remove `did:abt:` prefix
+ * Convert address to did: prepend `did:abt:` prefix
  *
  * @public
  * @static
  * @param {string} did - address string
  * @returns {string}
  */
-declare function toAddress(did: string): string;
-declare const _Lib: _Lib.T100;
-declare namespace _Lib {
-  export interface T100 {
-    BN: typeof bnJs;
-    isBN: (object: any) => boolean;
-    isBigNumber: (object: any) => boolean;
-    isHexPrefixed: (str: string) => boolean;
-    stripHexPrefix: (str: string) => any;
-    utf8ToHex: (str: string) => string;
-    hexToUtf8: (hex: string) => string;
-    numberToHex: (value: string | number | bnJs) => string;
-    hexToNumber: (value: string | number | bnJs) => number;
-    isHex: (hex: string) => boolean;
-    isHexStrict: (hex: string) => boolean;
-    isUint8Array: typeof isUint8Array;
-    hexToBytes: (hex: string) => any[];
-    bytesToHex: (bytes: any[]) => string;
-    toHex: (value: any, returnType: boolean) => string;
-    numberToString: (arg: any) => any;
-    fromUnitToToken: (input: string | number, decimal?: number, optionsInput?: any) => string;
-    fromTokenToUnit: (input: string, decimal?: number) => bnJs;
-    toBN: (number: string | number | bnJs) => bnJs;
-    toUint8Array: typeof toUint8Array;
-    toBuffer: typeof toBuffer;
-    toBase58: typeof toBase58;
-    fromBase58: typeof fromBase58;
-    toBase64: typeof toBase64;
-    fromBase64: typeof fromBase64;
-    UUID: typeof UUID;
-    isUUID: typeof isUUID;
-    toDid: typeof toDid;
-    toAddress: typeof toAddress;
-    formatTxType: (type: any) => any;
-    leftPad: any;
-    rightPad: any;
-  }
-}
-export = _Lib;
+export declare function toDid(address: string): string;
+export declare const formatTxType: (type: string) => string;