@qevm/providers 1.0.1 → 1.0.2

package/lib/json-rpc-provider.js

@@ -1,85 +1,34 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonRpcProvider = exports.JsonRpcSigner = void 0;
-var abstract_signer_1 = require("@qevm/abstract-signer");
-var bignumber_1 = require("@ethersproject/bignumber");
-var bytes_1 = require("@qevm/bytes");
-var hash_1 = require("@qevm/hash");
-var properties_1 = require("@ethersproject/properties");
-var strings_1 = require("@ethersproject/strings");
-var transactions_1 = require("@qevm/transactions");
-var web_1 = require("@ethersproject/web");
-var logger_1 = require("@ethersproject/logger");
-var _version_1 = require("./_version");
-var logger = new logger_1.Logger(_version_1.version);
-var base_provider_1 = require("./base-provider");
-var errorGas = ["call", "estimateGas"];
+const abstract_signer_1 = require("@qevm/abstract-signer");
+const bignumber_1 = require("@qevm/bignumber");
+const bytes_1 = require("@qevm/bytes");
+const hash_1 = require("@qevm/hash");
+const properties_1 = require("@ethersproject/properties");
+const strings_1 = require("@qevm/strings");
+const transactions_1 = require("@qevm/transactions");
+const web_1 = require("@qevm/web");
+const logger_1 = require("@ethersproject/logger");
+const _version_1 = require("./_version");
+const logger = new logger_1.Logger(_version_1.version);
+const base_provider_1 = require("./base-provider");
+const errorGas = ["call", "estimateGas"];
 function spelunk(value, requireData) {
     if (value == null) {
         return null;
     }
     // These *are* the droids we're looking for.
     if (typeof (value.message) === "string" && value.message.match("reverted")) {
-        var data = (0, bytes_1.isHexString)(value.data) ? value.data : null;
+        const data = (0, bytes_1.isHexString)(value.data) ? value.data : null;
         if (!requireData || data) {
-            return { message: value.message, data: data };
+            return { message: value.message, data };
         }
     }
     // Spelunk further...
     if (typeof (value) === "object") {
-        for (var key in value) {
-            var result = spelunk(value[key], requireData);
+        for (const key in value) {
+            const result = spelunk(value[key], requireData);
             if (result) {
                 return result;
             }
@@ -96,39 +45,34 @@ function spelunk(value, requireData) {
     return null;
 }
 function checkError(method, error, params) {
-    var transaction = params.transaction || params.signedTransaction;
+    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") {
-        var result = spelunk(error, true);
+        const result = spelunk(error, true);
         if (result) {
             return result.data;
         }
         // Nothing descriptive..
         logger.throwError("missing revert data in call exception; Transaction reverted without a reason string", logger_1.Logger.errors.CALL_EXCEPTION, {
-            data: "0x",
-            transaction: transaction,
-            error: error
+            data: "0x", transaction, error
         });
     }
     if (method === "estimateGas") {
         // Try to find something, with a preference on SERVER_ERROR body
-        var result = spelunk(error.body, false);
+        let result = spelunk(error.body, 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_1.Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
-                reason: result.message,
-                method: method,
-                transaction: transaction,
-                error: error
+                reason: result.message, method, transaction, error
             });
         }
     }
     // @TODO: Should we spelunk for message too?
-    var message = error.message;
+    let message = error.message;
     if (error.code === logger_1.Logger.errors.SERVER_ERROR && error.error && typeof (error.error.message) === "string") {
         message = error.error.message;
     }
@@ -142,40 +86,30 @@ function checkError(method, error, params) {
     // "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_1.Logger.errors.INSUFFICIENT_FUNDS, {
-            error: error,
-            method: method,
-            transaction: transaction
+            error, method, transaction
         });
     }
     // "nonce too low"
     if (message.match(/nonce (is )?too low/i)) {
         logger.throwError("nonce has already been used", logger_1.Logger.errors.NONCE_EXPIRED, {
-            error: error,
-            method: method,
-            transaction: transaction
+            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_1.Logger.errors.REPLACEMENT_UNDERPRICED, {
-            error: error,
-            method: method,
-            transaction: transaction
+            error, method, transaction
         });
     }
     // "replacement transaction underpriced"
     if (message.match(/only replay-protected/i)) {
         logger.throwError("legacy pre-eip-155 transactions not supported", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
-            error: error,
-            method: method,
-            transaction: transaction
+            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_1.Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
-            error: error,
-            method: method,
-            transaction: transaction
+            error, method, transaction
         });
     }
     throw error;
