@qevm/providers 1.0.2 → 1.0.3

package/src.ts/etherscan-provider.ts

@@ -1,454 +0,0 @@
-"use strict";
-
-import { BlockTag, TransactionRequest, TransactionResponse } from "@qevm/abstract-provider";
-import { hexlify, hexValue, isHexString } from "@qevm/bytes";
-import { Network, Networkish } from "@ethersproject/networks";
-import { deepCopy, defineReadOnly } from "@ethersproject/properties";
-import { accessListify } from "@qevm/transactions";
-import { ConnectionInfo, fetchJson } from "@qevm/web";
-
-import { showThrottleMessage } from "./formatter";
-
-import { Logger } from "@ethersproject/logger";
-import { version } from "./_version";
-const logger = new Logger(version);
-
-import { BaseProvider } from "./base-provider";
-
-
-// The transaction has already been sanitized by the calls in Provider
-function getTransactionPostData(transaction: TransactionRequest): Record<string, string> {
-    const result: Record<string, string> = { };
-    for (let key in transaction) {
-        if ((<any>transaction)[key] == null) { continue; }
-        let value = (<any>transaction)[key];
-        if (key === "type" && value === 0) { continue; }
-
-        // Quantity-types require no leading zero, unless 0
-        if ((<any>{ type: true, gasLimit: true, gasPrice: true, maxFeePerGs: true, maxPriorityFeePerGas: true, nonce: true, value: true })[key]) {
-            value = hexValue(hexlify(value));
-        } else if (key === "accessList") {
-            value = "[" + accessListify(value).map((set) => {
-                return `{address:"${ set.address }",storageKeys:["${ set.storageKeys.join('","') }"]}`;
-            }).join(",") + "]";
-        } else {
-            value = hexlify(value);
-        }
-        result[key] = value;
-    }
-    return result;
-}
-
-function getResult(result: { status?: number, message?: string, result?: any }): any {
-    // getLogs, getHistory have weird success responses
-    if (result.status == 0 && (result.message === "No records found" || result.message === "No transactions found")) {
-        return result.result;
-    }
-
-    if (result.status != 1 || typeof(result.message) !== "string" || !result.message.match(/^OK/)) {
-        const error: any = new Error("invalid response");
-        error.result = JSON.stringify(result);
-        if ((result.result || "").toLowerCase().indexOf("rate limit") >= 0) {
-            error.throttleRetry = true;
-        }
-        throw error;
-    }
-
-    return result.result;
-}
-
-function getJsonResult(result: { jsonrpc: string, result?: any, error?: { code?: number, data?: any, message?: string} } ): any {
-    // This response indicates we are being throttled
-    if (result && (<any>result).status == 0 && (<any>result).message == "NOTOK" && (result.result || "").toLowerCase().indexOf("rate limit") >= 0) {
-        const error: any = new Error("throttled response");
-        error.result = JSON.stringify(result);
-        error.throttleRetry = true;
-        throw error;
-    }
-
-    if (result.jsonrpc != "2.0") {
-        // @TODO: not any
-        const error: any = new Error("invalid response");
-        error.result = JSON.stringify(result);
-        throw error;
-    }
-
-    if (result.error) {
-        // @TODO: not any
-        const error: any = new Error(result.error.message || "unknown error");
-        if (result.error.code) { error.code = result.error.code; }
-        if (result.error.data) { error.data = result.error.data; }
-        throw error;
-    }
-
-    return result.result;
-}
-
-// The blockTag was normalized as a string by the Provider pre-perform operations
-function checkLogTag(blockTag: string): number | "latest" {
-    if (blockTag === "pending") { throw new Error("pending not supported"); }
-    if (blockTag === "latest") { return blockTag; }
-
-    return parseInt(blockTag.substring(2), 16);
-}
-
-
-function checkError(method: string, error: any, transaction: any): any {
-    // Undo the "convenience" some nodes are attempting to prevent backwards
-    // incompatibility; maybe for v6 consider forwarding reverts as errors
-    if (method === "call" && error.code === Logger.errors.SERVER_ERROR) {
-        const e = error.error;
-
-        // Etherscan keeps changing their string
-        if (e && (e.message.match(/reverted/i) || e.message.match(/VM execution error/i))) {
-            // Etherscan prefixes the data like "Reverted 0x1234"
-            let data = e.data;
-            if (data) { data = "0x" + data.replace(/^.*0x/i, ""); }
-
-            if (isHexString(data)) { return data; }
-
-            logger.throwError("missing revert data in call exception", Logger.errors.CALL_EXCEPTION, {
-                error, data: "0x"
-            });
-        }
-    }
-
-    // Get the message from any nested error structure
-    let message = error.message;
-    if (error.code === Logger.errors.SERVER_ERROR) {
-        if (error.error && typeof(error.error.message) === "string") {
-            message = error.error.message;
-        } else if (typeof(error.body) === "string") {
-            message = error.body;
-        } else if (typeof(error.responseText) === "string") {
-            message = error.responseText;
-        }
-    }
-    message = (message || "").toLowerCase();
-
-    // "Insufficient funds. The account you tried to send transaction from does not have enough funds. Required 21464000000000 and got: 0"
-    if (message.match(/insufficient funds/)) {
-        logger.throwError("insufficient funds for intrinsic transaction cost", Logger.errors.INSUFFICIENT_FUNDS, {
-           error, method, transaction
-        });
-    }
-
-    // "Transaction with the same hash was already imported."
-    if (message.match(/same hash was already imported|transaction nonce is too low|nonce too low/)) {
-        logger.throwError("nonce has already been used", Logger.errors.NONCE_EXPIRED, {
-           error, method, transaction
-        });
-    }
-
-    // "Transaction gas price is too low. There is another transaction with same nonce in the queue. Try increasing the gas price or incrementing the nonce."
-    if (message.match(/another transaction with same nonce/)) {
-         logger.throwError("replacement fee too low", Logger.errors.REPLACEMENT_UNDERPRICED, {
-            error, method, transaction
-         });
-    }
-
-    if (message.match(/execution failed due to an exception|execution reverted/)) {
-        logger.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
-            error, method, transaction
-        });
-    }
-
-    throw error;
-}
-
-export class EtherscanProvider extends BaseProvider{
-    readonly baseUrl: string;
-    readonly apiKey: string | null;
-
-    constructor(network?: Networkish, apiKey?: string) {
-        super(network);
-
-        defineReadOnly(this, "baseUrl", this.getBaseUrl());
-        defineReadOnly(this, "apiKey", apiKey || null);
-    }
-
-    getBaseUrl(): string {
-        switch(this.network ? this.network.name: "invalid") {
-            case "homestead":
-                return "https:/\/api.etherscan.io";
-            case "goerli":
-                return "https:/\/api-goerli.etherscan.io";
-            case "sepolia":
-                return "https:/\/api-sepolia.etherscan.io";
-            case "matic":
-                return "https:/\/api.polygonscan.com";
-            case "maticmum":
-                return "https:/\/api-testnet.polygonscan.com";
-            case "arbitrum":
-                return "https:/\/api.arbiscan.io";
-            case "arbitrum-goerli":
-                return "https:/\/api-goerli.arbiscan.io";
-            case "optimism":
-                return "https:/\/api-optimistic.etherscan.io";
-            case "optimism-goerli":
-                return "https:/\/api-goerli-optimistic.etherscan.io";
-            default:
-        }
-
-        return logger.throwArgumentError("unsupported network", "network", this.network.name);
-    }
-
-    getUrl(module: string, params: Record<string, string>): string {
-        const query = Object.keys(params).reduce((accum, key) => {
-            const value = params[key];
-            if (value != null) {
-                accum += `&${ key }=${ value }`
-            }
-            return accum
-        }, "");
-        const apiKey = ((this.apiKey) ? `&apikey=${ this.apiKey }`: "");
-        return `${ this.baseUrl }/api?module=${ module }${ query }${ apiKey }`;
-    }
-
-    getPostUrl(): string {
-        return `${ this.baseUrl }/api`;
-    }
-
-    getPostData(module: string, params: Record<string, any>): Record<string, any> {
-        params.module = module;
-        params.apikey = this.apiKey;
-        return params;
-    }
-
-    async fetch(module: string, params: Record<string, any>, post?: boolean): Promise<any> {
-        const url = (post ? this.getPostUrl(): this.getUrl(module, params));
-        const payload = (post ? this.getPostData(module, params): null);
-        const procFunc = (module === "proxy") ? getJsonResult: getResult;
-
-        this.emit("debug", {
-            action: "request",
-            request: url,
-            provider: this
-        });
-
-        const connection: ConnectionInfo = {
-            url: url,
-            throttleSlotInterval: 1000,
-            throttleCallback: (attempt: number, url: string) => {
-                if (this.isCommunityResource()) {
-                    showThrottleMessage();
-                }
-                return Promise.resolve(true);
-            }
-        };
-
-        let payloadStr: string = null;
-        if (payload) {
-            connection.headers = { "content-type": "application/x-www-form-urlencoded; charset=UTF-8" };
-            payloadStr = Object.keys(payload).map((key) => {
-                return `${ key }=${ payload[key] }`
-            }).join("&");
-        }
-
-        const result = await fetchJson(connection, payloadStr, procFunc || getJsonResult);
-
-        this.emit("debug", {
-            action: "response",
-            request: url,
-            response: deepCopy(result),
-            provider: this
-        });
-
-        return result;
-    }
-
-    async detectNetwork(): Promise<Network> {
-        return this.network;
-    }
-
-    async perform(method: string, params: any): Promise<any> {
-
-        switch (method) {
-            case "getBlockNumber":
-                return this.fetch("proxy", { action: "eth_blockNumber" });
-
-            case "getGasPrice":
-                return this.fetch("proxy", { action: "eth_gasPrice" });
-
-            case "getBalance":
-                // Returns base-10 result
-                return this.fetch("account", {
-                    action: "balance",
-                    address: params.address,
-                    tag: params.blockTag
-                });
-
-            case "getTransactionCount":
-                return this.fetch("proxy", {
-                    action: "eth_getTransactionCount",
-                    address: params.address,
-                    tag: params.blockTag
-                });
-
-            case "getCode":
-                return this.fetch("proxy", {
-                    action: "eth_getCode",
-                    address: params.address,
-                    tag: params.blockTag
-                });
-
-            case "getStorageAt":
-                return this.fetch("proxy", {
-                    action: "eth_getStorageAt",
-                    address: params.address,
-                    position: params.position,
-                    tag: params.blockTag
-                });
-
-            case "sendTransaction":
-                return this.fetch("proxy", {
-                    action: "eth_sendRawTransaction",
-                    hex: params.signedTransaction
-                }, true).catch((error) => {
-                    return checkError("sendTransaction", error, params.signedTransaction);
-                });
-
-            case "getBlock":
-                if (params.blockTag) {
-                    return this.fetch("proxy", {
-                        action: "eth_getBlockByNumber",
-                        tag: params.blockTag,
-                        boolean: (params.includeTransactions ? "true": "false")
-                    });
-                }
-                throw new Error("getBlock by blockHash not implemented");
-
-            case "getTransaction":
-                return this.fetch("proxy", {
-                    action: "eth_getTransactionByHash",
-                    txhash: params.transactionHash
-                });
-
-            case "getTransactionReceipt":
-                return this.fetch("proxy", {
-                    action: "eth_getTransactionReceipt",
-                    txhash: params.transactionHash
-                });
-
-            case "call": {
-                if (params.blockTag !== "latest") {
-                    throw new Error("EtherscanProvider does not support blockTag for call");
-                }
-
-                const postData = getTransactionPostData(params.transaction);
-                postData.module = "proxy";
-                postData.action = "eth_call";
-
-                try {
-                    return await this.fetch("proxy", postData, true);
-                } catch (error) {
-                    return checkError("call", error, params.transaction);
-                }
-            }
-
-            case "estimateGas": {
-                const postData = getTransactionPostData(params.transaction);
-                postData.module = "proxy";
-                postData.action = "eth_estimateGas";
-
-                try {
-                    return await this.fetch("proxy", postData, true);
-                } catch (error) {
-                    return checkError("estimateGas", error, params.transaction);
-                }
-            }
-
-            case "getLogs": {
-                const args: Record<string, any> = { action: "getLogs" }
-
-                if (params.filter.fromBlock) {
-                    args.fromBlock = checkLogTag(params.filter.fromBlock);
-                }
-
-                if (params.filter.toBlock) {
-                    args.toBlock = checkLogTag(params.filter.toBlock);
-                }
-
-                if (params.filter.address) {
-                    args.address = params.filter.address;
-                }
-
-                // @TODO: We can handle slightly more complicated logs using the logs API
-                if (params.filter.topics && params.filter.topics.length > 0) {
-                    if (params.filter.topics.length > 1) {
-                        logger.throwError("unsupported topic count", Logger.errors.UNSUPPORTED_OPERATION, { topics: params.filter.topics });
-                    }
-
-                    if (params.filter.topics.length === 1) {
-                        const topic0 = params.filter.topics[0];
-                        if (typeof(topic0) !== "string" || topic0.length !== 66) {
-                            logger.throwError("unsupported topic format", Logger.errors.UNSUPPORTED_OPERATION, { topic0: topic0 });
-                        }
-                        args.topic0 = topic0;
-                    }
-                }
-
-                const logs: Array<any> = await this.fetch("logs", args);
-
-                // Cache txHash => blockHash
-                let blocks: { [tag: string]: string } = {};
-
-                // Add any missing blockHash to the logs
-                for (let i = 0; i < logs.length; i++) {
-                    const log = logs[i];
-                    if (log.blockHash != null) { continue; }
-                    if (blocks[log.blockNumber] == null) {
-                        const block = await this.getBlock(log.blockNumber);
-                        if (block) {
-                            blocks[log.blockNumber] = block.hash;
-                        }
-                    }
-                    log.blockHash = blocks[log.blockNumber];
-                }
-
-                return logs;
-            }
-
-            case "getEtherPrice":
-                if (this.network.name !== "homestead") { return 0.0; }
-                return parseFloat((await this.fetch("stats", { action: "ethprice" })).ethusd);
-
-            default:
-                break;
-         }
-
-        return super.perform(method, params);
-    }
-
-    // Note: The `page` page parameter only allows pagination within the
-    //       10,000 window available without a page and offset parameter
-    //       Error: Result window is too large, PageNo x Offset size must
-    //              be less than or equal to 10000
-    async getHistory(addressOrName: string | Promise<string>, startBlock?: BlockTag, endBlock?: BlockTag): Promise<Array<TransactionResponse>> {
-        const params = {
-            action: "txlist",
-            address: (await this.resolveName(addressOrName)),
-            startblock: ((startBlock == null) ? 0: startBlock),
-            endblock: ((endBlock == null) ? 99999999: endBlock),
-            sort: "asc"
-        };
-
-        const result = await this.fetch("account", params);
-
-        return result.map((tx: any) => {
-            ["contractAddress", "to"].forEach(function(key) {
-                if (tx[key] == "") { delete tx[key]; }
-            });
-            if (tx.creates == null && tx.contractAddress != null) {
-                tx.creates = tx.contractAddress;
-            }
-            const item = this.formatter.transactionResponse(tx);
-            if (tx.timeStamp) { item.timestamp = parseInt(tx.timeStamp); }
-            return item;
-        });
-    }
-
-    isCommunityResource(): boolean {
-        return (this.apiKey == null);
-    }
-}

