essential-eth 0.5.4 → 0.5.9

package/lib/cjs/types/Transaction.types.d.ts

@@ -1,4 +1,6 @@
+import type Big from 'big.js';
 import { TinyBig } from '../shared/tiny-big/tiny-big';
+import { BytesLike } from './../utils/bytes';
 declare type Modify<T, R> = Omit<T, keyof R> & R;
 export interface RPCTransaction extends RPCBlockTransaction {
     maxFeePerGas: string;
@@ -7,14 +9,14 @@ export interface RPCTransaction extends RPCBlockTransaction {
 export declare type TransactionResponse = Modify<RPCTransaction, {
     blockNumber: number;
     chainId: number;
-    nonce: number;
+    gas: TinyBig;
+    gasLimit: TinyBig;
+    gasPrice: TinyBig;
+    nonce: TinyBig;
     transactionIndex: number;
     type: number;
     v: number;
     value: TinyBig;
-    gasPrice: TinyBig;
-    gas: TinyBig;
-    gasLimit: TinyBig;
 } & {
     maxFeePerGas: TinyBig;
     maxPriorityFeePerGas: TinyBig;
@@ -22,6 +24,7 @@ export declare type TransactionResponse = Modify<RPCTransaction, {
 }>;
 /**
  * Type that contains information from the receipt of a transaction
+ *
  * * Similar to [`Type TransactionReceipt on ethers.providers`](https://docs.ethers.io/v5/api/providers/types/#providers-TransactionReceipt)
  */
 export declare type TransactionReceipt = Modify<RPCTransactionReceipt, {
@@ -37,11 +40,35 @@ export declare type TransactionReceipt = Modify<RPCTransactionReceipt, {
     byzantium: boolean;
     confirmations: number;
 }>;
+export interface RPCTransactionRequest {
+    from?: string;
+    to: string;
+    gas?: string;
+    gasPrice?: string;
+    value?: string;
+    data?: BytesLike;
+    nonce?: string;
+    maxPriorityFeePerGas?: string;
+    maxFeePerGas?: string;
+}
+export interface TransactionRequest {
+    to?: string;
+    from?: string;
+    nonce?: TinyBig | string | Big | number;
+    gas?: TinyBig | number | Big | string;
+    gasPrice?: TinyBig | Big | string | number;
+    data?: BytesLike;
+    value?: TinyBig | string | Big | number;
+    chainId?: number;
+    type?: number;
+    maxPriorityFeePerGas?: TinyBig | string | Big | number;
+    maxFeePerGas?: TinyBig | string | Big | number;
+}
 /**
  * Type for the logs that are included in transaction receipts
- * * Similar to [`Type Log on ethers.providers`](https://docs.ethers.io/v5/api/providers/types/#providers-Log)
+ * Similar to [`Type Log on ethers.providers`](https://docs.ethers.io/v5/api/providers/types/#providers-Log)
  */
-export declare type Log = Modify<Omit<RPCLog, 'removed'>, {
+export declare type Log = Modify<RPCLog, {
     blockNumber: number;
     logIndex: number;
     transactionIndex: number;

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

@@ -2,10 +2,8 @@ export declare type Bytes = ArrayLike<number>;
 /**
  * @example
  * [1,2,3]
- *
  * @example
  * 0x123
- *
  * @example
  * '0x123'
  */
@@ -36,22 +34,22 @@ export interface Signature {
 }
 /**
  * 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)
+ * 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
- * ```js
+ * ```javascript
  * isBytesLike([1,2,3]);
  * // true
  * ```
- *
  * @example
- * ```js
+ * ```javascript
  * isBytesLike(false);
  * // false
  * ```
- *
  * @example
- * ```js
+ * ```javascript
  * isBytesLike(new Uint8Array(1));
  * // true
  * ```
@@ -59,22 +57,22 @@ export interface Signature {
 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)
+ * 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
- * ```js
+ * ```javascript
  * isBytes([1,2,3]);
  * // true
  * ```
- *
  * @example
- * ```js
+ * ```javascript
  * isBytes(false);
  * // false
  * ```
- *
  * @example
- * ```js
+ * ```javascript
  * isBytes(new Uint8Array(1));
  * // true
  * ```
@@ -82,22 +80,23 @@ export declare function isBytesLike(value: any): value is BytesLike;
 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)
+ * 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
- * ```js
+ * ```javascript
  * arrayify(1);
  * // Uint8Array(1) [ 1 ]
  * ```
- *
  * @example
- * ```js
+ * ```javascript
  * arrayify(0x1234);
  * // Uint8Array(2) [ 18, 52 ]
  * ```
- *
  * @example
- * ```js
+ * ```javascript
  * arrayify('0x1', { hexPad: 'right' });
  * // Uint8Array(1) [ 16 ]
  * ```
@@ -105,38 +104,159 @@ export declare function isBytes(value: any): value is Bytes;
 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)
+ * 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
- * ```js
+ * ```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)
+ * 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
- * ```js
+ * ```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.
@@ -145,24 +265,21 @@ export declare function hexStripZeros(value: BytesLike): string;
  *
  * 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
- *
+ * @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);