essential-eth 0.5.0 → 0.5.1

package/lib/cjs/utils/bytes.js

@@ -0,0 +1,484 @@
+"use strict";
+// primary duplicate code from https://github.com/ethers-io/ethers.js/blob/f599d6f23dad0d0acaa3828d6b7acaab2d5e455b/packages/bytes/src.ts/index.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexZeroPad = exports.hexStripZeros = exports.hexValue = exports.hexConcat = exports.hexDataSlice = exports.hexDataLength = exports.hexlify = exports.isHexString = exports.zeroPad = exports.stripZeros = exports.concat = exports.arrayify = exports.isBytes = exports.isBytesLike = void 0;
+const logger_1 = require("../logger/logger");
+///////////////////////////////
+function isHexable(value) {
+    return !!value.toHexString;
+}
+function isBytesLike(value) {
+    return (isHexString(value) && !(value.length % 2)) || isBytes(value);
+}
+exports.isBytesLike = isBytesLike;
+function isInteger(value) {
+    return typeof value === 'number' && value == value && value % 1 === 0;
+}
+function isBytes(value) {
+    if (value == null) {
+        return false;
+    }
+    if (value.constructor === Uint8Array) {
+        return true;
+    }
+    if (typeof value === 'string') {
+        return false;
+    }
+    if (!isInteger(value.length) || value.length < 0) {
+        return false;
+    }
+    for (let i = 0; i < value.length; i++) {
+        const v = value[i];
+        if (!isInteger(v) || v < 0 || v >= 256) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isBytes = isBytes;
+function arrayify(value, options) {
+    if (!options) {
+        options = {};
+    }
+    if (typeof value === 'number') {
+        logger_1.logger.checkSafeUint53(value, 'invalid arrayify value');
+        const result = [];
+        while (value) {
+            result.unshift(value & 0xff);
+            value = parseInt(String(value / 256));
+        }
+        if (result.length === 0) {
+            result.push(0);
+        }
+        return new Uint8Array(result);
+    }
+    if (options.allowMissingPrefix &&
+        typeof value === 'string' &&
+        value.substring(0, 2) !== '0x') {
+        value = '0x' + value;
+    }
+    if (isHexable(value)) {
+        value = value.toHexString();
+    }
+    if (isHexString(value)) {
+        let hex = value.substring(2);
+        if (hex.length % 2) {
+            if (options.hexPad === 'left') {
+                hex = '0' + hex;
+            }
+            else if (options.hexPad === 'right') {
+                hex += '0';
+            }
+            else {
+                logger_1.logger.throwArgumentError('hex data is odd-length', 'value', value);
+            }
+        }
+        const result = [];
+        for (let i = 0; i < hex.length; i += 2) {
+            result.push(parseInt(hex.substring(i, i + 2), 16));
+        }
+        return new Uint8Array(result);
+    }
+    if (isBytes(value)) {
+        return new Uint8Array(value);
+    }
+    return logger_1.logger.throwArgumentError('invalid arrayify value', 'value', value);
+}
+exports.arrayify = arrayify;
+function concat(items) {
+    const objects = items.map((item) => arrayify(item));
+    const length = objects.reduce((accum, item) => accum + item.length, 0);
+    const result = new Uint8Array(length);
+    objects.reduce((offset, object) => {
+        result.set(object, offset);
+        return offset + object.length;
+    }, 0);
+    return result;
+}
+exports.concat = concat;
+function stripZeros(value) {
+    let result = arrayify(value);
+    if (result.length === 0) {
+        return result;
+    }
+    // Find the first non-zero entry
+    let start = 0;
+    while (start < result.length && result[start] === 0) {
+        start++;
+    }
+    // If we started with zeros, strip them
+    if (start) {
+        result = result.slice(start);
+    }
+    return result;
+}
+exports.stripZeros = stripZeros;
+function zeroPad(value, length) {
+    value = arrayify(value);
+    if (value.length > length) {
+        logger_1.logger.throwArgumentError('value out of range', 'value', value);
+    }
+    const result = new Uint8Array(length);
+    result.set(value, length - value.length);
+    return result;
+}
+exports.zeroPad = zeroPad;
+function isHexString(value, length) {
+    if (typeof value !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) {
+        return false;
+    }
+    if (length && value.length !== 2 + 2 * length) {
+        return false;
+    }
+    return true;
+}
+exports.isHexString = isHexString;
+const HexCharacters = '0123456789abcdef';
+/**
+ * @example
+ * ```js
+ * hexlify(4);
+ * // '0x04'
+ *
+ * hexlify(14);
+ * // '0x0e'
+ * ```
+ */
+function hexlify(value, options) {
+    if (!options) {
+        options = {};
+    }
+    if (typeof value === 'number') {
+        logger_1.logger.checkSafeUint53(value, 'invalid hexlify value');
+        let hex = '';
+        while (value) {
+            hex = HexCharacters[value & 0xf] + hex;
+            value = Math.floor(value / 16);
+        }
+        if (hex.length) {
+            if (hex.length % 2) {
+                hex = '0' + hex;
+            }
+            return '0x' + hex;
+        }
+        return '0x00';
+    }
+    if (typeof value === 'bigint') {
+        value = value.toString(16);
+        if (value.length % 2) {
+            return '0x0' + value;
+        }
+        return '0x' + value;
+    }
+    if (options.allowMissingPrefix &&
+        typeof value === 'string' &&
+        value.substring(0, 2) !== '0x') {
+        value = '0x' + value;
+    }
+    if (isHexable(value)) {
+        return value.toHexString();
+    }
+    if (isHexString(value)) {
+        if (value.length % 2) {
+            if (options.hexPad === 'left') {
+                value = '0x0' + value.substring(2);
+            }
+            else if (options.hexPad === 'right') {
+                value += '0';
+            }
+            else {
+                logger_1.logger.throwArgumentError('hex data is odd-length', 'value', value);
+            }
+        }
+        return value.toLowerCase();
+    }
+    if (isBytes(value)) {
+        let result = '0x';
+        for (let i = 0; i < value.length; i++) {
+            const v = value[i];
+            result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
+        }
+        return result;
+    }
+    return logger_1.logger.throwArgumentError('invalid hexlify value', 'value', value);
+}
+exports.hexlify = hexlify;
+function hexDataLength(data) {
+    if (typeof data !== 'string') {
+        data = hexlify(data);
+    }
+    else if (!isHexString(data) || data.length % 2) {
+        return null;
+    }
+    return (data.length - 2) / 2;
+}
+exports.hexDataLength = hexDataLength;
+function hexDataSlice(data, offset, endOffset) {
+    if (typeof data !== 'string') {
+        data = hexlify(data);
+    }
+    else if (!isHexString(data) || data.length % 2) {
+        logger_1.logger.throwArgumentError('invalid hexData', 'value', data);
+    }
+    offset = 2 + 2 * offset;
+    if (endOffset != null) {
+        return '0x' + data.substring(offset, 2 + 2 * endOffset);
+    }
+    return '0x' + data.substring(offset);
+}
+exports.hexDataSlice = hexDataSlice;
+function hexConcat(items) {
+    let result = '0x';
+    items.forEach((item) => {
+        result += hexlify(item).substring(2);
+    });
+    return result;
+}
+exports.hexConcat = hexConcat;
+function hexValue(value) {
+    const trimmed = hexStripZeros(hexlify(value, { hexPad: 'left' }));
+    if (trimmed === '0x') {
+        return '0x0';
+    }
+    return trimmed;
+}
+exports.hexValue = hexValue;
+function hexStripZeros(value) {
+    if (typeof value !== 'string') {
+        value = hexlify(value);
+    }
+    if (!isHexString(value)) {
+        logger_1.logger.throwArgumentError('invalid hex string', 'value', value);
+    }
+    value = value.substring(2);
+    let offset = 0;
+    while (offset < value.length && value[offset] === '0') {
+        offset++;
+    }
+    return '0x' + value.substring(offset);
+}
+exports.hexStripZeros = hexStripZeros;
+/**
+ * Returns a hex string padded to a specified length of bytes.
+ *
+ * Similar to ["hexZeroPad" in ethers.js](https://docs.ethers.io/v5/api/utils/bytes/#utils-hexZeroPad)
+ *
+ * Differs from ["padLeft" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#padleft) because web3 counts by characters, not bytes.
+ *
+ * @param hexValue - A hex-string, hex-number, or decimal number (auto-converts to base-16) to be padded
+ * @param length - The final length in bytes
+ *
+ * @throws - If the value is not a hex string or number
+ * @throws - If the value is longer than the length
+ *
+ * @example
+ * ```javascript
+ * hexZeroPad('0x60', 2);
+ * // '0x0060'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * hexZeroPad(0x60, 3);
+ * // '0x000060'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * hexZeroPad('12345', 1);
+ * // Throws
+ * ```
+ */
+function hexZeroPad(value, length) {
+    if (typeof value !== 'string') {
+        value = hexlify(value);
+    }
+    else if (!isHexString(value)) {
+        logger_1.logger.throwArgumentError('invalid hex string', 'value', value);
+    }
+    if (value.length > 2 * length + 2) {
+        logger_1.logger.throwError('value out of range', { value, length });
+    }
+    while (value.length < 2 * length + 2) {
+        value = '0x0' + value.substring(2);
+    }
+    return value;
+}
+exports.hexZeroPad = hexZeroPad;
+// export function splitSignature(signature: SignatureLike): Signature {
+//   const result: Signature = {
+//     r: '0x',
+//     s: '0x',
+//     _vs: '0x',
+//     recoveryParam: 0,
+//     v: 0,
+//     yParityAndS: '0x',
+//     compact: '0x',
+//   };
+//   if (isBytesLike(signature)) {
+//     const bytes: Uint8Array = arrayify(signature);
+//     // Get the r, s and v
+//     if (bytes.length === 64) {
+//       // EIP-2098; pull the v from the top bit of s and clear it
+//       result.v = 27 + (bytes[32] >> 7);
+//       bytes[32] &= 0x7f;
+//       result.r = hexlify(bytes.slice(0, 32));
+//       result.s = hexlify(bytes.slice(32, 64));
+//     } else if (bytes.length === 65) {
+//       result.r = hexlify(bytes.slice(0, 32));
+//       result.s = hexlify(bytes.slice(32, 64));
+//       result.v = bytes[64];
+//     } else {
+//       logger.throwArgumentError(
+//         'invalid signature string',
+//         'signature',
+//         signature,
+//       );
+//     }
+//     // Allow a recid to be used as the v
+//     if (result.v < 27) {
+//       if (result.v === 0 || result.v === 1) {
+//         result.v += 27;
+//       } else {
+//         logger.throwArgumentError(
+//           'signature invalid v byte',
+//           'signature',
+//           signature,
+//         );
+//       }
+//     }
+//     // Compute recoveryParam from v
+//     result.recoveryParam = 1 - (result.v % 2);
+//     // Compute _vs from recoveryParam and s
+//     if (result.recoveryParam) {
+//       bytes[32] |= 0x80;
+//     }
+//     result._vs = hexlify(bytes.slice(32, 64));
+//   } else {
+//     result.r = signature.r;
+//     result.s = signature.s;
+//     result.v = signature.v;
+//     result.recoveryParam = signature.recoveryParam;
+//     result._vs = signature._vs;
+//     // If the _vs is available, use it to populate missing s, v and recoveryParam
+//     // and verify non-missing s, v and recoveryParam
+//     if (result._vs != null) {
+//       const vs = zeroPad(arrayify(result._vs), 32);
+//       result._vs = hexlify(vs);
+//       // Set or check the recid
+//       const recoveryParam = vs[0] >= 128 ? 1 : 0;
+//       if (result.recoveryParam == null) {
+//         result.recoveryParam = recoveryParam;
+//       } else if (result.recoveryParam !== recoveryParam) {
+//         logger.throwArgumentError(
+//           'signature recoveryParam mismatch _vs',
+//           'signature',
+//           signature,
+//         );
+//       }
+//       // Set or check the s
+//       vs[0] &= 0x7f;
+//       const s = hexlify(vs);
+//       if (result.s == null) {
+//         result.s = s;
+//       } else if (result.s !== s) {
+//         logger.throwArgumentError(
+//           'signature v mismatch _vs',
+//           'signature',
+//           signature,
+//         );
+//       }
+//     }
+//     // Use recid and v to populate each other
+//     if (result.recoveryParam == null) {
+//       if (result.v == null) {
+//         logger.throwArgumentError(
+//           'signature missing v and recoveryParam',
+//           'signature',
+//           signature,
+//         );
+//       } else if (result.v === 0 || result.v === 1) {
+//         result.recoveryParam = result.v;
+//       } else {
+//         result.recoveryParam = 1 - (result.v % 2);
+//       }
+//     } else {
+//       if (result.v == null) {
+//         result.v = 27 + result.recoveryParam;
+//       } else {
+//         const recId =
+//           result.v === 0 || result.v === 1 ? result.v : 1 - (result.v % 2);
+//         if (result.recoveryParam !== recId) {
+//           logger.throwArgumentError(
+//             'signature recoveryParam mismatch v',
+//             'signature',
+//             signature,
+//           );
+//         }
+//       }
+//     }
+//     if (result.r == null || !isHexString(result.r)) {
+//       logger.throwArgumentError(
+//         'signature missing or invalid r',
+//         'signature',
+//         signature,
+//       );
+//     } else {
+//       result.r = hexZeroPad(result.r, 32);
+//     }
+//     if (result.s == null || !isHexString(result.s)) {
+//       logger.throwArgumentError(
+//         'signature missing or invalid s',
+//         'signature',
+//         signature,
+//       );
+//     } else {
+//       result.s = hexZeroPad(result.s, 32);
+//     }
+//     const vs = arrayify(result.s);
+//     if (vs[0] >= 128) {
+//       logger.throwArgumentError(
+//         'signature s out of range',
+//         'signature',
+//         signature,
+//       );
+//     }
+//     if (result.recoveryParam) {
+//       vs[0] |= 0x80;
+//     }
+//     const _vs = hexlify(vs);
+//     if (result._vs) {
+//       if (!isHexString(result._vs)) {
+//         logger.throwArgumentError(
+//           'signature invalid _vs',
+//           'signature',
+//           signature,
+//         );
+//       }
+//       result._vs = hexZeroPad(result._vs, 32);
+//     }
+//     // Set or check the _vs
+//     if (result._vs == null) {
+//       result._vs = _vs;
+//     } else if (result._vs !== _vs) {
+//       logger.throwArgumentError(
+//         'signature _vs mismatch v and s',
+//         'signature',
+//         signature,
+//       );
+//     }
+//   }
+//   result.yParityAndS = result._vs;
+//   result.compact = result.r + result.yParityAndS.substring(2);
+//   return result;
+// }
+// export function joinSignature(signature: SignatureLike): string {
+//   signature = splitSignature(signature);
+//   return hexlify(
+//     concat([
+//       signature.r,
+//       signature.s,
+//       signature.recoveryParam ? '0x1c' : '0x1b',
+//     ]),
+//   );
+// }

package/lib/cjs/utils/solidity-keccak256.d.ts

@@ -0,0 +1,30 @@
+export declare function pack(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
+export declare const hashKeccak256: (data: string) => string;
+/**
+ * Hashes data from Solidity using the Keccak256 algorithm.
+ *
+ * Similar to ["solidityKeccak256" in ethers.js](https://docs.ethers.io/v5/api/utils/hashing/#utils-solidityKeccak256)
+ *
+ * @param types - Each [Solidity type](https://docs.soliditylang.org/en/v0.8.13/types.html) corresponding to the values passed in. Helps the function parse and pack data properly.
+ *
+ * @param values - Data to be concatenated (combined) and then hashed.
+ *
+ * @returns - A Keccak256 hash (hex string) based on the values provided
+ *
+ * @example
+ * ```javascript
+ * const types = ['string', 'bool', 'uint32'];
+ * const values = ['essential-eth is great', true, 14];
+ * solidityKeccak256(types, values);
+ * // '0xe4d4c8e809faac09d58f468f0aeab9474fe8965d554c6c0f868c433c3fd6acab'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * const types = ['bytes4', 'uint32[5]'];
+ * const values = [[116, 101, 115, 116], [5, 3, 4, 9, 18]];
+ * solidityKeccak256(types, values);
+ * // '0x038707a887f09355dc545412b058e7ba8f3c74047050c7c5e5e52eec608053d9'
+ * ```
+ */
+export declare function solidityKeccak256(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;

package/lib/cjs/utils/solidity-keccak256.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solidityKeccak256 = exports.hashKeccak256 = exports.pack = void 0;
+const buffer_1 = require("buffer");
+const sha3_1 = require("sha3");
+const logger_1 = require("../logger/logger");
+const tiny_big_1 = require("../shared/tiny-big/tiny-big");
+const bytes_1 = require("./bytes");
+const regexBytes = new RegExp('^bytes([0-9]+)$');
+const regexNumber = new RegExp('^(u?int)([0-9]*)$');
+const regexArray = new RegExp('^(.*)\\[([0-9]*)\\]$');
+const Zeros = '0000000000000000000000000000000000000000000000000000000000000000';
+function _pack(type, value, isArray) {
+    switch (type) {
+        case 'address':
+            if (isArray) {
+                return (0, bytes_1.zeroPad)(value, 32);
+            }
+            return (0, bytes_1.arrayify)(value);
+        case 'string':
+            return buffer_1.Buffer.from(value);
+        case 'bytes':
+            return (0, bytes_1.arrayify)(value);
+        case 'bool':
+            value = value ? '0x01' : '0x00';
+            if (isArray) {
+                return (0, bytes_1.zeroPad)(value, 32);
+            }
+            return (0, bytes_1.arrayify)(value);
+    }
+    let match = type.match(regexNumber);
+    if (match) {
+        //let signed = (match[1] === "int")
+        let size = parseInt(match[2] || '256');
+        if ((match[2] && String(size) !== match[2]) ||
+            size % 8 !== 0 ||
+            size === 0 ||
+            size > 256) {
+            logger_1.logger.throwArgumentError('invalid number type', 'type', type);
+        }
+        if (isArray) {
+            size = 256;
+        }
+        value = (0, tiny_big_1.tinyBig)(value).toTwos(size).toNumber();
+        const hexValue = (0, bytes_1.hexlify)(value);
+        return (0, bytes_1.zeroPad)(hexValue, size / 8);
+    }
+    match = type.match(regexBytes);
+    if (match) {
+        const size = parseInt(match[1]);
+        if (String(size) !== match[1] || size === 0 || size > 32) {
+            logger_1.logger.throwArgumentError('invalid bytes type', 'type', type);
+        }
+        if ((0, bytes_1.arrayify)(value).byteLength !== size) {
+            logger_1.logger.throwArgumentError(`invalid value for ${type}`, 'value', value);
+        }
+        if (isArray) {
+            return (0, bytes_1.arrayify)((value + Zeros).substring(0, 66));
+        }
+        return value;
+    }
+    match = type.match(regexArray);
+    if (match && Array.isArray(value)) {
+        const baseType = match[1];
+        const count = parseInt(match[2] || String(value.length));
+        if (count != value.length) {
+            logger_1.logger.throwArgumentError(`invalid array length for ${type}`, 'value', value);
+        }
+        const result = [];
+        value.forEach(function (value) {
+            result.push(_pack(baseType, value, true));
+        });
+        return (0, bytes_1.concat)(result);
+    }
+    return logger_1.logger.throwArgumentError('invalid type', 'type', type);
+}
+function pack(types, values) {
+    if (types.length != values.length) {
+        logger_1.logger.throwArgumentError('wrong number of values; expected ${ types.length }', 'values', values);
+    }
+    const tight = [];
+    types.forEach(function (type, index) {
+        tight.push(_pack(type, values[index]));
+    });
+    return (0, bytes_1.hexlify)((0, bytes_1.concat)(tight));
+}
+exports.pack = pack;
+const hashKeccak256 = (data) => {
+    const keccak = new sha3_1.Keccak(256);
+    const bufferableData = buffer_1.Buffer.from(data.replace(/^0x/, ''), 'hex');
+    const addressHash = '0x' + keccak.update(bufferableData).digest('hex');
+    return addressHash;
+};
+exports.hashKeccak256 = hashKeccak256;
+/**
+ * Hashes data from Solidity using the Keccak256 algorithm.
+ *
+ * Similar to ["solidityKeccak256" in ethers.js](https://docs.ethers.io/v5/api/utils/hashing/#utils-solidityKeccak256)
+ *
+ * @param types - Each [Solidity type](https://docs.soliditylang.org/en/v0.8.13/types.html) corresponding to the values passed in. Helps the function parse and pack data properly.
+ *
+ * @param values - Data to be concatenated (combined) and then hashed.
+ *
+ * @returns - A Keccak256 hash (hex string) based on the values provided
+ *
+ * @example
+ * ```javascript
+ * const types = ['string', 'bool', 'uint32'];
+ * const values = ['essential-eth is great', true, 14];
+ * solidityKeccak256(types, values);
+ * // '0xe4d4c8e809faac09d58f468f0aeab9474fe8965d554c6c0f868c433c3fd6acab'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * const types = ['bytes4', 'uint32[5]'];
+ * const values = [[116, 101, 115, 116], [5, 3, 4, 9, 18]];
+ * solidityKeccak256(types, values);
+ * // '0x038707a887f09355dc545412b058e7ba8f3c74047050c7c5e5e52eec608053d9'
+ * ```
+ */
+function solidityKeccak256(types, values) {
+    return (0, exports.hashKeccak256)(pack(types, values));
+}
+exports.solidityKeccak256 = solidityKeccak256;

package/lib/esm/index.d.ts

@@ -8,8 +8,9 @@ import { TransactionResponse } from './types/Transaction.types';
 import { etherToGwei } from './utils/ether-to-gwei';
 import { etherToWei } from './utils/ether-to-wei';
 import { gweiToEther } from './utils/gwei-to-ether';
-import { hexZeroPad } from './utils/hex-zero-pad';
 import { isAddress } from './utils/is-address';
 import { toChecksumAddress } from './utils/to-checksum-address';
 import { weiToEther } from './utils/wei-to-ether';
-export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, hexZeroPad, Contract, TinyBig, BlockResponse, ContractTypes, JSONABI, JSONABIArgument, Network, TransactionResponse, };
+export * from './utils/bytes';
+export * from './utils/solidity-keccak256';
+export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, Contract, TinyBig, BlockResponse, ContractTypes, JSONABI, JSONABIArgument, Network, TransactionResponse, };

package/lib/esm/index.js

@@ -4,8 +4,9 @@ import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
 import { etherToGwei } from './utils/ether-to-gwei';
 import { etherToWei } from './utils/ether-to-wei';
 import { gweiToEther } from './utils/gwei-to-ether';
-import { hexZeroPad } from './utils/hex-zero-pad';
 import { isAddress } from './utils/is-address';
 import { toChecksumAddress } from './utils/to-checksum-address';
 import { weiToEther } from './utils/wei-to-ether';
-export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, hexZeroPad, Contract, TinyBig, };
+export * from './utils/bytes';
+export * from './utils/solidity-keccak256';
+export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, Contract, TinyBig, };

package/lib/esm/logger/logger.d.ts

@@ -0,0 +1,11 @@
+declare class Logger {
+    private packageVersion;
+    constructor();
+    throwError(message: string, args: {
+        [key: string]: any;
+    }): never;
+    throwArgumentError(message: string, arg: string, value: any): never;
+    checkSafeUint53(value: number, message?: string): void;
+}
+export declare const logger: Logger;
+export {};