essential-eth 0.5.11-next.0 → 0.5.13-next.0

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

@@ -0,0 +1,35 @@
+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) {
+    const cleanedBlock = Object.assign({}, block);
+    Object.keys(block).forEach((key) => {
+        if (!block[key])
+            return;
+        switch (key) {
+            case 'difficulty':
+            case 'totalDifficulty':
+            case 'gasLimit':
+            case 'gasUsed':
+            case 'size':
+            case 'timestamp':
+            case 'baseFeePerGas':
+                cleanedBlock[key] = tinyBig(hexToDecimal(block[key]));
+                break;
+            case 'number':
+                cleanedBlock[key] = Number(hexToDecimal(block[key]));
+                break;
+            case 'miner':
+                cleanedBlock[key] = toChecksumAddress(block[key]);
+                break;
+        }
+    });
+    if (returnTransactionObjects) {
+        const txns = block.transactions;
+        txns.forEach((transaction, index) => {
+            cleanedBlock.transactions[index] = cleanTransaction(transaction);
+        });
+    }
+    return cleanedBlock;
+}

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

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

package/dist/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/dist/esm/classes/utils/clean-transaction-receipt.d.ts

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

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

@@ -0,0 +1,34 @@
+import { tinyBig, toChecksumAddress } from '../..';
+import { cleanLog } from './clean-log';
+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) => {
+                    cleanedTransactionReceipt[key][index] = cleanLog(log, true);
+                });
+        }
+    });
+    cleanedTransactionReceipt.byzantium =
+        cleanedTransactionReceipt.blockNumber >= 4370000;
+    return cleanedTransactionReceipt;
+}

package/dist/esm/classes/utils/clean-transaction.d.ts

@@ -0,0 +1,2 @@
+import type { RPCTransaction, TransactionResponse } from '../../types/Transaction.types';
+export declare function cleanTransaction(transaction: RPCTransaction): TransactionResponse;

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

@@ -0,0 +1,33 @@
+import { tinyBig, toChecksumAddress } from '../..';
+import { hexToDecimal } from './hex-to-decimal';
+export function cleanTransaction(transaction) {
+    const cleanedTransaction = Object.assign({}, transaction);
+    Object.keys(transaction).forEach((key) => {
+        if (!transaction[key])
+            return;
+        switch (key) {
+            case 'blockNumber':
+            case 'chainId':
+            case 'transactionIndex':
+            case 'type':
+            case 'v':
+                cleanedTransaction[key] = Number(hexToDecimal(transaction[key]));
+                break;
+            case 'from':
+            case 'to':
+                if (transaction[key]) {
+                    cleanedTransaction[key] = toChecksumAddress(transaction[key]);
+                }
+                break;
+            case 'value':
+            case 'gas':
+            case 'gasPrice':
+            case 'maxFeePerGas':
+            case 'maxPriorityFeePerGas':
+            case 'nonce':
+                cleanedTransaction[key] = tinyBig(hexToDecimal(transaction[key]));
+                break;
+        }
+    });
+    return cleanedTransaction;
+}

package/dist/esm/classes/utils/encode-decode-transaction.d.ts

@@ -0,0 +1,4 @@
+import type { JSONABIArgument } from '../../types/Contract.types';
+export declare const hexFalse: string;
+export declare function encodeData(jsonABIArgument: JSONABIArgument, args: any[]): string;
+export declare function decodeRPCResponse(jsonABIArgument: JSONABIArgument, nodeResponse: string): string | number | boolean | import("../..").TinyBig | (string | number | boolean | import("../..").TinyBig)[];

package/dist/esm/classes/utils/encode-decode-transaction.js

