essential-eth 0.5.12 → 0.5.13-next.2

package/lib/cjs/utils/bytes.d.ts

@@ -1,289 +0,0 @@
-export declare type Bytes = ArrayLike<number>;
-/**
- * @example
- * [1,2,3]
- * @example
- * 0x123
- * @example
- * '0x123'
- */
-export declare type BytesLike = Bytes | string;
-export declare type BytesLikeWithNumber = BytesLike | number;
-export interface DataOptions {
-    allowMissingPrefix?: boolean;
-    hexPad?: 'left' | 'right' | null;
-}
-export interface Hexable {
-    toHexString(): string;
-}
-export declare type SignatureLike = {
-    r: string;
-    s?: string;
-    _vs?: string;
-    recoveryParam?: number;
-    v?: number;
-} | BytesLike;
-export interface Signature {
-    r: string;
-    s: string;
-    _vs: string;
-    recoveryParam: number;
-    v: number;
-    yParityAndS: string;
-    compact: string;
-}
-/**
- * Returns true if and only if value is a valid [Bytes](#bytes) or DataHexString
- * Same as [`ethers.utils.isBytesLike`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isBytesLike)
- *
- * @param value the value to check whether or not it matches BytesLike
- * @returns whether or not the value matches BytesLike
- * @example
- * ```javascript
- * isBytesLike([1,2,3]);
- * // true
- * ```
- * @example
- * ```javascript
- * isBytesLike(false);
- * // false
- * ```
- * @example
- * ```javascript
- * isBytesLike(new Uint8Array(1));
- * // true
- * ```
- */
-export declare function isBytesLike(value: any): value is BytesLike;
-/**
- * Returns true if and only if value is a valid [Bytes](#bytes)
- * Same as [`ethers.utils.isBytes`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isBytes)
- *
- * @param value the value to check whether or not it matches Bytes
- * @returns whether or not the value matches Bytes
- * @example
- * ```javascript
- * isBytes([1,2,3]);
- * // true
- * ```
- * @example
- * ```javascript
- * isBytes(false);
- * // false
- * ```
- * @example
- * ```javascript
- * isBytes(new Uint8Array(1));
- * // true
- * ```
- */
-export declare function isBytes(value: any): value is Bytes;
-/**
- * Converts DataHexStringOrArrayish to a Uint8Array
- * Same as [`ethers.utils.arrayify`](https://docs.ethers.io/v5/api/utils/bytes/#utils-arrayify)
- *
- * @param value the value to convert to a Uint8Array
- * @param options options to use when converting the value to a Uint8Array
- * @returns the value represented as a Uint8Array
- * @example
- * ```javascript
- * arrayify(1);
- * // Uint8Array(1) [ 1 ]
- * ```
- * @example
- * ```javascript
- * arrayify(0x1234);
- * // Uint8Array(2) [ 18, 52 ]
- * ```
- * @example
- * ```javascript
- * arrayify('0x1', { hexPad: 'right' });
- * // Uint8Array(1) [ 16 ]
- * ```
- */
-export declare function arrayify(value: BytesLike | Hexable | number, options?: DataOptions): Uint8Array;
-/**
- * Concatenates all the BytesLike in arrayOfBytesLike into a single Uint8Array.
- * Same as [`ethers.utils.concat`](https://docs.ethers.io/v5/api/utils/bytes/#utils-concat)
- *
- * @param arrayOfBytesLike the array of {@link BytesLike} to concatenate together
- * @returns a concatenated Uint8Array
- * @example
- * ```javascript
- * concat([0, 1]);
- * // Uint8Array(2) [ 0, 1 ]
- * ```
- */
-export declare function concat(arrayOfBytesLike: ReadonlyArray<BytesLikeWithNumber>): Uint8Array;
-/**
- * Strips leading zeros from a BytesLike object
- *
- * @param value the value to strip leading zeros from
- * @returns value without leading zeroes, expressed as a Uint8Array
- * @example
- * ```javascript
- * stripZeros('0x00002834');
- * // Uint8Array { [Iterator]  0: 40, 1: 52 }
- * // Equivalent to '0x2834'
- * ```
- */
-export declare function stripZeros(value: BytesLike): Uint8Array;
-/**
- * Pads the beginning of a {@link BytesLike} with zeros so it's the specified length as a Uint8Array
- *
- * @param value the value to pad
- * @param length the desired length of the value
- * @returns the value padded with zeros to the specified length
- * @example
- * ```javascript
- * zeroPad('0x039284');
- * // Uint8Array { [Iterator]  0: 0, 1: 0, 2: 0, 3: 3, 4: 146, 5: 132 }
- * // Equivalent to 0x000000039284
- * ```
- * @example
- * ```javascript
- * zeroPad([39, 25, 103, 45], 5);
- * // Uint8Array { [Iterator]  0: 0, 1: 39, 2: 25, 3: 103, 4: 45 }
- * ```
- */
-export declare function zeroPad(value: BytesLike, length: number): Uint8Array;
-/**
- * Returns true if and only if object is a valid hex string.
- * If length is specified and object is not a valid DataHexString of length bytes, an InvalidArgument error is thrown.
- * Same as [`ethers.utils.isHexString`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isHexString)
- *
- * @param value the value to check whether or not it's a hex string
- * @param length a length of bytes that the value should be equal to
- * @returns whether the value is a valid hex string (and optionally, whether it matches the length specified)
- * @example
- * ```javascript
- * isHexString('0x4924');
- * // true
- * ```
- * @example
- * ```javascript
- * isHexString('0x4924', 4);
- * // false
- * // length of 4 in bytes would mean a hex string with 8 characters
- * ```
- */
-export declare function isHexString(value: any, length?: number): boolean;
-/**
- * Converts a value into a hex string
- *
- * @param value the value to convert
- * @param options options to use when converting the value to a hex string
- * @returns the value represented as a hex string
- * @example
- * ```javascript
- * hexlify(4);
- * // '0x04'
- * ```
- * @example
- * ```javascript
- * hexlify(14);
- * // '0x0e'
- * ```
- */
-export declare function hexlify(value: BytesLike | Hexable | number | bigint, options?: DataOptions): string;
-/**
- * Gets the length of data represented as a hex string
- *
- * @param data the data to check the length of
- * @returns the length of the data
- * @example
- * ```javascript
- * hexDataLength([2, 4, 0, 1]);
- * // 4
- * ```
- * @example
- * ```javascript
- * hexDataLength('0x3925');
- * // 2
- * ```
- */
-export declare function hexDataLength(data: BytesLike): number | null;
-/**
- * Slices a {@link BytesLike} to extract a certain part of the input
- *
- * @param data the data to slice from
- * @param offset the index to start extraction at
- * @param endOffset the index to end extraction at
- * @returns the extracted data as a hex string
- * @example
- * ```javascript
- * hexDataSlice([20, 6, 48], 0, 2);
- * // '0x1406'
- * ```
- */
-export declare function hexDataSlice(data: BytesLikeWithNumber, offset: number, endOffset?: number): string;
-/**
- * Concatenates values together into one hex string
- *
- * @param items the items to concatenate together
- * @returns a single hex string including all of the items to be concatenated
- * @example
- * ```javascript
- * hexConcat([[2, 4, 0, 1], 9, '0x2934', '0x3947']);
- * // '0x020400010929343947'
- * ```
- */
-export declare function hexConcat(items: ReadonlyArray<BytesLike>): string;
-/**
- * Converts a number of different types into a hex string
- *
- * @param value the value to convert into a hex string
- * @returns the value represented as a hex string
- * @example
- * ```javascript
- * hexValue(39);
- * // '0x27'
- * ```
- * @example
- * ```javascript
- * hexValue([9, 4, 19, 4]);
- * // '0x9041304'
- * ```
- */
-export declare function hexValue(value: BytesLike | Hexable | number | bigint): string;
-/**
- * Strips the leading zeros from a value and returns it as a hex string
- *
- * @param value the value to strip zeros from
- * @returns a hex string representation of the value, without leading zeros
- * @example
- * ```javascript
- * hexStripZeros([0,0,0,48]);
- * // '0x30'
- * ```
- */
-export declare function hexStripZeros(value: BytesLike): string;
-/**
- * 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 value A hex-string, hex-number, or decimal number (auto-converts to base-16) to be padded
- * @param length The final length in bytes
- * @returns A hex string padded to the specified length
- * @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
- * ```
- */
-export declare function hexZeroPad(value: BytesLikeWithNumber, length: number): string;

