@qevm/providers 1.0.1 → 1.0.3

package/lib/base-provider.js

@@ -1,78 +1,27 @@
 "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 };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseProvider = exports.Resolver = exports.Event = void 0;
-var abstract_provider_1 = require("@qevm/abstract-provider");
-var base64_1 = require("@ethersproject/base64");
-var basex_1 = require("@ethersproject/basex");
-var bignumber_1 = require("@ethersproject/bignumber");
-var bytes_1 = require("@qevm/bytes");
-var constants_1 = require("@ethersproject/constants");
-var hash_1 = require("@qevm/hash");
-var networks_1 = require("@ethersproject/networks");
-var properties_1 = require("@ethersproject/properties");
-var sha2_1 = require("@ethersproject/sha2");
-var strings_1 = require("@ethersproject/strings");
-var web_1 = require("@ethersproject/web");
-var bech32_1 = __importDefault(require("bech32"));
-var logger_1 = require("@ethersproject/logger");
-var _version_1 = require("./_version");
-var logger = new logger_1.Logger(_version_1.version);
-var formatter_1 = require("./formatter");
-var MAX_CCIP_REDIRECTS = 10;
+const abstract_provider_1 = require("@qevm/abstract-provider");
+const base64_1 = require("@qevm/base64");
+const basex_1 = require("@qevm/basex");
+const bignumber_1 = require("@qevm/bignumber");
+const bytes_1 = require("@qevm/bytes");
+const constants_1 = require("@qevm/constants");
+const hash_1 = require("@qevm/hash");
+const networks_1 = require("@qevm/networks");
+const properties_1 = require("@qevm/properties");
+const sha2_1 = require("@qevm/sha2");
+const strings_1 = require("@qevm/strings");
+const web_1 = require("@qevm/web");
+const bech32_1 = __importDefault(require("bech32"));
+const logger_1 = require("@qevm/logger");
+const _version_1 = require("./_version");
+const logger = new logger_1.Logger(_version_1.version);
+const formatter_1 = require("./formatter");
+const MAX_CCIP_REDIRECTS = 10;
 //////////////////////////////
 // Event Serializeing
 function checkTopic(topic) {
@@ -90,39 +39,41 @@ function serializeTopics(topics) {
     while (topics.length > 0 && topics[topics.length - 1] == null) {
         topics.pop();
     }
-    return topics.map(function (topic) {
+    return topics
+        .map((topic) => {
         if (Array.isArray(topic)) {
             // Only track unique OR-topics
-            var unique_1 = {};
-            topic.forEach(function (topic) {
-                unique_1[checkTopic(topic)] = true;
+            const unique = {};
+            topic.forEach((topic) => {
+                unique[checkTopic(topic)] = true;
             });
             // The order of OR-topics does not matter
-            var sorted = Object.keys(unique_1);
+            const sorted = Object.keys(unique);
             sorted.sort();
             return sorted.join("|");
         }
         else {
             return checkTopic(topic);
         }
-    }).join("&");
+    })
+        .join("&");
 }
 function deserializeTopics(data) {
     if (data === "") {
         return [];
     }
-    return data.split(/&/g).map(function (topic) {
+    return data.split(/&/g).map((topic) => {
         if (topic === "") {
             return [];
         }
-        var comps = topic.split("|").map(function (topic) {
-            return ((topic === "null") ? null : topic);
+        const comps = topic.split("|").map((topic) => {
+            return topic === "null" ? null : topic;
         });
-        return ((comps.length === 1) ? comps[0] : comps);
+        return comps.length === 1 ? comps[0] : comps;
     });
 }
 function getEventTag(eventName) {
-    if (typeof (eventName) === "string") {
+    if (typeof eventName === "string") {
         eventName = eventName.toLowerCase();
         if ((0, bytes_1.hexDataLength)(eventName) === 32) {
             return "tx:" + eventName;
@@ -138,18 +89,21 @@ function getEventTag(eventName) {
         logger.warn("not implemented");
         throw new Error("not implemented");
     }
-    else if (eventName && typeof (eventName) === "object") {
-        return "filter:" + (eventName.address || "*") + ":" + serializeTopics(eventName.topics || []);
+    else if (eventName && typeof eventName === "object") {
+        return ("filter:" +
+            (eventName.address || "*") +
+            ":" +
+            serializeTopics(eventName.topics || []));
     }
     throw new Error("invalid event - " + eventName);
 }
 //////////////////////////////
 // Helper Object
 function getTime() {
-    return (new Date()).getTime();
+    return new Date().getTime();
 }
 function stall(duration) {
-    return new Promise(function (resolve) {
+    return new Promise((resolve) => {
         setTimeout(resolve, duration);
     });
 }
@@ -167,75 +121,57 @@ function stall(duration) {
  *   - topics array
  *   - transaction hash
  */
-var PollableEvents = ["block", "network", "pending", "poll"];
-var Event = /** @class */ (function () {
-    function Event(tag, listener, once) {
+const PollableEvents = ["block", "network", "pending", "poll"];
+class Event {
+    constructor(tag, listener, once) {
         (0, properties_1.defineReadOnly)(this, "tag", tag);
         (0, properties_1.defineReadOnly)(this, "listener", listener);
         (0, properties_1.defineReadOnly)(this, "once", once);
         this._lastBlockNumber = -2;
         this._inflight = false;
     }
-    Object.defineProperty(Event.prototype, "event", {
-        get: function () {
-            switch (this.type) {
-                case "tx":
-                    return this.hash;
-                case "filter":
-                    return this.filter;
-            }
-            return this.tag;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Event.prototype, "type", {
-        get: function () {
-            return this.tag.split(":")[0];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Event.prototype, "hash", {
-        get: function () {
-            var comps = this.tag.split(":");
-            if (comps[0] !== "tx") {
-                return null;
-            }
-            return comps[1];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Event.prototype, "filter", {
-        get: function () {
-            var comps = this.tag.split(":");
-            if (comps[0] !== "filter") {
-                return null;
-            }
-            var address = comps[1];
-            var topics = deserializeTopics(comps[2]);
-            var filter = {};
-            if (topics.length > 0) {
-                filter.topics = topics;
-            }
-            if (address && address !== "*") {
-                filter.address = address;
-            }
-            return filter;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Event.prototype.pollable = function () {
+    get event() {
+        switch (this.type) {
+            case "tx":
+                return this.hash;
+            case "filter":
+                return this.filter;
+        }
+        return this.tag;
+    }
+    get type() {
+        return this.tag.split(":")[0];
+    }
+    get hash() {
+        const comps = this.tag.split(":");
+        if (comps[0] !== "tx") {
+            return null;
+        }
+        return comps[1];
+    }
+    get filter() {
+        const comps = this.tag.split(":");
+        if (comps[0] !== "filter") {
+            return null;
+        }
+        const address = comps[1];
+        const topics = deserializeTopics(comps[2]);
+        const filter = {};
+        if (topics.length > 0) {
+            filter.topics = topics;
+        }
+        if (address && address !== "*") {
+            filter.address = address;
+        }
+        return filter;
+    }
+    pollable() {
         return (this.tag.indexOf(":") >= 0 || PollableEvents.indexOf(this.tag) >= 0);
-    };
-    return Event;
-}());
+    }
+}
 exports.Event = Event;
-;
 // https://github.com/satoshilabs/slips/blob/master/slip-0044.md
-var coinInfos = {
+const coinInfos = {
     "0": { symbol: "btc", p2pkh: 0x00, p2sh: 0x05, prefix: "bc" },
     "2": { symbol: "ltc", p2pkh: 0x30, p2sh: 0x32, prefix: "ltc" },
     "3": { symbol: "doge", p2pkh: 0x1e, p2sh: 0x16 },
@@ -250,8 +186,8 @@ function bytes32ify(value) {
 function base58Encode(data) {
     return basex_1.Base58.encode((0, bytes_1.concat)([data, (0, bytes_1.hexDataSlice)((0, sha2_1.sha256)((0, sha2_1.sha256)(data)), 0, 4)]));
 }
-var matcherIpfs = new RegExp("^(ipfs):/\/(.*)$", "i");
-var matchers = [
+const matcherIpfs = new RegExp("^(ipfs):/\/(.*)$", "i");
+const matchers = [
     new RegExp("^(https):/\/(.*)$", "i"),
     new RegExp("^(data):(.*)$", "i"),
     matcherIpfs,
@@ -268,8 +204,8 @@ function _parseBytes(result, start) {
     if (result === "0x") {
         return null;
     }
-    var offset = bignumber_1.BigNumber.from((0, bytes_1.hexDataSlice)(result, start, start + 32)).toNumber();
-    var length = bignumber_1.BigNumber.from((0, bytes_1.hexDataSlice)(result, offset, offset + 32)).toNumber();
+    const offset = bignumber_1.BigNumber.from((0, bytes_1.hexDataSlice)(result, start, start + 32)).toNumber();
+    const length = bignumber_1.BigNumber.from((0, bytes_1.hexDataSlice)(result, offset, offset + 32)).toNumber();
     return (0, bytes_1.hexDataSlice)(result, offset + 32, offset + 32 + length);
 }
 // Trim off the ipfs:// prefix and return the default gateway URL
@@ -283,36 +219,36 @@ function getIpfsLink(link) {
     else {
         logger.throwArgumentError("unsupported IPFS format", "link", link);
     }
-    return "https://gateway.ipfs.io/ipfs/" + link;
+    return `https:/\/gateway.ipfs.io/ipfs/${link}`;
 }
 function numPad(value) {
-    var result = (0, bytes_1.arrayify)(value);
+    const result = (0, bytes_1.arrayify)(value);
     if (result.length > 32) {
         throw new Error("internal; should not happen");
     }
-    var padded = new Uint8Array(32);
+    const padded = new Uint8Array(32);
     padded.set(result, 32 - result.length);
     return padded;
 }
 function bytesPad(value) {
-    if ((value.length % 32) === 0) {
+    if (value.length % 32 === 0) {
         return value;
     }
-    var result = new Uint8Array(Math.ceil(value.length / 32) * 32);
+    const result = new Uint8Array(Math.ceil(value.length / 32) * 32);
     result.set(value);
     return result;
 }
 // ABI Encodes a series of (bytes, bytes, ...)
 function encodeBytes(datas) {
-    var result = [];
-    var byteCount = 0;
+    const result = [];
+    let byteCount = 0;
     // Add place-holders for pointers as we add items
-    for (var i = 0; i < datas.length; i++) {
+    for (let i = 0; i < datas.length; i++) {
         result.push(null);
         byteCount += 32;
     }
-    for (var i = 0; i < datas.length; i++) {
-        var data = (0, bytes_1.arrayify)(datas[i]);
+    for (let i = 0; i < datas.length; i++) {
+        const data = (0, bytes_1.arrayify)(datas[i]);
         // Update the bytes offset
         result[i] = numPad(byteCount);
         // The length and padded value of data
@@ -322,420 +258,401 @@ function encodeBytes(datas) {
     }
     return (0, bytes_1.hexConcat)(result);
 }
-var Resolver = /** @class */ (function () {
+class Resolver {
     // The resolvedAddress is only for creating a ReverseLookup resolver
-    function Resolver(provider, address, name, resolvedAddress) {
+    constructor(provider, address, name, resolvedAddress) {
         (0, properties_1.defineReadOnly)(this, "provider", provider);
         (0, properties_1.defineReadOnly)(this, "name", name);
         (0, properties_1.defineReadOnly)(this, "address", provider.formatter.address(address));
         (0, properties_1.defineReadOnly)(this, "_resolvedAddress", resolvedAddress);
     }
-    Resolver.prototype.supportsWildcard = function () {
-        var _this = this;
+    supportsWildcard() {
         if (!this._supportsEip2544) {
             // supportsInterface(bytes4 = selector("resolve(bytes,bytes)"))
-            this._supportsEip2544 = this.provider.call({
+            this._supportsEip2544 = this.provider
+                .call({
                 to: this.address,
-                data: "0x01ffc9a79061b92300000000000000000000000000000000000000000000000000000000"
-            }).then(function (result) {
+                data: "0x01ffc9a79061b92300000000000000000000000000000000000000000000000000000000",
+            })
+                .then((result) => {
                 return bignumber_1.BigNumber.from(result).eq(1);
-            }).catch(function (error) {
+            })
+                .catch((error) => {
                 if (error.code === logger_1.Logger.errors.CALL_EXCEPTION) {
                     return false;
                 }
                 // Rethrow the error: link is down, etc. Let future attempts retry.
-                _this._supportsEip2544 = null;
+                this._supportsEip2544 = null;
                 throw error;
             });
         }
         return this._supportsEip2544;
-    };
-    Resolver.prototype._fetch = function (selector, parameters) {
-        return __awaiter(this, void 0, void 0, function () {
-            var tx, parseBytes, result, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        tx = {
-                            to: this.address,
-                            ccipReadEnabled: true,
-                            data: (0, bytes_1.hexConcat)([selector, (0, hash_1.namehash)(this.name), (parameters || "0x")])
-                        };
-                        parseBytes = false;
-                        return [4 /*yield*/, this.supportsWildcard()];
-                    case 1:
-                        if (_a.sent()) {
-                            parseBytes = true;
-                            // selector("resolve(bytes,bytes)")
-                            tx.data = (0, bytes_1.hexConcat)(["0x9061b923", encodeBytes([(0, hash_1.dnsEncode)(this.name), tx.data])]);
-                        }
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, this.provider.call(tx)];
-                    case 3:
-                        result = _a.sent();
-                        if (((0, bytes_1.arrayify)(result).length % 32) === 4) {
-                            logger.throwError("resolver threw error", logger_1.Logger.errors.CALL_EXCEPTION, {
-                                transaction: tx, data: result
-                            });
-                        }
-                        if (parseBytes) {
-                            result = _parseBytes(result, 0);
-                        }
-                        return [2 /*return*/, result];
-                    case 4:
-                        error_1 = _a.sent();
-                        if (error_1.code === logger_1.Logger.errors.CALL_EXCEPTION) {
-                            return [2 /*return*/, null];
-                        }
-                        throw error_1;
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Resolver.prototype._fetchBytes = function (selector, parameters) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this._fetch(selector, parameters)];
-                    case 1:
-                        result = _a.sent();
-                        if (result != null) {
-                            return [2 /*return*/, _parseBytes(result, 0)];
-                        }
-                        return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    Resolver.prototype._getAddress = function (coinType, hexBytes) {
-        var coinInfo = coinInfos[String(coinType)];
+    }
+    async _fetch(selector, parameters) {
+        // e.g. keccak256("addr(bytes32,uint256)")
+        const tx = {
+            to: this.address,
+            ccipReadEnabled: true,
+            data: (0, bytes_1.hexConcat)([
+                selector,
+                (0, hash_1.namehash)(this.name),
+                parameters || "0x",
+            ]),
+        };
+        // Wildcard support; use EIP-2544 to resolve the request
+        let parseBytes = false;
+        if (await this.supportsWildcard()) {
+            parseBytes = true;
+            // selector("resolve(bytes,bytes)")
+            tx.data = (0, bytes_1.hexConcat)([
+                "0x9061b923",
+                encodeBytes([(0, hash_1.dnsEncode)(this.name), tx.data]),
+            ]);
+        }
+        try {
+            let result = await this.provider.call(tx);
+            if ((0, bytes_1.arrayify)(result).length % 32 === 4) {
+                logger.throwError("resolver threw error", logger_1.Logger.errors.CALL_EXCEPTION, {
+                    transaction: tx,
+                    data: result,
+                });
+            }
+            if (parseBytes) {
+                result = _parseBytes(result, 0);
+            }
+            return result;
+        }
+        catch (error) {
+            if (error.code === logger_1.Logger.errors.CALL_EXCEPTION) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async _fetchBytes(selector, parameters) {
+        const result = await this._fetch(selector, parameters);
+        if (result != null) {
+            return _parseBytes(result, 0);
+        }
+        return null;
+    }
+    _getAddress(coinType, hexBytes) {
+        const coinInfo = coinInfos[String(coinType)];
         if (coinInfo == null) {
-            logger.throwError("unsupported coin type: " + coinType, logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "getAddress(" + coinType + ")"
+            logger.throwError(`unsupported coin type: ${coinType}`, logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
+                operation: `getAddress(${coinType})`,
             });
         }
         if (coinInfo.ilk === "eth") {
             return this.provider.formatter.address(hexBytes);
         }
-        var bytes = (0, bytes_1.arrayify)(hexBytes);
+        const bytes = (0, bytes_1.arrayify)(hexBytes);
         // P2PKH: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
         if (coinInfo.p2pkh != null) {
-            var p2pkh = hexBytes.match(/^0x76a9([0-9a-f][0-9a-f])([0-9a-f]*)88ac$/);
+            const p2pkh = hexBytes.match(/^0x76a9([0-9a-f][0-9a-f])([0-9a-f]*)88ac$/);
             if (p2pkh) {
-                var length_1 = parseInt(p2pkh[1], 16);
-                if (p2pkh[2].length === length_1 * 2 && length_1 >= 1 && length_1 <= 75) {
-                    return base58Encode((0, bytes_1.concat)([[coinInfo.p2pkh], ("0x" + p2pkh[2])]));
+                const length = parseInt(p2pkh[1], 16);
+                if (p2pkh[2].length === length * 2 &&
+                    length >= 1 &&
+                    length <= 75) {
+                    return base58Encode((0, bytes_1.concat)([[coinInfo.p2pkh], "0x" + p2pkh[2]]));
                 }
             }
         }
         // P2SH: OP_HASH160 <scriptHash> OP_EQUAL
         if (coinInfo.p2sh != null) {
-            var p2sh = hexBytes.match(/^0xa9([0-9a-f][0-9a-f])([0-9a-f]*)87$/);
+            const p2sh = hexBytes.match(/^0xa9([0-9a-f][0-9a-f])([0-9a-f]*)87$/);
             if (p2sh) {
-                var length_2 = parseInt(p2sh[1], 16);
-                if (p2sh[2].length === length_2 * 2 && length_2 >= 1 && length_2 <= 75) {
-                    return base58Encode((0, bytes_1.concat)([[coinInfo.p2sh], ("0x" + p2sh[2])]));
+                const length = parseInt(p2sh[1], 16);
+                if (p2sh[2].length === length * 2 &&
+                    length >= 1 &&
+                    length <= 75) {
+                    return base58Encode((0, bytes_1.concat)([[coinInfo.p2sh], "0x" + p2sh[2]]));
                 }
             }
         }
         // Bech32
         if (coinInfo.prefix != null) {
-            var length_3 = bytes[1];
+            const length = bytes[1];
             // https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#witness-program
-            var version_1 = bytes[0];
-            if (version_1 === 0x00) {
-                if (length_3 !== 20 && length_3 !== 32) {
-                    version_1 = -1;
+            let version = bytes[0];
+            if (version === 0x00) {
+                if (length !== 20 && length !== 32) {
+                    version = -1;
                 }
             }
             else {
-                version_1 = -1;
+                version = -1;
             }
-            if (version_1 >= 0 && bytes.length === 2 + length_3 && length_3 >= 1 && length_3 <= 75) {
-                var words = bech32_1.default.toWords(bytes.slice(2));
-                words.unshift(version_1);
+            if (version >= 0 &&
+                bytes.length === 2 + length &&
+                length >= 1 &&
+                length <= 75) {
+                const words = bech32_1.default.toWords(bytes.slice(2));
+                words.unshift(version);
                 return bech32_1.default.encode(coinInfo.prefix, words);
             }
         }
         return null;
-    };
-    Resolver.prototype.getAddress = function (coinType) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result, error_2, hexBytes, address;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (coinType == null) {
-                            coinType = 60;
-                        }
-                        if (!(coinType === 60)) return [3 /*break*/, 4];
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this._fetch("0x3b3b57de")];
-                    case 2:
-                        result = _a.sent();
-                        // No address
-                        if (result === "0x" || result === constants_1.HashZero) {
-                            return [2 /*return*/, null];
-                        }
-                        return [2 /*return*/, this.provider.formatter.callAddress(result)];
-                    case 3:
-                        error_2 = _a.sent();
-                        if (error_2.code === logger_1.Logger.errors.CALL_EXCEPTION) {
-                            return [2 /*return*/, null];
-                        }
-                        throw error_2;
-                    case 4: return [4 /*yield*/, this._fetchBytes("0xf1cb7e06", bytes32ify(coinType))];
-                    case 5:
-                        hexBytes = _a.sent();
-                        // No address
-                        if (hexBytes == null || hexBytes === "0x") {
-                            return [2 /*return*/, null];
-                        }
-                        address = this._getAddress(coinType, hexBytes);
-                        if (address == null) {
-                            logger.throwError("invalid or unsupported coin data", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
-                                operation: "getAddress(" + coinType + ")",
-                                coinType: coinType,
-                                data: hexBytes
-                            });
-                        }
-                        return [2 /*return*/, address];
+    }
+    async getAddress(coinType) {
+        if (coinType == null) {
+            coinType = 60;
+        }
+        // If Ethereum, use the standard `addr(bytes32)`
+        if (coinType === 60) {
+            try {
+                // keccak256("addr(bytes32)")
+                const result = await this._fetch("0x3b3b57de");
+                // No address
+                if (result === "0x" || result === constants_1.HashZero) {
+                    return null;
+                }
+                return this.provider.formatter.callAddress(result);
+            }
+            catch (error) {
+                if (error.code === logger_1.Logger.errors.CALL_EXCEPTION) {
+                    return null;
                 }
+                throw error;
+            }
+        }
+        // keccak256("addr(bytes32,uint256")
+        const hexBytes = await this._fetchBytes("0xf1cb7e06", bytes32ify(coinType));
+        // No address
+        if (hexBytes == null || hexBytes === "0x") {
+            return null;
+        }
+        // Compute the address
+        const address = this._getAddress(coinType, hexBytes);
+        if (address == null) {
+            logger.throwError(`invalid or unsupported coin data`, logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
+                operation: `getAddress(${coinType})`,
+                coinType: coinType,
+                data: hexBytes,
             });
-        });
-    };
-    Resolver.prototype.getAvatar = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var linkage, avatar, i, match, scheme, _a, selector, owner, _b, comps, addr, tokenId, tokenOwner, _c, _d, balance, _e, _f, tx, metadataUrl, _g, metadata, imageUrl, ipfs, error_3;
-            return __generator(this, function (_h) {
-                switch (_h.label) {
-                    case 0:
-                        linkage = [{ type: "name", content: this.name }];
-                        _h.label = 1;
-                    case 1:
-                        _h.trys.push([1, 19, , 20]);
-                        return [4 /*yield*/, this.getText("avatar")];
-                    case 2:
-                        avatar = _h.sent();
-                        if (avatar == null) {
-                            return [2 /*return*/, null];
-                        }
-                        i = 0;
-                        _h.label = 3;
-                    case 3:
-                        if (!(i < matchers.length)) return [3 /*break*/, 18];
-                        match = avatar.match(matchers[i]);
-                        if (match == null) {
-                            return [3 /*break*/, 17];
-                        }
-                        scheme = match[1].toLowerCase();
-                        _a = scheme;
-                        switch (_a) {
-                            case "https": return [3 /*break*/, 4];
-                            case "data": return [3 /*break*/, 5];
-                            case "ipfs": return [3 /*break*/, 6];
-                            case "erc721": return [3 /*break*/, 7];
-                            case "erc1155": return [3 /*break*/, 7];
-                        }
-                        return [3 /*break*/, 17];
-                    case 4:
+        }
+        return address;
+    }
+    async getAvatar() {
+        const linkage = [
+            { type: "name", content: this.name },
+        ];
+        try {
+            // test data for ricmoo.eth
+            //const avatar = "eip155:1/erc721:0x265385c7f4132228A0d54EB1A9e7460b91c0cC68/29233";
+            const avatar = await this.getText("avatar");
+            if (avatar == null) {
+                return null;
+            }
+            for (let i = 0; i < matchers.length; i++) {
+                const match = avatar.match(matchers[i]);
+                if (match == null) {
+                    continue;
+                }
+                const scheme = match[1].toLowerCase();
+                switch (scheme) {
+                    case "https":
                         linkage.push({ type: "url", content: avatar });
-                        return [2 /*return*/, { linkage: linkage, url: avatar }];
-                    case 5:
+                        return { linkage, url: avatar };
+                    case "data":
                         linkage.push({ type: "data", content: avatar });
-                        return [2 /*return*/, { linkage: linkage, url: avatar }];
-                    case 6:
+                        return { linkage, url: avatar };
+                    case "ipfs":
                         linkage.push({ type: "ipfs", content: avatar });
-                        return [2 /*return*/, { linkage: linkage, url: getIpfsLink(avatar) }];
-                    case 7:
-                        selector = (scheme === "erc721") ? "0xc87b56dd" : "0x0e89341c";
+                        return { linkage, url: getIpfsLink(avatar) };
+                    case "erc721":
+                    case "erc1155": {
+                        // Depending on the ERC type, use tokenURI(uint256) or url(uint256)
+                        const selector = scheme === "erc721" ? "0xc87b56dd" : "0x0e89341c";
                         linkage.push({ type: scheme, content: avatar });
-                        _b = this._resolvedAddress;
-                        if (_b) return [3 /*break*/, 9];
-                        return [4 /*yield*/, this.getAddress()];
-                    case 8:
-                        _b = (_h.sent());
-                        _h.label = 9;
-                    case 9:
-                        owner = (_b);
-                        comps = (match[2] || "").split("/");
+                        // The owner of this name
+                        const owner = this._resolvedAddress || (await this.getAddress());
+                        const comps = (match[2] || "").split("/");
                         if (comps.length !== 2) {
-                            return [2 /*return*/, null];
-                        }
-                        return [4 /*yield*/, this.provider.formatter.address(comps[0])];
-                    case 10:
-                        addr = _h.sent();
-                        tokenId = (0, bytes_1.hexZeroPad)(bignumber_1.BigNumber.from(comps[1]).toHexString(), 32);
-                        if (!(scheme === "erc721")) return [3 /*break*/, 12];
-                        _d = (_c = this.provider.formatter).callAddress;
-                        return [4 /*yield*/, this.provider.call({
-                                to: addr, data: (0, bytes_1.hexConcat)(["0x6352211e", tokenId])
-                            })];
-                    case 11:
-                        tokenOwner = _d.apply(_c, [_h.sent()]);
-                        if (owner !== tokenOwner) {
-                            return [2 /*return*/, null];
+                            return null;
+                        }
+                        const addr = await this.provider.formatter.address(comps[0]);
+                        const tokenId = (0, bytes_1.hexZeroPad)(bignumber_1.BigNumber.from(comps[1]).toHexString(), 32);
+                        // Check that this account owns the token
+                        if (scheme === "erc721") {
+                            // ownerOf(uint256 tokenId)
+                            const tokenOwner = this.provider.formatter.callAddress(await this.provider.call({
+                                to: addr,
+                                data: (0, bytes_1.hexConcat)([
+                                    "0x6352211e",
+                                    tokenId,
+                                ]),
+                            }));
+                            if (owner !== tokenOwner) {
+                                return null;
+                            }
+                            linkage.push({
+                                type: "owner",
+                                content: tokenOwner,
+                            });
                         }
-                        linkage.push({ type: "owner", content: tokenOwner });
-                        return [3 /*break*/, 14];
-                    case 12:
-                        if (!(scheme === "erc1155")) return [3 /*break*/, 14];
-                        _f = (_e = bignumber_1.BigNumber).from;
-                        return [4 /*yield*/, this.provider.call({
-                                to: addr, data: (0, bytes_1.hexConcat)(["0x00fdd58e", (0, bytes_1.hexZeroPad)(owner, 32), tokenId])
-                            })];
-                    case 13:
-                        balance = _f.apply(_e, [_h.sent()]);
-                        if (balance.isZero()) {
-                            return [2 /*return*/, null];
+                        else if (scheme === "erc1155") {
+                            // balanceOf(address owner, uint256 tokenId)
+                            const balance = bignumber_1.BigNumber.from(await this.provider.call({
+                                to: addr,
+                                data: (0, bytes_1.hexConcat)([
+                                    "0x00fdd58e",
+                                    (0, bytes_1.hexZeroPad)(owner, 32),
+                                    tokenId,
+                                ]),
+                            }));
+                            if (balance.isZero()) {
+                                return null;
+                            }
+                            linkage.push({
+                                type: "balance",
+                                content: balance.toString(),
+                            });
                         }
-                        linkage.push({ type: "balance", content: balance.toString() });
-                        _h.label = 14;
-                    case 14:
-                        tx = {
+                        // Call the token contract for the metadata URL
+                        const tx = {
                             to: this.provider.formatter.address(comps[0]),
-                            data: (0, bytes_1.hexConcat)([selector, tokenId])
+                            data: (0, bytes_1.hexConcat)([selector, tokenId]),
                         };
-                        _g = _parseString;
-                        return [4 /*yield*/, this.provider.call(tx)];
-                    case 15:
-                        metadataUrl = _g.apply(void 0, [_h.sent(), 0]);
+                        let metadataUrl = _parseString(await this.provider.call(tx), 0);
                         if (metadataUrl == null) {
-                            return [2 /*return*/, null];
+                            return null;
                         }
-                        linkage.push({ type: "metadata-url-base", content: metadataUrl });
+                        linkage.push({
+                            type: "metadata-url-base",
+                            content: metadataUrl,
+                        });
                         // ERC-1155 allows a generic {id} in the URL
                         if (scheme === "erc1155") {
                             metadataUrl = metadataUrl.replace("{id}", tokenId.substring(2));
-                            linkage.push({ type: "metadata-url-expanded", content: metadataUrl });
+                            linkage.push({
+                                type: "metadata-url-expanded",
+                                content: metadataUrl,
+                            });
                         }
                         // Transform IPFS metadata links
                         if (metadataUrl.match(/^ipfs:/i)) {
                             metadataUrl = getIpfsLink(metadataUrl);
                         }
-                        linkage.push({ type: "metadata-url", content: metadataUrl });
-                        return [4 /*yield*/, (0, web_1.fetchJson)(metadataUrl)];
-                    case 16:
-                        metadata = _h.sent();
+                        linkage.push({
+                            type: "metadata-url",
+                            content: metadataUrl,
+                        });
+                        // Get the token metadata
+                        const metadata = await (0, web_1.fetchJson)(metadataUrl);
                         if (!metadata) {
-                            return [2 /*return*/, null];
+                            return null;
                         }
-                        linkage.push({ type: "metadata", content: JSON.stringify(metadata) });
-                        imageUrl = metadata.image;
-                        if (typeof (imageUrl) !== "string") {
-                            return [2 /*return*/, null];
+                        linkage.push({
+                            type: "metadata",
+                            content: JSON.stringify(metadata),
+                        });
+                        // Pull the image URL out
+                        let imageUrl = metadata.image;
+                        if (typeof imageUrl !== "string") {
+                            return null;
                         }
                         if (imageUrl.match(/^(https:\/\/|data:)/i)) {
                             // Allow
                         }
                         else {
-                            ipfs = imageUrl.match(matcherIpfs);
+                            // Transform IPFS link to gateway
+                            const ipfs = imageUrl.match(matcherIpfs);
                             if (ipfs == null) {
-                                return [2 /*return*/, null];
+                                return null;
                             }
-                            linkage.push({ type: "url-ipfs", content: imageUrl });
+                            linkage.push({
+                                type: "url-ipfs",
+                                content: imageUrl,
+                            });
                             imageUrl = getIpfsLink(imageUrl);
                         }
                         linkage.push({ type: "url", content: imageUrl });
-                        return [2 /*return*/, { linkage: linkage, url: imageUrl }];
-                    case 17:
-                        i++;
-                        return [3 /*break*/, 3];
-                    case 18: return [3 /*break*/, 20];
-                    case 19:
-                        error_3 = _h.sent();
-                        return [3 /*break*/, 20];
-                    case 20: return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    Resolver.prototype.getContentHash = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexBytes, ipfs, length_4, ipns, length_5, swarm, skynet, urlSafe_1, hash;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this._fetchBytes("0xbc1c58d1")];
-                    case 1:
-                        hexBytes = _a.sent();
-                        // No contenthash
-                        if (hexBytes == null || hexBytes === "0x") {
-                            return [2 /*return*/, null];
-                        }
-                        ipfs = hexBytes.match(/^0xe3010170(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/);
-                        if (ipfs) {
-                            length_4 = parseInt(ipfs[3], 16);
-                            if (ipfs[4].length === length_4 * 2) {
-                                return [2 /*return*/, "ipfs:/\/" + basex_1.Base58.encode("0x" + ipfs[1])];
-                            }
-                        }
-                        ipns = hexBytes.match(/^0xe5010172(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/);
-                        if (ipns) {
-                            length_5 = parseInt(ipns[3], 16);
-                            if (ipns[4].length === length_5 * 2) {
-                                return [2 /*return*/, "ipns:/\/" + basex_1.Base58.encode("0x" + ipns[1])];
-                            }
-                        }
-                        swarm = hexBytes.match(/^0xe40101fa011b20([0-9a-f]*)$/);
-                        if (swarm) {
-                            if (swarm[1].length === (32 * 2)) {
-                                return [2 /*return*/, "bzz:/\/" + swarm[1]];
-                            }
-                        }
-                        skynet = hexBytes.match(/^0x90b2c605([0-9a-f]*)$/);
-                        if (skynet) {
-                            if (skynet[1].length === (34 * 2)) {
-                                urlSafe_1 = { "=": "", "+": "-", "/": "_" };
-                                hash = (0, base64_1.encode)("0x" + skynet[1]).replace(/[=+\/]/g, function (a) { return (urlSafe_1[a]); });
-                                return [2 /*return*/, "sia:/\/" + hash];
-                            }
-                        }
-                        return [2 /*return*/, logger.throwError("invalid or unsupported content hash data", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
-                                operation: "getContentHash()",
-                                data: hexBytes
-                            })];
-                }
-            });
-        });
-    };
-    Resolver.prototype.getText = function (key) {
-        return __awaiter(this, void 0, void 0, function () {
-            var keyBytes, hexBytes;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        keyBytes = (0, strings_1.toUtf8Bytes)(key);
-                        // The nodehash consumes the first slot, so the string pointer targets
-                        // offset 64, with the length at offset 64 and data starting at offset 96
-                        keyBytes = (0, bytes_1.concat)([bytes32ify(64), bytes32ify(keyBytes.length), keyBytes]);
-                        // Pad to word-size (32 bytes)
-                        if ((keyBytes.length % 32) !== 0) {
-                            keyBytes = (0, bytes_1.concat)([keyBytes, (0, bytes_1.hexZeroPad)("0x", 32 - (key.length % 32))]);
-                        }
-                        return [4 /*yield*/, this._fetchBytes("0x59d1d43c", (0, bytes_1.hexlify)(keyBytes))];
-                    case 1:
-                        hexBytes = _a.sent();
-                        if (hexBytes == null || hexBytes === "0x") {
-                            return [2 /*return*/, null];
-                        }
-                        return [2 /*return*/, (0, strings_1.toUtf8String)(hexBytes)];
+                        return { linkage, url: imageUrl };
+                    }
                 }
-            });
+            }
+        }
+        catch (error) { }
+        return null;
+    }
+    async getContentHash() {
+        // keccak256("contenthash()")
+        const hexBytes = await this._fetchBytes("0xbc1c58d1");
+        // No contenthash
+        if (hexBytes == null || hexBytes === "0x") {
+            return null;
+        }
+        // IPFS (CID: 1, Type: DAG-PB)
+        const ipfs = hexBytes.match(/^0xe3010170(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/);
+        if (ipfs) {
+            const length = parseInt(ipfs[3], 16);
+            if (ipfs[4].length === length * 2) {
+                return "ipfs:/\/" + basex_1.Base58.encode("0x" + ipfs[1]);
+            }
+        }
+        // IPNS (CID: 1, Type: libp2p-key)
+        const ipns = hexBytes.match(/^0xe5010172(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/);
+        if (ipns) {
+            const length = parseInt(ipns[3], 16);
+            if (ipns[4].length === length * 2) {
+                return "ipns:/\/" + basex_1.Base58.encode("0x" + ipns[1]);
+            }
+        }
+        // Swarm (CID: 1, Type: swarm-manifest; hash/length hard-coded to keccak256/32)
+        const swarm = hexBytes.match(/^0xe40101fa011b20([0-9a-f]*)$/);
+        if (swarm) {
+            if (swarm[1].length === 32 * 2) {
+                return "bzz:/\/" + swarm[1];
+            }
+        }
+        const skynet = hexBytes.match(/^0x90b2c605([0-9a-f]*)$/);
+        if (skynet) {
+            if (skynet[1].length === 34 * 2) {
+                // URL Safe base64; https://datatracker.ietf.org/doc/html/rfc4648#section-5
+                const urlSafe = {
+                    "=": "",
+                    "+": "-",
+                    "/": "_",
+                };
+                const hash = (0, base64_1.encode)("0x" + skynet[1]).replace(/[=+\/]/g, (a) => urlSafe[a]);
+                return "sia:/\/" + hash;
+            }
+        }
+        return logger.throwError(`invalid or unsupported content hash data`, logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
+            operation: "getContentHash()",
+            data: hexBytes,
         });
-    };
-    return Resolver;
-}());
+    }
+    async getText(key) {
+        // The key encoded as parameter to fetchBytes
+        let keyBytes = (0, strings_1.toUtf8Bytes)(key);
+        // The nodehash consumes the first slot, so the string pointer targets
+        // offset 64, with the length at offset 64 and data starting at offset 96
+        keyBytes = (0, bytes_1.concat)([
+            bytes32ify(64),
+            bytes32ify(keyBytes.length),
+            keyBytes,
+        ]);
+        // Pad to word-size (32 bytes)
+        if (keyBytes.length % 32 !== 0) {
+            keyBytes = (0, bytes_1.concat)([
+                keyBytes,
+                (0, bytes_1.hexZeroPad)("0x", 32 - (key.length % 32)),
+            ]);
+        }
+        const hexBytes = await this._fetchBytes("0x59d1d43c", (0, bytes_1.hexlify)(keyBytes));
+        if (hexBytes == null || hexBytes === "0x") {
+            return null;
+        }
+        return (0, strings_1.toUtf8String)(hexBytes);
+    }
+}
 exports.Resolver = Resolver;
-var defaultFormatter = null;
-var nextPollId = 1;
-var BaseProvider = /** @class */ (function (_super) {
-    __extends(BaseProvider, _super);
+let defaultFormatter = null;
+let nextPollId = 1;
+class BaseProvider extends abstract_provider_1.Provider {
     /**
      *  ready
      *
@@ -745,1769 +662,1349 @@ var BaseProvider = /** @class */ (function (_super) {
      *  MUST set this. Standard named networks have a known chainId.
      *
      */
-    function BaseProvider(network) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this) || this;
+    constructor(network) {
+        super();
         // Events being listened to
-        _this._events = [];
-        _this._emitted = { block: -2 };
-        _this.disableCcipRead = false;
-        _this.formatter = _newTarget.getFormatter();
+        this._events = [];
+        this._emitted = { block: -2 };
+        this.disableCcipRead = false;
+        this.formatter = new.target.getFormatter();
         // If network is any, this Provider allows the underlying
         // network to change dynamically, and we auto-detect the
         // current network
-        (0, properties_1.defineReadOnly)(_this, "anyNetwork", (network === "any"));
-        if (_this.anyNetwork) {
-            network = _this.detectNetwork();
+        (0, properties_1.defineReadOnly)(this, "anyNetwork", network === "any");
+        if (this.anyNetwork) {
+            network = this.detectNetwork();
         }
         if (network instanceof Promise) {
-            _this._networkPromise = network;
+            this._networkPromise = network;
             // Squash any "unhandled promise" errors; that do not need to be handled
-            network.catch(function (error) { });
+            network.catch((error) => { });
             // Trigger initial network setting (async)
-            _this._ready().catch(function (error) { });
+            this._ready().catch((error) => { });
         }
         else {
-            var knownNetwork = (0, properties_1.getStatic)(_newTarget, "getNetwork")(network);
+            const knownNetwork = (0, properties_1.getStatic)(new.target, "getNetwork")(network);
             if (knownNetwork) {
-                (0, properties_1.defineReadOnly)(_this, "_network", knownNetwork);
-                _this.emit("network", knownNetwork, null);
+                (0, properties_1.defineReadOnly)(this, "_network", knownNetwork);
+                this.emit("network", knownNetwork, null);
             }
             else {
                 logger.throwArgumentError("invalid network", "network", network);
             }
         }
-        _this._maxInternalBlockNumber = -1024;
-        _this._lastBlockNumber = -2;
-        _this._maxFilterBlockRange = 10;
-        _this._pollingInterval = 4000;
-        _this._fastQueryDate = 0;
-        return _this;
-    }
-    BaseProvider.prototype._ready = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var network, error_4;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(this._network == null)) return [3 /*break*/, 7];
-                        network = null;
-                        if (!this._networkPromise) return [3 /*break*/, 4];
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this._networkPromise];
-                    case 2:
-                        network = _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_4 = _a.sent();
-                        return [3 /*break*/, 4];
-                    case 4:
-                        if (!(network == null)) return [3 /*break*/, 6];
-                        return [4 /*yield*/, this.detectNetwork()];
-                    case 5:
-                        network = _a.sent();
-                        _a.label = 6;
-                    case 6:
-                        // This should never happen; every Provider sub-class should have
-                        // suggested a network by here (or have thrown).
-                        if (!network) {
-                            logger.throwError("no network detected", logger_1.Logger.errors.UNKNOWN_ERROR, {});
-                        }
-                        // Possible this call stacked so do not call defineReadOnly again
-                        if (this._network == null) {
-                            if (this.anyNetwork) {
-                                this._network = network;
-                            }
-                            else {
-                                (0, properties_1.defineReadOnly)(this, "_network", network);
-                            }
-                            this.emit("network", network, null);
-                        }
-                        _a.label = 7;
-                    case 7: return [2 /*return*/, this._network];
+        this._maxInternalBlockNumber = -1024;
+        this._lastBlockNumber = -2;
+        this._maxFilterBlockRange = 10;
+        this._pollingInterval = 4000;
+        this._fastQueryDate = 0;
+    }
+    async _ready() {
+        if (this._network == null) {
+            let network = null;
+            if (this._networkPromise) {
+                try {
+                    network = await this._networkPromise;
+                }
+                catch (error) { }
+            }
+            // Try the Provider's network detection (this MUST throw if it cannot)
+            if (network == null) {
+                network = await this.detectNetwork();
+            }
+            // This should never happen; every Provider sub-class should have
+            // suggested a network by here (or have thrown).
+            if (!network) {
+                logger.throwError("no network detected", logger_1.Logger.errors.UNKNOWN_ERROR, {});
+            }
+            // Possible this call stacked so do not call defineReadOnly again
+            if (this._network == null) {
+                if (this.anyNetwork) {
+                    this._network = network;
+                }
+                else {
+                    (0, properties_1.defineReadOnly)(this, "_network", network);
+                }
+                this.emit("network", network, null);
+            }
+        }
+        return this._network;
+    }
+    // This will always return the most recently established network.
+    // For "any", this can change (a "network" event is emitted before
+    // any change is reflected); otherwise this cannot change
+    get ready() {
+        return (0, web_1.poll)(() => {
+            return this._ready().then((network) => {
+                return network;
+            }, (error) => {
+                // If the network isn't running yet, we will wait
+                if (error.code === logger_1.Logger.errors.NETWORK_ERROR &&
+                    error.event === "noNetwork") {
+                    return undefined;
                 }
+                throw error;
             });
         });
-    };
-    Object.defineProperty(BaseProvider.prototype, "ready", {
-        // This will always return the most recently established network.
-        // For "any", this can change (a "network" event is emitted before
-        // any change is reflected); otherwise this cannot change
-        get: function () {
-            var _this = this;
-            return (0, web_1.poll)(function () {
-                return _this._ready().then(function (network) {
-                    return network;
-                }, function (error) {
-                    // If the network isn't running yet, we will wait
-                    if (error.code === logger_1.Logger.errors.NETWORK_ERROR && error.event === "noNetwork") {
-                        return undefined;
-                    }
-                    throw error;
-                });
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
     // @TODO: Remove this and just create a singleton formatter
-    BaseProvider.getFormatter = function () {
+    static getFormatter() {
         if (defaultFormatter == null) {
             defaultFormatter = new formatter_1.Formatter();
         }
         return defaultFormatter;
-    };
+    }
     // @TODO: Remove this and just use getNetwork
-    BaseProvider.getNetwork = function (network) {
-        return (0, networks_1.getNetwork)((network == null) ? "homestead" : network);
-    };
-    BaseProvider.prototype.ccipReadFetch = function (tx, calldata, urls) {
-        return __awaiter(this, void 0, void 0, function () {
-            var sender, data, errorMessages, i, url, href, json, result, errorMessage;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.disableCcipRead || urls.length === 0) {
-                            return [2 /*return*/, null];
-                        }
-                        sender = tx.to.toLowerCase();
-                        data = calldata.toLowerCase();
-                        errorMessages = [];
-                        i = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(i < urls.length)) return [3 /*break*/, 4];
-                        url = urls[i];
-                        href = url.replace("{sender}", sender).replace("{data}", data);
-                        json = (url.indexOf("{data}") >= 0) ? null : JSON.stringify({ data: data, sender: sender });
-                        return [4 /*yield*/, (0, web_1.fetchJson)({ url: href, errorPassThrough: true }, json, function (value, response) {
-                                value.status = response.statusCode;
-                                return value;
-                            })];
-                    case 2:
-                        result = _a.sent();
-                        if (result.data) {
-                            return [2 /*return*/, result.data];
-                        }
-                        errorMessage = (result.message || "unknown error");
-                        // 4xx indicates the result is not present; stop
-                        if (result.status >= 400 && result.status < 500) {
-                            return [2 /*return*/, logger.throwError("response not found during CCIP fetch: " + errorMessage, logger_1.Logger.errors.SERVER_ERROR, { url: url, errorMessage: errorMessage })];
-                        }
-                        // 5xx indicates server issue; try the next url
-                        errorMessages.push(errorMessage);
-                        _a.label = 3;
-                    case 3:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, logger.throwError("error encountered during CCIP fetch: " + errorMessages.map(function (m) { return JSON.stringify(m); }).join(", "), logger_1.Logger.errors.SERVER_ERROR, {
-                            urls: urls,
-                            errorMessages: errorMessages
-                        })];
-                }
+    static getNetwork(network) {
+        return (0, networks_1.getNetwork)(network == null ? "homestead" : network);
+    }
+    async ccipReadFetch(tx, calldata, urls) {
+        if (this.disableCcipRead || urls.length === 0) {
+            return null;
+        }
+        const sender = tx.to.toLowerCase();
+        const data = calldata.toLowerCase();
+        const errorMessages = [];
+        for (let i = 0; i < urls.length; i++) {
+            const url = urls[i];
+            // URL expansion
+            const href = url
+                .replace("{sender}", sender)
+                .replace("{data}", data);
+            // If no {data} is present, use POST; otherwise GET
+            const json = url.indexOf("{data}") >= 0
+                ? null
+                : JSON.stringify({ data, sender });
+            const result = await (0, web_1.fetchJson)({ url: href, errorPassThrough: true }, json, (value, response) => {
+                value.status = response.statusCode;
+                return value;
             });
+            if (result.data) {
+                return result.data;
+            }
+            const errorMessage = result.message || "unknown error";
+            // 4xx indicates the result is not present; stop
+            if (result.status >= 400 && result.status < 500) {
+                return logger.throwError(`response not found during CCIP fetch: ${errorMessage}`, logger_1.Logger.errors.SERVER_ERROR, { url, errorMessage });
+            }
+            // 5xx indicates server issue; try the next url
+            errorMessages.push(errorMessage);
+        }
+        return logger.throwError(`error encountered during CCIP fetch: ${errorMessages.map((m) => JSON.stringify(m)).join(", ")}`, logger_1.Logger.errors.SERVER_ERROR, {
+            urls,
+            errorMessages,
         });
-    };
+    }
     // Fetches the blockNumber, but will reuse any result that is less
     // than maxAge old or has been requested since the last request
-    BaseProvider.prototype._getInternalBlockNumber = function (maxAge) {
-        return __awaiter(this, void 0, void 0, function () {
-            var internalBlockNumber, result, error_5, reqTime, checkInternalBlockNumber;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this._ready()];
-                    case 1:
-                        _a.sent();
-                        if (!(maxAge > 0)) return [3 /*break*/, 7];
-                        _a.label = 2;
-                    case 2:
-                        if (!this._internalBlockNumber) return [3 /*break*/, 7];
-                        internalBlockNumber = this._internalBlockNumber;
-                        _a.label = 3;
-                    case 3:
-                        _a.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, internalBlockNumber];
-                    case 4:
-                        result = _a.sent();
-                        if ((getTime() - result.respTime) <= maxAge) {
-                            return [2 /*return*/, result.blockNumber];
-                        }
-                        // Too old; fetch a new value
-                        return [3 /*break*/, 7];
-                    case 5:
-                        error_5 = _a.sent();
-                        // The fetch rejected; if we are the first to get the
-                        // rejection, drop through so we replace it with a new
-                        // fetch; all others blocked will then get that fetch
-                        // which won't match the one they "remembered" and loop
-                        if (this._internalBlockNumber === internalBlockNumber) {
-                            return [3 /*break*/, 7];
-                        }
-                        return [3 /*break*/, 6];
-                    case 6: return [3 /*break*/, 2];
-                    case 7:
-                        reqTime = getTime();
-                        checkInternalBlockNumber = (0, properties_1.resolveProperties)({
-                            blockNumber: this.perform("getBlockNumber", {}),
-                            networkError: this.getNetwork().then(function (network) { return (null); }, function (error) { return (error); })
-                        }).then(function (_a) {
-                            var blockNumber = _a.blockNumber, networkError = _a.networkError;
-                            if (networkError) {
-                                // Unremember this bad internal block number
-                                if (_this._internalBlockNumber === checkInternalBlockNumber) {
-                                    _this._internalBlockNumber = null;
-                                }
-                                throw networkError;
-                            }
-                            var respTime = getTime();
-                            blockNumber = bignumber_1.BigNumber.from(blockNumber).toNumber();
-                            if (blockNumber < _this._maxInternalBlockNumber) {
-                                blockNumber = _this._maxInternalBlockNumber;
-                            }
-                            _this._maxInternalBlockNumber = blockNumber;
-                            _this._setFastBlockNumber(blockNumber); // @TODO: Still need this?
-                            return { blockNumber: blockNumber, reqTime: reqTime, respTime: respTime };
-                        });
-                        this._internalBlockNumber = checkInternalBlockNumber;
-                        // Swallow unhandled exceptions; if needed they are handled else where
-                        checkInternalBlockNumber.catch(function (error) {
-                            // Don't null the dead (rejected) fetch, if it has already been updated
-                            if (_this._internalBlockNumber === checkInternalBlockNumber) {
-                                _this._internalBlockNumber = null;
-                            }
-                        });
-                        return [4 /*yield*/, checkInternalBlockNumber];
-                    case 8: return [2 /*return*/, (_a.sent()).blockNumber];
+    async _getInternalBlockNumber(maxAge) {
+        await this._ready();
+        // Allowing stale data up to maxAge old
+        if (maxAge > 0) {
+            // While there are pending internal block requests...
+            while (this._internalBlockNumber) {
+                // ..."remember" which fetch we started with
+                const internalBlockNumber = this._internalBlockNumber;
+                try {
+                    // Check the result is not too stale
+                    const result = await internalBlockNumber;
+                    if (getTime() - result.respTime <= maxAge) {
+                        return result.blockNumber;
+                    }
+                    // Too old; fetch a new value
+                    break;
                 }
-            });
+                catch (error) {
+                    // The fetch rejected; if we are the first to get the
+                    // rejection, drop through so we replace it with a new
+                    // fetch; all others blocked will then get that fetch
+                    // which won't match the one they "remembered" and loop
+                    if (this._internalBlockNumber === internalBlockNumber) {
+                        break;
+                    }
+                }
+            }
+        }
+        const reqTime = getTime();
+        const checkInternalBlockNumber = (0, properties_1.resolveProperties)({
+            blockNumber: this.perform("getBlockNumber", {}),
+            networkError: this.getNetwork().then((network) => null, (error) => error),
+        }).then(({ blockNumber, networkError }) => {
+            if (networkError) {
+                // Unremember this bad internal block number
+                if (this._internalBlockNumber === checkInternalBlockNumber) {
+                    this._internalBlockNumber = null;
+                }
+                throw networkError;
+            }
+            const respTime = getTime();
+            blockNumber = bignumber_1.BigNumber.from(blockNumber).toNumber();
+            if (blockNumber < this._maxInternalBlockNumber) {
+                blockNumber = this._maxInternalBlockNumber;
+            }
+            this._maxInternalBlockNumber = blockNumber;
+            this._setFastBlockNumber(blockNumber); // @TODO: Still need this?
+            return { blockNumber, reqTime, respTime };
         });
-    };
-    BaseProvider.prototype.poll = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var pollId, runners, blockNumber, error_6, i;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        pollId = nextPollId++;
-                        runners = [];
-                        blockNumber = null;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this._getInternalBlockNumber(100 + this.pollingInterval / 2)];
-                    case 2:
-                        blockNumber = _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_6 = _a.sent();
-                        this.emit("error", error_6);
-                        return [2 /*return*/];
-                    case 4:
-                        this._setFastBlockNumber(blockNumber);
-                        // Emit a poll event after we have the latest (fast) block number
-                        this.emit("poll", pollId, blockNumber);
-                        // If the block has not changed, meh.
-                        if (blockNumber === this._lastBlockNumber) {
-                            this.emit("didPoll", pollId);
-                            return [2 /*return*/];
-                        }
-                        // First polling cycle, trigger a "block" events
-                        if (this._emitted.block === -2) {
-                            this._emitted.block = blockNumber - 1;
-                        }
-                        if (Math.abs((this._emitted.block) - blockNumber) > 1000) {
-                            logger.warn("network block skew detected; skipping block events (emitted=" + this._emitted.block + " blockNumber" + blockNumber + ")");
-                            this.emit("error", logger.makeError("network block skew detected", logger_1.Logger.errors.NETWORK_ERROR, {
-                                blockNumber: blockNumber,
-                                event: "blockSkew",
-                                previousBlockNumber: this._emitted.block
-                            }));
-                            this.emit("block", blockNumber);
-                        }
-                        else {
-                            // Notify all listener for each block that has passed
-                            for (i = this._emitted.block + 1; i <= blockNumber; i++) {
-                                this.emit("block", i);
+        this._internalBlockNumber = checkInternalBlockNumber;
+        // Swallow unhandled exceptions; if needed they are handled else where
+        checkInternalBlockNumber.catch((error) => {
+            // Don't null the dead (rejected) fetch, if it has already been updated
+            if (this._internalBlockNumber === checkInternalBlockNumber) {
+                this._internalBlockNumber = null;
+            }
+        });
+        return (await checkInternalBlockNumber).blockNumber;
+    }
+    async poll() {
+        const pollId = nextPollId++;
+        // Track all running promises, so we can trigger a post-poll once they are complete
+        const runners = [];
+        let blockNumber = null;
+        try {
+            blockNumber = await this._getInternalBlockNumber(100 + this.pollingInterval / 2);
+        }
+        catch (error) {
+            this.emit("error", error);
+            return;
+        }
+        this._setFastBlockNumber(blockNumber);
+        // Emit a poll event after we have the latest (fast) block number
+        this.emit("poll", pollId, blockNumber);
+        // If the block has not changed, meh.
+        if (blockNumber === this._lastBlockNumber) {
+            this.emit("didPoll", pollId);
+            return;
+        }
+        // First polling cycle, trigger a "block" events
+        if (this._emitted.block === -2) {
+            this._emitted.block = blockNumber - 1;
+        }
+        if (Math.abs(this._emitted.block - blockNumber) > 1000) {
+            logger.warn(`network block skew detected; skipping block events (emitted=${this._emitted.block} blockNumber${blockNumber})`);
+            this.emit("error", logger.makeError("network block skew detected", logger_1.Logger.errors.NETWORK_ERROR, {
+                blockNumber: blockNumber,
+                event: "blockSkew",
+                previousBlockNumber: this._emitted.block,
+            }));
+            this.emit("block", blockNumber);
+        }
+        else {
+            // Notify all listener for each block that has passed
+            for (let i = this._emitted.block + 1; i <= blockNumber; i++) {
+                this.emit("block", i);
+            }
+        }
+        // The emitted block was updated, check for obsolete events
+        if (this._emitted.block !== blockNumber) {
+            this._emitted.block = blockNumber;
+            Object.keys(this._emitted).forEach((key) => {
+                // The block event does not expire
+                if (key === "block") {
+                    return;
+                }
+                // The block we were at when we emitted this event
+                const eventBlockNumber = this._emitted[key];
+                // We cannot garbage collect pending transactions or blocks here
+                // They should be garbage collected by the Provider when setting
+                // "pending" events
+                if (eventBlockNumber === "pending") {
+                    return;
+                }
+                // Evict any transaction hashes or block hashes over 12 blocks
+                // old, since they should not return null anyways
+                if (blockNumber - eventBlockNumber > 12) {
+                    delete this._emitted[key];
+                }
+            });
+        }
+        // First polling cycle
+        if (this._lastBlockNumber === -2) {
+            this._lastBlockNumber = blockNumber - 1;
+        }
+        // Find all transaction hashes we are waiting on
+        this._events.forEach((event) => {
+            switch (event.type) {
+                case "tx": {
+                    const hash = event.hash;
+                    let runner = this.getTransactionReceipt(hash)
+                        .then((receipt) => {
+                        if (!receipt || receipt.blockNumber == null) {
+                            return null;
+                        }
+                        this._emitted["t:" + hash] = receipt.blockNumber;
+                        this.emit(hash, receipt);
+                        return null;
+                    })
+                        .catch((error) => {
+                        this.emit("error", error);
+                    });
+                    runners.push(runner);
+                    break;
+                }
+                case "filter": {
+                    // We only allow a single getLogs to be in-flight at a time
+                    if (!event._inflight) {
+                        event._inflight = true;
+                        // This is the first filter for this event, so we want to
+                        // restrict events to events that happened no earlier than now
+                        if (event._lastBlockNumber === -2) {
+                            event._lastBlockNumber = blockNumber - 1;
+                        }
+                        // Filter from the last *known* event; due to load-balancing
+                        // and some nodes returning updated block numbers before
+                        // indexing events, a logs result with 0 entries cannot be
+                        // trusted and we must retry a range which includes it again
+                        const filter = event.filter;
+                        filter.fromBlock = event._lastBlockNumber + 1;
+                        filter.toBlock = blockNumber;
+                        // Prevent fitler ranges from growing too wild, since it is quite
+                        // likely there just haven't been any events to move the lastBlockNumber.
+                        const minFromBlock = filter.toBlock - this._maxFilterBlockRange;
+                        if (minFromBlock > filter.fromBlock) {
+                            filter.fromBlock = minFromBlock;
+                        }
+                        if (filter.fromBlock < 0) {
+                            filter.fromBlock = 0;
+                        }
+                        const runner = this.getLogs(filter)
+                            .then((logs) => {
+                            // Allow the next getLogs
+                            event._inflight = false;
+                            if (logs.length === 0) {
+                                return;
                             }
-                        }
-                        // The emitted block was updated, check for obsolete events
-                        if (this._emitted.block !== blockNumber) {
-                            this._emitted.block = blockNumber;
-                            Object.keys(this._emitted).forEach(function (key) {
-                                // The block event does not expire
-                                if (key === "block") {
-                                    return;
-                                }
-                                // The block we were at when we emitted this event
-                                var eventBlockNumber = _this._emitted[key];
-                                // We cannot garbage collect pending transactions or blocks here
-                                // They should be garbage collected by the Provider when setting
-                                // "pending" events
-                                if (eventBlockNumber === "pending") {
-                                    return;
-                                }
-                                // Evict any transaction hashes or block hashes over 12 blocks
-                                // old, since they should not return null anyways
-                                if (blockNumber - eventBlockNumber > 12) {
-                                    delete _this._emitted[key];
+                            logs.forEach((log) => {
+                                // Only when we get an event for a given block number
+                                // can we trust the events are indexed
+                                if (log.blockNumber > event._lastBlockNumber) {
+                                    event._lastBlockNumber =
+                                        log.blockNumber;
                                 }
+                                // Make sure we stall requests to fetch blocks and txs
+                                this._emitted["b:" + log.blockHash] =
+                                    log.blockNumber;
+                                this._emitted["t:" + log.transactionHash] =
+                                    log.blockNumber;
+                                this.emit(filter, log);
                             });
-                        }
-                        // First polling cycle
-                        if (this._lastBlockNumber === -2) {
-                            this._lastBlockNumber = blockNumber - 1;
-                        }
-                        // Find all transaction hashes we are waiting on
-                        this._events.forEach(function (event) {
-                            switch (event.type) {
-                                case "tx": {
-                                    var hash_2 = event.hash;
-                                    var runner = _this.getTransactionReceipt(hash_2).then(function (receipt) {
-                                        if (!receipt || receipt.blockNumber == null) {
-                                            return null;
-                                        }
-                                        _this._emitted["t:" + hash_2] = receipt.blockNumber;
-                                        _this.emit(hash_2, receipt);
-                                        return null;
-                                    }).catch(function (error) { _this.emit("error", error); });
-                                    runners.push(runner);
-                                    break;
-                                }
-                                case "filter": {
-                                    // We only allow a single getLogs to be in-flight at a time
-                                    if (!event._inflight) {
-                                        event._inflight = true;
-                                        // This is the first filter for this event, so we want to
-                                        // restrict events to events that happened no earlier than now
-                                        if (event._lastBlockNumber === -2) {
-                                            event._lastBlockNumber = blockNumber - 1;
-                                        }
-                                        // Filter from the last *known* event; due to load-balancing
-                                        // and some nodes returning updated block numbers before
-                                        // indexing events, a logs result with 0 entries cannot be
-                                        // trusted and we must retry a range which includes it again
-                                        var filter_1 = event.filter;
-                                        filter_1.fromBlock = event._lastBlockNumber + 1;
-                                        filter_1.toBlock = blockNumber;
-                                        // Prevent fitler ranges from growing too wild, since it is quite
-                                        // likely there just haven't been any events to move the lastBlockNumber.
-                                        var minFromBlock = filter_1.toBlock - _this._maxFilterBlockRange;
-                                        if (minFromBlock > filter_1.fromBlock) {
-                                            filter_1.fromBlock = minFromBlock;
-                                        }
-                                        if (filter_1.fromBlock < 0) {
-                                            filter_1.fromBlock = 0;
-                                        }
-                                        var runner = _this.getLogs(filter_1).then(function (logs) {
-                                            // Allow the next getLogs
-                                            event._inflight = false;
-                                            if (logs.length === 0) {
-                                                return;
-                                            }
-                                            logs.forEach(function (log) {
-                                                // Only when we get an event for a given block number
-                                                // can we trust the events are indexed
-                                                if (log.blockNumber > event._lastBlockNumber) {
-                                                    event._lastBlockNumber = log.blockNumber;
-                                                }
-                                                // Make sure we stall requests to fetch blocks and txs
-                                                _this._emitted["b:" + log.blockHash] = log.blockNumber;
-                                                _this._emitted["t:" + log.transactionHash] = log.blockNumber;
-                                                _this.emit(filter_1, log);
-                                            });
-                                        }).catch(function (error) {
-                                            _this.emit("error", error);
-                                            // Allow another getLogs (the range was not updated)
-                                            event._inflight = false;
-                                        });
-                                        runners.push(runner);
-                                    }
-                                    break;
-                                }
-                            }
+                        })
+                            .catch((error) => {
+                            this.emit("error", error);
+                            // Allow another getLogs (the range was not updated)
+                            event._inflight = false;
                         });
-                        this._lastBlockNumber = blockNumber;
-                        // Once all events for this loop have been processed, emit "didPoll"
-                        Promise.all(runners).then(function () {
-                            _this.emit("didPoll", pollId);
-                        }).catch(function (error) { _this.emit("error", error); });
-                        return [2 /*return*/];
+                        runners.push(runner);
+                    }
+                    break;
                 }
-            });
+            }
+        });
+        this._lastBlockNumber = blockNumber;
+        // Once all events for this loop have been processed, emit "didPoll"
+        Promise.all(runners)
+            .then(() => {
+            this.emit("didPoll", pollId);
+        })
+            .catch((error) => {
+            this.emit("error", error);
         });
-    };
+        return;
+    }
     // Deprecated; do not use this
-    BaseProvider.prototype.resetEventsBlock = function (blockNumber) {
+    resetEventsBlock(blockNumber) {
         this._lastBlockNumber = blockNumber - 1;
         if (this.polling) {
             this.poll();
         }
-    };
-    Object.defineProperty(BaseProvider.prototype, "network", {
-        get: function () {
-            return this._network;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    get network() {
+        return this._network;
+    }
     // This method should query the network if the underlying network
     // can change, such as when connected to a JSON-RPC backend
-    BaseProvider.prototype.detectNetwork = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, logger.throwError("provider does not support network detection", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
-                        operation: "provider.detectNetwork"
-                    })];
-            });
-        });
-    };
-    BaseProvider.prototype.getNetwork = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var network, currentNetwork, error;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this._ready()];
-                    case 1:
-                        network = _a.sent();
-                        return [4 /*yield*/, this.detectNetwork()];
-                    case 2:
-                        currentNetwork = _a.sent();
-                        if (!(network.chainId !== currentNetwork.chainId)) return [3 /*break*/, 5];
-                        if (!this.anyNetwork) return [3 /*break*/, 4];
-                        this._network = currentNetwork;
-                        // Reset all internal block number guards and caches
-                        this._lastBlockNumber = -2;
-                        this._fastBlockNumber = null;
-                        this._fastBlockNumberPromise = null;
-                        this._fastQueryDate = 0;
-                        this._emitted.block = -2;
-                        this._maxInternalBlockNumber = -1024;
-                        this._internalBlockNumber = null;
-                        // The "network" event MUST happen before this method resolves
-                        // so any events have a chance to unregister, so we stall an
-                        // additional event loop before returning from /this/ call
-                        this.emit("network", currentNetwork, network);
-                        return [4 /*yield*/, stall(0)];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/, this._network];
-                    case 4:
-                        error = logger.makeError("underlying network changed", logger_1.Logger.errors.NETWORK_ERROR, {
-                            event: "changed",
-                            network: network,
-                            detectedNetwork: currentNetwork
-                        });
-                        this.emit("error", error);
-                        throw error;
-                    case 5: return [2 /*return*/, network];
-                }
-            });
+    async detectNetwork() {
+        return logger.throwError("provider does not support network detection", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
+            operation: "provider.detectNetwork",
         });
-    };
-    Object.defineProperty(BaseProvider.prototype, "blockNumber", {
-        get: function () {
-            var _this = this;
-            this._getInternalBlockNumber(100 + this.pollingInterval / 2).then(function (blockNumber) {
-                _this._setFastBlockNumber(blockNumber);
-            }, function (error) { });
-            return (this._fastBlockNumber != null) ? this._fastBlockNumber : -1;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(BaseProvider.prototype, "polling", {
-        get: function () {
-            return (this._poller != null);
-        },
-        set: function (value) {
-            var _this = this;
-            if (value && !this._poller) {
-                this._poller = setInterval(function () { _this.poll(); }, this.pollingInterval);
-                if (!this._bootstrapPoll) {
-                    this._bootstrapPoll = setTimeout(function () {
-                        _this.poll();
-                        // We block additional polls until the polling interval
-                        // is done, to prevent overwhelming the poll function
-                        _this._bootstrapPoll = setTimeout(function () {
-                            // If polling was disabled, something may require a poke
-                            // since starting the bootstrap poll and it was disabled
-                            if (!_this._poller) {
-                                _this.poll();
-                            }
-                            // Clear out the bootstrap so we can do another
-                            _this._bootstrapPoll = null;
-                        }, _this.pollingInterval);
-                    }, 0);
-                }
+    }
+    async getNetwork() {
+        const network = await this._ready();
+        // Make sure we are still connected to the same network; this is
+        // only an external call for backends which can have the underlying
+        // network change spontaneously
+        const currentNetwork = await this.detectNetwork();
+        if (network.chainId !== currentNetwork.chainId) {
+            // We are allowing network changes, things can get complex fast;
+            // make sure you know what you are doing if you use "any"
+            if (this.anyNetwork) {
+                this._network = currentNetwork;
+                // Reset all internal block number guards and caches
+                this._lastBlockNumber = -2;
+                this._fastBlockNumber = null;
+                this._fastBlockNumberPromise = null;
+                this._fastQueryDate = 0;
+                this._emitted.block = -2;
+                this._maxInternalBlockNumber = -1024;
+                this._internalBlockNumber = null;
+                // The "network" event MUST happen before this method resolves
+                // so any events have a chance to unregister, so we stall an
+                // additional event loop before returning from /this/ call
+                this.emit("network", currentNetwork, network);
+                await stall(0);
+                return this._network;
             }
-            else if (!value && this._poller) {
-                clearInterval(this._poller);
-                this._poller = null;
+            const error = logger.makeError("underlying network changed", logger_1.Logger.errors.NETWORK_ERROR, {
+                event: "changed",
+                network: network,
+                detectedNetwork: currentNetwork,
+            });
+            this.emit("error", error);
+            throw error;
+        }
+        return network;
+    }
+    get blockNumber() {
+        this._getInternalBlockNumber(100 + this.pollingInterval / 2).then((blockNumber) => {
+            this._setFastBlockNumber(blockNumber);
+        }, (error) => { });
+        return this._fastBlockNumber != null ? this._fastBlockNumber : -1;
+    }
+    get polling() {
+        return this._poller != null;
+    }
+    set polling(value) {
+        if (value && !this._poller) {
+            this._poller = setInterval(() => {
+                this.poll();
+            }, this.pollingInterval);
+            if (!this._bootstrapPoll) {
+                this._bootstrapPoll = setTimeout(() => {
+                    this.poll();
+                    // We block additional polls until the polling interval
+                    // is done, to prevent overwhelming the poll function
+                    this._bootstrapPoll = setTimeout(() => {
+                        // If polling was disabled, something may require a poke
+                        // since starting the bootstrap poll and it was disabled
+                        if (!this._poller) {
+                            this.poll();
+                        }
+                        // Clear out the bootstrap so we can do another
+                        this._bootstrapPoll = null;
+                    }, this.pollingInterval);
+                }, 0);
             }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(BaseProvider.prototype, "pollingInterval", {
-        get: function () {
-            return this._pollingInterval;
-        },
-        set: function (value) {
-            var _this = this;
-            if (typeof (value) !== "number" || value <= 0 || parseInt(String(value)) != value) {
-                throw new Error("invalid polling interval");
-            }
-            this._pollingInterval = value;
-            if (this._poller) {
-                clearInterval(this._poller);
-                this._poller = setInterval(function () { _this.poll(); }, this._pollingInterval);
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    BaseProvider.prototype._getFastBlockNumber = function () {
-        var _this = this;
-        var now = getTime();
+        }
+        else if (!value && this._poller) {
+            clearInterval(this._poller);
+            this._poller = null;
+        }
+    }
+    get pollingInterval() {
+        return this._pollingInterval;
+    }
+    set pollingInterval(value) {
+        if (typeof value !== "number" ||
+            value <= 0 ||
+            parseInt(String(value)) != value) {
+            throw new Error("invalid polling interval");
+        }
+        this._pollingInterval = value;
+        if (this._poller) {
+            clearInterval(this._poller);
+            this._poller = setInterval(() => {
+                this.poll();
+            }, this._pollingInterval);
+        }
+    }
+    _getFastBlockNumber() {
+        const now = getTime();
         // Stale block number, request a newer value
-        if ((now - this._fastQueryDate) > 2 * this._pollingInterval) {
+        if (now - this._fastQueryDate > 2 * this._pollingInterval) {
             this._fastQueryDate = now;
-            this._fastBlockNumberPromise = this.getBlockNumber().then(function (blockNumber) {
-                if (_this._fastBlockNumber == null || blockNumber > _this._fastBlockNumber) {
-                    _this._fastBlockNumber = blockNumber;
+            this._fastBlockNumberPromise = this.getBlockNumber().then((blockNumber) => {
+                if (this._fastBlockNumber == null ||
+                    blockNumber > this._fastBlockNumber) {
+                    this._fastBlockNumber = blockNumber;
                 }
-                return _this._fastBlockNumber;
+                return this._fastBlockNumber;
             });
         }
         return this._fastBlockNumberPromise;
-    };
-    BaseProvider.prototype._setFastBlockNumber = function (blockNumber) {
+    }
+    _setFastBlockNumber(blockNumber) {
         // Older block, maybe a stale request
-        if (this._fastBlockNumber != null && blockNumber < this._fastBlockNumber) {
+        if (this._fastBlockNumber != null &&
+            blockNumber < this._fastBlockNumber) {
             return;
         }
         // Update the time we updated the blocknumber
         this._fastQueryDate = getTime();
         // Newer block number, use  it
-        if (this._fastBlockNumber == null || blockNumber > this._fastBlockNumber) {
+        if (this._fastBlockNumber == null ||
+            blockNumber > this._fastBlockNumber) {
             this._fastBlockNumber = blockNumber;
             this._fastBlockNumberPromise = Promise.resolve(blockNumber);
         }
-    };
-    BaseProvider.prototype.waitForTransaction = function (transactionHash, confirmations, timeout) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this._waitForTransaction(transactionHash, (confirmations == null) ? 1 : confirmations, timeout || 0, null)];
-            });
-        });
-    };
-    BaseProvider.prototype._waitForTransaction = function (transactionHash, confirmations, timeout, replaceable) {
-        return __awaiter(this, void 0, void 0, function () {
-            var receipt;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getTransactionReceipt(transactionHash)];
-                    case 1:
-                        receipt = _a.sent();
-                        // Receipt is already good
-                        if ((receipt ? receipt.confirmations : 0) >= confirmations) {
-                            return [2 /*return*/, receipt];
-                        }
-                        // Poll until the receipt is good...
-                        return [2 /*return*/, new Promise(function (resolve, reject) {
-                                var cancelFuncs = [];
-                                var done = false;
-                                var alreadyDone = function () {
-                                    if (done) {
-                                        return true;
-                                    }
-                                    done = true;
-                                    cancelFuncs.forEach(function (func) { func(); });
-                                    return false;
-                                };
-                                var minedHandler = function (receipt) {
-                                    if (receipt.confirmations < confirmations) {
-                                        return;
-                                    }
-                                    if (alreadyDone()) {
-                                        return;
-                                    }
-                                    resolve(receipt);
-                                };
-                                _this.on(transactionHash, minedHandler);
-                                cancelFuncs.push(function () { _this.removeListener(transactionHash, minedHandler); });
-                                if (replaceable) {
-                                    var lastBlockNumber_1 = replaceable.startBlock;
-                                    var scannedBlock_1 = null;
-                                    var replaceHandler_1 = function (blockNumber) { return __awaiter(_this, void 0, void 0, function () {
-                                        var _this = this;
-                                        return __generator(this, function (_a) {
-                                            switch (_a.label) {
-                                                case 0:
-                                                    if (done) {
-                                                        return [2 /*return*/];
-                                                    }
-                                                    // Wait 1 second; this is only used in the case of a fault, so
-                                                    // we will trade off a little bit of latency for more consistent
-                                                    // results and fewer JSON-RPC calls
-                                                    return [4 /*yield*/, stall(1000)];
-                                                case 1:
-                                                    // Wait 1 second; this is only used in the case of a fault, so
-                                                    // we will trade off a little bit of latency for more consistent
-                                                    // results and fewer JSON-RPC calls
-                                                    _a.sent();
-                                                    this.getTransactionCount(replaceable.from).then(function (nonce) { return __awaiter(_this, void 0, void 0, function () {
-                                                        var mined, block, ti, tx, receipt_1, reason;
-                                                        return __generator(this, function (_a) {
-                                                            switch (_a.label) {
-                                                                case 0:
-                                                                    if (done) {
-                                                                        return [2 /*return*/];
-                                                                    }
-                                                                    if (!(nonce <= replaceable.nonce)) return [3 /*break*/, 1];
-                                                                    lastBlockNumber_1 = blockNumber;
-                                                                    return [3 /*break*/, 9];
-                                                                case 1: return [4 /*yield*/, this.getTransaction(transactionHash)];
-                                                                case 2:
-                                                                    mined = _a.sent();
-                                                                    if (mined && mined.blockNumber != null) {
-                                                                        return [2 /*return*/];
-                                                                    }
-                                                                    // First time scanning. We start a little earlier for some
-                                                                    // wiggle room here to handle the eventually consistent nature
-                                                                    // of blockchain (e.g. the getTransactionCount was for a
-                                                                    // different block)
-                                                                    if (scannedBlock_1 == null) {
-                                                                        scannedBlock_1 = lastBlockNumber_1 - 3;
-                                                                        if (scannedBlock_1 < replaceable.startBlock) {
-                                                                            scannedBlock_1 = replaceable.startBlock;
-                                                                        }
-                                                                    }
-                                                                    _a.label = 3;
-                                                                case 3:
-                                                                    if (!(scannedBlock_1 <= blockNumber)) return [3 /*break*/, 9];
-                                                                    if (done) {
-                                                                        return [2 /*return*/];
-                                                                    }
-                                                                    return [4 /*yield*/, this.getBlockWithTransactions(scannedBlock_1)];
-                                                                case 4:
-                                                                    block = _a.sent();
-                                                                    ti = 0;
-                                                                    _a.label = 5;
-                                                                case 5:
-                                                                    if (!(ti < block.transactions.length)) return [3 /*break*/, 8];
-                                                                    tx = block.transactions[ti];
-                                                                    // Successfully mined!
-                                                                    if (tx.hash === transactionHash) {
-                                                                        return [2 /*return*/];
-                                                                    }
-                                                                    if (!(tx.from === replaceable.from && tx.nonce === replaceable.nonce)) return [3 /*break*/, 7];
-                                                                    if (done) {
-                                                                        return [2 /*return*/];
-                                                                    }
-                                                                    return [4 /*yield*/, this.waitForTransaction(tx.hash, confirmations)];
-                                                                case 6:
-                                                                    receipt_1 = _a.sent();
-                                                                    // Already resolved or rejected (prolly a timeout)
-                                                                    if (alreadyDone()) {
-                                                                        return [2 /*return*/];
-                                                                    }
-                                                                    reason = "replaced";
-                                                                    if (tx.data === replaceable.data && tx.to === replaceable.to && tx.value.eq(replaceable.value)) {
-                                                                        reason = "repriced";
-                                                                    }
-                                                                    else if (tx.data === "0x" && tx.from === tx.to && tx.value.isZero()) {
-                                                                        reason = "cancelled";
-                                                                    }
-                                                                    // Explain why we were replaced
-                                                                    reject(logger.makeError("transaction was replaced", logger_1.Logger.errors.TRANSACTION_REPLACED, {
-                                                                        cancelled: (reason === "replaced" || reason === "cancelled"),
-                                                                        reason: reason,
-                                                                        replacement: this._wrapTransaction(tx),
-                                                                        hash: transactionHash,
-                                                                        receipt: receipt_1
-                                                                    }));
-                                                                    return [2 /*return*/];
-                                                                case 7:
-                                                                    ti++;
-                                                                    return [3 /*break*/, 5];
-                                                                case 8:
-                                                                    scannedBlock_1++;
-                                                                    return [3 /*break*/, 3];
-                                                                case 9:
-                                                                    if (done) {
-                                                                        return [2 /*return*/];
-                                                                    }
-                                                                    this.once("block", replaceHandler_1);
-                                                                    return [2 /*return*/];
-                                                            }
-                                                        });
-                                                    }); }, function (error) {
-                                                        if (done) {
-                                                            return;
-                                                        }
-                                                        _this.once("block", replaceHandler_1);
-                                                    });
-                                                    return [2 /*return*/];
-                                            }
-                                        });
-                                    }); };
-                                    if (done) {
+    }
+    async waitForTransaction(transactionHash, confirmations, timeout) {
+        return this._waitForTransaction(transactionHash, confirmations == null ? 1 : confirmations, timeout || 0, null);
+    }
+    async _waitForTransaction(transactionHash, confirmations, timeout, replaceable) {
+        const receipt = await this.getTransactionReceipt(transactionHash);
+        // Receipt is already good
+        if ((receipt ? receipt.confirmations : 0) >= confirmations) {
+            return receipt;
+        }
+        // Poll until the receipt is good...
+        return new Promise((resolve, reject) => {
+            const cancelFuncs = [];
+            let done = false;
+            const alreadyDone = function () {
+                if (done) {
+                    return true;
+                }
+                done = true;
+                cancelFuncs.forEach((func) => {
+                    func();
+                });
+                return false;
+            };
+            const minedHandler = (receipt) => {
+                if (receipt.confirmations < confirmations) {
+                    return;
+                }
+                if (alreadyDone()) {
+                    return;
+                }
+                resolve(receipt);
+            };
+            this.on(transactionHash, minedHandler);
+            cancelFuncs.push(() => {
+                this.removeListener(transactionHash, minedHandler);
+            });
+            if (replaceable) {
+                let lastBlockNumber = replaceable.startBlock;
+                let scannedBlock = null;
+                const replaceHandler = async (blockNumber) => {
+                    if (done) {
+                        return;
+                    }
+                    // Wait 1 second; this is only used in the case of a fault, so
+                    // we will trade off a little bit of latency for more consistent
+                    // results and fewer JSON-RPC calls
+                    await stall(1000);
+                    this.getTransactionCount(replaceable.from).then(async (nonce) => {
+                        if (done) {
+                            return;
+                        }
+                        if (nonce <= replaceable.nonce) {
+                            lastBlockNumber = blockNumber;
+                        }
+                        else {
+                            // First check if the transaction was mined
+                            {
+                                const mined = await this.getTransaction(transactionHash);
+                                if (mined && mined.blockNumber != null) {
+                                    return;
+                                }
+                            }
+                            // First time scanning. We start a little earlier for some
+                            // wiggle room here to handle the eventually consistent nature
+                            // of blockchain (e.g. the getTransactionCount was for a
+                            // different block)
+                            if (scannedBlock == null) {
+                                scannedBlock = lastBlockNumber - 3;
+                                if (scannedBlock < replaceable.startBlock) {
+                                    scannedBlock = replaceable.startBlock;
+                                }
+                            }
+                            while (scannedBlock <= blockNumber) {
+                                if (done) {
+                                    return;
+                                }
+                                const block = await this.getBlockWithTransactions(scannedBlock);
+                                for (let ti = 0; ti < block.transactions.length; ti++) {
+                                    const tx = block.transactions[ti];
+                                    // Successfully mined!
+                                    if (tx.hash === transactionHash) {
                                         return;
                                     }
-                                    _this.once("block", replaceHandler_1);
-                                    cancelFuncs.push(function () {
-                                        _this.removeListener("block", replaceHandler_1);
-                                    });
-                                }
-                                if (typeof (timeout) === "number" && timeout > 0) {
-                                    var timer_1 = setTimeout(function () {
+                                    // Matches our transaction from and nonce; its a replacement
+                                    if (tx.from === replaceable.from &&
+                                        tx.nonce === replaceable.nonce) {
+                                        if (done) {
+                                            return;
+                                        }
+                                        // Get the receipt of the replacement
+                                        const receipt = await this.waitForTransaction(tx.hash, confirmations);
+                                        // Already resolved or rejected (prolly a timeout)
                                         if (alreadyDone()) {
                                             return;
                                         }
-                                        reject(logger.makeError("timeout exceeded", logger_1.Logger.errors.TIMEOUT, { timeout: timeout }));
-                                    }, timeout);
-                                    if (timer_1.unref) {
-                                        timer_1.unref();
+                                        // The reason we were replaced
+                                        let reason = "replaced";
+                                        if (tx.data === replaceable.data &&
+                                            tx.to === replaceable.to &&
+                                            tx.value.eq(replaceable.value)) {
+                                            reason = "repriced";
+                                        }
+                                        else if (tx.data === "0x" &&
+                                            tx.from === tx.to &&
+                                            tx.value.isZero()) {
+                                            reason = "cancelled";
+                                        }
+                                        // Explain why we were replaced
+                                        reject(logger.makeError("transaction was replaced", logger_1.Logger.errors
+                                            .TRANSACTION_REPLACED, {
+                                            cancelled: reason ===
+                                                "replaced" ||
+                                                reason ===
+                                                    "cancelled",
+                                            reason,
+                                            replacement: this._wrapTransaction(tx),
+                                            hash: transactionHash,
+                                            receipt,
+                                        }));
+                                        return;
                                     }
-                                    cancelFuncs.push(function () { clearTimeout(timer_1); });
                                 }
-                            })];
-                }
-            });
-        });
-    };
-    BaseProvider.prototype.getBlockNumber = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this._getInternalBlockNumber(0)];
-            });
-        });
-    };
-    BaseProvider.prototype.getGasPrice = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.perform("getGasPrice", {})];
-                    case 2:
-                        result = _a.sent();
-                        try {
-                            return [2 /*return*/, bignumber_1.BigNumber.from(result)];
+                                scannedBlock++;
+                            }
                         }
-                        catch (error) {
-                            return [2 /*return*/, logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
-                                    method: "getGasPrice",
-                                    result: result,
-                                    error: error
-                                })];
+                        if (done) {
+                            return;
                         }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    BaseProvider.prototype.getBalance = function (addressOrName, blockTag) {
-        return __awaiter(this, void 0, void 0, function () {
-            var params, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, (0, properties_1.resolveProperties)({
-                                address: this._getAddress(addressOrName),
-                                blockTag: this._getBlockTag(blockTag)
-                            })];
-                    case 2:
-                        params = _a.sent();
-                        return [4 /*yield*/, this.perform("getBalance", params)];
-                    case 3:
-                        result = _a.sent();
-                        try {
-                            return [2 /*return*/, bignumber_1.BigNumber.from(result)];
+                        this.once("block", replaceHandler);
+                    }, (error) => {
+                        if (done) {
+                            return;
                         }
-                        catch (error) {
-                            return [2 /*return*/, logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
-                                    method: "getBalance",
-                                    params: params,
-                                    result: result,
-                                    error: error
-                                })];
-                        }
-                        return [2 /*return*/];
+                        this.once("block", replaceHandler);
+                    });
+                };
+                if (done) {
+                    return;
+                }
+                this.once("block", replaceHandler);
+                cancelFuncs.push(() => {
+                    this.removeListener("block", replaceHandler);
+                });
+            }
+            if (typeof timeout === "number" && timeout > 0) {
+                const timer = setTimeout(() => {
+                    if (alreadyDone()) {
+                        return;
+                    }
+                    reject(logger.makeError("timeout exceeded", logger_1.Logger.errors.TIMEOUT, { timeout: timeout }));
+                }, timeout);
+                if (timer.unref) {
+                    timer.unref();
                 }
+                cancelFuncs.push(() => {
+                    clearTimeout(timer);
+                });
+            }
+        });
+    }
+    async getBlockNumber() {
+        return this._getInternalBlockNumber(0);
+    }
+    async getGasPrice() {
+        await this.getNetwork();
+        const result = await this.perform("getGasPrice", {});
+        try {
+            return bignumber_1.BigNumber.from(result);
+        }
+        catch (error) {
+            return logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
+                method: "getGasPrice",
+                result,
+                error,
             });
+        }
+    }
+    async getBalance(addressOrName, blockTag) {
+        await this.getNetwork();
+        const params = await (0, properties_1.resolveProperties)({
+            address: this._getAddress(addressOrName),
+            blockTag: this._getBlockTag(blockTag),
         });
-    };
-    BaseProvider.prototype.getTransactionCount = function (addressOrName, blockTag) {
-        return __awaiter(this, void 0, void 0, function () {
-            var params, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, (0, properties_1.resolveProperties)({
-                                address: this._getAddress(addressOrName),
-                                blockTag: this._getBlockTag(blockTag)
-                            })];
-                    case 2:
-                        params = _a.sent();
-                        return [4 /*yield*/, this.perform("getTransactionCount", params)];
-                    case 3:
-                        result = _a.sent();
-                        try {
-                            return [2 /*return*/, bignumber_1.BigNumber.from(result).toNumber()];
-                        }
-                        catch (error) {
-                            return [2 /*return*/, logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
-                                    method: "getTransactionCount",
-                                    params: params,
-                                    result: result,
-                                    error: error
-                                })];
-                        }
-                        return [2 /*return*/];
-                }
+        const result = await this.perform("getBalance", params);
+        try {
+            return bignumber_1.BigNumber.from(result);
+        }
+        catch (error) {
+            return logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
+                method: "getBalance",
+                params,
+                result,
+                error,
             });
+        }
+    }
+    async getTransactionCount(addressOrName, blockTag) {
+        await this.getNetwork();
+        const params = await (0, properties_1.resolveProperties)({
+            address: this._getAddress(addressOrName),
+            blockTag: this._getBlockTag(blockTag),
         });
-    };
-    BaseProvider.prototype.getCode = function (addressOrName, blockTag) {
-        return __awaiter(this, void 0, void 0, function () {
-            var params, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, (0, properties_1.resolveProperties)({
-                                address: this._getAddress(addressOrName),
-                                blockTag: this._getBlockTag(blockTag)
-                            })];
-                    case 2:
-                        params = _a.sent();
-                        return [4 /*yield*/, this.perform("getCode", params)];
-                    case 3:
-                        result = _a.sent();
-                        try {
-                            return [2 /*return*/, (0, bytes_1.hexlify)(result)];
-                        }
-                        catch (error) {
-                            return [2 /*return*/, logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
-                                    method: "getCode",
-                                    params: params,
-                                    result: result,
-                                    error: error
-                                })];
-                        }
-                        return [2 /*return*/];
-                }
+        const result = await this.perform("getTransactionCount", params);
+        try {
+            return bignumber_1.BigNumber.from(result).toNumber();
+        }
+        catch (error) {
+            return logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
+                method: "getTransactionCount",
+                params,
+                result,
+                error,
             });
+        }
+    }
+    async getCode(addressOrName, blockTag) {
+        await this.getNetwork();
+        const params = await (0, properties_1.resolveProperties)({
+            address: this._getAddress(addressOrName),
+            blockTag: this._getBlockTag(blockTag),
         });
-    };
-    BaseProvider.prototype.getStorageAt = function (addressOrName, position, blockTag) {
-        return __awaiter(this, void 0, void 0, function () {
-            var params, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, (0, properties_1.resolveProperties)({
-                                address: this._getAddress(addressOrName),
-                                blockTag: this._getBlockTag(blockTag),
-                                position: Promise.resolve(position).then(function (p) { return (0, bytes_1.hexValue)(p); })
-                            })];
-                    case 2:
-                        params = _a.sent();
-                        return [4 /*yield*/, this.perform("getStorageAt", params)];
-                    case 3:
-                        result = _a.sent();
-                        try {
-                            return [2 /*return*/, (0, bytes_1.hexlify)(result)];
-                        }
-                        catch (error) {
-                            return [2 /*return*/, logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
-                                    method: "getStorageAt",
-                                    params: params,
-                                    result: result,
-                                    error: error
-                                })];
-                        }
-                        return [2 /*return*/];
-                }
+        const result = await this.perform("getCode", params);
+        try {
+            return (0, bytes_1.hexlify)(result);
+        }
+        catch (error) {
+            return logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
+                method: "getCode",
+                params,
+                result,
+                error,
             });
+        }
+    }
+    async getStorageAt(addressOrName, position, blockTag) {
+        await this.getNetwork();
+        const params = await (0, properties_1.resolveProperties)({
+            address: this._getAddress(addressOrName),
+            blockTag: this._getBlockTag(blockTag),
+            position: Promise.resolve(position).then((p) => (0, bytes_1.hexValue)(p)),
         });
-    };
+        const result = await this.perform("getStorageAt", params);
+        try {
+            return (0, bytes_1.hexlify)(result);
+        }
+        catch (error) {
+            return logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
+                method: "getStorageAt",
+                params,
+                result,
+                error,
+            });
+        }
+    }
     // This should be called by any subclass wrapping a TransactionResponse
-    BaseProvider.prototype._wrapTransaction = function (tx, hash, startBlock) {
-        var _this = this;
+    _wrapTransaction(tx, hash, startBlock) {
         if (hash != null && (0, bytes_1.hexDataLength)(hash) !== 32) {
             throw new Error("invalid response - sendTransaction");
         }
-        var result = tx;
+        const result = tx;
         // Check the hash we expect is the same as the hash the server reported
         if (hash != null && tx.hash !== hash) {
             logger.throwError("Transaction hash mismatch from Provider.sendTransaction.", logger_1.Logger.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash });
         }
-        result.wait = function (confirms, timeout) { return __awaiter(_this, void 0, void 0, function () {
-            var replacement, receipt;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (confirms == null) {
-                            confirms = 1;
-                        }
-                        if (timeout == null) {
-                            timeout = 0;
-                        }
-                        replacement = undefined;
-                        if (confirms !== 0 && startBlock != null) {
-                            replacement = {
-                                data: tx.data,
-                                from: tx.from,
-                                nonce: tx.nonce,
-                                to: tx.to,
-                                value: tx.value,
-                                startBlock: startBlock
-                            };
-                        }
-                        return [4 /*yield*/, this._waitForTransaction(tx.hash, confirms, timeout, replacement)];
-                    case 1:
-                        receipt = _a.sent();
-                        if (receipt == null && confirms === 0) {
-                            return [2 /*return*/, null];
-                        }
-                        // No longer pending, allow the polling loop to garbage collect this
-                        this._emitted["t:" + tx.hash] = receipt.blockNumber;
-                        if (receipt.status === 0) {
-                            logger.throwError("transaction failed", logger_1.Logger.errors.CALL_EXCEPTION, {
-                                transactionHash: tx.hash,
-                                transaction: tx,
-                                receipt: receipt
-                            });
-                        }
-                        return [2 /*return*/, receipt];
-                }
-            });
-        }); };
+        result.wait = async (confirms, timeout) => {
+            if (confirms == null) {
+                confirms = 1;
+            }
+            if (timeout == null) {
+                timeout = 0;
+            }
+            // Get the details to detect replacement
+            let replacement = undefined;
+            if (confirms !== 0 && startBlock != null) {
+                replacement = {
+                    data: tx.data,
+                    from: tx.from,
+                    nonce: tx.nonce,
+                    to: tx.to,
+                    value: tx.value,
+                    startBlock,
+                };
+            }
+            const receipt = await this._waitForTransaction(tx.hash, confirms, timeout, replacement);
+            if (receipt == null && confirms === 0) {
+                return null;
+            }
+            // No longer pending, allow the polling loop to garbage collect this
+            this._emitted["t:" + tx.hash] = receipt.blockNumber;
+            if (receipt.status === 0) {
+                logger.throwError("transaction failed", logger_1.Logger.errors.CALL_EXCEPTION, {
+                    transactionHash: tx.hash,
+                    transaction: tx,
+                    receipt: receipt,
+                });
+            }
+            return receipt;
+        };
         return result;
-    };
-    BaseProvider.prototype.sendTransaction = function (signedTransaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexTx, tx, blockNumber, hash, error_7;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, Promise.resolve(signedTransaction).then(function (t) { return (0, bytes_1.hexlify)(t); })];
-                    case 2:
-                        hexTx = _a.sent();
-                        tx = this.formatter.transaction(signedTransaction);
-                        if (tx.confirmations == null) {
-                            tx.confirmations = 0;
-                        }
-                        return [4 /*yield*/, this._getInternalBlockNumber(100 + 2 * this.pollingInterval)];
-                    case 3:
-                        blockNumber = _a.sent();
-                        _a.label = 4;
-                    case 4:
-                        _a.trys.push([4, 6, , 7]);
-                        return [4 /*yield*/, this.perform("sendTransaction", { signedTransaction: hexTx })];
-                    case 5:
-                        hash = _a.sent();
-                        return [2 /*return*/, this._wrapTransaction(tx, hash, blockNumber)];
-                    case 6:
-                        error_7 = _a.sent();
-                        error_7.transaction = tx;
-                        error_7.transactionHash = tx.hash;
-                        throw error_7;
-                    case 7: return [2 /*return*/];
-                }
+    }
+    async sendTransaction(signedTransaction) {
+        await this.getNetwork();
+        const hexTx = await Promise.resolve(signedTransaction).then((t) => (0, bytes_1.hexlify)(t));
+        const tx = this.formatter.transaction(signedTransaction);
+        if (tx.confirmations == null) {
+            tx.confirmations = 0;
+        }
+        const blockNumber = await this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
+        try {
+            const hash = await this.perform("sendTransaction", {
+                signedTransaction: hexTx,
             });
+            return this._wrapTransaction(tx, hash, blockNumber);
+        }
+        catch (error) {
+            error.transaction = tx;
+            error.transactionHash = tx.hash;
+            throw error;
+        }
+    }
+    async _getTransactionRequest(transaction) {
+        const values = await transaction;
+        const tx = {};
+        ["from", "to"].forEach((key) => {
+            if (values[key] == null) {
+                return;
+            }
+            tx[key] = Promise.resolve(values[key]).then((v) => v ? this._getAddress(v) : null);
         });
-    };
-    BaseProvider.prototype._getTransactionRequest = function (transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var values, tx, _a, _b;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, transaction];
-                    case 1:
-                        values = _c.sent();
-                        tx = {};
-                        ["from", "to"].forEach(function (key) {
-                            if (values[key] == null) {
-                                return;
-                            }
-                            tx[key] = Promise.resolve(values[key]).then(function (v) { return (v ? _this._getAddress(v) : null); });
-                        });
-                        ["gasLimit", "gasPrice", "maxFeePerGas", "maxPriorityFeePerGas", "value"].forEach(function (key) {
-                            if (values[key] == null) {
-                                return;
-                            }
-                            tx[key] = Promise.resolve(values[key]).then(function (v) { return (v ? bignumber_1.BigNumber.from(v) : null); });
-                        });
-                        ["type"].forEach(function (key) {
-                            if (values[key] == null) {
-                                return;
-                            }
-                            tx[key] = Promise.resolve(values[key]).then(function (v) { return ((v != null) ? v : null); });
-                        });
-                        if (values.accessList) {
-                            tx.accessList = this.formatter.accessList(values.accessList);
-                        }
-                        ["data"].forEach(function (key) {
-                            if (values[key] == null) {
-                                return;
-                            }
-                            tx[key] = Promise.resolve(values[key]).then(function (v) { return (v ? (0, bytes_1.hexlify)(v) : null); });
-                        });
-                        _b = (_a = this.formatter).transactionRequest;
-                        return [4 /*yield*/, (0, properties_1.resolveProperties)(tx)];
-                    case 2: return [2 /*return*/, _b.apply(_a, [_c.sent()])];
-                }
-            });
+        [
+            "gasLimit",
+            "gasPrice",
+            "maxFeePerGas",
+            "maxPriorityFeePerGas",
+            "value",
+        ].forEach((key) => {
+            if (values[key] == null) {
+                return;
+            }
+            tx[key] = Promise.resolve(values[key]).then((v) => v ? bignumber_1.BigNumber.from(v) : null);
         });
-    };
-    BaseProvider.prototype._getFilter = function (filter) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result, _a, _b;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, filter];
-                    case 1:
-                        filter = _c.sent();
-                        result = {};
-                        if (filter.address != null) {
-                            result.address = this._getAddress(filter.address);
-                        }
-                        ["blockHash", "topics"].forEach(function (key) {
-                            if (filter[key] == null) {
-                                return;
-                            }
-                            result[key] = filter[key];
-                        });
-                        ["fromBlock", "toBlock"].forEach(function (key) {
-                            if (filter[key] == null) {
-                                return;
-                            }
-                            result[key] = _this._getBlockTag(filter[key]);
+        ["type"].forEach((key) => {
+            if (values[key] == null) {
+                return;
+            }
+            tx[key] = Promise.resolve(values[key]).then((v) => v != null ? v : null);
+        });
+        if (values.accessList) {
+            tx.accessList = this.formatter.accessList(values.accessList);
+        }
+        ["data"].forEach((key) => {
+            if (values[key] == null) {
+                return;
+            }
+            tx[key] = Promise.resolve(values[key]).then((v) => v ? (0, bytes_1.hexlify)(v) : null);
+        });
+        return this.formatter.transactionRequest(await (0, properties_1.resolveProperties)(tx));
+    }
+    async _getFilter(filter) {
+        filter = await filter;
+        const result = {};
+        if (filter.address != null) {
+            result.address = this._getAddress(filter.address);
+        }
+        ["blockHash", "topics"].forEach((key) => {
+            if (filter[key] == null) {
+                return;
+            }
+            result[key] = filter[key];
+        });
+        ["fromBlock", "toBlock"].forEach((key) => {
+            if (filter[key] == null) {
+                return;
+            }
+            result[key] = this._getBlockTag(filter[key]);
+        });
+        return this.formatter.filter(await (0, properties_1.resolveProperties)(result));
+    }
+    async _call(transaction, blockTag, attempt) {
+        if (attempt >= MAX_CCIP_REDIRECTS) {
+            logger.throwError("CCIP read exceeded maximum redirections", logger_1.Logger.errors.SERVER_ERROR, {
+                redirects: attempt,
+                transaction,
+            });
+        }
+        const txSender = transaction.to;
+        const result = await this.perform("call", { transaction, blockTag });
+        // CCIP Read request via OffchainLookup(address,string[],bytes,bytes4,bytes)
+        if (attempt >= 0 &&
+            blockTag === "latest" &&
+            txSender != null &&
+            result.substring(0, 10) === "0x556f1830" &&
+            (0, bytes_1.hexDataLength)(result) % 32 === 4) {
+            try {
+                const data = (0, bytes_1.hexDataSlice)(result, 4);
+                // Check the sender of the OffchainLookup matches the transaction
+                const sender = (0, bytes_1.hexDataSlice)(data, 0, 32);
+                if (!bignumber_1.BigNumber.from(sender).eq(txSender)) {
+                    logger.throwError("CCIP Read sender did not match", logger_1.Logger.errors.CALL_EXCEPTION, {
+                        name: "OffchainLookup",
+                        signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
+                        transaction,
+                        data: result,
+                    });
+                }
+                // Read the URLs from the response
+                const urls = [];
+                const urlsOffset = bignumber_1.BigNumber.from((0, bytes_1.hexDataSlice)(data, 32, 64)).toNumber();
+                const urlsLength = bignumber_1.BigNumber.from((0, bytes_1.hexDataSlice)(data, urlsOffset, urlsOffset + 32)).toNumber();
+                const urlsData = (0, bytes_1.hexDataSlice)(data, urlsOffset + 32);
+                for (let u = 0; u < urlsLength; u++) {
+                    const url = _parseString(urlsData, u * 32);
+                    if (url == null) {
+                        logger.throwError("CCIP Read contained corrupt URL string", logger_1.Logger.errors.CALL_EXCEPTION, {
+                            name: "OffchainLookup",
+                            signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
+                            transaction,
+                            data: result,
                         });
-                        _b = (_a = this.formatter).filter;
-                        return [4 /*yield*/, (0, properties_1.resolveProperties)(result)];
-                    case 2: return [2 /*return*/, _b.apply(_a, [_c.sent()])];
+                    }
+                    urls.push(url);
                 }
-            });
-        });
-    };
-    BaseProvider.prototype._call = function (transaction, blockTag, attempt) {
-        return __awaiter(this, void 0, void 0, function () {
-            var txSender, result, data, sender, urls, urlsOffset, urlsLength, urlsData, u, url, calldata, callbackSelector, extraData, ccipResult, tx, error_8;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (attempt >= MAX_CCIP_REDIRECTS) {
-                            logger.throwError("CCIP read exceeded maximum redirections", logger_1.Logger.errors.SERVER_ERROR, {
-                                redirects: attempt,
-                                transaction: transaction
-                            });
-                        }
-                        txSender = transaction.to;
-                        return [4 /*yield*/, this.perform("call", { transaction: transaction, blockTag: blockTag })];
-                    case 1:
-                        result = _a.sent();
-                        if (!(attempt >= 0 && blockTag === "latest" && txSender != null && result.substring(0, 10) === "0x556f1830" && ((0, bytes_1.hexDataLength)(result) % 32 === 4))) return [3 /*break*/, 5];
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        data = (0, bytes_1.hexDataSlice)(result, 4);
-                        sender = (0, bytes_1.hexDataSlice)(data, 0, 32);
-                        if (!bignumber_1.BigNumber.from(sender).eq(txSender)) {
-                            logger.throwError("CCIP Read sender did not match", logger_1.Logger.errors.CALL_EXCEPTION, {
-                                name: "OffchainLookup",
-                                signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
-                                transaction: transaction,
-                                data: result
-                            });
-                        }
-                        urls = [];
-                        urlsOffset = bignumber_1.BigNumber.from((0, bytes_1.hexDataSlice)(data, 32, 64)).toNumber();
-                        urlsLength = bignumber_1.BigNumber.from((0, bytes_1.hexDataSlice)(data, urlsOffset, urlsOffset + 32)).toNumber();
-                        urlsData = (0, bytes_1.hexDataSlice)(data, urlsOffset + 32);
-                        for (u = 0; u < urlsLength; u++) {
-                            url = _parseString(urlsData, u * 32);
-                            if (url == null) {
-                                logger.throwError("CCIP Read contained corrupt URL string", logger_1.Logger.errors.CALL_EXCEPTION, {
-                                    name: "OffchainLookup",
-                                    signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
-                                    transaction: transaction,
-                                    data: result
-                                });
-                            }
-                            urls.push(url);
-                        }
-                        calldata = _parseBytes(data, 64);
-                        // Get the callbackSelector (bytes4)
-                        if (!bignumber_1.BigNumber.from((0, bytes_1.hexDataSlice)(data, 100, 128)).isZero()) {
-                            logger.throwError("CCIP Read callback selector included junk", logger_1.Logger.errors.CALL_EXCEPTION, {
-                                name: "OffchainLookup",
-                                signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
-                                transaction: transaction,
-                                data: result
-                            });
-                        }
-                        callbackSelector = (0, bytes_1.hexDataSlice)(data, 96, 100);
-                        extraData = _parseBytes(data, 128);
-                        return [4 /*yield*/, this.ccipReadFetch(transaction, calldata, urls)];
-                    case 3:
-                        ccipResult = _a.sent();
-                        if (ccipResult == null) {
-                            logger.throwError("CCIP Read disabled or provided no URLs", logger_1.Logger.errors.CALL_EXCEPTION, {
-                                name: "OffchainLookup",
-                                signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
-                                transaction: transaction,
-                                data: result
-                            });
-                        }
-                        tx = {
-                            to: txSender,
-                            data: (0, bytes_1.hexConcat)([callbackSelector, encodeBytes([ccipResult, extraData])])
-                        };
-                        return [2 /*return*/, this._call(tx, blockTag, attempt + 1)];
-                    case 4:
-                        error_8 = _a.sent();
-                        if (error_8.code === logger_1.Logger.errors.SERVER_ERROR) {
-                            throw error_8;
-                        }
-                        return [3 /*break*/, 5];
-                    case 5:
-                        try {
-                            return [2 /*return*/, (0, bytes_1.hexlify)(result)];
-                        }
-                        catch (error) {
-                            return [2 /*return*/, logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
-                                    method: "call",
-                                    params: { transaction: transaction, blockTag: blockTag },
-                                    result: result,
-                                    error: error
-                                })];
-                        }
-                        return [2 /*return*/];
+                // Get the CCIP calldata to forward
+                const calldata = _parseBytes(data, 64);
+                // Get the callbackSelector (bytes4)
+                if (!bignumber_1.BigNumber.from((0, bytes_1.hexDataSlice)(data, 100, 128)).isZero()) {
+                    logger.throwError("CCIP Read callback selector included junk", logger_1.Logger.errors.CALL_EXCEPTION, {
+                        name: "OffchainLookup",
+                        signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
+                        transaction,
+                        data: result,
+                    });
                 }
-            });
-        });
-    };
-    BaseProvider.prototype.call = function (transaction, blockTag) {
-        return __awaiter(this, void 0, void 0, function () {
-            var resolved;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, (0, properties_1.resolveProperties)({
-                                transaction: this._getTransactionRequest(transaction),
-                                blockTag: this._getBlockTag(blockTag),
-                                ccipReadEnabled: Promise.resolve(transaction.ccipReadEnabled)
-                            })];
-                    case 2:
-                        resolved = _a.sent();
-                        return [2 /*return*/, this._call(resolved.transaction, resolved.blockTag, resolved.ccipReadEnabled ? 0 : -1)];
+                const callbackSelector = (0, bytes_1.hexDataSlice)(data, 96, 100);
+                // Get the extra data to send back to the contract as context
+                const extraData = _parseBytes(data, 128);
+                const ccipResult = await this.ccipReadFetch(transaction, calldata, urls);
+                if (ccipResult == null) {
+                    logger.throwError("CCIP Read disabled or provided no URLs", logger_1.Logger.errors.CALL_EXCEPTION, {
+                        name: "OffchainLookup",
+                        signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
+                        transaction,
+                        data: result,
+                    });
                 }
-            });
-        });
-    };
-    BaseProvider.prototype.estimateGas = function (transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var params, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, (0, properties_1.resolveProperties)({
-                                transaction: this._getTransactionRequest(transaction)
-                            })];
-                    case 2:
-                        params = _a.sent();
-                        return [4 /*yield*/, this.perform("estimateGas", params)];
-                    case 3:
-                        result = _a.sent();
-                        try {
-                            return [2 /*return*/, bignumber_1.BigNumber.from(result)];
-                        }
-                        catch (error) {
-                            return [2 /*return*/, logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
-                                    method: "estimateGas",
-                                    params: params,
-                                    result: result,
-                                    error: error
-                                })];
-                        }
-                        return [2 /*return*/];
+                const tx = {
+                    to: txSender,
+                    data: (0, bytes_1.hexConcat)([
+                        callbackSelector,
+                        encodeBytes([ccipResult, extraData]),
+                    ]),
+                };
+                return this._call(tx, blockTag, attempt + 1);
+            }
+            catch (error) {
+                if (error.code === logger_1.Logger.errors.SERVER_ERROR) {
+                    throw error;
                 }
+            }
+        }
+        try {
+            return (0, bytes_1.hexlify)(result);
+        }
+        catch (error) {
+            return logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
+                method: "call",
+                params: { transaction, blockTag },
+                result,
+                error,
             });
