@qevm/providers 1.0.2 → 1.0.3

package/src.ts/index.ts

@@ -11,33 +11,40 @@ import {
     Provider,
     TransactionReceipt,
     TransactionRequest,
-    TransactionResponse
+    TransactionResponse,
 } from "@qevm/abstract-provider";
 
-import { getNetwork } from "@ethersproject/networks";
-import { Network, Networkish } from "@ethersproject/networks";
+import { getNetwork } from "@qevm/networks";
+import { Network, Networkish } from "@qevm/networks";
 
-import { BaseProvider, EnsProvider, EnsResolver, Resolver } from "./base-provider";
+import {
+    BaseProvider,
+    EnsProvider,
+    EnsResolver,
+    Resolver,
+} from "./base-provider";
 
-import { AlchemyProvider, AlchemyWebSocketProvider } from "./alchemy-provider";
-import { AnkrProvider } from "./ankr-provider";
-import { CloudflareProvider } from "./cloudflare-provider";
-import { EtherscanProvider } from "./etherscan-provider";
 import { FallbackProvider, FallbackProviderConfig } from "./fallback-provider";
 import { IpcProvider } from "./ipc-provider";
-import { InfuraProvider, InfuraWebSocketProvider } from "./infura-provider";
 import { JsonRpcProvider, JsonRpcSigner } from "./json-rpc-provider";
 import { JsonRpcBatchProvider } from "./json-rpc-batch-provider";
-import { NodesmithProvider } from "./nodesmith-provider";
-import { PocketProvider } from "./pocket-provider";
-import { StaticJsonRpcProvider, UrlJsonRpcProvider } from "./url-json-rpc-provider";
+import {
+    StaticJsonRpcProvider,
+    UrlJsonRpcProvider,
+} from "./url-json-rpc-provider";
 import { Web3Provider } from "./web3-provider";
 import { WebSocketProvider } from "./websocket-provider";
 import { ExternalProvider, JsonRpcFetchFunc } from "./web3-provider";
 
-import { CommunityResourcable, Formatter, isCommunityResourcable, isCommunityResource, showThrottleMessage } from "./formatter";
+import {
+    CommunityResourcable,
+    Formatter,
+    isCommunityResourcable,
+    isCommunityResource,
+    showThrottleMessage,
+} from "./formatter";
 
-import { Logger } from "@ethersproject/logger";
+import { Logger } from "@qevm/logger";
 import { version } from "./_version";
 const logger = new Logger(version);
 
