essential-eth 0.5.4-alpha.0 → 0.5.6

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

@@ -0,0 +1,8 @@
+/**
+ * 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
+ */
+export declare function computeAddress(key: string): string;

package/lib/cjs/utils/compute-address.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeAddress = void 0;
+const __1 = require("..");
+const bytes_1 = require("./bytes");
+const keccak256_1 = require("./keccak256");
+/**
+ * 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
+ */
+function computeAddress(key) {
+    // compressed public keys start with 0x04
+    // uncompressed public keys start with 0x03 or 0x02
+    if (!key.startsWith('0x04') &&
+        !key.startsWith('0x03') &&
+        !key.startsWith('0x02')) {
+        key = (0, __1.computePublicKey)(key);
+    }
+    return (0, __1.toChecksumAddress)((0, bytes_1.hexDataSlice)((0, keccak256_1.keccak256)((0, bytes_1.hexDataSlice)(key, 1)), 12));
+}
+exports.computeAddress = computeAddress;

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

@@ -0,0 +1,9 @@
+import { BytesLike } from './bytes';
+/**
+ * Computes the public key from a given private key
+ *
+ * @param key the private key to find a public key from
+ *
+ * @returns the public key
+ */
+export declare function computePublicKey(privKey: BytesLike): string;

package/lib/cjs/utils/compute-public-key.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computePublicKey = void 0;
+const secp256k1_1 = require("@noble/secp256k1");
+const bytes_1 = require("./bytes");
+/**
+ * Computes the public key from a given private key
+ *
+ * @param key the private key to find a public key from
+ *
+ * @returns the public key
+ */
+function computePublicKey(privKey) {
+    privKey = (0, bytes_1.hexlify)(privKey).slice(2);
+    return '0x' + secp256k1_1.Point.fromPrivateKey(privKey).toHex();
+}
+exports.computePublicKey = computePublicKey;

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

