@qevm/providers 1.0.2 → 1.0.3

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

@@ -2,141 +2,230 @@
 
 // See: https://github.com/ethereum/wiki/wiki/JSON-RPC
 
-import { Provider, TransactionRequest, TransactionResponse } from "@qevm/abstract-provider";
-import { Signer, TypedDataDomain, TypedDataField, TypedDataSigner } from "@qevm/abstract-signer";
+import {
+    Provider,
+    TransactionRequest,
+    TransactionResponse,
+} from "@qevm/abstract-provider";
+import {
+    Signer,
+    TypedDataDomain,
+    TypedDataField,
+    TypedDataSigner,
+} from "@qevm/abstract-signer";
 import { BigNumber } from "@qevm/bignumber";
 import { Bytes, hexlify, hexValue, hexZeroPad, isHexString } from "@qevm/bytes";
 import { _TypedDataEncoder } from "@qevm/hash";
-import { Network, Networkish } from "@ethersproject/networks";
-import { checkProperties, deepCopy, Deferrable, defineReadOnly, getStatic, resolveProperties, shallowCopy } from "@ethersproject/properties";
+import { Network, Networkish } from "@qevm/networks";
+import {
+    checkProperties,
+    deepCopy,
+    Deferrable,
+    defineReadOnly,
+    getStatic,
+    resolveProperties,
+    shallowCopy,
+} from "@qevm/properties";
 import { toUtf8Bytes } from "@qevm/strings";
 import { AccessList, accessListify } from "@qevm/transactions";
 import { ConnectionInfo, fetchJson, poll } from "@qevm/web";
 
-import { Logger } from "@ethersproject/logger";
+import { Logger } from "@qevm/logger";
 import { version } from "./_version";
 const logger = new Logger(version);
 
 import { BaseProvider, Event } from "./base-provider";
 
+const errorGas = ["call", "estimateGas"];
 
