essential-eth 0.5.0 → 0.5.4

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solidityKeccak256 = exports.pack = void 0;
+const buffer_1 = require("buffer");
+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]*)\\]$');
+function _pack(type, value, isArray) {
+    switch (type) {
+        case 'address':
+            if (isArray) {
+                return (0, bytes_1.zeroPad)(value, 32);
+            }
+            return (0, bytes_1.arrayify)(value);
+        case 'string':
+            return buffer_1.Buffer.from(value);
+        case 'bytes':
+            return (0, bytes_1.arrayify)(value);
+        case 'bool':
+            value = value ? '0x01' : '0x00';
+            if (isArray) {
+                return (0, bytes_1.zeroPad)(value, 32);
+            }
+            return (0, bytes_1.arrayify)(value);
+    }
+    let match = type.match(regexNumber);
+    if (match) {
+        //let signed = (match[1] === "int")
+        let size = parseInt(match[2] || '256');
+        if ((match[2] && String(size) !== match[2]) ||
+            size % 8 !== 0 ||
+            size === 0 ||
+            size > 256) {
+            logger_1.logger.throwArgumentError('invalid number type', 'type', type);
+        }
+        if (isArray) {
+            size = 256;
+        }
+        value = (0, tiny_big_1.tinyBig)(value).toTwos(size).toNumber();
+        const hexValue = (0, bytes_1.hexlify)(value);
+        return (0, bytes_1.zeroPad)(hexValue, size / 8);
+    }
+    match = type.match(regexBytes);
+    if (match) {
+        const size = parseInt(match[1]);
+        if (String(size) !== match[1] || size === 0 || size > 32) {
+            logger_1.logger.throwArgumentError('invalid bytes type', 'type', type);
+        }
+        if ((0, bytes_1.arrayify)(value).byteLength !== size) {
+            logger_1.logger.throwArgumentError(`invalid value for ${type}`, 'value', value);
+        }
+        if (isArray) {
+            return (0, bytes_1.arrayify)((value + encode_decode_transaction_1.hexFalse).substring(0, 66));
+        }
+        return value;
+    }
+    match = type.match(regexArray);
+    if (match && Array.isArray(value)) {
+        const baseType = match[1];
+        const count = parseInt(match[2] || String(value.length));
+        if (count != value.length) {
+            logger_1.logger.throwArgumentError(`invalid array length for ${type}`, 'value', value);
+        }
+        const result = [];
+        value.forEach(function (value) {
+            result.push(_pack(baseType, value, true));
+        });
+        return (0, bytes_1.concat)(result);
+    }
+    return logger_1.logger.throwArgumentError('invalid type', 'type', type);
+}
+function pack(types, values) {
+    if (types.length != values.length) {
+        logger_1.logger.throwArgumentError('wrong number of values; expected ${ types.length }', 'values', values);
+    }
+    const tight = [];
+    types.forEach(function (type, index) {
+        tight.push(_pack(type, values[index]));
+    });
+    return (0, bytes_1.hexlify)((0, bytes_1.concat)(tight));
+}
+exports.pack = pack;
+/**
+ * Hashes data from Solidity using the Keccak256 algorithm.
+ *
+ * Similar to ["solidityKeccak256" in ethers.js](https://docs.ethers.io/v5/api/utils/hashing/#utils-solidityKeccak256)
+ *
+ * @param types - Each [Solidity type](https://docs.soliditylang.org/en/v0.8.13/types.html) corresponding to the values passed in. Helps the function parse and pack data properly.
+ *
+ * @param values - Data to be concatenated (combined) and then hashed.
+ *
+ * @returns - A Keccak256 hash (hex string) based on the values provided
+ *
+ * @example
+ * ```javascript
+ * const types = ['string', 'bool', 'uint32'];
+ * const values = ['essential-eth is great', true, 14];
+ * solidityKeccak256(types, values);
+ * // '0xe4d4c8e809faac09d58f468f0aeab9474fe8965d554c6c0f868c433c3fd6acab'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * const types = ['bytes4', 'uint32[5]'];
+ * const values = [[116, 101, 115, 116], [5, 3, 4, 9, 18]];
+ * solidityKeccak256(types, values);
+ * // '0x038707a887f09355dc545412b058e7ba8f3c74047050c7c5e5e52eec608053d9'
+ * ```
+ */
+function solidityKeccak256(types, values) {
+    return (0, keccak256_1.keccak256)(pack(types, values));
+}
+exports.solidityKeccak256 = solidityKeccak256;

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/esm/classes/Contract.js