@@ -0,0 +1,12 @@
+import { 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.
+ *
+ * @example
+ * ```js
+ * hashMessage("Hello World");
+ * // '0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2'
+ * ```
+ */
+export declare function hashMessage(message: Bytes | string): string;

package/lib/cjs/utils/hash-message.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashMessage = void 0;
+const index_1 = require("../index");
+const messagePrefix = '\x19Ethereum Signed Message:\n';
+/**
+ * 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.
+ *
+ * @example
+ * ```js
+ * hashMessage("Hello World");
+ * // '0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2'
+ * ```
+ */
+function hashMessage(message) {
+    if (typeof message === 'string') {
+        message = (0, index_1.toUtf8Bytes)(message);
+    }
+    return (0, index_1.keccak256)((0, index_1.concat)([
+        (0, index_1.toUtf8Bytes)(messagePrefix),
+        (0, index_1.toUtf8Bytes)(String(message.length)),
+        message,
+    ]));
+}
+exports.hashMessage = hashMessage;

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

@@ -0,0 +1,2 @@
+import { BytesLike } from './bytes';
+export declare const keccak256: (data: BytesLike) => string;

package/lib/cjs/utils/keccak256.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccak256 = void 0;
+const sha3_1 = require("sha3");
+const keccak256 = (data) => {
+    let bufferableData;
+    if (typeof data === 'string') {
+        bufferableData = Buffer.from(data.replace(/^0x/, ''), 'hex');
+    }
+    else {
+        bufferableData = Buffer.from(data);
+    }
+    const keccak = new sha3_1.Keccak(256);
+    const addressHash = '0x' + keccak.update(bufferableData).digest('hex');
+    return addressHash;
+};
+exports.keccak256 = keccak256;

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

@@ -1,5 +1,4 @@
 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.
  *

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

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.solidityKeccak256 = exports.hashKeccak256 = exports.pack = void 0;
+exports.solidityKeccak256 = exports.pack = void 0;
 const buffer_1 = require("buffer");
-const sha3_1 = require("sha3");
 const encode_decode_transaction_1 = require("../classes/utils/encode-decode-transaction");
 const logger_1 = require("../logger/logger");
 const tiny_big_1 = require("../shared/tiny-big/tiny-big");
 const bytes_1 = require("./bytes");
+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]*)\\]$');
@@ -85,13 +85,6 @@ function pack(types, values) {
     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.
  *
@@ -120,6 +113,6 @@ exports.hashKeccak256 = hashKeccak256;
  * ```
  */
 function solidityKeccak256(types, values) {
-    return (0, exports.hashKeccak256)(pack(types, values));
+    return (0, keccak256_1.keccak256)(pack(types, values));
 }
 exports.solidityKeccak256 = solidityKeccak256;

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

@@ -0,0 +1,26 @@
+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,165 @@
+"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-utf8-bytes.d.ts

@@ -0,0 +1 @@
+export declare function toUtf8Bytes(data: string): Uint8Array;

package/lib/cjs/utils/to-utf8-bytes.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toUtf8Bytes = void 0;
+function toUtf8Bytes(data) {
+    return new Uint8Array(Buffer.from(data));
+}
+exports.toUtf8Bytes = toUtf8Bytes;

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

@@ -28,7 +28,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-transaction-receipt.d.ts

@@ -0,0 +1,2 @@
+import { RPCTransactionReceipt, TransactionReceipt } from '../../types/Transaction.types';
+export declare function cleanTransactionReceipt(transactionReceipt: RPCTransactionReceipt): TransactionReceipt;

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

@@ -0,0 +1,48 @@
+import { tinyBig, toChecksumAddress } from '../..';
+import { cleanTransaction } from './clean-transaction';
+import { hexToDecimal } from './hex-to-decimal';
+export function cleanTransactionReceipt(transactionReceipt) {
+    const cleanedTransaction = cleanTransaction(transactionReceipt);
+    const cleanedTransactionReceipt = Object.assign({}, cleanedTransaction);
+    Object.keys(transactionReceipt).forEach((key) => {
+        if (!transactionReceipt[key])
+            return;
+        switch (key) {
+            case 'status':
+                cleanedTransactionReceipt[key] = Number(hexToDecimal(transactionReceipt[key]));
+                break;
+            case 'contractAddress':
+                if (transactionReceipt[key]) {
+                    cleanedTransactionReceipt[key] = toChecksumAddress(transactionReceipt[key]);
+                }
+                break;
+            case 'cumulativeGasUsed':
+            case 'effectiveGasPrice':
+            case 'gasUsed':
+                cleanedTransactionReceipt[key] = tinyBig(hexToDecimal(transactionReceipt[key]));
+                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.byzantium =
+        cleanedTransactionReceipt.blockNumber >= 4370000;
+    return cleanedTransactionReceipt;
+}

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_getTransactionCount';
+declare type RPCMethodName = 'eth_getBlockByNumber' | 'eth_getBlockByHash' | 'eth_call' | 'eth_chainId' | 'eth_gasPrice' | 'eth_getBalance' | 'eth_getTransactionByHash' | 'eth_getTransactionReceipt' | 'eth_getTransactionCount' | 'eth_blockNumber' | 'eth_estimateGas';
 export declare function buildRPCPostBody(method: RPCMethodName, params: unknown[]): {
     jsonrpc: string;
     id: number;

package/lib/esm/index.d.ts

@@ -1,17 +1,25 @@
-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 { Network } from './types/Network.types';
-import { TransactionResponse } from './types/Transaction.types';
+import { BlockTransactionResponse, Log, RPCLog, RPCTransaction, RPCTransactionReceipt, TransactionReceipt, 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';
+export * from './providers/types';
 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, 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, JSONABI, JSONABIArgument, Network, TransactionResponse, RPCBlock, RPCTransaction, RPCTransactionReceipt, TransactionReceipt, BlockTag, RPCLog, Log, BlockTransactionResponse, ConstructorOptions, };

package/lib/esm/index.js

@@ -1,13 +1,21 @@
-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';
+export * from './providers/types';
 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, 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-alpha.0";
+export declare const version = "0.5.6";

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

@@ -1 +1 @@
-export const version = '0.5.4-alpha.0';
+export const version = '0.5.6';

package/lib/esm/providers/BaseProvider.d.ts

@@ -1,7 +1,8 @@
 import { TinyBig } from '../shared/tiny-big/tiny-big';
 import { BlockResponse, BlockTag } from '../types/Block.types';
 import { Network } from '../types/Network.types';
-import { TransactionResponse } from '../types/Transaction.types';
+import { TransactionReceipt, TransactionResponse } from '../types/Transaction.types';
+import { TransactionRequest } from './types';
 export declare abstract class BaseProvider {
     abstract selectRpcUrl(): string;
     abstract post(body: Record<string, unknown>): Promise<any>;
@@ -9,9 +10,12 @@ export declare abstract class BaseProvider {
     protected _post: (body: Record<string, unknown>) => Promise<any>;
     constructor(rpcUrls: string[]);
     getNetwork(): Promise<Network>;
+    getBlockNumber(): Promise<number>;
     getTransaction(transactionHash: string): Promise<TransactionResponse>;
+    getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt>;
     getTransactionCount(address: string, blockTag?: BlockTag): Promise<number>;
     getBlock(timeFrame?: BlockTag, returnTransactionObjects?: boolean): Promise<BlockResponse>;
     getGasPrice(): Promise<TinyBig>;
     getBalance(address: string, blockTag?: BlockTag): Promise<TinyBig>;
+    estimateGas(transaction: TransactionRequest): Promise<TinyBig>;
 }

package/lib/esm/providers/BaseProvider.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { cleanBlock } from '../classes/utils/clean-block';
 import { cleanTransaction } from '../classes/utils/clean-transaction';
+import { cleanTransactionReceipt } from '../classes/utils/clean-transaction-receipt';
 import { buildRPCPostBody, post } from '../classes/utils/fetchers';
 import { hexToDecimal } from '../classes/utils/hex-to-decimal';
 import { tinyBig } from '../shared/tiny-big/tiny-big';
@@ -31,6 +32,12 @@ export class BaseProvider {
             };
         });
     }
+    getBlockNumber() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentBlockNumber = (yield this.post(buildRPCPostBody('eth_blockNumber', [])));
+            return Number(hexToDecimal(currentBlockNumber));
+        });
+    }
     getTransaction(transactionHash) {
         return __awaiter(this, void 0, void 0, function* () {
             const [rpcTransaction, blockNumber] = yield Promise.all([
@@ -43,6 +50,18 @@ export class BaseProvider {
             return cleanedTransaction;
         });
     }
+    getTransactionReceipt(transactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [rpcTransaction, blockNumber] = yield Promise.all([
+                this.post(buildRPCPostBody('eth_getTransactionReceipt', [transactionHash])),
+                this.getBlock('latest'),
+            ]);
+            const cleanedTransactionReceipt = cleanTransactionReceipt(rpcTransaction);
+            cleanedTransactionReceipt.confirmations =
+                blockNumber.number - cleanedTransactionReceipt.blockNumber + 1;
+            return cleanedTransactionReceipt;
+        });
+    }
     getTransactionCount(address, blockTag = 'latest') {
         return __awaiter(this, void 0, void 0, function* () {
             if (typeof blockTag === 'number') {
@@ -85,4 +104,11 @@ export class BaseProvider {
             return tinyBig(hexToDecimal(hexBalance));
         });
     }
+    estimateGas(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = buildRPCPostBody('eth_estimateGas', [transaction]);
+            const gasUsed = (yield this.post(body));
+            return tinyBig(hexToDecimal(gasUsed));
+        });
+    }
 }

package/lib/esm/providers/FallthroughProvider.d.ts

@@ -1,5 +1,5 @@
 import { BaseProvider } from './BaseProvider';
-interface ConstructorOptions {
+export interface ConstructorOptions {
     timeoutDuration?: number;
 }
 export declare class FallthroughProvider extends BaseProvider {
@@ -9,4 +9,3 @@ export declare class FallthroughProvider extends BaseProvider {
     constructor(rpcUrls: string[], options?: ConstructorOptions);
     post: (body: Record<string, unknown>) => Promise<any>;
 }
-export {};

package/lib/esm/providers/types.d.ts

@@ -0,0 +1,7 @@
+import { BytesLike } from '../utils/bytes';
+export interface TransactionRequest {
+    to?: string;
+    from?: string;
+    data?: BytesLike;
+    [key: string]: any;
+}

package/lib/esm/providers/types.js

@@ -0,0 +1 @@
+export {};