@qevm/providers 1.0.1

package/src.ts/nodesmith-provider.ts

@@ -0,0 +1,50 @@
+/* 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);
+    }
+}

package/src.ts/pocket-provider.ts

@@ -0,0 +1,93 @@
+"use strict";
+
+import { Network } from "@ethersproject/networks";
+import { ConnectionInfo } from "@ethersproject/web";
+
+import { Logger } from "@ethersproject/logger";
+import { version } from "./_version";
+const logger = new Logger(version);
+
+import { UrlJsonRpcProvider } from "./url-json-rpc-provider";
+
+const defaultApplicationId = "62e1ad51b37b8e00394bda3b";
+
+
+export class PocketProvider extends UrlJsonRpcProvider {
+    readonly applicationId: string;
+    readonly applicationSecretKey: string;
+    readonly loadBalancer: boolean;
+
+    static getApiKey(apiKey: any): any {
+        const apiKeyObj: { applicationId: string, applicationSecretKey: string, loadBalancer: boolean } = {
+            applicationId: null,
+            loadBalancer: true,
+            applicationSecretKey: null
+        };
+
+        // Parse applicationId and applicationSecretKey
+        if (apiKey == null) {
+            apiKeyObj.applicationId = defaultApplicationId;
+
+        } else if (typeof (apiKey) === "string") {
+            apiKeyObj.applicationId = apiKey;
+
+        } else if (apiKey.applicationSecretKey != null) {
+            apiKeyObj.applicationId = apiKey.applicationId;
+            apiKeyObj.applicationSecretKey = apiKey.applicationSecretKey;
+
+        } else if (apiKey.applicationId) {
+            apiKeyObj.applicationId = apiKey.applicationId;
+
+        } else {
+            logger.throwArgumentError("unsupported PocketProvider apiKey", "apiKey", apiKey);
+        }
+
+        return apiKeyObj;
+    }
+
+    static getUrl(network: Network, apiKey: any): ConnectionInfo {
+        let host: string = null;
+        switch (network ? network.name : "unknown") {
+            case "goerli":
+                host = "eth-goerli.gateway.pokt.network";
+                break;
+            case "homestead":
+                host = "eth-mainnet.gateway.pokt.network";
+                break;
+            case "kovan":
+                host = "poa-kovan.gateway.pokt.network";
+                break;
+            case "matic":
+                host = "poly-mainnet.gateway.pokt.network";
+                break;
+            case "maticmum":
+                host = "polygon-mumbai-rpc.gateway.pokt.network";
+                break;
+            case "rinkeby":
+                host = "eth-rinkeby.gateway.pokt.network";
+                break;
+            case "ropsten":
+                host = "eth-ropsten.gateway.pokt.network";
+                break;
+            default:
+                logger.throwError("unsupported network", Logger.errors.INVALID_ARGUMENT, {
+                    argument: "network",
+                    value: network
+                });
+        }
+
+        const url = `https:/\/${ host }/v1/lb/${ apiKey.applicationId }`
+
+        const connection: ConnectionInfo = { headers: { }, url };
+        if (apiKey.applicationSecretKey != null) {
+            connection.user = "";
+            connection.password = apiKey.applicationSecretKey
+        }
+
+        return connection;
+    }
+
+    isCommunityResource(): boolean {
+        return (this.applicationId === defaultApplicationId);
+    }
+}

package/src.ts/url-json-rpc-provider.ts

@@ -0,0 +1,106 @@
+
+"use strict";
+
+import { Network, Networkish } from "@ethersproject/networks";
+import { defineReadOnly, getStatic } from "@ethersproject/properties";
+import { ConnectionInfo } from "@ethersproject/web";
+
+import { Logger } from "@ethersproject/logger";
+import { version } from "./_version";
+const logger = new Logger(version);
+
+import { CommunityResourcable } from "./formatter";
+import { JsonRpcProvider, JsonRpcSigner } from "./json-rpc-provider";
+
+type getUrlFunc = (network: Network, apiKey: string) => string | ConnectionInfo;
+
+// A StaticJsonRpcProvider is useful when you *know* for certain that
+// the backend will never change, as it never calls eth_chainId to
+// verify its backend. However, if the backend does change, the effects
+// are undefined and may include:
+// - inconsistent results
+// - locking up the UI
+// - block skew warnings
+// - wrong results
+// If the network is not explicit (i.e. auto-detection is expected), the
+// node MUST be running and available to respond to requests BEFORE this
+// is instantiated.
+export class StaticJsonRpcProvider extends JsonRpcProvider {
+    async detectNetwork(): Promise<Network> {
+        let network = this.network;
+        if (network == null) {
+            network = await super.detectNetwork();
+
+            if (!network) {
+                logger.throwError("no network detected", Logger.errors.UNKNOWN_ERROR, { });
+            }
+
+            // If still not set, set it
+            if (this._network == null) {
+                // A static network does not support "any"
+                defineReadOnly(this, "_network", network);
+
+                this.emit("network", network, null);
+            }
+        }
+        return network;
+    }
+}
+
+export abstract class UrlJsonRpcProvider extends StaticJsonRpcProvider implements CommunityResourcable {
+    readonly apiKey: any;
+
+    constructor(network?: Networkish, apiKey?: any) {
+        logger.checkAbstract(new.target, UrlJsonRpcProvider);
+
+        // Normalize the Network and API Key
+        network = getStatic<(network: Networkish) => Network>(new.target, "getNetwork")(network);
+        apiKey = getStatic<(apiKey: string) => string>(new.target, "getApiKey")(apiKey);
+
+        const connection = getStatic<getUrlFunc>(new.target, "getUrl")(network, apiKey);
+
+        super(connection, network);
+
+        if (typeof(apiKey) === "string") {
+            defineReadOnly(this, "apiKey", apiKey);
+        } else if (apiKey != null) {
+            Object.keys(apiKey).forEach((key) => {
+                defineReadOnly<any, any>(this, key, apiKey[key]);
+            });
+        }
+    }
+
+    _startPending(): void {
+        logger.warn("WARNING: API provider does not support pending filters");
+    }
+
+    isCommunityResource(): boolean {
+        return false;
+    }
+
+    getSigner(address?: string): JsonRpcSigner {
+        return logger.throwError(
+            "API provider does not support signing",
+            Logger.errors.UNSUPPORTED_OPERATION,
+            { operation: "getSigner" }
+        );
+    }
+
+    listAccounts(): Promise<Array<string>> {
+        return Promise.resolve([]);
+    }
+
+    // Return a defaultApiKey if null, otherwise validate the API key
+    static getApiKey(apiKey: any): any {
+        return apiKey;
+    }
+
+    // Returns the url or connection for the given network and API key. The
+    // API key will have been sanitized by the getApiKey first, so any validation
+    // or transformations can be done there.
+    static getUrl(network: Network, apiKey: any): string | ConnectionInfo {
+        return logger.throwError("not implemented; sub-classes must override getUrl", Logger.errors.NOT_IMPLEMENTED, {
+            operation: "getUrl"
+        });
+    }
+}

package/src.ts/web3-provider.ts

@@ -0,0 +1,169 @@
+"use strict";
+
+import { Networkish } from "@ethersproject/networks";
+import { deepCopy, defineReadOnly } from "@ethersproject/properties";
+
+import { Logger } from "@ethersproject/logger";
+import { version } from "./_version";
+const logger = new Logger(version);
+
+import { JsonRpcProvider } from "./json-rpc-provider";
+
+// Exported Types
+export type ExternalProvider = {
+    isMetaMask?: boolean;
+    isStatus?: boolean;
+    host?: string;
+    path?: string;
+    sendAsync?: (request: { method: string, params?: Array<any> }, callback: (error: any, response: any) => void) => void
+    send?: (request: { method: string, params?: Array<any> }, callback: (error: any, response: any) => void) => void
+    request?: (request: { method: string, params?: Array<any> }) => Promise<any>
+}
+
+let _nextId = 1;
+
+export type JsonRpcFetchFunc = (method: string, params?: Array<any>) => Promise<any>;
+
+type Web3LegacySend = (request: any, callback: (error: Error, response: any) => void) => void;
+
+function buildWeb3LegacyFetcher(provider: ExternalProvider, sendFunc: Web3LegacySend) : JsonRpcFetchFunc {
+    const fetcher = "Web3LegacyFetcher";
+
+    return function(method: string, params: Array<any>): Promise<any> {
+        const request = {
+            method: method,
+            params: params,
+            id: (_nextId++),
+            jsonrpc: "2.0"
+        };
+
+        return new Promise((resolve, reject) => {
+            this.emit("debug", {
+                action: "request",
+                fetcher,
+                request: deepCopy(request),
+                provider: this
+            });
+
+            sendFunc(request, (error, response) => {
+
+                if (error) {
+                    this.emit("debug", {
+                        action: "response",
+                        fetcher,
+                        error,
+                        request,
+                        provider: this
+                    });
+
+                    return reject(error);
+                }
+
+                this.emit("debug", {
+                    action: "response",
+                    fetcher,
+                    request,
+                    response,
+                    provider: this
+                });
+
+                if (response.error) {
+                    const error = new Error(response.error.message);
+                    (<any>error).code = response.error.code;
+                    (<any>error).data = response.error.data;
+                    return reject(error);
+                }
+
+                resolve(response.result);
+            });
+        });
+    }
+}
+
+function buildEip1193Fetcher(provider: ExternalProvider): JsonRpcFetchFunc {
+    return function(method: string, params: Array<any>): Promise<any> {
+        if (params == null) { params = [ ]; }
+
+        const request = { method, params };
+
+        this.emit("debug", {
+            action: "request",
+            fetcher: "Eip1193Fetcher",
+            request: deepCopy(request),
+            provider: this
+        });
+
+        return provider.request(request).then((response) => {
+            this.emit("debug", {
+                action: "response",
+                fetcher: "Eip1193Fetcher",
+                request,
+                response,
+                provider: this
+            });
+
+            return response;
+
+        }, (error) => {
+            this.emit("debug", {
+                action: "response",
+                fetcher: "Eip1193Fetcher",
+                request,
+                error,
+                provider: this
+            });
+
+            throw error;
+        });
+    }
+}
+
+export class Web3Provider extends JsonRpcProvider {
+    readonly provider: ExternalProvider;
+    readonly jsonRpcFetchFunc: JsonRpcFetchFunc;
+
+    constructor(provider: ExternalProvider | JsonRpcFetchFunc, network?: Networkish) {
+        if (provider == null) {
+            logger.throwArgumentError("missing provider", "provider", provider);
+        }
+
+        let path: string = null;
+        let jsonRpcFetchFunc: JsonRpcFetchFunc = null;
+        let subprovider: ExternalProvider = null;
+
+        if (typeof(provider) === "function") {
+            path = "unknown:";
+            jsonRpcFetchFunc = provider;
+
+        } else {
+            path = provider.host || provider.path || "";
+            if (!path && provider.isMetaMask) {
+                path = "metamask";
+            }
+
+            subprovider = provider;
+
+            if (provider.request) {
+                if (path === "") { path = "eip-1193:"; }
+                jsonRpcFetchFunc = buildEip1193Fetcher(provider);
+            } else if (provider.sendAsync) {
+                jsonRpcFetchFunc = buildWeb3LegacyFetcher(provider, provider.sendAsync.bind(provider));
+            } else if (provider.send) {
+                jsonRpcFetchFunc = buildWeb3LegacyFetcher(provider, provider.send.bind(provider));
+            } else {
+                logger.throwArgumentError("unsupported provider", "provider", provider);
+            }
+
+            if (!path) { path = "unknown:"; }
+        }
+
+        super(path, network);
+
+        defineReadOnly(this, "jsonRpcFetchFunc", jsonRpcFetchFunc);
+        defineReadOnly(this, "provider", subprovider);
+    }
+
+    send(method: string, params: Array<any>): Promise<any> {
+        return this.jsonRpcFetchFunc(method, params);
+    }
+}