package/lib/cjs/utils/compute-address.d.ts

@@ -1,17 +0,0 @@
-/**
- * Computes the address that corresponds to a specified public or private key
- *
- * @param key the public or private key to find the address related to
- * @returns the address that corresponds to the key specified
- * @example
- * ```javascript
- * computeAddress('0x0458eb591f407aef12936bd2989ca699cf5061de9c4964dd6eb6005fd8f580c407434447e813969a1be6e9954b002cad84dfc67a69e032b273e4695e7d0db2d952'); // public key
- * // '0xA2902059a7BF992f1450BACD7357CCAa5cC8336a'
- * ```
- * @example
- * ```javascript
- * computeAddress('0x2f2c419acf4a1da8c1ebea75bb3fcfbd3ec2aa3bf0162901ccdc2f38b8f92427'); // private key
- * // '0xA2902059a7BF992f1450BACD7357CCAa5cC8336a'
- * ```
- */
-export declare function computeAddress(key: string): string;

package/lib/cjs/utils/compute-public-key.d.ts

@@ -1,18 +0,0 @@
-import type { BytesLike } from './bytes';
-/**
- * Computes the public key from a given private key
- *
- * @param privKey the private key to find a public key from
- * @returns the public key related to the specified private key
- * @example
- * ```javascript
- * computePublicKey('0xb27cc8dea0177d910110e8d3ec5480d56c723abf433529f4063f261ffdb9297c');
- * // '0x045cd0032015eecfde49f82f4e149d804e8ac6e3a0bface32e37c72a71ceac864fe84da7e8df84342f7b11dfb753c4d158f636142b46b29cf7f0f171ae0aa4fb87'
- * ```
- * @example
- * ```javascript
- * computePublicKey([50,102,50,99,52,49,57,97,99,102,52,97,49,100,97,56,99,49,101,98,101,97,55,53,98,98,51,102,99,102,98,100]);
- * // '0x04a9cea77eca949df84f661cee153426fb51f2294b9364b4fac240df57360b9b0ac9c99e4d7966491ab4c81f8c82e0cd24ec5759832ad4ab736d22c7d90b806ee8'
- * ```
- */
-export declare function computePublicKey(privKey: BytesLike): string;