package/src.ts/infura-provider.ts

@@ -1,143 +0,0 @@
-"use strict";
-
-import { Network, Networkish } from "@ethersproject/networks";
-import { defineReadOnly } from "@ethersproject/properties";
-import { ConnectionInfo } from "@qevm/web";
-
-import { WebSocketProvider } from "./websocket-provider";
-import { CommunityResourcable, showThrottleMessage } from "./formatter";
-
-import { Logger } from "@ethersproject/logger";
-import { version } from "./_version";
-const logger = new Logger(version);
-
-import { UrlJsonRpcProvider } from "./url-json-rpc-provider";
-
-
-const defaultProjectId = "84842078b09946638c03157f83405213"
-
-export class InfuraWebSocketProvider extends WebSocketProvider implements CommunityResourcable {
-    readonly apiKey: string;
-    readonly projectId: string;
-    readonly projectSecret: string;
-
-    constructor(network?: Networkish, apiKey?: any) {
-        const provider = new InfuraProvider(network, apiKey);
-        const connection = provider.connection;
-        if (connection.password) {
-            logger.throwError("INFURA WebSocket project secrets unsupported", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "InfuraProvider.getWebSocketProvider()"
-            });
-        }
-
-        const url = connection.url.replace(/^http/i, "ws").replace("/v3/", "/ws/v3/");
-        super(url, network);
-
-        defineReadOnly(this, "apiKey", provider.projectId);
-        defineReadOnly(this, "projectId", provider.projectId);
-        defineReadOnly(this, "projectSecret", provider.projectSecret);
-    }
-
-    isCommunityResource(): boolean {
-        return (this.projectId === defaultProjectId);
-    }
-}
-
-export class InfuraProvider extends UrlJsonRpcProvider {
-    readonly projectId: string;
-    readonly projectSecret: string;
-
-    static getWebSocketProvider(network?: Networkish, apiKey?: any): InfuraWebSocketProvider {
-        return new InfuraWebSocketProvider(network, apiKey);
-    }
-
-    static getApiKey(apiKey: any): any {
-        const apiKeyObj: { apiKey: string, projectId: string, projectSecret: string } = {
-            apiKey: defaultProjectId,
-            projectId: defaultProjectId,
-            projectSecret: null
-        };
-
-        if (apiKey == null) { return apiKeyObj; }
-
-        if (typeof(apiKey) === "string") {
-            apiKeyObj.projectId = apiKey;
-
-        } else if (apiKey.projectSecret != null) {
-            logger.assertArgument((typeof(apiKey.projectId) === "string"),
-                "projectSecret requires a projectId", "projectId", apiKey.projectId);
-            logger.assertArgument((typeof(apiKey.projectSecret) === "string"),
-                "invalid projectSecret", "projectSecret", "[REDACTED]");
-
-            apiKeyObj.projectId = apiKey.projectId;
-            apiKeyObj.projectSecret = apiKey.projectSecret;
-
-        } else if (apiKey.projectId) {
-            apiKeyObj.projectId = apiKey.projectId;
-        }
-
-        apiKeyObj.apiKey = apiKeyObj.projectId;
-
-        return apiKeyObj;
-    }
-
-    static getUrl(network: Network, apiKey: any): ConnectionInfo {
-        let host: string = null;
-        switch(network ? network.name: "unknown") {
-            case "homestead":
-                host = "mainnet.infura.io";
-                break;
-            case "goerli":
-                host = "goerli.infura.io";
-                break;
-            case "sepolia":
-                host = "sepolia.infura.io";
-                break;
-            case "matic":
-                host = "polygon-mainnet.infura.io";
-                break;
-            case "maticmum":
-                host = "polygon-mumbai.infura.io";
-                break;
-            case "optimism":
-                host = "optimism-mainnet.infura.io";
-                break;
-            case "optimism-goerli":
-                host = "optimism-goerli.infura.io";
-                break;
-            case "arbitrum":
-                host = "arbitrum-mainnet.infura.io";
-                break;
-            case "arbitrum-goerli":
-                host = "arbitrum-goerli.infura.io";
-                break;
-            default:
-                logger.throwError("unsupported network", Logger.errors.INVALID_ARGUMENT, {
-                    argument: "network",
-                    value: network
-                });
-        }
-
-        const connection: ConnectionInfo = {
-            allowGzip: true,
-            url: ("https:/" + "/" + host + "/v3/" + apiKey.projectId),
-            throttleCallback: (attempt: number, url: string) => {
-                if (apiKey.projectId === defaultProjectId) {
-                    showThrottleMessage();
-                }
-                return Promise.resolve(true);
-            }
-        };
-
-        if (apiKey.projectSecret != null) {
-            connection.user = "";
-            connection.password = apiKey.projectSecret
-        }
-
-        return connection;
-    }
-
-    isCommunityResource(): boolean {
-        return (this.projectId === defaultProjectId);
-    }
-}

