@qevm/providers 1.0.2 → 1.0.3

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

@@ -1,11 +1,10 @@
-
 "use strict";
 
-import { Network, Networkish } from "@ethersproject/networks";
-import { defineReadOnly, getStatic } from "@ethersproject/properties";
+import { Network, Networkish } from "@qevm/networks";
+import { defineReadOnly, getStatic } from "@qevm/properties";
 import { ConnectionInfo } from "@qevm/web";
 
-import { Logger } from "@ethersproject/logger";
+import { Logger } from "@qevm/logger";
 import { version } from "./_version";
 const logger = new Logger(version);
 
@@ -32,7 +31,11 @@ export class StaticJsonRpcProvider extends JsonRpcProvider {
             network = await super.detectNetwork();
 
             if (!network) {
-                logger.throwError("no network detected", Logger.errors.UNKNOWN_ERROR, { });
+                logger.throwError(
+                    "no network detected",
+                    Logger.errors.UNKNOWN_ERROR,
+                    {},
+                );
             }
 
             // If still not set, set it
@@ -47,21 +50,33 @@ export class StaticJsonRpcProvider extends JsonRpcProvider {
     }
 }
 
-export abstract class UrlJsonRpcProvider extends StaticJsonRpcProvider implements CommunityResourcable {
+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);
+        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") {
+        if (typeof apiKey === "string") {
             defineReadOnly(this, "apiKey", apiKey);
         } else if (apiKey != null) {
             Object.keys(apiKey).forEach((key) => {
@@ -82,7 +97,7 @@ export abstract class UrlJsonRpcProvider extends StaticJsonRpcProvider implement
         return logger.throwError(
             "API provider does not support signing",
             Logger.errors.UNSUPPORTED_OPERATION,
-            { operation: "getSigner" }
+            { operation: "getSigner" },
         );
     }
 
@@ -99,8 +114,12 @@ export abstract class UrlJsonRpcProvider extends StaticJsonRpcProvider implement
     // 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"
-        });
+        return logger.throwError(
+            "not implemented; sub-classes must override getUrl",
+            Logger.errors.NOT_IMPLEMENTED,
+            {
+                operation: "getUrl",
+            },
+        );
     }
 }

package/src.ts/web3-provider.ts

@@ -1,9 +1,9 @@
 "use strict";
 
-import { Networkish } from "@ethersproject/networks";
-import { deepCopy, defineReadOnly } from "@ethersproject/properties";
+import { Networkish } from "@qevm/networks";
+import { deepCopy, defineReadOnly } from "@qevm/properties";
 
-import { Logger } from "@ethersproject/logger";
+import { Logger } from "@qevm/logger";
 import { version } from "./_version";
 const logger = new Logger(version);
 
@@ -11,30 +11,47 @@ 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>
-}
+    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>;
+export type JsonRpcFetchFunc = (
+    method: string,
+    params?: Array<any>,
+) => Promise<any>;
 
-type Web3LegacySend = (request: any, callback: (error: Error, response: any) => void) => void;
+type Web3LegacySend = (
+    request: any,
+    callback: (error: Error, response: any) => void,
+) => void;
 