@@ -45,112 +52,97 @@ const logger = new Logger(version);
 // Helper Functions
 
 function getDefaultProvider(network?: Networkish, options?: any): BaseProvider {
-    if (network == null) { network = "homestead"; }
+    if (network == null) {
+        network = "homestead";
+    }
 
     // If passed a URL, figure out the right type of provider based on the scheme
-    if (typeof(network) === "string") {
+    if (typeof network === "string") {
         // @TODO: Add support for IpcProvider; maybe if it ends in ".ipc"?
 
         // Handle http and ws (and their secure variants)
         const match = network.match(/^(ws|http)s?:/i);
         if (match) {
             switch (match[1].toLowerCase()) {
-                case "http": case "https":
+                case "http":
+                case "https":
                     return new JsonRpcProvider(network);
-                case "ws": case "wss":
+                case "ws":
+                case "wss":
                     return new WebSocketProvider(network);
                 default:
-                    logger.throwArgumentError("unsupported URL scheme", "network", network);
+                    logger.throwArgumentError(
+                        "unsupported URL scheme",
+                        "network",
+                        network,
+                    );
             }
         }
     }
 
     const n = getNetwork(network);
     if (!n || !n._defaultProvider) {
-        logger.throwError("unsupported getDefaultProvider network", Logger.errors.NETWORK_ERROR, {
-            operation: "getDefaultProvider",
-            network: network
-        });
+        logger.throwError(
+            "unsupported getDefaultProvider network",
+            Logger.errors.NETWORK_ERROR,
+            {
+                operation: "getDefaultProvider",
+                network: network,
+            },
+        );
     }
 
-    return n._defaultProvider({
-        FallbackProvider,
-
-        AlchemyProvider,
-        AnkrProvider,
-        CloudflareProvider,
-        EtherscanProvider,
-        InfuraProvider,
-        JsonRpcProvider,
-        NodesmithProvider,
-        PocketProvider,
-        Web3Provider,
-
-        IpcProvider,
-    }, options);
+    return n._defaultProvider(
+        {
+            FallbackProvider,
+
+            JsonRpcProvider,
+            Web3Provider,
+
+            IpcProvider,
+        },
+        options,
+    );
 }
 
 ////////////////////////
 // Exports
 
 export {
-
     // Abstract Providers (or Abstract-ish)
     Provider,
     BaseProvider,
-
     Resolver,
-
     UrlJsonRpcProvider,
 
     ///////////////////////
     // Concrete Providers
-
     FallbackProvider,
-
-    AlchemyProvider,
-    AlchemyWebSocketProvider,
-    AnkrProvider,
-    CloudflareProvider,
-    EtherscanProvider,
-    InfuraProvider,
-    InfuraWebSocketProvider,
     JsonRpcProvider,
     JsonRpcBatchProvider,
-    NodesmithProvider,
-    PocketProvider,
     StaticJsonRpcProvider,
     Web3Provider,
     WebSocketProvider,
-
     IpcProvider,
 
-
     ///////////////////////
     // Signer
-
     JsonRpcSigner,
 
-
     ///////////////////////
     // Functions
-
     getDefaultProvider,
     getNetwork,
     isCommunityResource,
     isCommunityResourcable,
     showThrottleMessage,
 
-
     ///////////////////////
     // Objects
-
     Formatter,
 
-
     ///////////////////////
     // Types
-
     Block,
     BlockTag,
     EventType,
@@ -161,18 +153,12 @@ export {
     TransactionReceipt,
     TransactionRequest,
     TransactionResponse,
-
     ExternalProvider,
     JsonRpcFetchFunc,
-
     FallbackProviderConfig,
-
     Network,
     Networkish,
-
     EnsProvider,
     EnsResolver,
-
-    CommunityResourcable
+    CommunityResourcable,
 };
-

package/src.ts/ipc-provider.ts

@@ -2,22 +2,23 @@
 
 import { connect } from "net";
 
-import { defineReadOnly } from "@ethersproject/properties";
-import { Networkish } from "@ethersproject/networks";
+import { defineReadOnly } from "@qevm/properties";
+import { Networkish } from "@qevm/networks";
 
-import { Logger } from "@ethersproject/logger";
+import { Logger } from "@qevm/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" });
+            logger.throwError("missing path", Logger.errors.MISSING_ARGUMENT, {
+                arg: "path",
+            });
         }
 
         super("ipc://" + path, network);
@@ -37,7 +38,7 @@ export class IpcProvider extends JsonRpcProvider {
             method: method,
             params: params,
             id: 42,
-            jsonrpc: "2.0"
+            jsonrpc: "2.0",
         });
 
         return new Promise((resolve, reject) => {
@@ -46,7 +47,7 @@ export class IpcProvider extends JsonRpcProvider {
             let stream = connect(this.path);
 
             stream.on("data", (data) => {
-                response = Buffer.concat([ response, data ]);
+                response = Buffer.concat([response, data]);
             });
 
             stream.on("end", () => {

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

@@ -1,5 +1,4 @@
-
-import { deepCopy } from "@ethersproject/properties";
+import { deepCopy } from "@qevm/properties";
 import { fetchJson } from "@qevm/web";
 
 import { JsonRpcProvider } from "./json-rpc-provider";
@@ -9,21 +8,26 @@ import { JsonRpcProvider } from "./json-rpc-provider";
 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
+        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"
+            id: this._nextId++,
+            jsonrpc: "2.0",
         };
 
         if (this._pendingBatch == null) {
-            this._pendingBatch = [ ];
+            this._pendingBatch = [];
         }
 
         const inflightRequest: any = { request, resolve: null, reject: null };
@@ -38,7 +42,6 @@ export class JsonRpcBatchProvider extends JsonRpcProvider {
         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;
@@ -51,44 +54,45 @@ export class JsonRpcBatchProvider extends JsonRpcProvider {
                 this.emit("debug", {
                     action: "requestBatch",
                     request: deepCopy(request),
-                    provider: this
+                    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;
+                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);
-                        } else {
-                            inflightRequest.resolve(payload.result);
-                        }
-                    });
-
-                }, (error) => {
-                    this.emit("debug", {
-                        action: "response",
-                        error: error,
-                        request: request,
-                        provider: this
-                    });
-
-                    batch.forEach((inflightRequest) => {
-                        inflightRequest.reject(error);
-                    });
-                });
-
+                        });
+                    },
+                );
             }, 10);
         }