+        }
+    }
+    async call(transaction, blockTag) {
+        await this.getNetwork();
+        const resolved = await (0, properties_1.resolveProperties)({
+            transaction: this._getTransactionRequest(transaction),
+            blockTag: this._getBlockTag(blockTag),
+            ccipReadEnabled: Promise.resolve(transaction.ccipReadEnabled),
         });
-    };
-    BaseProvider.prototype._getAddress = function (addressOrName) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, addressOrName];
-                    case 1:
-                        addressOrName = _a.sent();
-                        if (typeof (addressOrName) !== "string") {
-                            logger.throwArgumentError("invalid address or ENS name", "name", addressOrName);
-                        }
-                        return [4 /*yield*/, this.resolveName(addressOrName)];
-                    case 2:
-                        address = _a.sent();
-                        if (address == null) {
-                            logger.throwError("ENS name not configured", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
-                                operation: "resolveName(" + JSON.stringify(addressOrName) + ")"
-                            });
-                        }
-                        return [2 /*return*/, address];
-                }
-            });
+        return this._call(resolved.transaction, resolved.blockTag, resolved.ccipReadEnabled ? 0 : -1);
+    }
+    async estimateGas(transaction) {
+        await this.getNetwork();
+        const params = await (0, properties_1.resolveProperties)({
+            transaction: this._getTransactionRequest(transaction),
         });
-    };
-    BaseProvider.prototype._getBlock = function (blockHashOrBlockTag, includeTransactions) {
-        return __awaiter(this, void 0, void 0, function () {
-            var blockNumber, params, _a, error_9;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _b.sent();
-                        return [4 /*yield*/, blockHashOrBlockTag];
-                    case 2:
-                        blockHashOrBlockTag = _b.sent();
-                        blockNumber = -128;
-                        params = {
-                            includeTransactions: !!includeTransactions
-                        };
-                        if (!(0, bytes_1.isHexString)(blockHashOrBlockTag, 32)) return [3 /*break*/, 3];
-                        params.blockHash = blockHashOrBlockTag;
-                        return [3 /*break*/, 6];
-                    case 3:
-                        _b.trys.push([3, 5, , 6]);
-                        _a = params;
-                        return [4 /*yield*/, this._getBlockTag(blockHashOrBlockTag)];
-                    case 4:
-                        _a.blockTag = _b.sent();
-                        if ((0, bytes_1.isHexString)(params.blockTag)) {
-                            blockNumber = parseInt(params.blockTag.substring(2), 16);
-                        }
-                        return [3 /*break*/, 6];
-                    case 5:
-                        error_9 = _b.sent();
-                        logger.throwArgumentError("invalid block hash or block tag", "blockHashOrBlockTag", blockHashOrBlockTag);
-                        return [3 /*break*/, 6];
-                    case 6: return [2 /*return*/, (0, web_1.poll)(function () { return __awaiter(_this, void 0, void 0, function () {
-                            var block, blockNumber_1, i, tx, confirmations, blockWithTxs;
-                            var _this = this;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, this.perform("getBlock", params)];
-                                    case 1:
-                                        block = _a.sent();
-                                        // Block was not found
-                                        if (block == null) {
-                                            // For blockhashes, if we didn't say it existed, that blockhash may
-                                            // not exist. If we did see it though, perhaps from a log, we know
-                                            // it exists, and this node is just not caught up yet.
-                                            if (params.blockHash != null) {
-                                                if (this._emitted["b:" + params.blockHash] == null) {
-                                                    return [2 /*return*/, null];
-                                                }
-                                            }
-                                            // For block tags, if we are asking for a future block, we return null
-                                            if (params.blockTag != null) {
-                                                if (blockNumber > this._emitted.block) {
-                                                    return [2 /*return*/, null];
-                                                }
-                                            }
-                                            // Retry on the next block
-                                            return [2 /*return*/, undefined];
-                                        }
-                                        if (!includeTransactions) return [3 /*break*/, 8];
-                                        blockNumber_1 = null;
-                                        i = 0;
-                                        _a.label = 2;
-                                    case 2:
-                                        if (!(i < block.transactions.length)) return [3 /*break*/, 7];
-                                        tx = block.transactions[i];
-                                        if (!(tx.blockNumber == null)) return [3 /*break*/, 3];
-                                        tx.confirmations = 0;
-                                        return [3 /*break*/, 6];
-                                    case 3:
-                                        if (!(tx.confirmations == null)) return [3 /*break*/, 6];
-                                        if (!(blockNumber_1 == null)) return [3 /*break*/, 5];
-                                        return [4 /*yield*/, this._getInternalBlockNumber(100 + 2 * this.pollingInterval)];
-                                    case 4:
-                                        blockNumber_1 = _a.sent();
-                                        _a.label = 5;
-                                    case 5:
-                                        confirmations = (blockNumber_1 - tx.blockNumber) + 1;
-                                        if (confirmations <= 0) {
-                                            confirmations = 1;
-                                        }
-                                        tx.confirmations = confirmations;
-                                        _a.label = 6;
-                                    case 6:
-                                        i++;
-                                        return [3 /*break*/, 2];
-                                    case 7:
-                                        blockWithTxs = this.formatter.blockWithTransactions(block);
-                                        blockWithTxs.transactions = blockWithTxs.transactions.map(function (tx) { return _this._wrapTransaction(tx); });
-                                        return [2 /*return*/, blockWithTxs];
-                                    case 8: return [2 /*return*/, this.formatter.block(block)];
-                                }
-                            });
-                        }); }, { oncePoll: this })];
-                }
+        const result = await this.perform("estimateGas", params);
+        try {
+            return bignumber_1.BigNumber.from(result);
+        }
+        catch (error) {
+            return logger.throwError("bad result from backend", logger_1.Logger.errors.SERVER_ERROR, {
+                method: "estimateGas",
+                params,
+                result,
+                error,
             });
-        });
-    };
-    BaseProvider.prototype.getBlock = function (blockHashOrBlockTag) {
-        return (this._getBlock(blockHashOrBlockTag, false));
-    };
-    BaseProvider.prototype.getBlockWithTransactions = function (blockHashOrBlockTag) {
-        return (this._getBlock(blockHashOrBlockTag, true));
-    };
-    BaseProvider.prototype.getTransaction = function (transactionHash) {
-        return __awaiter(this, void 0, void 0, function () {
-            var params;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, transactionHash];
-                    case 2:
-                        transactionHash = _a.sent();
-                        params = { transactionHash: this.formatter.hash(transactionHash, true) };
-                        return [2 /*return*/, (0, web_1.poll)(function () { return __awaiter(_this, void 0, void 0, function () {
-                                var result, tx, blockNumber, confirmations;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, this.perform("getTransaction", params)];
-                                        case 1:
-                                            result = _a.sent();
-                                            if (result == null) {
-                                                if (this._emitted["t:" + transactionHash] == null) {
-                                                    return [2 /*return*/, null];
-                                                }
-                                                return [2 /*return*/, undefined];
-                                            }
-                                            tx = this.formatter.transactionResponse(result);
-                                            if (!(tx.blockNumber == null)) return [3 /*break*/, 2];
-                                            tx.confirmations = 0;
-                                            return [3 /*break*/, 4];
-                                        case 2:
-                                            if (!(tx.confirmations == null)) return [3 /*break*/, 4];
-                                            return [4 /*yield*/, this._getInternalBlockNumber(100 + 2 * this.pollingInterval)];
-                                        case 3:
-                                            blockNumber = _a.sent();
-                                            confirmations = (blockNumber - tx.blockNumber) + 1;
-                                            if (confirmations <= 0) {
-                                                confirmations = 1;
-                                            }
-                                            tx.confirmations = confirmations;
-                                            _a.label = 4;
-                                        case 4: return [2 /*return*/, this._wrapTransaction(tx)];
-                                    }
-                                });
-                            }); }, { oncePoll: this })];
-                }
+        }
+    }
+    async _getAddress(addressOrName) {
+        addressOrName = await addressOrName;
+        if (typeof addressOrName !== "string") {
+            logger.throwArgumentError("invalid address or ENS name", "name", addressOrName);
+        }
+        const address = await this.resolveName(addressOrName);
+        if (address == null) {
+            logger.throwError("ENS name not configured", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
+                operation: `resolveName(${JSON.stringify(addressOrName)})`,
             });
-        });
-    };
-    BaseProvider.prototype.getTransactionReceipt = function (transactionHash) {
-        return __awaiter(this, void 0, void 0, function () {
-            var params;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, transactionHash];
-                    case 2:
-                        transactionHash = _a.sent();
-                        params = { transactionHash: this.formatter.hash(transactionHash, true) };
-                        return [2 /*return*/, (0, web_1.poll)(function () { return __awaiter(_this, void 0, void 0, function () {
-                                var result, receipt, blockNumber, confirmations;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, this.perform("getTransactionReceipt", params)];
-                                        case 1:
-                                            result = _a.sent();
-                                            if (result == null) {
-                                                if (this._emitted["t:" + transactionHash] == null) {
-                                                    return [2 /*return*/, null];
-                                                }
-                                                return [2 /*return*/, undefined];
-                                            }
-                                            // "geth-etc" returns receipts before they are ready
-                                            if (result.blockHash == null) {
-                                                return [2 /*return*/, undefined];
-                                            }
-                                            receipt = this.formatter.receipt(result);
-                                            if (!(receipt.blockNumber == null)) return [3 /*break*/, 2];
-                                            receipt.confirmations = 0;
-                                            return [3 /*break*/, 4];
-                                        case 2:
-                                            if (!(receipt.confirmations == null)) return [3 /*break*/, 4];
-                                            return [4 /*yield*/, this._getInternalBlockNumber(100 + 2 * this.pollingInterval)];
-                                        case 3:
-                                            blockNumber = _a.sent();
-                                            confirmations = (blockNumber - receipt.blockNumber) + 1;
-                                            if (confirmations <= 0) {
-                                                confirmations = 1;
-                                            }
-                                            receipt.confirmations = confirmations;
-                                            _a.label = 4;
-                                        case 4: return [2 /*return*/, receipt];
-                                    }
-                                });
-                            }); }, { oncePoll: this })];
+        }
+        return address;
+    }
+    async _getBlock(blockHashOrBlockTag, includeTransactions) {
+        await this.getNetwork();
+        blockHashOrBlockTag = await blockHashOrBlockTag;
+        // If blockTag is a number (not "latest", etc), this is the block number
+        let blockNumber = -128;
+        const params = {
+            includeTransactions: !!includeTransactions,
+        };
+        if ((0, bytes_1.isHexString)(blockHashOrBlockTag, 32)) {
+            params.blockHash = blockHashOrBlockTag;
+        }
+        else {
+            try {
+                params.blockTag = await this._getBlockTag(blockHashOrBlockTag);
+                if ((0, bytes_1.isHexString)(params.blockTag)) {
+                    blockNumber = parseInt(params.blockTag.substring(2), 16);
                 }
-            });
-        });
-    };
-    BaseProvider.prototype.getLogs = function (filter) {
-        return __awaiter(this, void 0, void 0, function () {
-            var params, logs;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, (0, properties_1.resolveProperties)({ filter: this._getFilter(filter) })];
-                    case 2:
-                        params = _a.sent();
-                        return [4 /*yield*/, this.perform("getLogs", params)];
-                    case 3:
-                        logs = _a.sent();
-                        logs.forEach(function (log) {
-                            if (log.removed == null) {
-                                log.removed = false;
-                            }
-                        });
-                        return [2 /*return*/, formatter_1.Formatter.arrayOf(this.formatter.filterLog.bind(this.formatter))(logs)];
+            }
+            catch (error) {
+                logger.throwArgumentError("invalid block hash or block tag", "blockHashOrBlockTag", blockHashOrBlockTag);
+            }
+        }
+        return (0, web_1.poll)(async () => {
+            const block = await this.perform("getBlock", params);
+            // Block was not found
+            if (block == null) {
+                // For blockhashes, if we didn't say it existed, that blockhash may
+                // not exist. If we did see it though, perhaps from a log, we know
+                // it exists, and this node is just not caught up yet.
+                if (params.blockHash != null) {
+                    if (this._emitted["b:" + params.blockHash] == null) {
+                        return null;
+                    }
                 }
-            });
-        });
-    };
-    BaseProvider.prototype.getEtherPrice = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this.perform("getEtherPrice", {})];
+                // For block tags, if we are asking for a future block, we return null
+                if (params.blockTag != null) {
+                    if (blockNumber > this._emitted.block) {
+                        return null;
+                    }
                 }