@@ -40,7 +40,7 @@ export class BaseContract {
                             ? estimateGas(data)
                             : null;
                     const req = () => __awaiter(this, void 0, void 0, function* () {
-                        return yield post(this._provider._rpcUrl, buildRPCPostBody('eth_call', [
+                        return yield post(this._provider.selectRpcUrl(), buildRPCPostBody('eth_call', [
                             Object.assign({ to: this._address.toLowerCase(), data }, (decimalGas
                                 ? { gas: `0x${decimalGas.toString(16)}` }
                                 : {})),

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/encode-decode-transaction.d.ts

@@ -1,3 +1,4 @@
 import { 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/lib/esm/classes/utils/encode-decode-transaction.js

@@ -1,8 +1,8 @@
 import { Keccak } from 'sha3';
 import { tinyBig, toChecksumAddress } from '../..';
 import { hexToDecimal } from './hex-to-decimal';
-const hexTrue = '0000000000000000000000000000000000000000000000000000000000000001';
-const hexFalse = '0000000000000000000000000000000000000000000000000000000000000000';
+export const hexFalse = '0'.repeat(64);
+const hexTrue = '0'.repeat(63) + '1';
 function expandType(type) {
     if (type === 'uint[]') {
         return 'uint256[]';

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

package/lib/esm/index.d.ts

@@ -1,4 +1,5 @@
 import { 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 { BlockResponse } from './types/Block.types';
@@ -8,8 +9,12 @@ import { TransactionResponse } from './types/Transaction.types';
 import { etherToGwei } from './utils/ether-to-gwei';
 import { etherToWei } from './utils/ether-to-wei';
 import { gweiToEther } from './utils/gwei-to-ether';
-import { hexZeroPad } from './utils/hex-zero-pad';
 import { isAddress } from './utils/is-address';
 import { toChecksumAddress } from './utils/to-checksum-address';
+import { toUtf8Bytes } from './utils/to-utf8-bytes';
 import { weiToEther } from './utils/wei-to-ether';
-export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, hexZeroPad, Contract, TinyBig, BlockResponse, ContractTypes, JSONABI, JSONABIArgument, Network, TransactionResponse, };
+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, };

package/lib/esm/index.js

@@ -1,11 +1,16 @@
 import { 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 { etherToGwei } from './utils/ether-to-gwei';
 import { etherToWei } from './utils/ether-to-wei';
 import { gweiToEther } from './utils/gwei-to-ether';
-import { hexZeroPad } from './utils/hex-zero-pad';
 import { isAddress } from './utils/is-address';
 import { toChecksumAddress } from './utils/to-checksum-address';
+import { toUtf8Bytes } from './utils/to-utf8-bytes';
 import { weiToEther } from './utils/wei-to-ether';
-export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, hexZeroPad, Contract, TinyBig, };
+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, };

package/lib/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/lib/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/lib/esm/logger/package-version.d.ts

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

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

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

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

@@ -0,0 +1,18 @@
+import { TinyBig } from '../shared/tiny-big/tiny-big';
+import { BlockResponse, BlockTag } from '../types/Block.types';
+import { Network } from '../types/Network.types';
+import { TransactionReceipt, 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>;
+    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>;
+}

package/lib/esm/providers/BaseProvider.js

@@ -0,0 +1,101 @@
+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 { 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';
+import chainsInfo from './utils/chains-info';
+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,
+            };
+        });
+    }
+    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* () {
+            if (typeof blockTag === 'number') {
+                blockTag = `0x${blockTag.toString(16)}`;
+            }
+            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 rpcTimeFrame;
+            let type = 'Number';
+            if (typeof timeFrame === 'number') {
+                rpcTimeFrame = `0x${timeFrame.toString(16)}`;
+            }
+            else if (timeFrame.startsWith('0x')) {
+                rpcTimeFrame = timeFrame;
+                type = 'Hash';
+            }
+            else {
+                rpcTimeFrame = timeFrame;
+            }
+            const rpcBlock = (yield this.post(buildRPCPostBody(`eth_getBlockBy${type}`, [
+                rpcTimeFrame,
+                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* () {
+            const hexBalance = (yield this.post(buildRPCPostBody('eth_getBalance', [address, blockTag])));
+            return tinyBig(hexToDecimal(hexBalance));
+        });
+    }
+}

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

@@ -0,0 +1,12 @@
+import { BaseProvider } from './BaseProvider';
+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>;
+}
+export {};

package/lib/esm/providers/FallthroughProvider.js

@@ -0,0 +1,41 @@
+import { logger } from '../logger/logger';
+import { BaseProvider } from './BaseProvider';
+const promiseTimeout = (prom, time) => Promise.race([
+    prom,
+    new Promise((_r, reject) => setTimeout(() => reject('Promise timed out'), time)),
+]);
+const DEFAULT_TIMEOUT_DURATION = 8000;
+export class FallthroughProvider extends BaseProvider {
+    constructor(rpcUrls, options = {}) {
+        if (!Array.isArray(rpcUrls)) {
+            logger.throwError('Array required', { rpcUrls });
+        }
+        if (rpcUrls.length <= 1) {
+            logger.throwError('More than one rpcUrl is required', { rpcUrls });
+        }
+        super(rpcUrls);
+        this.rpcUrlCounter = 0;
+        this.post = (body) => {
+            const genesisCount = this.rpcUrlCounter;
+            const recursivePostRetry = () => {
+                const genesisRpcUrl = this.selectRpcUrl();
+                const res = promiseTimeout(this._post(body), this.timeoutDuration).catch((e) => {
+                    if (genesisRpcUrl === this.selectRpcUrl()) {
+                        this.rpcUrlCounter =
+                            (this.rpcUrlCounter + 1) % this._rpcUrls.length;
+                    }
+                    if (this.rpcUrlCounter === genesisCount) {
+                        throw e;
+                    }
+                    return recursivePostRetry();
+                });
+                return res;
+            };
+            return recursivePostRetry();
+        };
+        this.timeoutDuration = options.timeoutDuration || DEFAULT_TIMEOUT_DURATION;
+    }
+    selectRpcUrl() {
+        return this._rpcUrls[this.rpcUrlCounter];
+    }
+}

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

@@ -1,15 +1,7 @@
-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';
-export declare class JsonRpcProvider {
-    readonly _rpcUrl: string;
-    private post;
+import { BaseProvider } from './BaseProvider';
+export declare class JsonRpcProvider extends BaseProvider {
+    selectRpcUrl(): string;
+    post(body: Record<string, unknown>): Promise<any>;
     constructor(rpcUrl?: string);
-    getBlock(timeFrame: BlockTag, returnTransactionObjects?: boolean): Promise<BlockResponse>;
-    getNetwork(): Promise<Network>;
-    getGasPrice(): Promise<TinyBig>;
-    getBalance(address: string, blockTag?: BlockTag): Promise<TinyBig>;
-    getTransaction(hash: string): Promise<TransactionResponse>;
 }
 export declare function jsonRpcProvider(rpcUrl?: string): JsonRpcProvider;

package/lib/esm/providers/JsonRpcProvider.js

@@ -1,74 +1,13 @@
-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 { cleanTransaction } from '../classes/utils/clean-transaction';
-import { buildRPCPostBody, post } from '../classes/utils/fetchers';
-import { hexToDecimal } from '../classes/utils/hex-to-decimal';
-import { tinyBig } from '../shared/tiny-big/tiny-big';
-import chainsInfo from './utils/chains-info';
-export class JsonRpcProvider {
-    constructor(rpcUrl) {
-        this.post = (body) => post(this._rpcUrl, body);
-        this._rpcUrl = rpcUrl || 'https://free-eth-node.com/api/eth';
+import { BaseProvider } from './BaseProvider';
+export class JsonRpcProvider extends BaseProvider {
+    selectRpcUrl() {
+        return this._rpcUrls[0];
     }
-    getBlock(timeFrame, returnTransactionObjects = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let rpcTimeFrame;
-            if (typeof timeFrame === 'number') {
-                rpcTimeFrame = `0x${timeFrame.toString(16)}`;
-            }
-            else {
-                rpcTimeFrame = timeFrame;
-            }
-            const rpcBlock = (yield this.post(buildRPCPostBody('eth_getBlockByNumber', [
-                rpcTimeFrame,
-                returnTransactionObjects,
-            ])));
-            return cleanBlock(rpcBlock, returnTransactionObjects);
-        });
+    post(body) {
+        return this._post(body);
     }
-    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,
-            };
-        });
-    }
-    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* () {
-            const hexBalance = (yield this.post(buildRPCPostBody('eth_getBalance', [address, blockTag])));
-            return tinyBig(hexToDecimal(hexBalance));
-        });
-    }
-    getTransaction(hash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [rpcTransaction, blockNumber] = yield Promise.all([
-                this.post(buildRPCPostBody('eth_getTransactionByHash', [hash])),
-                this.getBlock('latest'),
-            ]);
-            const cleanedTransaction = cleanTransaction(rpcTransaction);
-            cleanedTransaction.confirmations =
-                blockNumber.number - cleanedTransaction.blockNumber + 1;
-            return cleanedTransaction;
-        });
+    constructor(rpcUrl = 'https://free-eth-node.com/api/eth') {
+        super([rpcUrl]);
     }
 }
 export function jsonRpcProvider(rpcUrl) {

package/lib/esm/providers/test/rpc-urls.d.ts

@@ -3,6 +3,7 @@ export declare const fakeUrls: {
 };
 export declare const rpcUrls: {
     mainnet: string;
+    matic: string;
     gno: string;
     bnb: string;
     arb1: string;

package/lib/esm/providers/test/rpc-urls.js

@@ -3,6 +3,7 @@ export const fakeUrls = {
 };
 export const rpcUrls = {
     mainnet: `${process.env.RPC_ORIGIN}/api/eth`,
+    matic: `${process.env.RPC_ORIGIN}/api/MATIC`,
     gno: `${process.env.RPC_ORIGIN}/api/gno`,
     bnb: `${process.env.RPC_ORIGIN}/api/bnb`,
     arb1: `${process.env.RPC_ORIGIN}/api/arb1`,