@qevm/providers 1.0.1

package/src.ts/infura-provider.ts

@@ -0,0 +1,143 @@
+"use strict";
+
+import { Network, Networkish } from "@ethersproject/networks";
+import { defineReadOnly } from "@ethersproject/properties";
+import { ConnectionInfo } from "@ethersproject/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/ipc-provider.ts

@@ -0,0 +1,72 @@
+"use strict";
+
+import { connect } from "net";
+
+import { defineReadOnly } from "@ethersproject/properties";
+import { Networkish } from "@ethersproject/networks";
+
+import { Logger } from "@ethersproject/logger";
+import { version } from "./_version";
+const logger = new Logger(version);
+
+import { JsonRpcProvider } from "./json-rpc-provider";
+
+
+export class IpcProvider extends JsonRpcProvider {
+    readonly path: string;
+
+    constructor(path: string, network?: Networkish) {
+        if (path == null) {
+            logger.throwError("missing path", Logger.errors.MISSING_ARGUMENT, { arg: "path" });
+        }
+
+        super("ipc://" + path, network);
+
+        defineReadOnly(this, "path", path);
+    }
+
+    // @TODO: Create a connection to the IPC path and use filters instead of polling for block
+
+    send(method: string, params: Array<any>): Promise<any> {
+        // This method is very simple right now. We create a new socket
+        // connection each time, which may be slower, but the main
+        // advantage we are aiming for now is security. This simplifies
+        // multiplexing requests (since we do not need to multiplex).
+
+        let payload = JSON.stringify({
+            method: method,
+            params: params,
+            id: 42,
+            jsonrpc: "2.0"
+        });
+
+        return new Promise((resolve, reject) => {
+            let response = Buffer.alloc(0);
+
+            let stream = connect(this.path);
+
+            stream.on("data", (data) => {
+                response = Buffer.concat([ response, data ]);
+            });
+
+            stream.on("end", () => {
+                try {
+                    resolve(JSON.parse(response.toString()).result);
+                    // @TODO: Better pull apart the error
+                    stream.destroy();
+                } catch (error) {
+                    reject(error);
+                    stream.destroy();
+                }
+            });
+
+            stream.on("error", (error) => {
+                reject(error);
+                stream.destroy();
+            });
+
+            stream.write(payload);
+            stream.end();
+        });
+    }
+}

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

@@ -0,0 +1,97 @@
+
+import { deepCopy } from "@ethersproject/properties";
+import { fetchJson } from "@ethersproject/web";
+
+import { JsonRpcProvider } from "./json-rpc-provider";
+
+// Experimental
+
+export class JsonRpcBatchProvider extends JsonRpcProvider {
+    _pendingBatchAggregator: NodeJS.Timer;
+    _pendingBatch: Array<{
+        request: { method: string, params: Array<any>, id: number, jsonrpc: "2.0" },
+        resolve: (result: any) => void,
+        reject: (error: Error) => void
+    }>;
+
+    send(method: string, params: Array<any>): Promise<any> {
+        const request = {
+            method: method,
+            params: params,
+            id: (this._nextId++),
+            jsonrpc: "2.0"
+        };
+
+        if (this._pendingBatch == null) {
+            this._pendingBatch = [ ];
+        }
+
+        const inflightRequest: any = { request, resolve: null, reject: null };
+
+        const promise = new Promise((resolve, reject) => {
+            inflightRequest.resolve = resolve;
+            inflightRequest.reject = reject;
+        });
+
+        this._pendingBatch.push(inflightRequest);
+
+        if (!this._pendingBatchAggregator) {
+            // Schedule batch for next event loop + short duration
+            this._pendingBatchAggregator = setTimeout(() => {
+
+                // Get teh current batch and clear it, so new requests
+                // go into the next batch
+                const batch = this._pendingBatch;
+                this._pendingBatch = null;
+                this._pendingBatchAggregator = null;
+
+                // Get the request as an array of requests
+                const request = batch.map((inflight) => inflight.request);
+
+                this.emit("debug", {
+                    action: "requestBatch",
+                    request: deepCopy(request),
+                    provider: this
+                });
+
+                return fetchJson(this.connection, JSON.stringify(request)).then((result) => {
+                    this.emit("debug", {
+                        action: "response",
+                        request: request,
+                        response: result,
+                        provider: this
+                    });
+
+                    // For each result, feed it to the correct Promise, depending
+                    // on whether it was a success or error
+                    batch.forEach((inflightRequest, index) => {
+                        const payload = result[index];
+                        if (payload.error) {
+                            const error = new Error(payload.error.message);
+                            (<any>error).code = payload.error.code;
+                            (<any>error).data = payload.error.data;
+                            inflightRequest.reject(error);
+                        } else {
+                            inflightRequest.resolve(payload.result);
+                        }
+                    });
+
+                }, (error) => {
+                    this.emit("debug", {
+                        action: "response",
+                        error: error,
+                        request: request,
+                        provider: this
+                    });
+
+                    batch.forEach((inflightRequest) => {
+                        inflightRequest.reject(error);
+                    });
+                });
+
+            }, 10);
+        }
+
+        return promise;
+    }
+}