package/src.ts/nodesmith-provider.ts

@@ -1,50 +0,0 @@
-/* istanbul ignore file */
-
-"use strict";
-
-import { Network } from "@ethersproject/networks";
-import { UrlJsonRpcProvider } from "./url-json-rpc-provider";
-
-import { Logger } from "@ethersproject/logger";
-import { version } from "./_version";
-const logger = new Logger(version);
-
-// Special API key provided by Nodesmith for ethers.js
-const defaultApiKey = "ETHERS_JS_SHARED";
-
-export class NodesmithProvider extends UrlJsonRpcProvider {
-
-    static getApiKey(apiKey: any): any {
-        if (apiKey && typeof(apiKey) !== "string") {
-            logger.throwArgumentError("invalid apiKey", "apiKey", apiKey);
-        }
-        return apiKey || defaultApiKey;
-    }
-
-    static getUrl(network: Network, apiKey?: any): string {
-        logger.warn("NodeSmith will be discontinued on 2019-12-20; please migrate to another platform.");
-
-        let host = null;
-        switch (network.name) {
-            case "homestead":
-                host = "https://ethereum.api.nodesmith.io/v1/mainnet/jsonrpc";
-                break;
-            case "ropsten":
-                host = "https://ethereum.api.nodesmith.io/v1/ropsten/jsonrpc";
-                break;
-            case "rinkeby":
-                host = "https://ethereum.api.nodesmith.io/v1/rinkeby/jsonrpc";
-                break;
-            case "goerli":
-                host = "https://ethereum.api.nodesmith.io/v1/goerli/jsonrpc";
-                break;
-            case "kovan":
-                host = "https://ethereum.api.nodesmith.io/v1/kovan/jsonrpc";
-                break;
-            default:
-               logger.throwArgumentError("unsupported network", "network", arguments[0]);
-        }
-
-        return (host + "?apiKey=" + apiKey);
-    }
-}