essential-eth 0.5.10 → 0.5.12

package/lib/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 → lib/esm}/providers/FallthroughProvider.d.ts

@@ -1,11 +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>;
-}
+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>;
+}

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/{dist → lib/esm}/providers/JsonRpcProvider.d.ts

@@ -1,7 +1,7 @@
-import { BaseProvider } from './BaseProvider';
-export declare class JsonRpcProvider extends BaseProvider {
-    selectRpcUrl(): string;
-    post(body: Record<string, unknown>): Promise<any>;
-    constructor(rpcUrl?: string);
-}
-export declare function jsonRpcProvider(rpcUrl?: string): JsonRpcProvider;
+import { BaseProvider } from './BaseProvider';
+export declare class JsonRpcProvider extends BaseProvider {
+    selectRpcUrl(): string;
+    post(body: Record<string, unknown>): Promise<any>;
+    constructor(rpcUrl?: string);
+}
+export declare function jsonRpcProvider(rpcUrl?: string): JsonRpcProvider;

package/lib/esm/providers/JsonRpcProvider.js

@@ -0,0 +1,15 @@
+import { BaseProvider } from './BaseProvider';
+export class JsonRpcProvider extends BaseProvider {
+    selectRpcUrl() {
+        return this._rpcUrls[0];
+    }
+    post(body) {
+        return this._post(body);
+    }
+    constructor(rpcUrl = 'https://free-eth-node.com/api/eth') {
+        super([rpcUrl]);
+    }
+}
+export function jsonRpcProvider(rpcUrl) {
+    return new JsonRpcProvider(rpcUrl);
+}

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

@@ -0,0 +1,11 @@
+export declare const fakeUrls: {
+    readonly notRPCButRealHttp: "https://httpstat.us/200";
+};
+export declare const rpcUrls: {
+    mainnet: string;
+    matic: string;
+    gno: string;
+    bnb: string;
+    arb1: string;
+    gor: string;
+};

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

@@ -0,0 +1,11 @@
+export const fakeUrls = {
+    notRPCButRealHttp: 'https://httpstat.us/200',
+};
+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`,
+    gor: `${process.env.RPC_ORIGIN}/api/gor`,
+};