essential-eth 0.5.4 → 0.5.9

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

@@ -1,15 +1,26 @@
+/**
+ * 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
- *
+ * @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'];
@@ -17,7 +28,6 @@ export declare function pack(types: ReadonlyArray<string>, values: ReadonlyArray
  * solidityKeccak256(types, values);
  * // '0xe4d4c8e809faac09d58f468f0aeab9474fe8965d554c6c0f868c433c3fd6acab'
  * ```
- *
  * @example
  * ```javascript
  * const types = ['bytes4', 'uint32[5]'];

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

@@ -10,6 +10,16 @@ const keccak256_1 = require("./keccak256");
 const regexBytes = new RegExp('^bytes([0-9]+)$');
 const regexNumber = new RegExp('^(u?int)([0-9]*)$');
 const regexArray = new RegExp('^(.*)\\[([0-9]*)\\]$');
+/**
+ * Packs a type and value together into a UTF-8 Byte Array
+ *
+ * @internal
+ * @param type the Solidity type used for the value given
+ * @param value the value to pack with its type
+ * @param isArray whether the specified data is in an array
+ * @returns packed data consisting of the type and value
+ * @example N/A - internal function
+ */
 function _pack(type, value, isArray) {
     switch (type) {
         case 'address':
@@ -74,6 +84,20 @@ function _pack(type, value, isArray) {
     }
     return logger_1.logger.throwArgumentError('invalid type', 'type', type);
 }
+/**
+ * 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'
+ * ```
+ */
 function pack(types, values) {
     if (types.length != values.length) {
         logger_1.logger.throwArgumentError('wrong number of values; expected ${ types.length }', 'values', values);
@@ -90,12 +114,9 @@ exports.pack = pack;
  *
  * 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
- *
+ * @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'];
@@ -103,7 +124,6 @@ exports.pack = pack;
  * solidityKeccak256(types, values);
  * // '0xe4d4c8e809faac09d58f468f0aeab9474fe8965d554c6c0f868c433c3fd6acab'
  * ```
- *
  * @example
  * ```javascript
  * const types = ['bytes4', 'uint32[5]'];

package/lib/cjs/utils/split-signature.d.ts

@@ -0,0 +1,24 @@
+import { 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/split-signature.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSignature = void 0;
+const logger_1 = require("./../logger/logger");
+const bytes_1 = require("./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"
+ *  }
+ * ```
+ */
+function splitSignature(signature) {
+    const result = {
+        r: '0x',
+        s: '0x',
+        _vs: '0x',
+        recoveryParam: 0,
+        v: 0,
+        yParityAndS: '0x',
+        compact: '0x',
+    };
+    if ((0, bytes_1.isBytesLike)(signature)) {
+        const bytes = (0, bytes_1.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 = (0, bytes_1.hexlify)(bytes.slice(0, 32));
+            result.s = (0, bytes_1.hexlify)(bytes.slice(32, 64));
+        }
+        else if (bytes.length === 65) {
+            result.r = (0, bytes_1.hexlify)(bytes.slice(0, 32));
+            result.s = (0, bytes_1.hexlify)(bytes.slice(32, 64));
+            result.v = bytes[64];
+        }
+        else {
+            logger_1.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_1.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 = (0, bytes_1.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_1 = (0, bytes_1.zeroPad)((0, bytes_1.arrayify)(result._vs), 32);
+            result._vs = (0, bytes_1.hexlify)(vs_1);
+            // Set or check the recid
+            const recoveryParam = vs_1[0] >= 128 ? 1 : 0;
+            if (result.recoveryParam == null) {
+                result.recoveryParam = recoveryParam;
+            }
+            else if (result.recoveryParam !== recoveryParam) {
+                logger_1.logger.throwArgumentError('signature recoveryParam mismatch _vs', 'signature', signature);
+            }
+            // Set or check the s
+            vs_1[0] &= 0x7f;
+            const s = (0, bytes_1.hexlify)(vs_1);
+            if (result.s == null) {
+                result.s = s;
+            }
+            else if (result.s !== s) {
+                logger_1.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_1.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_1.logger.throwArgumentError('signature recoveryParam mismatch v', 'signature', signature);
+                }
+            }
+        }
+        if (result.r == null || !(0, bytes_1.isHexString)(result.r)) {
+            logger_1.logger.throwArgumentError('signature missing or invalid r', 'signature', signature);
+        }
+        else {
+            result.r = (0, bytes_1.hexZeroPad)(result.r, 32);
+        }
+        if (result.s == null || !(0, bytes_1.isHexString)(result.s)) {
+            logger_1.logger.throwArgumentError('signature missing or invalid s', 'signature', signature);
+        }
+        else {
+            result.s = (0, bytes_1.hexZeroPad)(result.s, 32);
+        }
+        const vs = (0, bytes_1.arrayify)(result.s);
+        if (vs[0] >= 128) {
+            logger_1.logger.throwArgumentError('signature s out of range', 'signature', signature);
+        }
+        if (result.recoveryParam) {
+            vs[0] |= 0x80;
+        }
+        const _vs = (0, bytes_1.hexlify)(vs);
+        if (result._vs) {
+            if (!(0, bytes_1.isHexString)(result._vs)) {
+                logger_1.logger.throwArgumentError('signature invalid _vs', 'signature', signature);
+            }
+            result._vs = (0, bytes_1.hexZeroPad)(result._vs, 32);
+        }
+        // Set or check the _vs
+        if (result._vs == null) {
+            result._vs = _vs;
+        }
+        else if (result._vs !== _vs) {
+            logger_1.logger.throwArgumentError('signature _vs mismatch v and s', 'signature', signature);
+        }
+    }
+    result.yParityAndS = result._vs;
+    result.compact = result.r + result.yParityAndS.substring(2);
+    return result;
+}
+exports.splitSignature = splitSignature;

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

@@ -2,8 +2,8 @@
  * 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
- *
+ * @param address An Ethereum address. Mixed, lower, and uppercase are all valid
+ * @returns a valid checksum address
  * @example
  * ```javascript
  * toChecksumAddress('0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359');

package/lib/cjs/utils/to-checksum-address.js

@@ -7,8 +7,8 @@ const validate_type_1 = require("../shared/validate-type");
  * 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
- *
+ * @param address An Ethereum address. Mixed, lower, and uppercase are all valid
+ * @returns a valid checksum address
  * @example
  * ```javascript
  * toChecksumAddress('0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359');

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

@@ -1 +1,15 @@
+/**
+ * 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/to-utf8-bytes.js

@@ -1,6 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toUtf8Bytes = void 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 }
+ * ```
+ */
 function toUtf8Bytes(data) {
     return new Uint8Array(Buffer.from(data));
 }

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

@@ -7,6 +7,8 @@ import { TinyBig } from '../shared/tiny-big/tiny-big';
  *
  * 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()
@@ -14,7 +16,6 @@ import { TinyBig } from '../shared/tiny-big/tiny-big';
  * weiToEther(1000000000000000000000).toString()
  * // '1000'
  * ```
- *
  * @example
  * ```javascript
  * weiToEther('1000000000000000000000').toNumber()

package/lib/cjs/utils/wei-to-ether.js

@@ -10,6 +10,8 @@ const validate_type_1 = require("../shared/validate-type");
  *
  * 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()
@@ -17,7 +19,6 @@ const validate_type_1 = require("../shared/validate-type");
  * weiToEther(1000000000000000000000).toString()
  * // '1000'
  * ```
- *
  * @example
  * ```javascript
  * weiToEther('1000000000000000000000').toNumber()
@@ -28,7 +29,17 @@ const validate_type_1 = require("../shared/validate-type");
  */
 function weiToEther(weiQuantity) {
     (0, validate_type_1.validateType)(weiQuantity, ['string', 'number', 'object']);
-    const result = (0, tiny_big_1.tinyBig)(weiQuantity).div('1000000000000000000');
-    return (0, tiny_big_1.tinyBig)(result);
+    // eslint-disable-next-line no-useless-catch
+    try {
+        let _weiQuantity = weiQuantity;
+        if (typeof weiQuantity === 'string' && weiQuantity.slice(0, 2) === '0x') {
+            _weiQuantity = BigInt(weiQuantity).toString();
+        }
+        const result = (0, tiny_big_1.tinyBig)(_weiQuantity).div('1000000000000000000');
+        return (0, tiny_big_1.tinyBig)(result);
+    }
+    catch (error) {
+        throw error;
+    }
 }
 exports.weiToEther = weiToEther;

package/lib/esm/classes/utils/clean-block.js

@@ -1,4 +1,5 @@
 import { toChecksumAddress } from '../..';
+import { tinyBig } from '../../shared/tiny-big/tiny-big';
 import { cleanTransaction } from './clean-transaction';
 import { hexToDecimal } from './hex-to-decimal';
 export function cleanBlock(block, returnTransactionObjects) {
@@ -7,22 +8,20 @@ export function cleanBlock(block, returnTransactionObjects) {
         if (!block[key])
             return;
         switch (key) {
+            case 'difficulty':
+            case 'totalDifficulty':
             case 'gasLimit':
             case 'gasUsed':
-            case 'number':
             case 'size':
             case 'timestamp':
             case 'baseFeePerGas':
-                cleanedBlock[key] = Number(hexToDecimal(block[key]));
+                cleanedBlock[key] = tinyBig(hexToDecimal(block[key]));
                 break;
-            case 'difficulty':
-            case 'totalDifficulty':
-                cleanedBlock[key] = hexToDecimal(block[key]);
+            case 'number':
+                cleanedBlock[key] = Number(hexToDecimal(block[key]));
                 break;
             case 'miner':
-                if (block[key]) {
-                    cleanedBlock[key] = toChecksumAddress(block[key]);
-                }
+                cleanedBlock[key] = toChecksumAddress(block[key]);
                 break;
         }
     });

package/lib/esm/classes/utils/clean-log.d.ts

@@ -0,0 +1,2 @@
+import { Log, RPCLog } from './../../types/Transaction.types';
+export declare function cleanLog(log: RPCLog, receiptLog: boolean): Log;

package/lib/esm/classes/utils/clean-log.js

@@ -0,0 +1,26 @@
+import { toChecksumAddress } from '../../utils/to-checksum-address';
+import { hexToDecimal } from './hex-to-decimal';
+export function cleanLog(log, receiptLog) {
+    const cleanedLog = Object.assign({}, log);
+    Object.keys(log).forEach((key) => {
+        switch (key) {
+            case 'address':
+                cleanedLog[key] = toChecksumAddress(log[key]);
+                break;
+            case 'blockNumber':
+            case 'logIndex':
+            case 'transactionIndex':
+                cleanedLog[key] = Number(hexToDecimal(log[key]));
+                break;
+            case 'removed':
+                if (receiptLog) {
+                    delete cleanedLog[key];
+                }
+                else if (log[key] == null) {
+                    cleanedLog[key] === false;
+                }
+                break;
+        }
+    });
+    return cleanedLog;
+}

package/lib/esm/classes/utils/clean-transaction-receipt.js

@@ -1,4 +1,5 @@
 import { tinyBig, toChecksumAddress } from '../..';
+import { cleanLog } from './clean-log';
 import { cleanTransaction } from './clean-transaction';
 import { hexToDecimal } from './hex-to-decimal';
 export function cleanTransactionReceipt(transactionReceipt) {
@@ -23,22 +24,7 @@ export function cleanTransactionReceipt(transactionReceipt) {
                 break;
             case 'logs':
                 transactionReceipt[key].forEach((log, index) => {
-                    Object.keys(log).forEach((logKey) => {
-                        switch (logKey) {
-                            case 'address':
-                                cleanedTransactionReceipt[key][index][logKey] =
-                                    toChecksumAddress(log[logKey]);
-                                break;
-                            case 'blockNumber':
-                            case 'logIndex':
-                            case 'transactionIndex':
-                                cleanedTransactionReceipt[key][index][logKey] = Number(hexToDecimal(log[logKey]));
-                                break;
-                            case 'removed':
-                                delete log[logKey];
-                                break;
-                        }
-                    });
+                    cleanedTransactionReceipt[key][index] = cleanLog(log, true);
                 });
         }
     });

package/lib/esm/classes/utils/clean-transaction.js

@@ -8,7 +8,6 @@ export function cleanTransaction(transaction) {
         switch (key) {
             case 'blockNumber':
             case 'chainId':
-            case 'nonce':
             case 'transactionIndex':
             case 'type':
             case 'v':
@@ -25,6 +24,7 @@ export function cleanTransaction(transaction) {
             case 'gasPrice':
             case 'maxFeePerGas':
             case 'maxPriorityFeePerGas':
+            case 'nonce':
                 cleanedTransaction[key] = tinyBig(hexToDecimal(transaction[key]));
                 break;
         }

package/lib/esm/classes/utils/fetchers.d.ts

@@ -1,5 +1,5 @@
 export declare function post(url: string, body: Record<string, unknown>): Promise<any>;
-declare type RPCMethodName = 'eth_getBlockByNumber' | 'eth_getBlockByHash' | 'eth_call' | 'eth_chainId' | 'eth_gasPrice' | 'eth_getBalance' | 'eth_getTransactionByHash' | 'eth_getTransactionReceipt' | 'eth_getTransactionCount';
+declare type RPCMethodName = 'eth_getBlockByNumber' | 'eth_getBlockByHash' | 'eth_call' | 'eth_chainId' | 'eth_gasPrice' | 'eth_getBalance' | 'eth_getTransactionByHash' | 'eth_getTransactionReceipt' | 'eth_getTransactionCount' | 'eth_getCode' | 'eth_blockNumber' | 'eth_estimateGas' | 'eth_getLogs';
 export declare function buildRPCPostBody(method: RPCMethodName, params: unknown[]): {
     jsonrpc: string;
     id: number;

package/lib/esm/classes/utils/prepare-transaction.d.ts

@@ -0,0 +1,2 @@
+import { RPCTransactionRequest, TransactionRequest } from './../../types/Transaction.types';
+export declare function prepareTransaction(transaction: TransactionRequest): RPCTransactionRequest;

package/lib/esm/classes/utils/prepare-transaction.js

@@ -0,0 +1,34 @@
+import Big from 'big.js';
+import { TinyBig } from '../../shared/tiny-big/tiny-big';
+import { hexlify } from '../../utils/bytes';
+export function prepareTransaction(transaction) {
+    const preparedTransaction = Object.assign({}, transaction);
+    Object.keys(transaction).forEach((key) => {
+        switch (key) {
+            case 'gas':
+            case 'gasPrice':
+            case 'nonce':
+            case 'maxFeePerGas':
+            case 'maxPriorityFeePerGas':
+            case 'value': {
+                const value = transaction[key];
+                if (value instanceof TinyBig) {
+                    preparedTransaction[key] = value.toHexString();
+                }
+                else if (value instanceof Big) {
+                    preparedTransaction[key] = `0x${BigInt(value.toString()).toString(16)}`;
+                }
+                else if (typeof transaction[key] === 'number')
+                    preparedTransaction[key] =
+                        '0x' + transaction[key].toString(16);
+                else
+                    preparedTransaction[key] = transaction[key].toString();
+                break;
+            }
+            case 'data':
+                preparedTransaction[key] = hexlify(transaction[key]);
+                break;
+        }
+    });
+    return preparedTransaction;
+}

package/lib/esm/index.d.ts

@@ -1,15 +1,20 @@
-import { Contract } from './classes/Contract';
-import { FallthroughProvider } from './providers/FallthroughProvider';
+import { BaseContract, Contract } from './classes/Contract';
+import { ConstructorOptions, FallthroughProvider } from './providers/FallthroughProvider';
 import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
-import { BlockResponse } from './types/Block.types';
+import { BlockResponse, BlockTag, RPCBlock } from './types/Block.types';
 import { ContractTypes, JSONABI, JSONABIArgument } from './types/Contract.types';
+import { Filter, FilterByBlockHash } from './types/Filter.types';
 import { Network } from './types/Network.types';
-import { TransactionResponse } from './types/Transaction.types';
+import { BlockTransactionResponse, Log, RPCLog, RPCTransaction, RPCTransactionReceipt, RPCTransactionRequest, TransactionReceipt, TransactionRequest, TransactionResponse } from './types/Transaction.types';
+import { computeAddress } from './utils/compute-address';
+import { computePublicKey } from './utils/compute-public-key';
 import { etherToGwei } from './utils/ether-to-gwei';
 import { etherToWei } from './utils/ether-to-wei';
 import { gweiToEther } from './utils/gwei-to-ether';
+import { hashMessage } from './utils/hash-message';
 import { isAddress } from './utils/is-address';
+import { splitSignature } from './utils/split-signature';
 import { toChecksumAddress } from './utils/to-checksum-address';
 import { toUtf8Bytes } from './utils/to-utf8-bytes';
 import { weiToEther } from './utils/wei-to-ether';
@@ -17,4 +22,4 @@ export * from './utils/bytes';
 export * from './utils/hash-message';
 export * from './utils/keccak256';
 export * from './utils/solidity-keccak256';
-export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, FallthroughProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, toUtf8Bytes, Contract, TinyBig, BlockResponse, ContractTypes, JSONABI, JSONABIArgument, Network, TransactionResponse, };
+export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, FallthroughProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, hashMessage, splitSignature, toUtf8Bytes, computeAddress, computePublicKey, Contract, TinyBig, BaseContract, BlockResponse, ContractTypes, Filter, FilterByBlockHash, JSONABI, JSONABIArgument, Network, TransactionResponse, RPCBlock, RPCTransaction, RPCTransactionReceipt, TransactionRequest, RPCTransactionRequest, TransactionReceipt, BlockTag, RPCLog, Log, BlockTransactionResponse, ConstructorOptions, };

package/lib/esm/index.js

@@ -1,11 +1,15 @@
-import { Contract } from './classes/Contract';
-import { FallthroughProvider } from './providers/FallthroughProvider';
+import { BaseContract, Contract } from './classes/Contract';
+import { FallthroughProvider, } from './providers/FallthroughProvider';
 import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
+import { computeAddress } from './utils/compute-address';
+import { computePublicKey } from './utils/compute-public-key';
 import { etherToGwei } from './utils/ether-to-gwei';
 import { etherToWei } from './utils/ether-to-wei';
 import { gweiToEther } from './utils/gwei-to-ether';
+import { hashMessage } from './utils/hash-message';
 import { isAddress } from './utils/is-address';
+import { splitSignature } from './utils/split-signature';
 import { toChecksumAddress } from './utils/to-checksum-address';
 import { toUtf8Bytes } from './utils/to-utf8-bytes';
 import { weiToEther } from './utils/wei-to-ether';
@@ -13,4 +17,4 @@ export * from './utils/bytes';
 export * from './utils/hash-message';
 export * from './utils/keccak256';
 export * from './utils/solidity-keccak256';
-export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, FallthroughProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, toUtf8Bytes, Contract, TinyBig, };
+export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, FallthroughProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, hashMessage, splitSignature, toUtf8Bytes, computeAddress, computePublicKey, Contract, TinyBig, BaseContract, };

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

@@ -1 +1 @@
-export declare const version = "0.5.4";
+export declare const version = "0.5.9";

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

@@ -1 +1 @@
-export const version = '0.5.4';
+export const version = '0.5.9';