@@ -188,7 +122,7 @@ function timer(timeout) {
 function getResult(payload) {
     if (payload.error) {
         // @TODO: not any
-        var error = new Error(payload.error.message);
+        const error = new Error(payload.error.message);
         error.code = payload.error.code;
         error.data = payload.error.data;
         throw error;
@@ -201,57 +135,53 @@ function getLowerCase(value) {
     }
     return value;
 }
-var _constructorGuard = {};
-var JsonRpcSigner = /** @class */ (function (_super) {
-    __extends(JsonRpcSigner, _super);
-    function JsonRpcSigner(constructorGuard, provider, addressOrIndex) {
-        var _this = _super.call(this) || this;
+const _constructorGuard = {};
+class JsonRpcSigner extends abstract_signer_1.Signer {
+    constructor(constructorGuard, provider, addressOrIndex) {
+        super();
         if (constructorGuard !== _constructorGuard) {
             throw new Error("do not call the JsonRpcSigner constructor directly; use provider.getSigner");
         }
-        (0, properties_1.defineReadOnly)(_this, "provider", provider);
+        (0, properties_1.defineReadOnly)(this, "provider", provider);
         if (addressOrIndex == null) {
             addressOrIndex = 0;
         }
         if (typeof (addressOrIndex) === "string") {
-            (0, properties_1.defineReadOnly)(_this, "_address", _this.provider.formatter.address(addressOrIndex));
-            (0, properties_1.defineReadOnly)(_this, "_index", null);
+            (0, properties_1.defineReadOnly)(this, "_address", this.provider.formatter.address(addressOrIndex));
+            (0, properties_1.defineReadOnly)(this, "_index", null);
         }
         else if (typeof (addressOrIndex) === "number") {
-            (0, properties_1.defineReadOnly)(_this, "_index", addressOrIndex);
-            (0, properties_1.defineReadOnly)(_this, "_address", null);
+            (0, properties_1.defineReadOnly)(this, "_index", addressOrIndex);
+            (0, properties_1.defineReadOnly)(this, "_address", null);
         }
         else {
             logger.throwArgumentError("invalid address or index", "addressOrIndex", addressOrIndex);
         }
-        return _this;
     }
-    JsonRpcSigner.prototype.connect = function (provider) {
+    connect(provider) {
         return logger.throwError("cannot alter JSON-RPC Signer connection", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
             operation: "connect"
         });
-    };
-    JsonRpcSigner.prototype.connectUnchecked = function () {
+    }
+    connectUnchecked() {
         return new UncheckedJsonRpcSigner(_constructorGuard, this.provider, this._address || this._index);
-    };
-    JsonRpcSigner.prototype.getAddress = function () {
-        var _this = this;
+    }
+    getAddress() {
         if (this._address) {
             return Promise.resolve(this._address);
         }
-        return this.provider.send("eth_accounts", []).then(function (accounts) {
-            if (accounts.length <= _this._index) {
-                logger.throwError("unknown account #" + _this._index, logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
+        return this.provider.send("eth_accounts", []).then((accounts) => {
+            if (accounts.length <= this._index) {
+                logger.throwError("unknown account #" + this._index, logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
                     operation: "getAddress"
                 });
             }
-            return _this.provider.formatter.address(accounts[_this._index]);
+            return this.provider.formatter.address(accounts[this._index]);
         });
-    };
-    JsonRpcSigner.prototype.sendUncheckedTransaction = function (transaction) {
-        var _this = this;
+    }
+    sendUncheckedTransaction(transaction) {
         transaction = (0, properties_1.shallowCopy)(transaction);
-        var fromAddress = this.getAddress().then(function (address) {
+        const fromAddress = this.getAddress().then((address) => {
             if (address) {
                 address = address.toLowerCase();
             }
@@ -261,35 +191,26 @@ var JsonRpcSigner = /** @class */ (function (_super) {
         // wishes to use this, it is easy to specify explicitly, otherwise
         // we look it up for them.
         if (transaction.gasLimit == null) {
-            var estimate = (0, properties_1.shallowCopy)(transaction);
+            const estimate = (0, properties_1.shallowCopy)(transaction);
             estimate.from = fromAddress;
             transaction.gasLimit = this.provider.estimateGas(estimate);
         }
         if (transaction.to != null) {
-            transaction.to = Promise.resolve(transaction.to).then(function (to) { return __awaiter(_this, void 0, void 0, function () {
-                var address;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (to == null) {
-                                return [2 /*return*/, null];
-                            }
-                            return [4 /*yield*/, this.provider.resolveName(to)];
-                        case 1:
-                            address = _a.sent();
-                            if (address == null) {
-                                logger.throwArgumentError("provided ENS name resolves to null", "tx.to", to);
-                            }
-                            return [2 /*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 (0, properties_1.resolveProperties)({
             tx: (0, properties_1.resolveProperties)(transaction),
             sender: fromAddress
-        }).then(function (_a) {
-            var tx = _a.tx, sender = _a.sender;
+        }).then(({ tx, sender }) => {
             if (tx.from != null) {
                 if (tx.from.toLowerCase() !== sender) {
                     logger.throwArgumentError("from address mismatch", "transaction", transaction);
@@ -298,10 +219,10 @@ var JsonRpcSigner = /** @class */ (function (_super) {
             else {
                 tx.from = sender;
             }
-            var hexTx = _this.provider.constructor.hexlifyTransaction(tx, { from: true });
-            return _this.provider.send("eth_sendTransaction", [hexTx]).then(function (hash) {
+            const hexTx = this.provider.constructor.hexlifyTransaction(tx, { from: true });
+            return this.provider.send("eth_sendTransaction", [hexTx]).then((hash) => {
                 return hash;
-            }, function (error) {
+            }, (error) => {
                 if (typeof (error.message) === "string" && error.message.match(/user denied/i)) {
                     logger.throwError("user rejected transaction", logger_1.Logger.errors.ACTION_REJECTED, {
                         action: "sendTransaction",
@@ -311,180 +232,102 @@ var JsonRpcSigner = /** @class */ (function (_super) {
                 return checkError("sendTransaction", error, hexTx);
             });
         });
-    };
-    JsonRpcSigner.prototype.signTransaction = function (transaction) {
+    }
+    signTransaction(transaction) {
         return logger.throwError("signing transactions is unsupported", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
             operation: "signTransaction"
         });
-    };
-    JsonRpcSigner.prototype.sendTransaction = function (transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var blockNumber, hash, error_1;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.provider._getInternalBlockNumber(100 + 2 * this.provider.pollingInterval)];
-                    case 1:
-                        blockNumber = _a.sent();
-                        return [4 /*yield*/, this.sendUncheckedTransaction(transaction)];
-                    case 2:
-                        hash = _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        _a.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, (0, web_1.poll)(function () { return __awaiter(_this, void 0, void 0, function () {
-                                var tx;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, this.provider.getTransaction(hash)];
-                                        case 1:
-                                            tx = _a.sent();
-                                            if (tx === null) {
-                                                return [2 /*return*/, undefined];
-                                            }
-                                            return [2 /*return*/, this.provider._wrapTransaction(tx, hash, blockNumber)];
-                                    }
-                                });
-                            }); }, { oncePoll: this.provider })];
-                    case 4: 
-                    // 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 [2 /*return*/, _a.sent()];
-                    case 5:
-                        error_1 = _a.sent();
-                        error_1.transactionHash = hash;
-                        throw error_1;
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    JsonRpcSigner.prototype.signMessage = function (message) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, address, error_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        data = ((typeof (message) === "string") ? (0, strings_1.toUtf8Bytes)(message) : message);
-                        return [4 /*yield*/, this.getAddress()];
-                    case 1:
-                        address = _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, this.provider.send("personal_sign", [(0, bytes_1.hexlify)(data), address.toLowerCase()])];
-                    case 3: return [2 /*return*/, _a.sent()];
-                    case 4:
-                        error_2 = _a.sent();
-                        if (typeof (error_2.message) === "string" && error_2.message.match(/user denied/i)) {
-                            logger.throwError("user rejected signing", logger_1.Logger.errors.ACTION_REJECTED, {
-                                action: "signMessage",
-                                from: address,
-                                messageData: message
-                            });
-                        }
-                        throw error_2;
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    JsonRpcSigner.prototype._legacySignMessage = function (message) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, address, error_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        data = ((typeof (message) === "string") ? (0, strings_1.toUtf8Bytes)(message) : message);
-                        return [4 /*yield*/, this.getAddress()];
-                    case 1:
-                        address = _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, this.provider.send("eth_sign", [address.toLowerCase(), (0, bytes_1.hexlify)(data)])];
-                    case 3: 
-                    // https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign
-                    return [2 /*return*/, _a.sent()];
-                    case 4:
-                        error_3 = _a.sent();
-                        if (typeof (error_3.message) === "string" && error_3.message.match(/user denied/i)) {
-                            logger.throwError("user rejected signing", logger_1.Logger.errors.ACTION_REJECTED, {
-                                action: "_legacySignMessage",
-                                from: address,
-                                messageData: message
-                            });
-                        }
-                        throw error_3;
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    JsonRpcSigner.prototype._signTypedData = function (domain, types, value) {
-        return __awaiter(this, void 0, void 0, function () {
-            var populated, address, error_4;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, hash_1._TypedDataEncoder.resolveNames(domain, types, value, function (name) {
-                            return _this.provider.resolveName(name);
-                        })];
-                    case 1:
-                        populated = _a.sent();
-                        return [4 /*yield*/, this.getAddress()];
-                    case 2:
-                        address = _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        _a.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, this.provider.send("eth_signTypedData_v4", [
-                                address.toLowerCase(),
-                                JSON.stringify(hash_1._TypedDataEncoder.getPayload(populated.domain, types, populated.value))
-                            ])];
-                    case 4: return [2 /*return*/, _a.sent()];
-                    case 5:
-                        error_4 = _a.sent();
-                        if (typeof (error_4.message) === "string" && error_4.message.match(/user denied/i)) {
-                            logger.throwError("user rejected signing", logger_1.Logger.errors.ACTION_REJECTED, {
-                                action: "_signTypedData",
-                                from: address,
-                                messageData: { domain: populated.domain, types: types, value: populated.value }
-                            });
-                        }
-                        throw error_4;
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    JsonRpcSigner.prototype.unlock = function (password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var provider, address;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        provider = this.provider;
-                        return [4 /*yield*/, this.getAddress()];
-                    case 1:
-                        address = _a.sent();
-                        return [2 /*return*/, provider.send("personal_unlockAccount", [address.toLowerCase(), password, null])];
+    }
+    async sendTransaction(transaction) {
+        // This cannot be mined any earlier than any recent block
+        const blockNumber = await this.provider._getInternalBlockNumber(100 + 2 * this.provider.pollingInterval);
+        // Send the transaction
+        const hash = await this.sendUncheckedTransaction(transaction);
+        try {
+            // 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 (0, web_1.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) {
+            error.transactionHash = hash;
+            throw error;
+        }
+    }
+    async signMessage(message) {
+        const data = ((typeof (message) === "string") ? (0, strings_1.toUtf8Bytes)(message) : message);
+        const address = await this.getAddress();
+        try {
+            return await this.provider.send("personal_sign", [(0, bytes_1.hexlify)(data), address.toLowerCase()]);
+        }
+        catch (error) {
+            if (typeof (error.message) === "string" && error.message.match(/user denied/i)) {
+                logger.throwError("user rejected signing", logger_1.Logger.errors.ACTION_REJECTED, {
+                    action: "signMessage",
+                    from: address,
+                    messageData: message
+                });
+            }
+            throw error;
+        }
+    }
+    async _legacySignMessage(message) {
+        const data = ((typeof (message) === "string") ? (0, strings_1.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(), (0, bytes_1.hexlify)(data)]);
+        }
+        catch (error) {
+            if (typeof (error.message) === "string" && error.message.match(/user denied/i)) {
+                logger.throwError("user rejected signing", logger_1.Logger.errors.ACTION_REJECTED, {
+                    action: "_legacySignMessage",
+                    from: address,
+                    messageData: message
+                });
+            }
+            throw error;
+        }
+    }
+    async _signTypedData(domain, types, value) {
+        // Populate any ENS names (in-place)
+        const populated = await hash_1._TypedDataEncoder.resolveNames(domain, types, value, (name) => {
+            return this.provider.resolveName(name);
         });
-    };
-    return JsonRpcSigner;
-}(abstract_signer_1.Signer));
+        const address = await this.getAddress();
+        try {
+            return await this.provider.send("eth_signTypedData_v4", [
+                address.toLowerCase(),
+                JSON.stringify(hash_1._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_1.Logger.errors.ACTION_REJECTED, {
+                    action: "_signTypedData",
+                    from: address,
+                    messageData: { domain: populated.domain, types, value: populated.value }
+                });
+            }
+            throw error;
+        }
+    }
+    async unlock(password) {
+        const provider = this.provider;
+        const address = await this.getAddress();
+        return provider.send("personal_unlockAccount", [address.toLowerCase(), password, null]);
+    }
+}
 exports.JsonRpcSigner = JsonRpcSigner;
-var UncheckedJsonRpcSigner = /** @class */ (function (_super) {
-    __extends(UncheckedJsonRpcSigner, _super);
-    function UncheckedJsonRpcSigner() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    UncheckedJsonRpcSigner.prototype.sendTransaction = function (transaction) {
-        var _this = this;
-        return this.sendUncheckedTransaction(transaction).then(function (hash) {
+class UncheckedJsonRpcSigner extends JsonRpcSigner {
+    sendTransaction(transaction) {
+        return this.sendUncheckedTransaction(transaction).then((hash) => {
             return {
                 hash: hash,
                 nonce: null,
@@ -495,139 +338,107 @@ var UncheckedJsonRpcSigner = /** @class */ (function (_super) {
                 chainId: null,
                 confirmations: 0,
                 from: null,
-                wait: function (confirmations) { return _this.provider.waitForTransaction(hash, confirmations); }
+                wait: (confirmations) => { return this.provider.waitForTransaction(hash, confirmations); }
             };
         });
-    };
-    return UncheckedJsonRpcSigner;
-}(JsonRpcSigner));
-var allowedTransactionKeys = {
+    }
+}
+const allowedTransactionKeys = {
     chainId: true, data: true, gasLimit: true, gasPrice: true, nonce: true, to: true, value: true,
     type: true, accessList: true,
     maxFeePerGas: true, maxPriorityFeePerGas: true
 };
-var JsonRpcProvider = /** @class */ (function (_super) {
-    __extends(JsonRpcProvider, _super);
-    function JsonRpcProvider(url, network) {
-        var _this = this;
-        var networkOrReady = network;
+class JsonRpcProvider extends base_provider_1.BaseProvider {
+    get _cache() {
+        if (this._eventLoopCache == null) {
+            this._eventLoopCache = {};
+        }
+        return this._eventLoopCache;
+    }
+    constructor(url, network) {
+        let networkOrReady = network;
         // The network is unknown, query the JSON-RPC for it
         if (networkOrReady == null) {
-            networkOrReady = new Promise(function (resolve, reject) {
-                setTimeout(function () {
-                    _this.detectNetwork().then(function (network) {
+            networkOrReady = new Promise((resolve, reject) => {
+                setTimeout(() => {
+                    this.detectNetwork().then((network) => {
                         resolve(network);
-                    }, function (error) {
+                    }, (error) => {
                         reject(error);
                     });
                 }, 0);
             });
         }
-        _this = _super.call(this, networkOrReady) || this;
+        super(networkOrReady);
         // Default URL
         if (!url) {
-            url = (0, properties_1.getStatic)(_this.constructor, "defaultUrl")();
+            url = (0, properties_1.getStatic)(this.constructor, "defaultUrl")();
         }
         if (typeof (url) === "string") {
-            (0, properties_1.defineReadOnly)(_this, "connection", Object.freeze({
+            (0, properties_1.defineReadOnly)(this, "connection", Object.freeze({
                 url: url
             }));
         }
         else {
-            (0, properties_1.defineReadOnly)(_this, "connection", Object.freeze((0, properties_1.shallowCopy)(url)));
+            (0, properties_1.defineReadOnly)(this, "connection", Object.freeze((0, properties_1.shallowCopy)(url)));
         }
-        _this._nextId = 42;
-        return _this;
+        this._nextId = 42;
     }
-    Object.defineProperty(JsonRpcProvider.prototype, "_cache", {
-        get: function () {
-            if (this._eventLoopCache == null) {
-                this._eventLoopCache = {};
-            }
-            return this._eventLoopCache;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    JsonRpcProvider.defaultUrl = function () {
+    static defaultUrl() {
         return "http:/\/localhost:8545";
-    };
-    JsonRpcProvider.prototype.detectNetwork = function () {
-        var _this = this;
+    }
+    detectNetwork() {
         if (!this._cache["detectNetwork"]) {
             this._cache["detectNetwork"] = this._uncachedDetectNetwork();
             // Clear this cache at the beginning of the next event loop
-            setTimeout(function () {
-                _this._cache["detectNetwork"] = null;
+            setTimeout(() => {
+                this._cache["detectNetwork"] = null;
             }, 0);
         }
         return this._cache["detectNetwork"];
-    };
-    JsonRpcProvider.prototype._uncachedDetectNetwork = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var chainId, error_5, error_6, getNetwork;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, timer(0)];
-                    case 1:
-                        _a.sent();
-                        chainId = null;
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 9]);
-                        return [4 /*yield*/, this.send("eth_chainId", [])];
-                    case 3:
-                        chainId = _a.sent();
-                        return [3 /*break*/, 9];
-                    case 4:
-                        error_5 = _a.sent();
-                        _a.label = 5;
-                    case 5:
-                        _a.trys.push([5, 7, , 8]);
-                        return [4 /*yield*/, this.send("net_version", [])];
-                    case 6:
-                        chainId = _a.sent();
-                        return [3 /*break*/, 8];
-                    case 7:
-                        error_6 = _a.sent();
-                        return [3 /*break*/, 8];
-                    case 8: return [3 /*break*/, 9];
-                    case 9:
-                        if (chainId != null) {
-                            getNetwork = (0, properties_1.getStatic)(this.constructor, "getNetwork");
-                            try {
-                                return [2 /*return*/, getNetwork(bignumber_1.BigNumber.from(chainId).toNumber())];
-                            }
-                            catch (error) {
-                                return [2 /*return*/, logger.throwError("could not detect network", logger_1.Logger.errors.NETWORK_ERROR, {
-                                        chainId: chainId,
-                                        event: "invalidNetwork",
-                                        serverError: error
-                                    })];
-                            }
-                        }
-                        return [2 /*return*/, logger.throwError("could not detect network", logger_1.Logger.errors.NETWORK_ERROR, {
-                                event: "noNetwork"
-                            })];
-                }
-            });
+    }
+    async _uncachedDetectNetwork() {
+        await timer(0);
+        let chainId = null;
+        try {
+            chainId = await this.send("eth_chainId", []);
+        }
+        catch (error) {
+            try {
+                chainId = await this.send("net_version", []);
+            }
+            catch (error) { }
+        }
+        if (chainId != null) {
+            const getNetwork = (0, properties_1.getStatic)(this.constructor, "getNetwork");
+            try {
+                return getNetwork(bignumber_1.BigNumber.from(chainId).toNumber());
+            }
+            catch (error) {
+                return logger.throwError("could not detect network", logger_1.Logger.errors.NETWORK_ERROR, {
+                    chainId: chainId,
+                    event: "invalidNetwork",
+                    serverError: error
+                });
+            }
+        }
+        return logger.throwError("could not detect network", logger_1.Logger.errors.NETWORK_ERROR, {
+            event: "noNetwork"
         });
-    };
-    JsonRpcProvider.prototype.getSigner = function (addressOrIndex) {
+    }
+    getSigner(addressOrIndex) {
         return new JsonRpcSigner(_constructorGuard, this, addressOrIndex);
-    };
-    JsonRpcProvider.prototype.getUncheckedSigner = function (addressOrIndex) {
+    }
+    getUncheckedSigner(addressOrIndex) {
         return this.getSigner(addressOrIndex).connectUnchecked();
-    };
-    JsonRpcProvider.prototype.listAccounts = function () {
-        var _this = this;
-        return this.send("eth_accounts", []).then(function (accounts) {
-            return accounts.map(function (a) { return _this.formatter.address(a); });
+    }
+    listAccounts() {
+        return this.send("eth_accounts", []).then((accounts) => {
+            return accounts.map((a) => this.formatter.address(a));
         });
-    };
-    JsonRpcProvider.prototype.send = function (method, params) {
-        var _this = this;
-        var request = {
+    }
+    send(method, params) {
+        const request = {
             method: method,
             params: params,
             id: (this._nextId++),
@@ -640,37 +451,37 @@ var JsonRpcProvider = /** @class */ (function (_super) {
         });
         // 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.
-        var 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];
         }
-        var result = (0, web_1.fetchJson)(this.connection, JSON.stringify(request), getResult).then(function (result) {
-            _this.emit("debug", {
+        const result = (0, web_1.fetchJson)(this.connection, JSON.stringify(request), getResult).then((result) => {
+            this.emit("debug", {
                 action: "response",
                 request: request,
                 response: result,
-                provider: _this
+                provider: this
             });
             return result;
-        }, function (error) {
-            _this.emit("debug", {
+        }, (error) => {
+            this.emit("debug", {
                 action: "response",
                 error: error,
                 request: request,
-                provider: _this
+                provider: this
             });
             throw error;
         });
         // Cache the fetch, but clear it on the next event loop
         if (cache) {
             this._cache[method] = result;
-            setTimeout(function () {
-                _this._cache[method] = null;
+            setTimeout(() => {
+                this._cache[method] = null;
             }, 0);
         }
         return result;
-    };
-    JsonRpcProvider.prototype.prepareRequest = function (method, params) {
+    }
+    prepareRequest(method, params) {
         switch (method) {
             case "getBlockNumber":
                 return ["eth_blockNumber", []];
@@ -699,11 +510,11 @@ var JsonRpcProvider = /** @class */ (function (_super) {
             case "getTransactionReceipt":
                 return ["eth_getTransactionReceipt", [params.transactionHash]];
             case "call": {
-                var hexlifyTransaction = (0, properties_1.getStatic)(this.constructor, "hexlifyTransaction");
+                const hexlifyTransaction = (0, properties_1.getStatic)(this.constructor, "hexlifyTransaction");
                 return ["eth_call", [hexlifyTransaction(params.transaction, { from: true }), params.blockTag]];
             }
             case "estimateGas": {
-                var hexlifyTransaction = (0, properties_1.getStatic)(this.constructor, "hexlifyTransaction");
+                const hexlifyTransaction = (0, properties_1.getStatic)(this.constructor, "hexlifyTransaction");
                 return ["eth_estimateGas", [hexlifyTransaction(params.transaction, { from: true })]];
             }
             case "getLogs":
@@ -715,57 +526,48 @@ var JsonRpcProvider = /** @class */ (function (_super) {
                 break;
         }
         return null;
-    };
-    JsonRpcProvider.prototype.perform = function (method, params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var tx, feeData, args, error_7;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(method === "call" || method === "estimateGas")) return [3 /*break*/, 2];
-                        tx = params.transaction;
-                        if (!(tx && tx.type != null && bignumber_1.BigNumber.from(tx.type).isZero())) return [3 /*break*/, 2];
-                        if (!(tx.maxFeePerGas == null && tx.maxPriorityFeePerGas == null)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.getFeeData()];
-                    case 1:
-                        feeData = _a.sent();
-                        if (feeData.maxFeePerGas == null && feeData.maxPriorityFeePerGas == null) {
-                            // Network doesn't know about EIP-1559 (and hence type)
-                            params = (0, properties_1.shallowCopy)(params);
-                            params.transaction = (0, properties_1.shallowCopy)(tx);
-                            delete params.transaction.type;
-                        }
-                        _a.label = 2;
-                    case 2:
-                        args = this.prepareRequest(method, params);
-                        if (args == null) {
-                            logger.throwError(method + " not implemented", logger_1.Logger.errors.NOT_IMPLEMENTED, { operation: method });
-                        }
-                        _a.label = 3;
-                    case 3:
-                        _a.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, this.send(args[0], args[1])];
-                    case 4: return [2 /*return*/, _a.sent()];
-                    case 5:
-                        error_7 = _a.sent();
-                        return [2 /*return*/, checkError(method, error_7, params)];
-                    case 6: return [2 /*return*/];
+    }
+    async perform(method, params) {
+        // Legacy networks do not like the type field being passed along (which
+        // is fair), so we delete type if it is 0 and a non-EIP-1559 network
+        if (method === "call" || method === "estimateGas") {
+            const tx = params.transaction;
+            if (tx && tx.type != null && bignumber_1.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) {
+                    const feeData = await this.getFeeData();
+                    if (feeData.maxFeePerGas == null && feeData.maxPriorityFeePerGas == null) {
+                        // Network doesn't know about EIP-1559 (and hence type)
+                        params = (0, properties_1.shallowCopy)(params);
+                        params.transaction = (0, properties_1.shallowCopy)(tx);
+                        delete params.transaction.type;
+                    }
                 }
-            });
-        });
-    };
-    JsonRpcProvider.prototype._startEvent = function (event) {
+            }
+        }
+        const args = this.prepareRequest(method, params);
+        if (args == null) {
+            logger.throwError(method + " not implemented", logger_1.Logger.errors.NOT_IMPLEMENTED, { operation: method });
+        }
+        try {
+            return await this.send(args[0], args[1]);
+        }
+        catch (error) {
+            return checkError(method, error, params);
+        }
+    }
+    _startEvent(event) {
         if (event.tag === "pending") {
             this._startPending();
         }
-        _super.prototype._startEvent.call(this, event);
-    };
-    JsonRpcProvider.prototype._startPending = function () {
+        super._startEvent(event);
+    }
+    _startPending() {
         if (this._pendingFilter != null) {
             return;
         }
-        var self = this;
-        var pendingFilter = this.send("eth_newPendingTransactionFilter", []);
+        const self = this;
+        const pendingFilter = this.send("eth_newPendingTransactionFilter", []);
         this._pendingFilter = pendingFilter;
         pendingFilter.then(function (filterId) {
             function poll() {
@@ -773,7 +575,7 @@ var JsonRpcProvider = /** @class */ (function (_super) {
                     if (self._pendingFilter != pendingFilter) {
                         return null;
                     }
-                    var seq = Promise.resolve();
+                    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";
@@ -794,18 +596,18 @@ var JsonRpcProvider = /** @class */ (function (_super) {
                     }
                     setTimeout(function () { poll(); }, 0);
                     return null;
-                }).catch(function (error) { });
+                }).catch((error) => { });
             }
             poll();
             return filterId;
-        }).catch(function (error) { });
-    };
-    JsonRpcProvider.prototype._stopEvent = function (event) {
+        }).catch((error) => { });
+    }
+    _stopEvent(event) {
         if (event.tag === "pending" && this.listenerCount("pending") === 0) {
             this._pendingFilter = null;
         }
-        _super.prototype._stopEvent.call(this, event);
-    };
+        super._stopEvent(event);
+    }
     // Convert an ethers.js transaction into a JSON-RPC transaction
     //  - gasLimit => gas
     //  - All values hexlified
@@ -815,24 +617,24 @@ var JsonRpcProvider = /** @class */ (function (_super) {
     //       before this is called
     // @TODO: This will likely be removed in future versions and prepareRequest
     //        will be the preferred method for this.
-    JsonRpcProvider.hexlifyTransaction = function (transaction, allowExtra) {
+    static hexlifyTransaction(transaction, allowExtra) {
         // Check only allowed properties are given
-        var allowed = (0, properties_1.shallowCopy)(allowedTransactionKeys);
+        const allowed = (0, properties_1.shallowCopy)(allowedTransactionKeys);
         if (allowExtra) {
-            for (var key in allowExtra) {
+            for (const key in allowExtra) {
                 if (allowExtra[key]) {
                     allowed[key] = true;
                 }
             }
         }
         (0, properties_1.checkProperties)(transaction, allowed);
-        var result = {};
+        const result = {};
         // JSON-RPC now requires numeric values to be "quantity" values
         ["chainId", "gasLimit", "gasPrice", "type", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "value"].forEach(function (key) {
             if (transaction[key] == null) {
                 return;
             }
-            var value = (0, bytes_1.hexValue)(bignumber_1.BigNumber.from(transaction[key]));
+            const value = (0, bytes_1.hexValue)(bignumber_1.BigNumber.from(transaction[key]));
             if (key === "gasLimit") {
                 key = "gas";
             }
@@ -848,8 +650,7 @@ var JsonRpcProvider = /** @class */ (function (_super) {
             result["accessList"] = (0, transactions_1.accessListify)(transaction.accessList);
         }
         return result;
-    };
-    return JsonRpcProvider;
-}(base_provider_1.BaseProvider));
+    }
+}
 exports.JsonRpcProvider = JsonRpcProvider;
 //# sourceMappingURL=json-rpc-provider.js.map