-function buildWeb3LegacyFetcher(provider: ExternalProvider, sendFunc: Web3LegacySend) : JsonRpcFetchFunc {
+function buildWeb3LegacyFetcher(
+    provider: ExternalProvider,
+    sendFunc: Web3LegacySend,
+): JsonRpcFetchFunc {
     const fetcher = "Web3LegacyFetcher";
 
-    return function(method: string, params: Array<any>): Promise<any> {
+    return function (method: string, params: Array<any>): Promise<any> {
         const request = {
             method: method,
             params: params,
-            id: (_nextId++),
-            jsonrpc: "2.0"
+            id: _nextId++,
+            jsonrpc: "2.0",
         };
 
         return new Promise((resolve, reject) => {
@@ -42,18 +59,17 @@ function buildWeb3LegacyFetcher(provider: ExternalProvider, sendFunc: Web3Legacy
                 action: "request",
                 fetcher,
                 request: deepCopy(request),
-                provider: this
+                provider: this,
             });
 
             sendFunc(request, (error, response) => {
-
                 if (error) {
                     this.emit("debug", {
                         action: "response",
                         fetcher,
                         error,
                         request,
-                        provider: this
+                        provider: this,
                     });
 
                     return reject(error);
@@ -64,7 +80,7 @@ function buildWeb3LegacyFetcher(provider: ExternalProvider, sendFunc: Web3Legacy
                     fetcher,
                     request,
                     response,
-                    provider: this
+                    provider: this,
                 });
 
                 if (response.error) {
@@ -77,12 +93,14 @@ function buildWeb3LegacyFetcher(provider: ExternalProvider, sendFunc: Web3Legacy
                 resolve(response.result);
             });
         });
-    }
+    };
 }
 
 function buildEip1193Fetcher(provider: ExternalProvider): JsonRpcFetchFunc {
-    return function(method: string, params: Array<any>): Promise<any> {
-        if (params == null) { params = [ ]; }
+    return function (method: string, params: Array<any>): Promise<any> {
+        if (params == null) {
+            params = [];
+        }
 
         const request = { method, params };
 
@@ -90,39 +108,44 @@ function buildEip1193Fetcher(provider: ExternalProvider): JsonRpcFetchFunc {
             action: "request",
             fetcher: "Eip1193Fetcher",
             request: deepCopy(request),
-            provider: this
+            provider: this,
         });
 
-        return provider.request(request).then((response) => {
-            this.emit("debug", {
-                action: "response",
-                fetcher: "Eip1193Fetcher",
-                request,
-                response,
-                provider: this
-            });
-
-            return response;
+        return provider.request(request).then(
+            (response) => {
+                this.emit("debug", {
+                    action: "response",
+                    fetcher: "Eip1193Fetcher",
+                    request,
+                    response,
+                    provider: this,
+                });
 
-        }, (error) => {
-            this.emit("debug", {
-                action: "response",
-                fetcher: "Eip1193Fetcher",
-                request,
-                error,
-                provider: this
-            });
+                return response;
+            },
+            (error) => {
+                this.emit("debug", {
+                    action: "response",
+                    fetcher: "Eip1193Fetcher",
+                    request,
+                    error,
+                    provider: this,
+                });
 
-            throw error;
-        });
-    }
+                throw error;
+            },
+        );
+    };
 }
 
 export class Web3Provider extends JsonRpcProvider {
     readonly provider: ExternalProvider;
     readonly jsonRpcFetchFunc: JsonRpcFetchFunc;
 
-    constructor(provider: ExternalProvider | JsonRpcFetchFunc, network?: Networkish) {
+    constructor(
+        provider: ExternalProvider | JsonRpcFetchFunc,
+        network?: Networkish,
+    ) {
         if (provider == null) {
             logger.throwArgumentError("missing provider", "provider", provider);
         }
@@ -131,30 +154,40 @@ export class Web3Provider extends JsonRpcProvider {
         let jsonRpcFetchFunc: JsonRpcFetchFunc = null;
         let subprovider: ExternalProvider = null;
 
-        if (typeof(provider) === "function") {
+        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:"; }
+                if (path === "") {
+                    path = "eip-1193:";
+                }
                 jsonRpcFetchFunc = buildEip1193Fetcher(provider);
             } else if (provider.sendAsync) {
-                jsonRpcFetchFunc = buildWeb3LegacyFetcher(provider, provider.sendAsync.bind(provider));
+                jsonRpcFetchFunc = buildWeb3LegacyFetcher(
+                    provider,
+                    provider.sendAsync.bind(provider),
+                );
             } else if (provider.send) {
-                jsonRpcFetchFunc = buildWeb3LegacyFetcher(provider, provider.send.bind(provider));
+                jsonRpcFetchFunc = buildWeb3LegacyFetcher(
+                    provider,
+                    provider.send.bind(provider),
+                );
             } else {
-                logger.throwArgumentError("unsupported provider", "provider", provider);
+                logger.throwArgumentError(
+                    "unsupported provider",
+                    "provider",
+                    provider,
+                );
             }
 
-            if (!path) { path = "unknown:"; }
+            if (!path) {
+                path = "unknown:";
+            }
         }
 
         super(path, network);