@@ -0,0 +1,98 @@
+import { Keccak } from 'sha3';
+import { tinyBig, toChecksumAddress } from '../..';
+import { hexToDecimal } from './hex-to-decimal';
+export const hexFalse = '0'.repeat(64);
+const hexTrue = '0'.repeat(63) + '1';
+function expandType(type) {
+    if (type === 'uint[]') {
+        return 'uint256[]';
+    }
+    else if (type === 'int[]') {
+        return 'int256[]';
+    }
+    return type;
+}
+export function encodeData(jsonABIArgument, args) {
+    const hash = new Keccak(256);
+    const functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map((input) => expandType(input.type))})`;
+    const functionHash = hash.update(functionString).digest('hex');
+    const jsonABIInputsLength = jsonABIArgument.inputs.length;
+    let shouldValidateInputLength = true;
+    if (jsonABIArgument.inputs.find((input) => input.type.includes('['))) {
+        shouldValidateInputLength = false;
+    }
+    if (shouldValidateInputLength && args.length !== jsonABIInputsLength) {
+        throw new Error(`args inputs  of "${args.length}" does not match expected length of "${jsonABIArgument.inputs.length}"`);
+    }
+    const argsWithTypes = (jsonABIArgument.inputs || []).reduce((acc, input, i) => {
+        var _a;
+        if (input.type.includes('[')) {
+            const basicType = (_a = /([^[]*)\[.*$/g.exec(input.type)) === null || _a === void 0 ? void 0 : _a[1];
+            args.forEach((arg) => {
+                acc = acc.concat([[arg, basicType]]);
+            });
+            return acc;
+        }
+        else {
+            return acc.concat([[args[i], input.type]]);
+        }
+    }, []);
+    const encodedArgs = argsWithTypes.map(([arg, inputType]) => {
+        let rawArg = arg;
+        switch (inputType) {
+            case 'bool':
+                return arg ? hexTrue : hexFalse;
+            case 'address':
+                rawArg = arg.replace(/^0x/g, '').toLowerCase();
+                break;
+            default:
+                if (inputType.startsWith('bytes')) {
+                    const argEncoded = rawArg
+                        .split('')
+                        .map((character) => character.charCodeAt(0).toString(16))
+                        .join('');
+                    const paddedEncodedArg = argEncoded.padEnd(64, '0');
+                    return paddedEncodedArg;
+                }
+                else if (inputType === 'uint256') {
+                    const argEncoded = BigInt(arg).toString(16);
+                    const paddedEncodedArg = argEncoded.padStart(64, '0');
+                    return paddedEncodedArg;
+                }
+                else if (inputType.startsWith('uint')) {
+                    break;
+                }
+                else {
+                    throw new Error(`essential-eth does not yet support "${inputType}" inputs. Make a PR today!"`);
+                }
+        }
+        const argEncoded = rawArg.toString(16);
+        const paddedEncodedArg = argEncoded.padStart(64, '0');
+        return paddedEncodedArg;
+    });
+    const functionEncoded = functionHash.slice(0, 8);
+    const data = `0x${functionEncoded}${encodedArgs.join('')}`;
+    return data;
+}
+export function decodeRPCResponse(jsonABIArgument, nodeResponse) {
+    const rawOutputs = jsonABIArgument.outputs;
+    const encodedOutputs = nodeResponse.slice(2).match(/.{1,64}/g);
+    const outputs = (encodedOutputs || []).map((output, i) => {
+        const outputType = (rawOutputs || [])[i].type;
+        switch (outputType) {
+            case 'bool':
+                return output === hexTrue;
+            case 'address':
+                return toChecksumAddress(`0x${output.slice(24)}`);
+            case 'uint256':
+                return tinyBig(hexToDecimal(`0x${output}`));
+            case 'bytes32':
+                return `0x${output}`;
+            case 'uint8':
+                return Number(hexToDecimal(`0x${output}`));
+            default:
+                throw new Error(`essential-eth does not yet support "${outputType}" outputs. Make a PR today!"`);
+        }
+    });
+    return outputs.length === 1 ? outputs[0] : outputs;
+}

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

@@ -0,0 +1,9 @@
+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' | 'eth_getCode' | 'eth_blockNumber' | 'eth_estimateGas' | 'eth_getLogs';
+export declare function buildRPCPostBody(method: RPCMethodName, params: unknown[]): {
+    jsonrpc: string;
+    id: number;
+    method: RPCMethodName;
+    params: unknown[];
+};
+export {};

package/dist/esm/classes/utils/fetchers.js