-            });
-        });
-    };
-    BaseProvider.prototype._getBlockTag = function (blockTag) {
-        return __awaiter(this, void 0, void 0, function () {
-            var blockNumber;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, blockTag];
-                    case 1:
-                        blockTag = _a.sent();
-                        if (!(typeof (blockTag) === "number" && blockTag < 0)) return [3 /*break*/, 3];
-                        if (blockTag % 1) {
-                            logger.throwArgumentError("invalid BlockTag", "blockTag", blockTag);
+                // Retry on the next block
+                return undefined;
+            }
+            // Add transactions
+            if (includeTransactions) {
+                let blockNumber = null;
+                for (let i = 0; i < block.transactions.length; i++) {
+                    const tx = block.transactions[i];
+                    if (tx.blockNumber == null) {
+                        tx.confirmations = 0;
+                    }
+                    else if (tx.confirmations == null) {
+                        if (blockNumber == null) {
+                            blockNumber =
+                                await this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
                         }
-                        return [4 /*yield*/, this._getInternalBlockNumber(100 + 2 * this.pollingInterval)];
-                    case 2:
-                        blockNumber = _a.sent();
-                        blockNumber += blockTag;
-                        if (blockNumber < 0) {
-                            blockNumber = 0;
+                        // Add the confirmations using the fast block number (pessimistic)
+                        let confirmations = blockNumber - tx.blockNumber + 1;
+                        if (confirmations <= 0) {
+                            confirmations = 1;
                         }
-                        return [2 /*return*/, this.formatter.blockTag(blockNumber)];
-                    case 3: return [2 /*return*/, this.formatter.blockTag(blockTag)];
+                        tx.confirmations = confirmations;
+                    }
                 }
-            });
-        });
-    };
-    BaseProvider.prototype.getResolver = function (name) {
-        return __awaiter(this, void 0, void 0, function () {
-            var currentName, addr, resolver, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        currentName = name;
-                        _b.label = 1;
-                    case 1:
-                        if (!true) return [3 /*break*/, 6];
-                        if (currentName === "" || currentName === ".") {
-                            return [2 /*return*/, null];
-                        }
-                        // Optimization since the eth node cannot change and does
-                        // not have a wildcard resolver
-                        if (name !== "eth" && currentName === "eth") {
-                            return [2 /*return*/, null];
-                        }
-                        return [4 /*yield*/, this._getResolver(currentName, "getResolver")];
-                    case 2:
-                        addr = _b.sent();
-                        if (!(addr != null)) return [3 /*break*/, 5];
-                        resolver = new Resolver(this, addr, name);
-                        _a = currentName !== name;
-                        if (!_a) return [3 /*break*/, 4];
-                        return [4 /*yield*/, resolver.supportsWildcard()];
-                    case 3:
-                        _a = !(_b.sent());
-                        _b.label = 4;
-                    case 4:
-                        // Legacy resolver found, using EIP-2544 so it isn't safe to use
-                        if (_a) {
-                            return [2 /*return*/, null];
-                        }
-                        return [2 /*return*/, resolver];
-                    case 5:
-                        // Get the parent node
-                        currentName = currentName.split(".").slice(1).join(".");
-                        return [3 /*break*/, 1];
-                    case 6: return [2 /*return*/];
+                const blockWithTxs = this.formatter.blockWithTransactions(block);
+                blockWithTxs.transactions = blockWithTxs.transactions.map((tx) => this._wrapTransaction(tx));
+                return blockWithTxs;
+            }
+            return this.formatter.block(block);
+        }, { oncePoll: this });
+    }
+    getBlock(blockHashOrBlockTag) {
+        return this._getBlock(blockHashOrBlockTag, false);
+    }
+    getBlockWithTransactions(blockHashOrBlockTag) {
+        return (this._getBlock(blockHashOrBlockTag, true));
+    }
+    async getTransaction(transactionHash) {
+        await this.getNetwork();
+        transactionHash = await transactionHash;
+        const params = {
+            transactionHash: this.formatter.hash(transactionHash, true),
+        };
+        return (0, web_1.poll)(async () => {
+            const result = await this.perform("getTransaction", params);
+            if (result == null) {
+                if (this._emitted["t:" + transactionHash] == null) {
+                    return null;
                 }
-            });
-        });
-    };
-    BaseProvider.prototype._getResolver = function (name, operation) {
-        return __awaiter(this, void 0, void 0, function () {
-            var network, addrData, error_10;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (operation == null) {
-                            operation = "ENS";
-                        }
-                        return [4 /*yield*/, this.getNetwork()];
-                    case 1:
-                        network = _a.sent();
-                        // No ENS...
-                        if (!network.ensAddress) {
-                            logger.throwError("network does not support ENS", logger_1.Logger.errors.UNSUPPORTED_OPERATION, { operation: operation, network: network.name });
-                        }
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, this.call({
-                                to: network.ensAddress,
-                                data: ("0x0178b8bf" + (0, hash_1.namehash)(name).substring(2))
-                            })];
-                    case 3:
-                        addrData = _a.sent();
-                        return [2 /*return*/, this.formatter.callAddress(addrData)];
-                    case 4:
-                        error_10 = _a.sent();
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/, null];
+                return undefined;
+            }
+            const tx = this.formatter.transactionResponse(result);
+            if (tx.blockNumber == null) {
+                tx.confirmations = 0;
+            }
+            else if (tx.confirmations == null) {
+                const blockNumber = await this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
+                // Add the confirmations using the fast block number (pessimistic)
+                let confirmations = blockNumber - tx.blockNumber + 1;
+                if (confirmations <= 0) {
+                    confirmations = 1;
                 }
-            });
-        });
-    };
-    BaseProvider.prototype.resolveName = function (name) {
-        return __awaiter(this, void 0, void 0, function () {
-            var resolver;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, name];
-                    case 1:
-                        name = _a.sent();
-                        // If it is already an address, nothing to resolve
-                        try {
-                            return [2 /*return*/, Promise.resolve(this.formatter.address(name))];
-                        }
-                        catch (error) {
-                            // If is is a hexstring, the address is bad (See #694)
-                            if ((0, bytes_1.isHexString)(name)) {
-                                throw error;
-                            }
-                        }
-                        if (typeof (name) !== "string") {
-                            logger.throwArgumentError("invalid ENS name", "name", name);
-                        }
-                        return [4 /*yield*/, this.getResolver(name)];
-                    case 2:
-                        resolver = _a.sent();
-                        if (!resolver) {
-                            return [2 /*return*/, null];
-                        }
-                        return [4 /*yield*/, resolver.getAddress()];
-                    case 3: return [2 /*return*/, _a.sent()];
+                tx.confirmations = confirmations;
+            }
+            return this._wrapTransaction(tx);
+        }, { oncePoll: this });
+    }
+    async getTransactionReceipt(transactionHash) {
+        await this.getNetwork();
+        transactionHash = await transactionHash;
+        const params = {
+            transactionHash: this.formatter.hash(transactionHash, true),
+        };
+        return (0, web_1.poll)(async () => {
+            const result = await this.perform("getTransactionReceipt", params);
+            if (result == null) {
+                if (this._emitted["t:" + transactionHash] == null) {
+                    return null;
                 }
-            });
-        });
-    };
-    BaseProvider.prototype.lookupAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var node, resolverAddr, name, _a, addr;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, address];
-                    case 1:
-                        address = _b.sent();
-                        address = this.formatter.address(address);
-                        node = address.substring(2).toLowerCase() + ".addr.reverse";
-                        return [4 /*yield*/, this._getResolver(node, "lookupAddress")];
-                    case 2:
-                        resolverAddr = _b.sent();
-                        if (resolverAddr == null) {
-                            return [2 /*return*/, null];
-                        }
-                        _a = _parseString;
-                        return [4 /*yield*/, this.call({
-                                to: resolverAddr,
-                                data: ("0x691f3431" + (0, hash_1.namehash)(node).substring(2))
-                            })];
-                    case 3:
-                        name = _a.apply(void 0, [_b.sent(), 0]);
-                        return [4 /*yield*/, this.resolveName(name)];
-                    case 4:
-                        addr = _b.sent();
-                        if (addr != address) {
-                            return [2 /*return*/, null];
-                        }
-                        return [2 /*return*/, name];
+                return undefined;
+            }
+            // "geth-etc" returns receipts before they are ready
+            if (result.blockHash == null) {
+                return undefined;
+            }
+            const receipt = this.formatter.receipt(result);
+            if (receipt.blockNumber == null) {
+                receipt.confirmations = 0;
+            }
+            else if (receipt.confirmations == null) {
+                const blockNumber = await this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
+                // Add the confirmations using the fast block number (pessimistic)
+                let confirmations = blockNumber - receipt.blockNumber + 1;
+                if (confirmations <= 0) {
+                    confirmations = 1;
                 }
-            });
+                receipt.confirmations = confirmations;
+            }
+            return receipt;
+        }, { oncePoll: this });
+    }
+    async getLogs(filter) {
+        await this.getNetwork();
+        const params = await (0, properties_1.resolveProperties)({
+            filter: this._getFilter(filter),
         });
-    };
-    BaseProvider.prototype.getAvatar = function (nameOrAddress) {
-        return __awaiter(this, void 0, void 0, function () {
-            var resolver, address, node, resolverAddress, avatar_1, error_11, name_1, _a, error_12, avatar;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        resolver = null;
-                        if (!(0, bytes_1.isHexString)(nameOrAddress)) return [3 /*break*/, 10];
-                        address = this.formatter.address(nameOrAddress);
-                        node = address.substring(2).toLowerCase() + ".addr.reverse";
-                        return [4 /*yield*/, this._getResolver(node, "getAvatar")];
-                    case 1:
-                        resolverAddress = _b.sent();
-                        if (!resolverAddress) {
-                            return [2 /*return*/, null];
-                        }
-                        // Try resolving the avatar against the addr.reverse resolver
-                        resolver = new Resolver(this, resolverAddress, node);
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, resolver.getAvatar()];
-                    case 3:
-                        avatar_1 = _b.sent();
-                        if (avatar_1) {
-                            return [2 /*return*/, avatar_1.url];
-                        }
-                        return [3 /*break*/, 5];
-                    case 4:
-                        error_11 = _b.sent();
-                        if (error_11.code !== logger_1.Logger.errors.CALL_EXCEPTION) {
-                            throw error_11;
-                        }
-                        return [3 /*break*/, 5];
-                    case 5:
-                        _b.trys.push([5, 8, , 9]);
-                        _a = _parseString;
-                        return [4 /*yield*/, this.call({
-                                to: resolverAddress,
-                                data: ("0x691f3431" + (0, hash_1.namehash)(node).substring(2))
-                            })];
-                    case 6:
-                        name_1 = _a.apply(void 0, [_b.sent(), 0]);
-                        return [4 /*yield*/, this.getResolver(name_1)];
-                    case 7:
-                        resolver = _b.sent();
-                        return [3 /*break*/, 9];
-                    case 8:
-                        error_12 = _b.sent();
-                        if (error_12.code !== logger_1.Logger.errors.CALL_EXCEPTION) {
-                            throw error_12;
-                        }
-                        return [2 /*return*/, null];
-                    case 9: return [3 /*break*/, 12];
-                    case 10: return [4 /*yield*/, this.getResolver(nameOrAddress)];
-                    case 11:
-                        // ENS name; forward lookup with wildcard
-                        resolver = _b.sent();
-                        if (!resolver) {
-                            return [2 /*return*/, null];
-                        }
-                        _b.label = 12;
-                    case 12: return [4 /*yield*/, resolver.getAvatar()];
-                    case 13:
-                        avatar = _b.sent();
-                        if (avatar == null) {
-                            return [2 /*return*/, null];
-                        }
-                        return [2 /*return*/, avatar.url];
+        const logs = await this.perform("getLogs", params);
+        logs.forEach((log) => {
+            if (log.removed == null) {
+                log.removed = false;
+            }
+        });
+        return formatter_1.Formatter.arrayOf(this.formatter.filterLog.bind(this.formatter))(logs);
+    }
+    async getEtherPrice() {
+        await this.getNetwork();
+        return this.perform("getEtherPrice", {});
+    }
+    async _getBlockTag(blockTag) {
+        blockTag = await blockTag;
+        if (typeof blockTag === "number" && blockTag < 0) {
+            if (blockTag % 1) {
+                logger.throwArgumentError("invalid BlockTag", "blockTag", blockTag);
+            }
+            let blockNumber = await this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
+            blockNumber += blockTag;
+            if (blockNumber < 0) {
+                blockNumber = 0;
+            }
+            return this.formatter.blockTag(blockNumber);
+        }
+        return this.formatter.blockTag(blockTag);
+    }
+    async getResolver(name) {
+        let currentName = name;
+        while (true) {
+            if (currentName === "" || currentName === ".") {
+                return null;
+            }
+            // Optimization since the eth node cannot change and does
+            // not have a wildcard resolver
+            if (name !== "eth" && currentName === "eth") {
+                return null;
+            }
+            // Check the current node for a resolver
+            const addr = await this._getResolver(currentName, "getResolver");
+            // Found a resolver!
+            if (addr != null) {
+                const resolver = new Resolver(this, addr, name);
+                // Legacy resolver found, using EIP-2544 so it isn't safe to use
+                if (currentName !== name &&
+                    !(await resolver.supportsWildcard())) {
+                    return null;
                 }
+                return resolver;
+            }
+            // Get the parent node
+            currentName = currentName.split(".").slice(1).join(".");
+        }
+    }
+    async _getResolver(name, operation) {
+        if (operation == null) {
+            operation = "ENS";
+        }
+        const network = await this.getNetwork();
+        // No ENS...
+        if (!network.ensAddress) {
+            logger.throwError("network does not support ENS", logger_1.Logger.errors.UNSUPPORTED_OPERATION, { operation, network: network.name });
+        }
+        try {
+            // keccak256("resolver(bytes32)")
+            const addrData = await this.call({
+                to: network.ensAddress,
+                data: "0x0178b8bf" + (0, hash_1.namehash)(name).substring(2),
             });
-        });
-    };
-    BaseProvider.prototype.perform = function (method, params) {
+            return this.formatter.callAddress(addrData);
+        }
+        catch (error) {
+            // ENS registry cannot throw errors on resolver(bytes32)
+        }
+        return null;
+    }
+    async resolveName(name) {
+        name = await name;
+        // If it is already an address, nothing to resolve
+        try {
+            return Promise.resolve(this.formatter.address(name));
+        }
+        catch (error) {
+            // If is is a hexstring, the address is bad (See #694)
+            if ((0, bytes_1.isHexString)(name)) {
+                throw error;
+            }
+        }
+        if (typeof name !== "string") {
+            logger.throwArgumentError("invalid ENS name", "name", name);
+        }
+        // Get the addr from the resolver
+        const resolver = await this.getResolver(name);
+        if (!resolver) {
+            return null;
+        }
+        return await resolver.getAddress();
+    }
+    async lookupAddress(address) {
+        address = await address;
+        address = this.formatter.address(address);
+        const node = address.substring(2).toLowerCase() + ".addr.reverse";
+        const resolverAddr = await this._getResolver(node, "lookupAddress");
+        if (resolverAddr == null) {
+            return null;
+        }
+        // keccak("name(bytes32)")
+        const name = _parseString(await this.call({
+            to: resolverAddr,
+            data: "0x691f3431" + (0, hash_1.namehash)(node).substring(2),
+        }), 0);
+        const addr = await this.resolveName(name);
+        if (addr != address) {
+            return null;
+        }
+        return name;
+    }
+    async getAvatar(nameOrAddress) {
+        let resolver = null;
+        if ((0, bytes_1.isHexString)(nameOrAddress)) {
+            // Address; reverse lookup
+            const address = this.formatter.address(nameOrAddress);
+            const node = address.substring(2).toLowerCase() + ".addr.reverse";
+            const resolverAddress = await this._getResolver(node, "getAvatar");
+            if (!resolverAddress) {
+                return null;
+            }
+            // Try resolving the avatar against the addr.reverse resolver
+            resolver = new Resolver(this, resolverAddress, node);
+            try {
+                const avatar = await resolver.getAvatar();
+                if (avatar) {
+                    return avatar.url;
+                }
+            }
+            catch (error) {
+                if (error.code !== logger_1.Logger.errors.CALL_EXCEPTION) {
+                    throw error;
+                }
+            }
+            // Try getting the name and performing forward lookup; allowing wildcards
+            try {
+                // keccak("name(bytes32)")
+                const name = _parseString(await this.call({
+                    to: resolverAddress,
+                    data: "0x691f3431" + (0, hash_1.namehash)(node).substring(2),
+                }), 0);
+                resolver = await this.getResolver(name);
+            }
+            catch (error) {
+                if (error.code !== logger_1.Logger.errors.CALL_EXCEPTION) {
+                    throw error;
+                }
+                return null;
+            }
+        }
+        else {
+            // ENS name; forward lookup with wildcard
+            resolver = await this.getResolver(nameOrAddress);
+            if (!resolver) {
+                return null;
+            }
+        }
+        const avatar = await resolver.getAvatar();
+        if (avatar == null) {
+            return null;
+        }
+        return avatar.url;
+    }
+    perform(method, params) {
         return logger.throwError(method + " not implemented", logger_1.Logger.errors.NOT_IMPLEMENTED, { operation: method });
-    };
-    BaseProvider.prototype._startEvent = function (event) {
-        this.polling = (this._events.filter(function (e) { return e.pollable(); }).length > 0);
-    };
-    BaseProvider.prototype._stopEvent = function (event) {
-        this.polling = (this._events.filter(function (e) { return e.pollable(); }).length > 0);
-    };
-    BaseProvider.prototype._addEventListener = function (eventName, listener, once) {
-        var event = new Event(getEventTag(eventName), listener, once);
+    }
+    _startEvent(event) {
+        this.polling = this._events.filter((e) => e.pollable()).length > 0;
+    }
+    _stopEvent(event) {
+        this.polling = this._events.filter((e) => e.pollable()).length > 0;
+    }
+    _addEventListener(eventName, listener, once) {
+        const event = new Event(getEventTag(eventName), listener, once);
         this._events.push(event);
         this._startEvent(event);
         return this;
-    };
-    BaseProvider.prototype.on = function (eventName, listener) {
+    }
+    on(eventName, listener) {
         return this._addEventListener(eventName, listener, false);
-    };
-    BaseProvider.prototype.once = function (eventName, listener) {
+    }
+    once(eventName, listener) {
         return this._addEventListener(eventName, listener, true);
-    };
-    BaseProvider.prototype.emit = function (eventName) {
-        var _this = this;
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        var result = false;
-        var stopped = [];
-        var eventTag = getEventTag(eventName);
-        this._events = this._events.filter(function (event) {
+    }
+    emit(eventName, ...args) {
+        let result = false;
+        let stopped = [];
+        let eventTag = getEventTag(eventName);
+        this._events = this._events.filter((event) => {
             if (event.tag !== eventTag) {
                 return true;
             }
-            setTimeout(function () {
-                event.listener.apply(_this, args);
+            setTimeout(() => {
+                event.listener.apply(this, args);
             }, 0);
             result = true;
             if (event.once) {
@@ -2516,36 +2013,37 @@ var BaseProvider = /** @class */ (function (_super) {
             }
             return true;
         });
-        stopped.forEach(function (event) { _this._stopEvent(event); });
+        stopped.forEach((event) => {
+            this._stopEvent(event);
+        });
         return result;
-    };
-    BaseProvider.prototype.listenerCount = function (eventName) {
+    }
+    listenerCount(eventName) {
         if (!eventName) {
             return this._events.length;
         }
-        var eventTag = getEventTag(eventName);
-        return this._events.filter(function (event) {
-            return (event.tag === eventTag);
+        let eventTag = getEventTag(eventName);
+        return this._events.filter((event) => {
+            return event.tag === eventTag;
         }).length;
-    };
-    BaseProvider.prototype.listeners = function (eventName) {
+    }
+    listeners(eventName) {
         if (eventName == null) {
-            return this._events.map(function (event) { return event.listener; });
+            return this._events.map((event) => event.listener);
         }
-        var eventTag = getEventTag(eventName);
+        let eventTag = getEventTag(eventName);
         return this._events
-            .filter(function (event) { return (event.tag === eventTag); })
-            .map(function (event) { return event.listener; });
-    };
-    BaseProvider.prototype.off = function (eventName, listener) {
-        var _this = this;
+            .filter((event) => event.tag === eventTag)
+            .map((event) => event.listener);
+    }
+    off(eventName, listener) {
         if (listener == null) {
             return this.removeAllListeners(eventName);
         }
-        var stopped = [];
-        var found = false;
-        var eventTag = getEventTag(eventName);
-        this._events = this._events.filter(function (event) {
+        const stopped = [];
+        let found = false;
+        let eventTag = getEventTag(eventName);
+        this._events = this._events.filter((event) => {
             if (event.tag !== eventTag || event.listener != listener) {
                 return true;
             }
@@ -2556,30 +2054,32 @@ var BaseProvider = /** @class */ (function (_super) {
             stopped.push(event);
             return false;
         });
-        stopped.forEach(function (event) { _this._stopEvent(event); });
+        stopped.forEach((event) => {
+            this._stopEvent(event);
+        });
         return this;
-    };
-    BaseProvider.prototype.removeAllListeners = function (eventName) {
-        var _this = this;
-        var stopped = [];
+    }
+    removeAllListeners(eventName) {
+        let stopped = [];
         if (eventName == null) {
             stopped = this._events;
             this._events = [];
         }
         else {
-            var eventTag_1 = getEventTag(eventName);
-            this._events = this._events.filter(function (event) {
-                if (event.tag !== eventTag_1) {
+            const eventTag = getEventTag(eventName);
+            this._events = this._events.filter((event) => {
+                if (event.tag !== eventTag) {
                     return true;
                 }
                 stopped.push(event);
                 return false;
             });
         }
-        stopped.forEach(function (event) { _this._stopEvent(event); });
+        stopped.forEach((event) => {
+            this._stopEvent(event);
+        });
         return this;
-    };
-    return BaseProvider;
-}(abstract_provider_1.Provider));
+    }
+}
 exports.BaseProvider = BaseProvider;
 //# sourceMappingURL=base-provider.js.map