-const errorGas = [ "call", "estimateGas" ];
-
-function spelunk(value: any, requireData: boolean): null | { message: string, data: null | string } {
-    if (value == null) { return null; }
+function spelunk(
+    value: any,
+    requireData: boolean,
+): null | { message: string; data: null | string } {
+    if (value == null) {
+        return null;
+    }
 
     // These *are* the droids we're looking for.
-    if (typeof(value.message) === "string" && value.message.match("reverted")) {
-        const data = isHexString(value.data) ? value.data: null;
+    if (typeof value.message === "string" && value.message.match("reverted")) {
+        const data = isHexString(value.data) ? value.data : null;
         if (!requireData || data) {
             return { message: value.message, data };
         }
     }
 
     // Spelunk further...
-    if (typeof(value) === "object") {
+    if (typeof value === "object") {
         for (const key in value) {
             const result = spelunk(value[key], requireData);
-            if (result) { return result; }
+            if (result) {
+                return result;
+            }
         }
         return null;
     }
 
     // Might be a JSON string we can further descend...
-    if (typeof(value) === "string") {
+    if (typeof value === "string") {
         try {
             return spelunk(JSON.parse(value), requireData);
-        } catch (error) { }
+        } catch (error) {}
     }
 
     return null;
 }
 
 function checkError(method: string, error: any, params: any): any {
-
     const transaction = params.transaction || params.signedTransaction;
 
     // Undo the "convenience" some nodes are attempting to prevent backwards
     // incompatibility; maybe for v6 consider forwarding reverts as errors
     if (method === "call") {
         const result = spelunk(error, true);
-        if (result) { return result.data; }
+        if (result) {
+            return result.data;
+        }
 
         // Nothing descriptive..
-        logger.throwError("missing revert data in call exception; Transaction reverted without a reason string", Logger.errors.CALL_EXCEPTION, {
-            data: "0x", transaction, error
-        });
+        logger.throwError(
+            "missing revert data in call exception; Transaction reverted without a reason string",
+            Logger.errors.CALL_EXCEPTION,
+            {
+                data: "0x",
+                transaction,
+                error,
+            },
+        );
     }
 
     if (method === "estimateGas") {
         // Try to find something, with a preference on SERVER_ERROR body
         let result = spelunk(error.body, false);
-        if (result == null) { result = spelunk(error, false); }
+        if (result == null) {
+            result = spelunk(error, false);
+        }
 
         // Found "reverted", this is a CALL_EXCEPTION
         if (result) {
-            logger.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
-                reason: result.message, method, transaction, error
-            });
+            logger.throwError(
+                "cannot estimate gas; transaction may fail or may require manual gas limit",
+                Logger.errors.UNPREDICTABLE_GAS_LIMIT,
+                {
+                    reason: result.message,
+                    method,
+                    transaction,
+                    error,
+                },
+            );
         }
     }
 
     // @TODO: Should we spelunk for message too?
 
     let message = error.message;
-    if (error.code === Logger.errors.SERVER_ERROR && error.error && typeof(error.error.message) === "string") {
+    if (
+        error.code === Logger.errors.SERVER_ERROR &&
+        error.error &&
+        typeof error.error.message === "string"
+    ) {
         message = error.error.message;
-    } else if (typeof(error.body) === "string") {
+    } else if (typeof error.body === "string") {
         message = error.body;
-    } else if (typeof(error.responseText) === "string") {
+    } else if (typeof error.responseText === "string") {
         message = error.responseText;
     }
     message = (message || "").toLowerCase();
 
     // "insufficient funds for gas * price + value + cost(data)"
-    if (message.match(/insufficient funds|base fee exceeds gas limit|InsufficientFunds/i)) {
-        logger.throwError("insufficient funds for intrinsic transaction cost", Logger.errors.INSUFFICIENT_FUNDS, {
-            error, method, transaction
-        });
+    if (
+        message.match(
+            /insufficient funds|base fee exceeds gas limit|InsufficientFunds/i,
+        )
+    ) {
+        logger.throwError(
+            "insufficient funds for intrinsic transaction cost",
+            Logger.errors.INSUFFICIENT_FUNDS,
+            {
+                error,
+                method,
+                transaction,
+            },
+        );
     }
 
     // "nonce too low"
     if (message.match(/nonce (is )?too low/i)) {
-        logger.throwError("nonce has already been used", Logger.errors.NONCE_EXPIRED, {
-            error, method, transaction
-        });
+        logger.throwError(
+            "nonce has already been used",
+            Logger.errors.NONCE_EXPIRED,
+            {
+                error,
+                method,
+                transaction,
+            },
+        );
     }
 
     // "replacement transaction underpriced"
-    if (message.match(/replacement transaction underpriced|transaction gas price.*too low/i)) {
-        logger.throwError("replacement fee too low", Logger.errors.REPLACEMENT_UNDERPRICED, {
-            error, method, transaction
-        });
+    if (
+        message.match(
+            /replacement transaction underpriced|transaction gas price.*too low/i,
+        )
+    ) {
+        logger.throwError(
+            "replacement fee too low",
+            Logger.errors.REPLACEMENT_UNDERPRICED,
+            {
+                error,
+                method,
+                transaction,
+            },
+        );
     }
 
     // "replacement transaction underpriced"
     if (message.match(/only replay-protected/i)) {
-        logger.throwError("legacy pre-eip-155 transactions not supported", Logger.errors.UNSUPPORTED_OPERATION, {
-            error, method, transaction
-        });
+        logger.throwError(
+            "legacy pre-eip-155 transactions not supported",
+            Logger.errors.UNSUPPORTED_OPERATION,
+            {
+                error,
+                method,
+                transaction,
+            },
+        );
     }
 
-    if (errorGas.indexOf(method) >= 0 && message.match(/gas required exceeds allowance|always failing transaction|execution reverted|revert/)) {
-        logger.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
-            error, method, transaction
-        });
+    if (
+        errorGas.indexOf(method) >= 0 &&
+        message.match(
+            /gas required exceeds allowance|always failing transaction|execution reverted|revert/,
+        )
+    ) {
+        logger.throwError(
+            "cannot estimate gas; transaction may fail or may require manual gas limit",
+            Logger.errors.UNPREDICTABLE_GAS_LIMIT,
+            {
+                error,
+                method,
+                transaction,
+            },
+        );
     }
 
     throw error;
 }
 
 function timer(timeout: number): Promise<any> {
-    return new Promise(function(resolve) {
+    return new Promise(function (resolve) {
         setTimeout(resolve, timeout);
     });
 }
 
-function getResult(payload: { error?: { code?: number, data?: any, message?: string }, result?: any }): any {
+function getResult(payload: {
+    error?: { code?: number; data?: any; message?: string };
+    result?: any;
+}): any {
     if (payload.error) {
         // @TODO: not any
         const error: any = new Error(payload.error.message);
@@ -149,7 +238,9 @@ function getResult(payload: { error?: { code?: number, data?: any, message?: str
 }
 
 function getLowerCase(value: string): string {
-    if (value) { return value.toLowerCase(); }
+    if (value) {
+        return value.toLowerCase();
+    }
     return value;
 }
 
@@ -160,38 +251,60 @@ export class JsonRpcSigner extends Signer implements TypedDataSigner {
     _index: number;
     _address: string;
 
-    constructor(constructorGuard: any, provider: JsonRpcProvider, addressOrIndex?: string | number) {
+    constructor(
+        constructorGuard: any,
+        provider: JsonRpcProvider,
+        addressOrIndex?: string | number,
+    ) {
         super();
 
         if (constructorGuard !== _constructorGuard) {
-            throw new Error("do not call the JsonRpcSigner constructor directly; use provider.getSigner");
+            throw new Error(
+                "do not call the JsonRpcSigner constructor directly; use provider.getSigner",
+            );
         }
 
         defineReadOnly(this, "provider", provider);
 
-        if (addressOrIndex == null) { addressOrIndex = 0; }
+        if (addressOrIndex == null) {
+            addressOrIndex = 0;
+        }
 
-        if (typeof(addressOrIndex) === "string") {
-            defineReadOnly(this, "_address", this.provider.formatter.address(addressOrIndex));
+        if (typeof addressOrIndex === "string") {
+            defineReadOnly(
+                this,
+                "_address",
+                this.provider.formatter.address(addressOrIndex),
+            );
             defineReadOnly(this, "_index", null);
-
-        } else if (typeof(addressOrIndex) === "number") {
+        } else if (typeof addressOrIndex === "number") {
             defineReadOnly(this, "_index", addressOrIndex);
             defineReadOnly(this, "_address", null);
-
         } else {
-            logger.throwArgumentError("invalid address or index", "addressOrIndex", addressOrIndex);
+            logger.throwArgumentError(
+                "invalid address or index",
+                "addressOrIndex",
+                addressOrIndex,
+            );
         }
     }
 
     connect(provider: Provider): JsonRpcSigner {
-        return logger.throwError("cannot alter JSON-RPC Signer connection", Logger.errors.UNSUPPORTED_OPERATION, {
-            operation: "connect"
-        });
+        return logger.throwError(
+            "cannot alter JSON-RPC Signer connection",
+            Logger.errors.UNSUPPORTED_OPERATION,
+            {
+                operation: "connect",
+            },
+        );
     }
 
     connectUnchecked(): JsonRpcSigner {
-        return new UncheckedJsonRpcSigner(_constructorGuard, this.provider, this._address || this._index);
+        return new UncheckedJsonRpcSigner(
+            _constructorGuard,
+            this.provider,
+            this._address || this._index,
+        );
     }
 
     getAddress(): Promise<string> {
@@ -201,19 +314,27 @@ export class JsonRpcSigner extends Signer implements TypedDataSigner {
 
         return this.provider.send("eth_accounts", []).then((accounts) => {
             if (accounts.length <= this._index) {
-                logger.throwError("unknown account #" + this._index, Logger.errors.UNSUPPORTED_OPERATION, {
-                    operation: "getAddress"
-                });
+                logger.throwError(
+                    "unknown account #" + this._index,
+                    Logger.errors.UNSUPPORTED_OPERATION,
+                    {
+                        operation: "getAddress",
+                    },
+                );
             }
-            return this.provider.formatter.address(accounts[this._index])
+            return this.provider.formatter.address(accounts[this._index]);
         });
     }
 
-    sendUncheckedTransaction(transaction: Deferrable<TransactionRequest>): Promise<string> {
+    sendUncheckedTransaction(
+        transaction: Deferrable<TransactionRequest>,
+    ): Promise<string> {
         transaction = shallowCopy(transaction);
 
         const fromAddress = this.getAddress().then((address) => {
-            if (address) { address = address.toLowerCase(); }
+            if (address) {
+                address = address.toLowerCase();
+            }
             return address;
         });
 
@@ -227,55 +348,89 @@ export class JsonRpcSigner extends Signer implements TypedDataSigner {
         }
 
         if (transaction.to != null) {
-            transaction.to = Promise.resolve(transaction.to).then(async (to) => {
-                if (to == null) { return null; }
-                const address = await this.provider.resolveName(to);
-                if (address == null) {
-                    logger.throwArgumentError("provided ENS name resolves to null", "tx.to", to);
-                }
-                return address;
-            });
+            transaction.to = Promise.resolve(transaction.to).then(
+                async (to) => {
+                    if (to == null) {
+                        return null;
+                    }
+                    const address = await this.provider.resolveName(to);
+                    if (address == null) {
+                        logger.throwArgumentError(
+                            "provided ENS name resolves to null",
+                            "tx.to",
+                            to,
+                        );
+                    }
+                    return address;
+                },
+            );
         }
 
         return resolveProperties({
             tx: resolveProperties(transaction),
-            sender: fromAddress
+            sender: fromAddress,
         }).then(({ tx, sender }) => {
-
             if (tx.from != null) {
                 if (tx.from.toLowerCase() !== sender) {
-                    logger.throwArgumentError("from address mismatch", "transaction", transaction);
+                    logger.throwArgumentError(
+                        "from address mismatch",
+                        "transaction",
+                        transaction,
+                    );
                 }
             } else {
                 tx.from = sender;
             }
 
-            const hexTx = (<any>this.provider.constructor).hexlifyTransaction(tx, { from: true });
-
-            return this.provider.send("eth_sendTransaction", [ hexTx ]).then((hash) => {
-                return hash;
-            }, (error) => {
-                if (typeof(error.message) === "string" && error.message.match(/user denied/i)) {
-                    logger.throwError("user rejected transaction", Logger.errors.ACTION_REJECTED, {
-                        action: "sendTransaction",
-                        transaction: tx
-                    });
-                }
+            const hexTx = (<any>this.provider.constructor).hexlifyTransaction(
+                tx,
+                { from: true },
+            );
+
+            return this.provider.send("eth_sendTransaction", [hexTx]).then(
+                (hash) => {
+                    return hash;
+                },
+                (error) => {
+                    if (
+                        typeof error.message === "string" &&
+                        error.message.match(/user denied/i)
+                    ) {
+                        logger.throwError(
+                            "user rejected transaction",
+                            Logger.errors.ACTION_REJECTED,
+                            {
+                                action: "sendTransaction",
+                                transaction: tx,
+                            },
+                        );
+                    }
 
-                return checkError("sendTransaction", error, hexTx);
-            });
+                    return checkError("sendTransaction", error, hexTx);
+                },
+            );
         });
     }
 
-    signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string> {
-        return logger.throwError("signing transactions is unsupported", Logger.errors.UNSUPPORTED_OPERATION, {
-            operation: "signTransaction"
-        });
+    signTransaction(
+        transaction: Deferrable<TransactionRequest>,
+    ): Promise<string> {
+        return logger.throwError(
+            "signing transactions is unsupported",
+            Logger.errors.UNSUPPORTED_OPERATION,
+            {
+                operation: "signTransaction",
+            },
+        );
     }
 
-    async sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse> {
+    async sendTransaction(
+        transaction: Deferrable<TransactionRequest>,
+    ): Promise<TransactionResponse> {
         // This cannot be mined any earlier than any recent block
-        const blockNumber = await this.provider._getInternalBlockNumber(100 + 2 * this.provider.pollingInterval);
+        const blockNumber = await this.provider._getInternalBlockNumber(
+            100 + 2 * this.provider.pollingInterval,
+        );
 
         // Send the transaction
         const hash = await this.sendUncheckedTransaction(transaction);
@@ -284,11 +439,20 @@ export class JsonRpcSigner extends Signer implements TypedDataSigner {
             // Unfortunately, JSON-RPC only provides and opaque transaction hash
             // for a response, and we need the actual transaction, so we poll
             // for it; it should show up very quickly
-            return await poll(async () => {
-                const tx = await this.provider.getTransaction(hash);
-                if (tx === null) { return undefined; }
-                return this.provider._wrapTransaction(tx, hash, blockNumber);
-            }, { oncePoll: this.provider });
+            return await poll(
+                async () => {
+                    const tx = await this.provider.getTransaction(hash);
+                    if (tx === null) {
+                        return undefined;
+                    }
+                    return this.provider._wrapTransaction(
+                        tx,
+                        hash,
+                        blockNumber,
+                    );
+                },
+                { oncePoll: this.provider },
+            );
         } catch (error) {
             (<any>error).transactionHash = hash;
             throw error;
@@ -296,61 +460,109 @@ export class JsonRpcSigner extends Signer implements TypedDataSigner {
     }
 
     async signMessage(message: Bytes | string): Promise<string> {
-        const data = ((typeof(message) === "string") ? toUtf8Bytes(message): message);
+        const data =
+            typeof message === "string" ? toUtf8Bytes(message) : message;
         const address = await this.getAddress();
         try {
-            return await this.provider.send("personal_sign", [ hexlify(data), address.toLowerCase() ]);
+            return await this.provider.send("personal_sign", [
+                hexlify(data),
+                address.toLowerCase(),
+            ]);
         } catch (error) {
-            if (typeof(error.message) === "string" && error.message.match(/user denied/i)) {
-                logger.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
-                    action: "signMessage",
-                    from: address,
-                    messageData: message
-                });
+            if (
+                typeof error.message === "string" &&
+                error.message.match(/user denied/i)
+            ) {
+                logger.throwError(
+                    "user rejected signing",
+                    Logger.errors.ACTION_REJECTED,
+                    {
+                        action: "signMessage",
+                        from: address,
+                        messageData: message,
+                    },
+                );
             }
             throw error;
         }
     }
 
     async _legacySignMessage(message: Bytes | string): Promise<string> {
-        const data = ((typeof(message) === "string") ? toUtf8Bytes(message): message);
+        const data =
+            typeof message === "string" ? toUtf8Bytes(message) : message;
         const address = await this.getAddress();
 
         try {
             // https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign
-            return await this.provider.send("eth_sign", [ address.toLowerCase(), hexlify(data) ]);
+            return await this.provider.send("eth_sign", [
+                address.toLowerCase(),
+                hexlify(data),
+            ]);
         } catch (error) {
-            if (typeof(error.message) === "string" && error.message.match(/user denied/i)) {
-                logger.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
-                    action: "_legacySignMessage",
-                    from: address,
-                    messageData: message
-                });
+            if (
+                typeof error.message === "string" &&
+                error.message.match(/user denied/i)
+            ) {
+                logger.throwError(
+                    "user rejected signing",
+                    Logger.errors.ACTION_REJECTED,
+                    {
+                        action: "_legacySignMessage",
+                        from: address,
+                        messageData: message,
+                    },
+                );
             }
             throw error;
         }
     }
 
-    async _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string> {
+    async _signTypedData(
+        domain: TypedDataDomain,
+        types: Record<string, Array<TypedDataField>>,
+        value: Record<string, any>,
+    ): Promise<string> {
         // Populate any ENS names (in-place)
-        const populated = await _TypedDataEncoder.resolveNames(domain, types, value, (name: string) => {
-            return this.provider.resolveName(name);
-        });
+        const populated = await _TypedDataEncoder.resolveNames(
+            domain,
+            types,
+            value,
+            (name: string) => {
+                return this.provider.resolveName(name);
+            },
+        );
 
         const address = await this.getAddress();
 
         try {
             return await this.provider.send("eth_signTypedData_v4", [
                 address.toLowerCase(),
-                JSON.stringify(_TypedDataEncoder.getPayload(populated.domain, types, populated.value))
+                JSON.stringify(
+                    _TypedDataEncoder.getPayload(
+                        populated.domain,
+                        types,
+                        populated.value,
+                    ),
+                ),
             ]);
         } catch (error) {
-            if (typeof(error.message) === "string" && error.message.match(/user denied/i)) {
-                logger.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
-                    action: "_signTypedData",
-                    from: address,
-                    messageData: { domain: populated.domain, types, value: populated.value }
-                });
+            if (
+                typeof error.message === "string" &&
+                error.message.match(/user denied/i)
+            ) {
+                logger.throwError(
+                    "user rejected signing",
+                    Logger.errors.ACTION_REJECTED,
+                    {
+                        action: "_signTypedData",
+                        from: address,
+                        messageData: {
+                            domain: populated.domain,
+                            types,
+                            value: populated.value,
+                        },
+                    },
+                );
             }
             throw error;
         }
@@ -361,12 +573,18 @@ export class JsonRpcSigner extends Signer implements TypedDataSigner {
 
         const address = await this.getAddress();
 
-        return provider.send("personal_unlockAccount", [ address.toLowerCase(), password, null ]);
+        return provider.send("personal_unlockAccount", [
+            address.toLowerCase(),
+            password,
+            null,
+        ]);
     }
 }
 
 class UncheckedJsonRpcSigner extends JsonRpcSigner {
-    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse> {
+    sendTransaction(
+        transaction: Deferrable<TransactionRequest>,
+    ): Promise<TransactionResponse> {
         return this.sendUncheckedTransaction(transaction).then((hash) => {
             return <TransactionResponse>{
                 hash: hash,
@@ -378,17 +596,30 @@ class UncheckedJsonRpcSigner extends JsonRpcSigner {
                 chainId: null,
                 confirmations: 0,
                 from: null,
-                wait: (confirmations?: number) => { return this.provider.waitForTransaction(hash, confirmations); }
+                wait: (confirmations?: number) => {
+                    return this.provider.waitForTransaction(
+                        hash,
+                        confirmations,
+                    );
+                },
             };
         });
     }
 }
 
-const allowedTransactionKeys: { [ key: string ]: boolean } = {
-    chainId: true, data: true, gasLimit: true, gasPrice:true, nonce: true, to: true, value: true,
-    type: true, accessList: true,
-    maxFeePerGas: true, maxPriorityFeePerGas: true
-}
+const allowedTransactionKeys: { [key: string]: boolean } = {
+    chainId: true,
+    data: true,
+    gasLimit: true,
+    gasPrice: true,
+    nonce: true,
+    to: true,
+    value: true,
+    type: true,
+    accessList: true,
+    maxFeePerGas: true,
+    maxPriorityFeePerGas: true,
+};
 
 export class JsonRpcProvider extends BaseProvider {
     readonly connection: ConnectionInfo;
@@ -402,7 +633,7 @@ export class JsonRpcProvider extends BaseProvider {
     _eventLoopCache: Record<string, Promise<any>>;
     get _cache(): Record<string, Promise<any>> {
         if (this._eventLoopCache == null) {
-            this._eventLoopCache = { };
+            this._eventLoopCache = {};
         }
         return this._eventLoopCache;
     }
@@ -414,11 +645,14 @@ export class JsonRpcProvider extends BaseProvider {
         if (networkOrReady == null) {
             networkOrReady = new Promise((resolve, reject) => {
                 setTimeout(() => {
-                    this.detectNetwork().then((network) => {
-                        resolve(network);
-                    }, (error) => {
-                        reject(error);
-                    });
+                    this.detectNetwork().then(
+                        (network) => {
+                            resolve(network);
+                        },
+                        (error) => {
+                            reject(error);
+                        },
+                    );
                 }, 0);
             });
         }
@@ -426,12 +660,18 @@ export class JsonRpcProvider extends BaseProvider {
         super(networkOrReady);
 
         // Default URL
-        if (!url) { url = getStatic<() => string>(this.constructor, "defaultUrl")(); }
+        if (!url) {
+            url = getStatic<() => string>(this.constructor, "defaultUrl")();
+        }
 
-        if (typeof(url) === "string") {
-            defineReadOnly(this, "connection",Object.freeze({
-                url: url
-            }));
+        if (typeof url === "string") {
+            defineReadOnly(
+                this,
+                "connection",
+                Object.freeze({
+                    url: url,
+                }),
+            );
         } else {
             defineReadOnly(this, "connection", Object.freeze(shallowCopy(url)));
         }
@@ -460,36 +700,49 @@ export class JsonRpcProvider extends BaseProvider {
 
         let chainId = null;
         try {
-            chainId = await this.send("eth_chainId", [ ]);
+            chainId = await this.send("eth_chainId", []);
         } catch (error) {
             try {
-                chainId = await this.send("net_version", [ ]);
-            } catch (error) { }
+                chainId = await this.send("net_version", []);
+            } catch (error) {}
         }
 
         if (chainId != null) {
-            const getNetwork = getStatic<(network: Networkish) => Network>(this.constructor, "getNetwork");
+            const getNetwork = getStatic<(network: Networkish) => Network>(
+                this.constructor,
+                "getNetwork",
+            );
             try {
                 return getNetwork(BigNumber.from(chainId).toNumber());
             } catch (error) {
-                return logger.throwError("could not detect network", Logger.errors.NETWORK_ERROR, {
-                    chainId: chainId,
-                    event: "invalidNetwork",
-                    serverError: error
-                });
+                return logger.throwError(
+                    "could not detect network",
+                    Logger.errors.NETWORK_ERROR,
+                    {
+                        chainId: chainId,
+                        event: "invalidNetwork",
+                        serverError: error,
+                    },
+                );
             }
         }
 
-        return logger.throwError("could not detect network", Logger.errors.NETWORK_ERROR, {
-            event: "noNetwork"
-        });
+        return logger.throwError(
+            "could not detect network",
+            Logger.errors.NETWORK_ERROR,
+            {
+                event: "noNetwork",
+            },
+        );
     }
 
     getSigner(addressOrIndex?: string | number): JsonRpcSigner {
         return new JsonRpcSigner(_constructorGuard, this, addressOrIndex);
     }
 
-    getUncheckedSigner(addressOrIndex?: string | number): UncheckedJsonRpcSigner {
+    getUncheckedSigner(
+        addressOrIndex?: string | number,
+    ): UncheckedJsonRpcSigner {
         return this.getSigner(addressOrIndex).connectUnchecked();
     }
 
@@ -503,43 +756,49 @@ export class JsonRpcProvider extends BaseProvider {
         const request = {
             method: method,
             params: params,
-            id: (this._nextId++),
-            jsonrpc: "2.0"
+            id: this._nextId++,
+            jsonrpc: "2.0",
         };
 
         this.emit("debug", {
             action: "request",
             request: deepCopy(request),
-            provider: this
+            provider: this,
         });
 
         // We can expand this in the future to any call, but for now these
         // are the biggest wins and do not require any serializing parameters.
-        const cache = ([ "eth_chainId", "eth_blockNumber" ].indexOf(method) >= 0);
+        const cache = ["eth_chainId", "eth_blockNumber"].indexOf(method) >= 0;
         if (cache && this._cache[method]) {
             return this._cache[method];
         }
 
-        const result = fetchJson(this.connection, JSON.stringify(request), getResult).then((result) => {
-            this.emit("debug", {
-                action: "response",
-                request: request,
-                response: result,
-                provider: this
-            });
-
-            return result;
+        const result = fetchJson(
+            this.connection,
+            JSON.stringify(request),
+            getResult,
+        ).then(
+            (result) => {
+                this.emit("debug", {
+                    action: "response",
+                    request: request,
+                    response: result,
+                    provider: this,
+                });
 
-        }, (error) => {
-            this.emit("debug", {
-                action: "response",
-                error: error,
-                request: request,
-                provider: this
-            });
+                return result;
+            },
+            (error) => {
+                this.emit("debug", {
+                    action: "response",
+                    error: error,
+                    request: request,
+                    provider: this,
+                });
 
-            throw error;
-        });
+                throw error;
+            },
+        );
 
         // Cache the fetch, but clear it on the next event loop
         if (cache) {
@@ -552,58 +811,99 @@ export class JsonRpcProvider extends BaseProvider {
         return result;
     }
 
-    prepareRequest(method: string, params: any): [ string, Array<any> ] {
+    prepareRequest(method: string, params: any): [string, Array<any>] {
         switch (method) {
             case "getBlockNumber":
-                return [ "eth_blockNumber", [] ];
+                return ["eth_blockNumber", []];
 
             case "getGasPrice":
-                return [ "eth_gasPrice", [] ];
+                return ["eth_gasPrice", []];
 
             case "getBalance":
-                return [ "eth_getBalance", [ getLowerCase(params.address), params.blockTag ] ];
+                return [
+                    "eth_getBalance",
+                    [getLowerCase(params.address), params.blockTag],
+                ];
 
             case "getTransactionCount":
-                return [ "eth_getTransactionCount", [ getLowerCase(params.address), params.blockTag ] ];
+                return [
+                    "eth_getTransactionCount",
+                    [getLowerCase(params.address), params.blockTag],
+                ];
 
             case "getCode":
-                return [ "eth_getCode", [ getLowerCase(params.address), params.blockTag ] ];
+                return [
+                    "eth_getCode",
+                    [getLowerCase(params.address), params.blockTag],
+                ];
 
             case "getStorageAt":
-                return [ "eth_getStorageAt", [ getLowerCase(params.address), hexZeroPad(params.position, 32), params.blockTag ] ];
+                return [
+                    "eth_getStorageAt",
+                    [
+                        getLowerCase(params.address),
+                        hexZeroPad(params.position, 32),
+                        params.blockTag,
+                    ],
+                ];
 
             case "sendTransaction":
-                return [ "eth_sendRawTransaction", [ params.signedTransaction ] ]
+                return ["eth_sendRawTransaction", [params.signedTransaction]];
 
             case "getBlock":
                 if (params.blockTag) {
-                    return [ "eth_getBlockByNumber", [ params.blockTag, !!params.includeTransactions ] ];
+                    return [
+                        "eth_getBlockByNumber",
+                        [params.blockTag, !!params.includeTransactions],
+                    ];
                 } else if (params.blockHash) {
-                    return [ "eth_getBlockByHash", [ params.blockHash, !!params.includeTransactions ] ];
+                    return [
+                        "eth_getBlockByHash",
+                        [params.blockHash, !!params.includeTransactions],
+                    ];
                 }
                 return null;
 
             case "getTransaction":
-                return [ "eth_getTransactionByHash", [ params.transactionHash ] ];
+                return ["eth_getTransactionByHash", [params.transactionHash]];
 
             case "getTransactionReceipt":
-                return [ "eth_getTransactionReceipt", [ params.transactionHash ] ];
+                return ["eth_getTransactionReceipt", [params.transactionHash]];
 
             case "call": {
-                const hexlifyTransaction = getStatic<(t: TransactionRequest, a?: { [key: string]: boolean }) => { [key: string]: string }>(this.constructor, "hexlifyTransaction");
-                return [ "eth_call", [ hexlifyTransaction(params.transaction, { from: true }), params.blockTag ] ];
+                const hexlifyTransaction = getStatic<
+                    (
+                        t: TransactionRequest,
+                        a?: { [key: string]: boolean },
+                    ) => { [key: string]: string }
+                >(this.constructor, "hexlifyTransaction");
+                return [
+                    "eth_call",
+                    [
+                        hexlifyTransaction(params.transaction, { from: true }),
+                        params.blockTag,
+                    ],
+                ];
             }
 
             case "estimateGas": {
-                const hexlifyTransaction = getStatic<(t: TransactionRequest, a?: { [key: string]: boolean }) => { [key: string]: string }>(this.constructor, "hexlifyTransaction");
-                return [ "eth_estimateGas", [ hexlifyTransaction(params.transaction, { from: true }) ] ];
+                const hexlifyTransaction = getStatic<
+                    (
+                        t: TransactionRequest,
+                        a?: { [key: string]: boolean },
+                    ) => { [key: string]: string }
+                >(this.constructor, "hexlifyTransaction");
+                return [
+                    "eth_estimateGas",
+                    [hexlifyTransaction(params.transaction, { from: true })],
+                ];
             }
 
             case "getLogs":
                 if (params.filter && params.filter.address != null) {
                     params.filter.address = getLowerCase(params.filter.address);
                 }
-                return [ "eth_getLogs", [ params.filter ] ];
+                return ["eth_getLogs", [params.filter]];
 
             default:
                 break;
@@ -619,9 +919,15 @@ export class JsonRpcProvider extends BaseProvider {
             const tx = params.transaction;
             if (tx && tx.type != null && BigNumber.from(tx.type).isZero()) {
                 // If there are no EIP-1559 properties, it might be non-EIP-1559
-                if (tx.maxFeePerGas == null && tx.maxPriorityFeePerGas == null) {
+                if (
+                    tx.maxFeePerGas == null &&
+                    tx.maxPriorityFeePerGas == null
+                ) {
                     const feeData = await this.getFeeData();
-                    if (feeData.maxFeePerGas == null && feeData.maxPriorityFeePerGas == null) {
+                    if (
+                        feeData.maxFeePerGas == null &&
+                        feeData.maxPriorityFeePerGas == null
+                    ) {
                         // Network doesn't know about EIP-1559 (and hence type)
                         params = shallowCopy(params);
                         params.transaction = shallowCopy(tx);
@@ -631,64 +937,87 @@ export class JsonRpcProvider extends BaseProvider {
             }
         }
 
-        const args = this.prepareRequest(method,  params);
+        const args = this.prepareRequest(method, params);
 
         if (args == null) {
-            logger.throwError(method + " not implemented", Logger.errors.NOT_IMPLEMENTED, { operation: method });
+            logger.throwError(
+                method + " not implemented",
+                Logger.errors.NOT_IMPLEMENTED,
+                { operation: method },
+            );
         }
         try {
-            return await this.send(args[0], args[1])
+            return await this.send(args[0], args[1]);
         } catch (error) {
             return checkError(method, error, params);
         }
     }
 
     _startEvent(event: Event): void {
-        if (event.tag === "pending") { this._startPending(); }
+        if (event.tag === "pending") {
+            this._startPending();
+        }
         super._startEvent(event);
     }
 
     _startPending(): void {
-        if (this._pendingFilter != null) { return; }
+        if (this._pendingFilter != null) {
+            return;
+        }
         const self = this;
 
-        const pendingFilter: Promise<number> = this.send("eth_newPendingTransactionFilter", []);
+        const pendingFilter: Promise<number> = this.send(
+            "eth_newPendingTransactionFilter",
+            [],
+        );
         this._pendingFilter = pendingFilter;
 
-        pendingFilter.then(function(filterId) {
-            function poll() {
-                self.send("eth_getFilterChanges", [ filterId ]).then(function(hashes: Array<string>) {
-                    if (self._pendingFilter != pendingFilter) { return null; }
-
-                    let seq = Promise.resolve();
-                    hashes.forEach(function(hash) {
-                        // @TODO: This should be garbage collected at some point... How? When?
-                        self._emitted["t:" + hash.toLowerCase()] = "pending";
-                        seq = seq.then(function() {
-                            return self.getTransaction(hash).then(function(tx): any {
-                                self.emit("pending", tx);
+        pendingFilter
+            .then(function (filterId) {
+                function poll() {
+                    self.send("eth_getFilterChanges", [filterId])
+                        .then(function (hashes: Array<string>) {
+                            if (self._pendingFilter != pendingFilter) {
                                 return null;
+                            }
+
+                            let seq = Promise.resolve();
+                            hashes.forEach(function (hash) {
+                                // @TODO: This should be garbage collected at some point... How? When?
+                                self._emitted["t:" + hash.toLowerCase()] =
+                                    "pending";
+                                seq = seq.then(function () {
+                                    return self
+                                        .getTransaction(hash)
+                                        .then(function (tx): any {
+                                            self.emit("pending", tx);
+                                            return null;
+                                        });
+                                });
                             });
-                        });
-                    });
-
-                    return seq.then(function() {
-                        return timer(1000);
-                    });
-                }).then(function(): any {
-                    if (self._pendingFilter != pendingFilter) {
-                        self.send("eth_uninstallFilter", [ filterId ]);
-                        return;
-                    }
-                    setTimeout(function() { poll(); }, 0);
 
-                    return null;
-                }).catch((error: Error) => { });
-            }
-            poll();
+                            return seq.then(function () {
+                                return timer(1000);
+                            });
+                        })
+                        .then(function (): any {
+                            if (self._pendingFilter != pendingFilter) {
+                                self.send("eth_uninstallFilter", [filterId]);
+                                return;
+                            }
+                            setTimeout(function () {
+                                poll();
+                            }, 0);
+
+                            return null;
+                        })
+                        .catch((error: Error) => {});
+                }
+                poll();
 
-            return filterId;
-        }).catch((error: Error) => { });
+                return filterId;
+            })
+            .catch((error: Error) => {});
     }
 
     _stopEvent(event: Event): void {
@@ -707,12 +1036,17 @@ export class JsonRpcProvider extends BaseProvider {
     //       before this is called
     // @TODO: This will likely be removed in future versions and prepareRequest
     //        will be the preferred method for this.
-    static hexlifyTransaction(transaction: TransactionRequest, allowExtra?: { [key: string]: boolean }): { [key: string]: string | AccessList } {
+    static hexlifyTransaction(
+        transaction: TransactionRequest,
+        allowExtra?: { [key: string]: boolean },
+    ): { [key: string]: string | AccessList } {
         // Check only allowed properties are given
         const allowed = shallowCopy(allowedTransactionKeys);
         if (allowExtra) {
             for (const key in allowExtra) {
-                if (allowExtra[key]) { allowed[key] = true; }
+                if (allowExtra[key]) {
+                    allowed[key] = true;
+                }
             }
         }
 
@@ -721,15 +1055,30 @@ export class JsonRpcProvider extends BaseProvider {
         const result: { [key: string]: string | AccessList } = {};
 
         // JSON-RPC now requires numeric values to be "quantity" values
-        ["chainId", "gasLimit", "gasPrice", "type", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "value"].forEach(function(key) {
-            if ((<any>transaction)[key] == null) { return; }
+        [
+            "chainId",
+            "gasLimit",
+            "gasPrice",
+            "type",
+            "maxFeePerGas",
+            "maxPriorityFeePerGas",
+            "nonce",
+            "value",
+        ].forEach(function (key) {
+            if ((<any>transaction)[key] == null) {
+                return;
+            }
             const value = hexValue(BigNumber.from((<any>transaction)[key]));
-            if (key === "gasLimit") { key = "gas"; }
+            if (key === "gasLimit") {
+                key = "gas";
+            }
             result[key] = value;
         });
 
-        ["from", "to", "data"].forEach(function(key) {
-            if ((<any>transaction)[key] == null) { return; }
+        ["from", "to", "data"].forEach(function (key) {
+            if ((<any>transaction)[key] == null) {
+                return;
+            }
             result[key] = hexlify((<any>transaction)[key]);
         });