@@ -0,0 +1,43 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import unfetch from 'isomorphic-unfetch';
+export function post(url, body) {
+    return unfetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    })
+        .then((r) => __awaiter(this, void 0, void 0, function* () {
+        const t = yield r.text();
+        try {
+            return JSON.parse(t);
+        }
+        catch (_a) {
+            throw new Error(`Invalid JSON RPC response: "${t}"`);
+        }
+    }))
+        .then((response) => {
+        const result = response === null || response === void 0 ? void 0 : response.result;
+        if (!result) {
+            throw new Error(`Invalid JSON RPC response: ${JSON.stringify(response)}`);
+        }
+        return response.result;
+    });
+}
+export function buildRPCPostBody(method, params) {
+    return {
+        jsonrpc: '2.0',
+        id: 1,
+        method,
+        params,
+    };
+}

package/dist/esm/classes/utils/hex-to-decimal.d.ts

@@ -0,0 +1 @@
+export declare function hexToDecimal(hex: string): string;

package/dist/esm/classes/utils/hex-to-decimal.js

@@ -0,0 +1,3 @@
+export function hexToDecimal(hex) {
+    return BigInt(hex).toString();
+}

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

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

package/dist/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/dist/esm/index.d.ts

@@ -0,0 +1,25 @@
+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, 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 { 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';
+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, 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/dist/esm/index.js

@@ -0,0 +1,20 @@
+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 './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, hashMessage, splitSignature, toUtf8Bytes, computeAddress, computePublicKey, Contract, TinyBig, BaseContract, };

package/dist/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 {};

package/dist/esm/logger/logger.js

@@ -0,0 +1,33 @@
+import { version } from './package-version';
+class Logger {
+    constructor() {
+        this.packageVersion = version;
+    }
+    throwError(message, args) {
+        const argsLength = Object.keys(args).length;
+        throw new Error(`${message} (${Object.entries(args).map(([key, value], index) => `${key}=${value}${index < argsLength - 1 && ', '}`)}, version=essential-eth@${this.packageVersion})`);
+    }
+    throwArgumentError(message, arg, value) {
+        throw new Error(`${message} (argument="${arg}" value=${value}, version=essential-eth@${this.packageVersion})`);
+    }
+    checkSafeUint53(value, message = 'value not safe') {
+        if (typeof value !== 'number') {
+            return;
+        }
+        if (value < 0 || value >= 0x1fffffffffffff) {
+            this.throwError(message, {
+                operation: 'checkSafeInteger',
+                fault: 'out-of-safe-range',
+                value: value,
+            });
+        }
+        if (value % 1) {
+            this.throwError(message, {
+                operation: 'checkSafeInteger',
+                fault: 'non-integer',
+                value: value,
+            });
+        }
+    }
+}
+export const logger = new Logger();

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

@@ -0,0 +1 @@
+export declare const version = "0.5.13-next.0";

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

@@ -0,0 +1 @@
+export const version = '0.5.13-next.0';

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

@@ -0,0 +1,24 @@
+import type { TinyBig } from '../shared/tiny-big/tiny-big';
+import type { BlockResponse, BlockTag } from '../types/Block.types';
+import type { Filter, FilterByBlockHash } from '../types/Filter.types';
+import type { Network } from '../types/Network.types';
+import type { Log, TransactionReceipt, TransactionRequest, TransactionResponse } from '../types/Transaction.types';
+export declare abstract class BaseProvider {
+    abstract selectRpcUrl(): string;
+    abstract post(body: Record<string, unknown>): Promise<any>;
+    readonly _rpcUrls: string[];
+    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>;
+    getCode(address: string, blockTag?: BlockTag): Promise<string>;
+    estimateGas(transaction: TransactionRequest): Promise<TinyBig>;
+    getLogs(filter: Filter | FilterByBlockHash): Promise<Array<Log>>;
+    call(transaction: TransactionRequest, blockTag?: BlockTag): Promise<string>;
+}

package/dist/esm/providers/BaseProvider.js

@@ -0,0 +1,157 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { cleanBlock } from '../classes/utils/clean-block';
+import { cleanLog } from '../classes/utils/clean-log';
+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 { prepareTransaction } from '../classes/utils/prepare-transaction';
+import { logger } from '../logger/logger';
+import { tinyBig } from '../shared/tiny-big/tiny-big';
+import chainsInfo from './utils/chains-info';
+function prepBlockTag(blockTag) {
+    return typeof blockTag === 'number'
+        ? tinyBig(blockTag).toHexString()
+        : blockTag;
+}
+export class BaseProvider {
+    constructor(rpcUrls) {
+        this._rpcUrls = [];
+        this._post = (body) => post(this.selectRpcUrl(), body);
+        this._rpcUrls = rpcUrls;
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hexChainId = (yield this.post(buildRPCPostBody('eth_chainId', [])));
+            const chainId = hexToDecimal(hexChainId);
+            const info = chainsInfo[chainId];
+            return {
+                chainId: Number(chainId),
+                name: info[0] || 'unknown',
+                ensAddress: info[1] || null,
+            };
+        });
+    }
+    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([
+                this.post(buildRPCPostBody('eth_getTransactionByHash', [transactionHash])),
+                this.getBlock('latest'),
+            ]);
+            const cleanedTransaction = cleanTransaction(rpcTransaction);
+            cleanedTransaction.confirmations =
+                blockNumber.number - cleanedTransaction.blockNumber + 1;
+            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* () {
+            blockTag = prepBlockTag(blockTag);
+            const transactionCount = (yield this.post(buildRPCPostBody('eth_getTransactionCount', [address, blockTag])));
+            return Number(hexToDecimal(transactionCount));
+        });
+    }
+    getBlock(timeFrame = 'latest', returnTransactionObjects = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let type = 'Number';
+            if (typeof timeFrame === 'string' && timeFrame.length === 66) {
+                type = 'Hash';
+            }
+            else {
+                timeFrame = prepBlockTag(timeFrame);
+            }
+            const rpcBlock = (yield this.post(buildRPCPostBody(`eth_getBlockBy${type}`, [
+                timeFrame,
+                returnTransactionObjects,
+            ])));
+            return cleanBlock(rpcBlock, returnTransactionObjects);
+        });
+    }
+    getGasPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hexGasPrice = (yield this.post(buildRPCPostBody('eth_gasPrice', [])));
+            return tinyBig(hexToDecimal(hexGasPrice));
+        });
+    }
+    getBalance(address, blockTag = 'latest') {
+        return __awaiter(this, void 0, void 0, function* () {
+            blockTag = prepBlockTag(blockTag);
+            const hexBalance = (yield this.post(buildRPCPostBody('eth_getBalance', [address, blockTag])));
+            return tinyBig(hexToDecimal(hexBalance));
+        });
+    }
+    getCode(address, blockTag = 'latest') {
+        return __awaiter(this, void 0, void 0, function* () {
+            blockTag = prepBlockTag(blockTag);
+            const contractCode = (yield this.post(buildRPCPostBody('eth_getCode', [address, blockTag])));
+            return contractCode;
+        });
+    }
+    estimateGas(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rpcTransaction = prepareTransaction(transaction);
+            const gasUsed = (yield this.post(buildRPCPostBody('eth_estimateGas', [rpcTransaction])));
+            return tinyBig(hexToDecimal(gasUsed));
+        });
+    }
+    getLogs(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filterByRange = filter;
+            if (filterByRange.fromBlock)
+                filterByRange.fromBlock = prepBlockTag(filterByRange.fromBlock);
+            if (filterByRange.toBlock)
+                filterByRange.toBlock = prepBlockTag(filterByRange.toBlock);
+            const rpcLogs = (yield this.post(buildRPCPostBody('eth_getLogs', [filter])));
+            const logs = rpcLogs.map((log) => cleanLog(log, false));
+            return logs;
+        });
+    }
+    call(transaction, blockTag = 'latest') {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (transaction.gasPrice &&
+                (transaction.maxPriorityFeePerGas || transaction.maxFeePerGas)) {
+                logger.throwError('Cannot specify both "gasPrice" and ("maxPriorityFeePerGas" or "maxFeePerGas")', {
+                    gasPrice: transaction.gasPrice,
+                    maxFeePerGas: transaction.maxFeePerGas,
+                    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+                });
+            }
+            if (transaction.maxFeePerGas && transaction.maxPriorityFeePerGas) {
+                logger.throwError('Cannot specify both "maxFeePerGas" and "maxPriorityFeePerGas"', {
+                    maxFeePerGas: transaction.maxFeePerGas,
+                    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+                });
+            }
+            blockTag = prepBlockTag(blockTag);
+            const rpcTransaction = prepareTransaction(transaction);
+            const transactionRes = (yield this.post(buildRPCPostBody('eth_call', [rpcTransaction, blockTag])));
+            return transactionRes;
+        });
+    }
+}

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

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