package/lib/cjs/utils/ether-to-gwei.d.ts

@@ -1,27 +0,0 @@
-import type Big from 'big.js';
-import type { TinyBig } from '../shared/tiny-big/tiny-big';
-/**
- * Convert from Ether to Gwei
- *
- * No direct equivalent in ether.js; requires multiple functions to achieve.
- *
- * No direct equivalent in web3; requires multiple functions to achieve.
- *
- * @param etherQuantity the amount of ether to convert to gwei
- * @returns a number of gwei equivalent to the specified ether
- * @example
- * ```javascript
- * etherToGwei('1000').toString()
- * // '1000000000000'
- * etherToGwei(1000).toString()
- * // '1000000000000'
- * ```
- * @example
- * ```javascript
- * etherToGwei('1000').toNumber()
- * // 1000000000000
- * etherToGwei(1000).toNumber()
- * // 1000000000000
- * ```
- */
-export declare function etherToGwei(etherQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/cjs/utils/ether-to-wei.d.ts

@@ -1,27 +0,0 @@
-import type Big from 'big.js';
-import type { TinyBig } from '../shared/tiny-big/tiny-big';
-/**
- * Convert Ether to Wei
- *
- * Similar to ["parseEther" in ethers.js](https://docs.ethers.io/v5/api/utils/display-logic/#utils-parseEther)
- *
- * Similar to ["toWei" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#towei)
- *
- * @param etherQuantity the amount of ether to convert to wei
- * @returns a number of wei equivalent to the specified ether
- * @example
- * ```javascript
- * etherToWei('1000').toString()
- * // '1000000000000000000000'
- * etherToWei(1000).toString()
- * // '1000000000000000000000'
- * ```
- * @example
- * ```javascript
- * etherToWei('1000').toNumber()
- * // 1000000000000000000000
- * etherToWei(1000).toNumber()
- * // 1000000000000000000000
- * ```
- */
-export declare function etherToWei(etherQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/cjs/utils/gwei-to-ether.d.ts

@@ -1,27 +0,0 @@
-import type Big from 'big.js';
-import type { TinyBig } from './../shared/tiny-big/tiny-big';
-/**
- * Convert from Gwei to Ether
- *
- * No direct equivalent in ethers.js; requires multiple functions to achieve.
- *
- * No direct equivalent in web3; requires multiple functions to achieve.
- *
- * @param gweiQuantity the amount of gwei to convert to ether
- * @returns a number of ether equivalent to the specified gwei
- * @example
- * ```javascript
- * gweiToEther('1000000000000').toString()
- * // '1000'
- * gweiToEther(1000000000000).toString()
- * // '1000'
- * ```
- * @example
- * ```javascript
- * gweiToEther('1000000000000').toNumber()
- * // 1000
- * gweiToEther(1000000000000).toNumber()
- * // 1000
- * ```
- */
-export declare function gweiToEther(gweiQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/cjs/utils/hash-message.d.ts

@@ -1,14 +0,0 @@
-import type { Bytes } from '../index';
-/**
- * Computes the EIP-191 personal message digest of message.
- * Personal messages are converted to UTF-8 bytes and prefixed with \x19Ethereum Signed Message: and the length of message.
- *
- * @param message the message to hash
- * @returns a message hashed using Keccak256 that matches the EIP-191 standard
- * @example
- * ```javascript
- * hashMessage("Hello World");
- * // '0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2'
- * ```
- */
-export declare function hashMessage(message: Bytes | string): string;

package/lib/cjs/utils/is-address.d.ts

@@ -1,24 +0,0 @@
-/**
- * Returns a boolean as to whether the input is a valid address.
- * Does NOT support ICAP addresses
- *
- * @param address the address to check the validity of
- * @returns a boolean for whether the input is a valid address
- * @example
- * ```javascript
- * isAddress('0xc0deaf6bd3f0c6574a6a625ef2f22f62a5150eab');
- * // true
- * ```
- * @example
- * ```javascript
- * isAddress('bad');
- * // false
- * ```
- * @example
- * ```javascript
- * // Does NOT support ENS.
- * isAddress('vitalik.eth');
- * // false
- * ```
- */
-export declare function isAddress(address: string): boolean;

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

@@ -1,16 +0,0 @@
-import type { BytesLike } from './bytes';
-/**
- * Hashes data into a Keccak256 hex string
- *
- * @param data the data to be hashed using Keccak256
- * @returns a hex string with data hashed using Keccak256
- * @example
- * ```javascript
- * keccak256('essential-eth');
- * // '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'
- *
- * keccak256('0x123');
- * // '0x5fa2358263196dbbf23d1ca7a509451f7a2f64c15837bfbb81298b1e3e24e4fa'
- * ```
- */
-export declare function keccak256(data: BytesLike): string;

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

@@ -1,39 +0,0 @@
-/**
- * Converts arrays with types and values into a hex string that can be hashed
- *
- * @param types array of Solidity types, where `type[0]` is the type for `value[0]`
- * @param values array of values, where `value[0]` is of type `type[0]`
- * @returns a hex string with the data given, packed to include its types
- * @example
- * ```javascript
- * const types = ['bool', 'string', 'uint64'];
- * const values = [true, 'text', 30];
- * pack(types, values);
- * // '0x0174657874000000000000001e'
- * ```
- */
-export declare function pack(types: ReadonlyArray<string>, values: ReadonlyArray<any>): 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/split-signature.d.ts

@@ -1,24 +0,0 @@
-import type { Signature, SignatureLike } from './bytes';
-/**
- * Expands a signature into the full signature object and fills in missing properties.
- *
- * Same as ["splitSignature" in ethers.js](https://docs.ethers.io/v5/api/utils/bytes/#utils-splitSignature)
- *
- * @param signature the signature object to split, parse, and compute missing properties from
- * @returns a full signature object with all properties filled
- * @example
- * ```javascript
- * const signature = '0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee331b';
- * splitSignature(signature);
- *  {
- *    r: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b39716",
- *    s: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
- *    _vs: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
- *    recoveryParam: 0,
- *    v: 27,
- *    yParityAndS: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
- *    compact: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
- *  }
- * ```
- */
-export declare function splitSignature(signature: SignatureLike): Signature;

package/lib/cjs/utils/to-checksum-address.d.ts

@@ -1,17 +0,0 @@
-/**
- * Returns an Ethereum address in proper mixed-case checksum.
- * Does NOT support ICAP
- *
- * @param address An Ethereum address. Mixed, lower, and uppercase are all valid
- * @returns a valid checksum address
- * @example
- * ```javascript
- * toChecksumAddress('0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359');
- * // '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359'
- * ```
- *
- * Similar to ["getAddress" in ethers.js](https://docs.ethers.io/v5/api/utils/address/#utils-getAddress)
- *
- * Similar to ["toChecksumAddress" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#tochecksumaddress)
- */
-export declare function toChecksumAddress(address: string): string;

package/lib/cjs/utils/to-utf8-bytes.d.ts

@@ -1,15 +0,0 @@
-/**
- * Converts a string into a UTF-8 Byte Array
- *
- * @param data the input to be converted to a UTF-8 Byte Array
- * @returns the specified data as a UTF-8 Byte Array
- * @example
- * ```javascript
- * toUtf8Bytes('essential-eth');
- * // Uint8Array { [Iterator] 0: 101, 1: 115, 2: 115, 3: 101, 4: 110, 5: 116, 6: 105, 7: 97, 8: 108, 9: 45, 10: 101, 11: 116, 12: 104 }
- *
- * toUtf8Bytes('ethereum');
- * // Uint8Array { [Iterator]  0: 101, 1: 116, 2: 104, 3: 101, 4: 114, 5: 101, 6: 117, 7: 109 }
- * ```
- */
-export declare function toUtf8Bytes(data: string): Uint8Array;

package/lib/cjs/utils/wei-to-ether.d.ts

@@ -1,27 +0,0 @@
-import type Big from 'big.js';
-import type { TinyBig } from '../shared/tiny-big/tiny-big';
-/**
- * Convert from Wei to Ether
- *
- * Similar to ["formatEther" in ethers.js](https://docs.ethers.io/v5/api/utils/display-logic/#utils-formatEther)
- *
- * Similar to ["fromWei" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#fromwei)
- *
- * @param weiQuantity the amount of wei to convert to ether
- * @returns a number of ether equivalent to the specified wei
- * @example
- * ```javascript
- * weiToEther('1000000000000000000000').toString()
- * // '1000'
- * weiToEther(1000000000000000000000).toString()
- * // '1000'
- * ```
- * @example
- * ```javascript
- * weiToEther('1000000000000000000000').toNumber()
- * // 1000
- * weiToEther(1000000000000000000000).toNumber()
- * // 1000
- * ```
- */
-export declare function weiToEther(weiQuantity: string | number | TinyBig | Big): TinyBig;

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

@@ -1 +0,0 @@
-export declare const version = "0.5.12";

package/lib/esm/logger/package-version.js

@@ -1 +0,0 @@
-export const version = '0.5.12';