@solana/web3.js 1.30.0 → 1.32.0

package/lib/index.esm.js

@@ -1,6 +1,4 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import * as nacl from 'tweetnacl';
-import nacl__default from 'tweetnacl';
+import nacl from 'tweetnacl';
 import { Buffer } from 'buffer';
 import BN from 'bn.js';
 import bs58 from 'bs58';
@@ -13,7 +11,7 @@ import RpcClient from 'jayson/lib/client/browser';
 import http from 'http';
 import https from 'https';
 import secp256k1 from 'secp256k1';
-import { keccak_256 } from 'js-sha3';
+import sha3 from 'js-sha3';
 
 const toBuffer = arr => {
   if (Buffer.isBuffer(arr)) {
@@ -25,743 +23,334 @@ const toBuffer = arr => {
   }
 };
 
-const version$2 = "logger/5.5.0";
+var hash$1 = {};
 
-let _permanentCensorErrors = false;
-let _censorErrors = false;
-const LogLevels = { debug: 1, "default": 2, info: 2, warning: 3, error: 4, off: 5 };
-let _logLevel = LogLevels["default"];
-let _globalLogger = null;
-function _checkNormalize() {
-    try {
-        const missing = [];
-        // Make sure all forms of normalization are supported
-        ["NFD", "NFC", "NFKD", "NFKC"].forEach((form) => {
-            try {
-                if ("test".normalize(form) !== "test") {
-                    throw new Error("bad normalize");
-                }
-                ;
-            }
-            catch (error) {
-                missing.push(form);
-            }
-        });
-        if (missing.length) {
-            throw new Error("missing " + missing.join(", "));
-        }
-        if (String.fromCharCode(0xe9).normalize("NFD") !== String.fromCharCode(0x65, 0x0301)) {
-            throw new Error("broken implementation");
+var utils$9 = {};
+
+var minimalisticAssert = assert$6;
+
+function assert$6(val, msg) {
+  if (!val)
+    throw new Error(msg || 'Assertion failed');
+}
+
+assert$6.equal = function assertEqual(l, r, msg) {
+  if (l != r)
+    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
+};
+
+var inherits$1 = {exports: {}};
+
+var inherits_browser = {exports: {}};
+
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  inherits_browser.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor;
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  inherits_browser.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor;
+    var TempCtor = function () {};
+    TempCtor.prototype = superCtor.prototype;
+    ctor.prototype = new TempCtor();
+    ctor.prototype.constructor = ctor;
+  };
+}
+
+try {
+  var util = require('util');
+  if (typeof util.inherits !== 'function') throw '';
+  inherits$1.exports = util.inherits;
+} catch (e) {
+  inherits$1.exports = inherits_browser.exports;
+}
+
+var assert$5 = minimalisticAssert;
+var inherits = inherits$1.exports;
+
+utils$9.inherits = inherits;
+
+function isSurrogatePair(msg, i) {
+  if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) {
+    return false;
+  }
+  if (i < 0 || i + 1 >= msg.length) {
+    return false;
+  }
+  return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00;
+}
+
+function toArray(msg, enc) {
+  if (Array.isArray(msg))
+    return msg.slice();
+  if (!msg)
+    return [];
+  var res = [];
+  if (typeof msg === 'string') {
+    if (!enc) {
+      // Inspired by stringToUtf8ByteArray() in closure-library by Google
+      // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143
+      // Apache License 2.0
+      // https://github.com/google/closure-library/blob/master/LICENSE
+      var p = 0;
+      for (var i = 0; i < msg.length; i++) {
+        var c = msg.charCodeAt(i);
+        if (c < 128) {
+          res[p++] = c;
+        } else if (c < 2048) {
+          res[p++] = (c >> 6) | 192;
+          res[p++] = (c & 63) | 128;
+        } else if (isSurrogatePair(msg, i)) {
+          c = 0x10000 + ((c & 0x03FF) << 10) + (msg.charCodeAt(++i) & 0x03FF);
+          res[p++] = (c >> 18) | 240;
+          res[p++] = ((c >> 12) & 63) | 128;
+          res[p++] = ((c >> 6) & 63) | 128;
+          res[p++] = (c & 63) | 128;
+        } else {
+          res[p++] = (c >> 12) | 224;
+          res[p++] = ((c >> 6) & 63) | 128;
+          res[p++] = (c & 63) | 128;
         }
+      }
+    } else if (enc === 'hex') {
+      msg = msg.replace(/[^a-z0-9]+/ig, '');
+      if (msg.length % 2 !== 0)
+        msg = '0' + msg;
+      for (i = 0; i < msg.length; i += 2)
+        res.push(parseInt(msg[i] + msg[i + 1], 16));
     }
-    catch (error) {
-        return error.message;
+  } else {
+    for (i = 0; i < msg.length; i++)
+      res[i] = msg[i] | 0;
+  }
+  return res;
+}
+utils$9.toArray = toArray;
+
+function toHex(msg) {
+  var res = '';
+  for (var i = 0; i < msg.length; i++)
+    res += zero2(msg[i].toString(16));
+  return res;
+}
+utils$9.toHex = toHex;
+
+function htonl(w) {
+  var res = (w >>> 24) |
+            ((w >>> 8) & 0xff00) |
+            ((w << 8) & 0xff0000) |
+            ((w & 0xff) << 24);
+  return res >>> 0;
+}
+utils$9.htonl = htonl;
+
+function toHex32(msg, endian) {
+  var res = '';
+  for (var i = 0; i < msg.length; i++) {
+    var w = msg[i];
+    if (endian === 'little')
+      w = htonl(w);
+    res += zero8(w.toString(16));
+  }
+  return res;
+}
+utils$9.toHex32 = toHex32;
+
+function zero2(word) {
+  if (word.length === 1)
+    return '0' + word;
+  else
+    return word;
+}
+utils$9.zero2 = zero2;
+
+function zero8(word) {
+  if (word.length === 7)
+    return '0' + word;
+  else if (word.length === 6)
+    return '00' + word;
+  else if (word.length === 5)
+    return '000' + word;
+  else if (word.length === 4)
+    return '0000' + word;
+  else if (word.length === 3)
+    return '00000' + word;
+  else if (word.length === 2)
+    return '000000' + word;
+  else if (word.length === 1)
+    return '0000000' + word;
+  else
+    return word;
+}
+utils$9.zero8 = zero8;
+
+function join32(msg, start, end, endian) {
+  var len = end - start;
+  assert$5(len % 4 === 0);
+  var res = new Array(len / 4);
+  for (var i = 0, k = start; i < res.length; i++, k += 4) {
+    var w;
+    if (endian === 'big')
+      w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];
+    else
+      w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];
+    res[i] = w >>> 0;
+  }
+  return res;
+}
+utils$9.join32 = join32;
+
+function split32(msg, endian) {
+  var res = new Array(msg.length * 4);
+  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
+    var m = msg[i];
+    if (endian === 'big') {
+      res[k] = m >>> 24;
+      res[k + 1] = (m >>> 16) & 0xff;
+      res[k + 2] = (m >>> 8) & 0xff;
+      res[k + 3] = m & 0xff;
+    } else {
+      res[k + 3] = m >>> 24;
+      res[k + 2] = (m >>> 16) & 0xff;
+      res[k + 1] = (m >>> 8) & 0xff;
+      res[k] = m & 0xff;
     }
-    return null;
+  }
+  return res;
 }
-const _normalizeError = _checkNormalize();
-var LogLevel;
-(function (LogLevel) {
-    LogLevel["DEBUG"] = "DEBUG";
-    LogLevel["INFO"] = "INFO";
-    LogLevel["WARNING"] = "WARNING";
-    LogLevel["ERROR"] = "ERROR";
-    LogLevel["OFF"] = "OFF";
-})(LogLevel || (LogLevel = {}));
-var ErrorCode;
-(function (ErrorCode) {
-    ///////////////////
-    // Generic Errors
-    // Unknown Error
-    ErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-    // Not Implemented
-    ErrorCode["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
-    // Unsupported Operation
-    //   - operation
-    ErrorCode["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
-    // Network Error (i.e. Ethereum Network, such as an invalid chain ID)
-    //   - event ("noNetwork" is not re-thrown in provider.ready; otherwise thrown)
-    ErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
-    // Some sort of bad response from the server
-    ErrorCode["SERVER_ERROR"] = "SERVER_ERROR";
-    // Timeout
-    ErrorCode["TIMEOUT"] = "TIMEOUT";
-    ///////////////////
-    // Operational  Errors
-    // Buffer Overrun
-    ErrorCode["BUFFER_OVERRUN"] = "BUFFER_OVERRUN";
-    // Numeric Fault
-    //   - operation: the operation being executed
-    //   - fault: the reason this faulted
-    ErrorCode["NUMERIC_FAULT"] = "NUMERIC_FAULT";
-    ///////////////////
-    // Argument Errors
-    // Missing new operator to an object
-    //  - name: The name of the class
-    ErrorCode["MISSING_NEW"] = "MISSING_NEW";
-    // Invalid argument (e.g. value is incompatible with type) to a function:
-    //   - argument: The argument name that was invalid
-    //   - value: The value of the argument
-    ErrorCode["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
-    // Missing argument to a function:
-    //   - count: The number of arguments received
-    //   - expectedCount: The number of arguments expected
-    ErrorCode["MISSING_ARGUMENT"] = "MISSING_ARGUMENT";
-    // Too many arguments
-    //   - count: The number of arguments received
-    //   - expectedCount: The number of arguments expected
-    ErrorCode["UNEXPECTED_ARGUMENT"] = "UNEXPECTED_ARGUMENT";
-    ///////////////////
-    // Blockchain Errors
-    // Call exception
-    //  - transaction: the transaction
-    //  - address?: the contract address
-    //  - args?: The arguments passed into the function
-    //  - method?: The Solidity method signature
-    //  - errorSignature?: The EIP848 error signature
-    //  - errorArgs?: The EIP848 error parameters
-    //  - reason: The reason (only for EIP848 "Error(string)")
-    ErrorCode["CALL_EXCEPTION"] = "CALL_EXCEPTION";
-    // Insufficient funds (< value + gasLimit * gasPrice)
-    //   - transaction: the transaction attempted
-    ErrorCode["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
-    // Nonce has already been used
-    //   - transaction: the transaction attempted
-    ErrorCode["NONCE_EXPIRED"] = "NONCE_EXPIRED";
-    // The replacement fee for the transaction is too low
-    //   - transaction: the transaction attempted
-    ErrorCode["REPLACEMENT_UNDERPRICED"] = "REPLACEMENT_UNDERPRICED";
-    // The gas limit could not be estimated
-    //   - transaction: the transaction passed to estimateGas
-    ErrorCode["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
-    // The transaction was replaced by one with a higher gas price
-    //   - reason: "cancelled", "replaced" or "repriced"
-    //   - cancelled: true if reason == "cancelled" or reason == "replaced")
-    //   - hash: original transaction hash
-    //   - replacement: the full TransactionsResponse for the replacement
-    //   - receipt: the receipt of the replacement
-    ErrorCode["TRANSACTION_REPLACED"] = "TRANSACTION_REPLACED";
-})(ErrorCode || (ErrorCode = {}));
-const HEX = "0123456789abcdef";
-class Logger {
-    constructor(version) {
-        Object.defineProperty(this, "version", {
-            enumerable: true,
-            value: version,
-            writable: false
-        });
-    }
-    _log(logLevel, args) {
-        const level = logLevel.toLowerCase();
-        if (LogLevels[level] == null) {
-            this.throwArgumentError("invalid log level name", "logLevel", logLevel);
-        }
-        if (_logLevel > LogLevels[level]) {
-            return;
-        }
-        console.log.apply(console, args);
-    }
-    debug(...args) {
-        this._log(Logger.levels.DEBUG, args);
-    }
-    info(...args) {
-        this._log(Logger.levels.INFO, args);
-    }
-    warn(...args) {
-        this._log(Logger.levels.WARNING, args);
-    }
-    makeError(message, code, params) {
-        // Errors are being censored
-        if (_censorErrors) {
-            return this.makeError("censored error", code, {});
-        }
-        if (!code) {
-            code = Logger.errors.UNKNOWN_ERROR;
-        }
-        if (!params) {
-            params = {};
-        }
-        const messageDetails = [];
-        Object.keys(params).forEach((key) => {
-            const value = params[key];
-            try {
-                if (value instanceof Uint8Array) {
-                    let hex = "";
-                    for (let i = 0; i < value.length; i++) {
-                        hex += HEX[value[i] >> 4];
-                        hex += HEX[value[i] & 0x0f];
-                    }
-                    messageDetails.push(key + "=Uint8Array(0x" + hex + ")");
-                }
-                else {
-                    messageDetails.push(key + "=" + JSON.stringify(value));
-                }
-            }
-            catch (error) {
-                messageDetails.push(key + "=" + JSON.stringify(params[key].toString()));
-            }
-        });
-        messageDetails.push(`code=${code}`);
-        messageDetails.push(`version=${this.version}`);
-        const reason = message;
-        if (messageDetails.length) {
-            message += " (" + messageDetails.join(", ") + ")";
-        }
-        // @TODO: Any??
-        const error = new Error(message);
-        error.reason = reason;
-        error.code = code;
-        Object.keys(params).forEach(function (key) {
-            error[key] = params[key];
-        });
-        return error;
-    }
-    throwError(message, code, params) {
-        throw this.makeError(message, code, params);
-    }
-    throwArgumentError(message, name, value) {
-        return this.throwError(message, Logger.errors.INVALID_ARGUMENT, {
-            argument: name,
-            value: value
-        });
-    }
-    assert(condition, message, code, params) {
-        if (!!condition) {
-            return;
-        }
-        this.throwError(message, code, params);
-    }
-    assertArgument(condition, message, name, value) {
-        if (!!condition) {
-            return;
-        }
-        this.throwArgumentError(message, name, value);
-    }
-    checkNormalize(message) {
-        if (_normalizeError) {
-            this.throwError("platform missing String.prototype.normalize", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "String.prototype.normalize", form: _normalizeError
-            });
-        }
-    }
-    checkSafeUint53(value, message) {
-        if (typeof (value) !== "number") {
-            return;
-        }
-        if (message == null) {
-            message = "value not safe";
-        }
-        if (value < 0 || value >= 0x1fffffffffffff) {
-            this.throwError(message, Logger.errors.NUMERIC_FAULT, {
-                operation: "checkSafeInteger",
-                fault: "out-of-safe-range",
-                value: value
-            });
-        }
-        if (value % 1) {
-            this.throwError(message, Logger.errors.NUMERIC_FAULT, {
-                operation: "checkSafeInteger",
-                fault: "non-integer",
-                value: value
-            });
-        }
-    }
-    checkArgumentCount(count, expectedCount, message) {
-        if (message) {
-            message = ": " + message;
-        }
-        else {
-            message = "";
-        }
-        if (count < expectedCount) {
-            this.throwError("missing argument" + message, Logger.errors.MISSING_ARGUMENT, {
-                count: count,
-                expectedCount: expectedCount
-            });
-        }
-        if (count > expectedCount) {
-            this.throwError("too many arguments" + message, Logger.errors.UNEXPECTED_ARGUMENT, {
-                count: count,
-                expectedCount: expectedCount
-            });
-        }
-    }
-    checkNew(target, kind) {
-        if (target === Object || target == null) {
-            this.throwError("missing new", Logger.errors.MISSING_NEW, { name: kind.name });
-        }
-    }
-    checkAbstract(target, kind) {
-        if (target === kind) {
-            this.throwError("cannot instantiate abstract class " + JSON.stringify(kind.name) + " directly; use a sub-class", Logger.errors.UNSUPPORTED_OPERATION, { name: target.name, operation: "new" });
-        }
-        else if (target === Object || target == null) {
-            this.throwError("missing new", Logger.errors.MISSING_NEW, { name: kind.name });
-        }
-    }
-    static globalLogger() {
-        if (!_globalLogger) {
-            _globalLogger = new Logger(version$2);
-        }
-        return _globalLogger;
-    }
-    static setCensorship(censorship, permanent) {
-        if (!censorship && permanent) {
-            this.globalLogger().throwError("cannot permanently disable censorship", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "setCensorship"
-            });
-        }
-        if (_permanentCensorErrors) {
-            if (!censorship) {
-                return;
-            }
-            this.globalLogger().throwError("error censorship permanent", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "setCensorship"
-            });
-        }
-        _censorErrors = !!censorship;
-        _permanentCensorErrors = !!permanent;
-    }
-    static setLogLevel(logLevel) {
-        const level = LogLevels[logLevel.toLowerCase()];
-        if (level == null) {
-            Logger.globalLogger().warn("invalid log level - " + logLevel);
-            return;
-        }
-        _logLevel = level;
-    }
-    static from(version) {
-        return new Logger(version);
-    }
-}
-Logger.errors = ErrorCode;
-Logger.levels = LogLevel;
+utils$9.split32 = split32;
 
-const version$1 = "bytes/5.5.0";
+function rotr32$1(w, b) {
+  return (w >>> b) | (w << (32 - b));
+}
+utils$9.rotr32 = rotr32$1;
 
-const logger = new Logger(version$1);
-///////////////////////////////
-function isHexable(value) {
-    return !!(value.toHexString);
+function rotl32$2(w, b) {
+  return (w << b) | (w >>> (32 - b));
 }
-function addSlice(array) {
-    if (array.slice) {
-        return array;
-    }
-    array.slice = function () {
-        const args = Array.prototype.slice.call(arguments);
-        return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args)));
-    };
-    return array;
+utils$9.rotl32 = rotl32$2;
+
+function sum32$3(a, b) {
+  return (a + b) >>> 0;
 }
-function isInteger(value) {
-    return (typeof (value) === "number" && value == value && (value % 1) === 0);
+utils$9.sum32 = sum32$3;
+
+function sum32_3$1(a, b, c) {
+  return (a + b + c) >>> 0;
 }
-function isBytes(value) {
-    if (value == null) {
-        return false;
-    }
-    if (value.constructor === Uint8Array) {
-        return true;
-    }
-    if (typeof (value) === "string") {
-        return false;
-    }
-    if (!isInteger(value.length) || value.length < 0) {
-        return false;
-    }
-    for (let i = 0; i < value.length; i++) {
-        const v = value[i];
-        if (!isInteger(v) || v < 0 || v >= 256) {
-            return false;
-        }
-    }
-    return true;
+utils$9.sum32_3 = sum32_3$1;
+
+function sum32_4$2(a, b, c, d) {
+  return (a + b + c + d) >>> 0;
 }
-function arrayify(value, options) {
-    if (!options) {
-        options = {};
-    }
-    if (typeof (value) === "number") {
-        logger.checkSafeUint53(value, "invalid arrayify value");
-        const result = [];
-        while (value) {
-            result.unshift(value & 0xff);
-            value = parseInt(String(value / 256));
-        }
-        if (result.length === 0) {
-            result.push(0);
-        }
-        return addSlice(new Uint8Array(result));
-    }
-    if (options.allowMissingPrefix && typeof (value) === "string" && value.substring(0, 2) !== "0x") {
-        value = "0x" + value;
-    }
-    if (isHexable(value)) {
-        value = value.toHexString();
-    }
-    if (isHexString(value)) {
-        let hex = value.substring(2);
-        if (hex.length % 2) {
-            if (options.hexPad === "left") {
-                hex = "0x0" + hex.substring(2);
-            }
-            else if (options.hexPad === "right") {
-                hex += "0";
-            }
-            else {
-                logger.throwArgumentError("hex data is odd-length", "value", value);
-            }
-        }
-        const result = [];
-        for (let i = 0; i < hex.length; i += 2) {
-            result.push(parseInt(hex.substring(i, i + 2), 16));
-        }
-        return addSlice(new Uint8Array(result));
-    }
-    if (isBytes(value)) {
-        return addSlice(new Uint8Array(value));
-    }
-    return logger.throwArgumentError("invalid arrayify value", "value", value);
+utils$9.sum32_4 = sum32_4$2;
+
+function sum32_5$2(a, b, c, d, e) {
+  return (a + b + c + d + e) >>> 0;
 }
-function isHexString(value, length) {
-    if (typeof (value) !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
-        return false;
-    }
-    if (length && value.length !== 2 + 2 * length) {
-        return false;
-    }
-    return true;
+utils$9.sum32_5 = sum32_5$2;
+
+function sum64$1(buf, pos, ah, al) {
+  var bh = buf[pos];
+  var bl = buf[pos + 1];
+
+  var lo = (al + bl) >>> 0;
+  var hi = (lo < al ? 1 : 0) + ah + bh;
+  buf[pos] = hi >>> 0;
+  buf[pos + 1] = lo;
 }
+utils$9.sum64 = sum64$1;
 
-var hash$1 = {};
+function sum64_hi$1(ah, al, bh, bl) {
+  var lo = (al + bl) >>> 0;
+  var hi = (lo < al ? 1 : 0) + ah + bh;
+  return hi >>> 0;
+}
+utils$9.sum64_hi = sum64_hi$1;
 
-var utils$9 = {};
+function sum64_lo$1(ah, al, bh, bl) {
+  var lo = al + bl;
+  return lo >>> 0;
+}
+utils$9.sum64_lo = sum64_lo$1;
 
-var minimalisticAssert = assert$6;
+function sum64_4_hi$1(ah, al, bh, bl, ch, cl, dh, dl) {
+  var carry = 0;
+  var lo = al;
+  lo = (lo + bl) >>> 0;
+  carry += lo < al ? 1 : 0;
+  lo = (lo + cl) >>> 0;
+  carry += lo < cl ? 1 : 0;
+  lo = (lo + dl) >>> 0;
+  carry += lo < dl ? 1 : 0;
 
-function assert$6(val, msg) {
-  if (!val)
-    throw new Error(msg || 'Assertion failed');
+  var hi = ah + bh + ch + dh + carry;
+  return hi >>> 0;
 }
+utils$9.sum64_4_hi = sum64_4_hi$1;
 
-assert$6.equal = function assertEqual(l, r, msg) {
-  if (l != r)
-    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
-};
+function sum64_4_lo$1(ah, al, bh, bl, ch, cl, dh, dl) {
+  var lo = al + bl + cl + dl;
+  return lo >>> 0;
+}
+utils$9.sum64_4_lo = sum64_4_lo$1;
 
-var inherits$1 = {exports: {}};
+function sum64_5_hi$1(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+  var carry = 0;
+  var lo = al;
+  lo = (lo + bl) >>> 0;
+  carry += lo < al ? 1 : 0;
+  lo = (lo + cl) >>> 0;
+  carry += lo < cl ? 1 : 0;
+  lo = (lo + dl) >>> 0;
+  carry += lo < dl ? 1 : 0;
+  lo = (lo + el) >>> 0;
+  carry += lo < el ? 1 : 0;
 
-var inherits_browser = {exports: {}};
+  var hi = ah + bh + ch + dh + eh + carry;
+  return hi >>> 0;
+}
+utils$9.sum64_5_hi = sum64_5_hi$1;
 
-if (typeof Object.create === 'function') {
-  // implementation from standard node.js 'util' module
-  inherits_browser.exports = function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor;
-    ctor.prototype = Object.create(superCtor.prototype, {
-      constructor: {
-        value: ctor,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-  };
-} else {
-  // old school shim for old browsers
-  inherits_browser.exports = function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor;
-    var TempCtor = function () {};
-    TempCtor.prototype = superCtor.prototype;
-    ctor.prototype = new TempCtor();
-    ctor.prototype.constructor = ctor;
-  };
+function sum64_5_lo$1(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+  var lo = al + bl + cl + dl + el;
+
+  return lo >>> 0;
 }
+utils$9.sum64_5_lo = sum64_5_lo$1;
 
-try {
-  var util = require('util');
-  if (typeof util.inherits !== 'function') throw '';
-  inherits$1.exports = util.inherits;
-} catch (e) {
-  inherits$1.exports = inherits_browser.exports;
+function rotr64_hi$1(ah, al, num) {
+  var r = (al << (32 - num)) | (ah >>> num);
+  return r >>> 0;
 }
+utils$9.rotr64_hi = rotr64_hi$1;
 
-var assert$5 = minimalisticAssert;
-var inherits = inherits$1.exports;
+function rotr64_lo$1(ah, al, num) {
+  var r = (ah << (32 - num)) | (al >>> num);
+  return r >>> 0;
+}
+utils$9.rotr64_lo = rotr64_lo$1;
 
-utils$9.inherits = inherits;
+function shr64_hi$1(ah, al, num) {
+  return ah >>> num;
+}
+utils$9.shr64_hi = shr64_hi$1;
 
-function isSurrogatePair(msg, i) {
-  if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) {
-    return false;
-  }
-  if (i < 0 || i + 1 >= msg.length) {
-    return false;
-  }
-  return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00;
+function shr64_lo$1(ah, al, num) {
+  var r = (ah << (32 - num)) | (al >>> num);
+  return r >>> 0;
 }
-
-function toArray(msg, enc) {
-  if (Array.isArray(msg))
-    return msg.slice();
-  if (!msg)
-    return [];
-  var res = [];
-  if (typeof msg === 'string') {
-    if (!enc) {
-      // Inspired by stringToUtf8ByteArray() in closure-library by Google
-      // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143
-      // Apache License 2.0
-      // https://github.com/google/closure-library/blob/master/LICENSE
-      var p = 0;
-      for (var i = 0; i < msg.length; i++) {
-        var c = msg.charCodeAt(i);
-        if (c < 128) {
-          res[p++] = c;
-        } else if (c < 2048) {
-          res[p++] = (c >> 6) | 192;
-          res[p++] = (c & 63) | 128;
-        } else if (isSurrogatePair(msg, i)) {
-          c = 0x10000 + ((c & 0x03FF) << 10) + (msg.charCodeAt(++i) & 0x03FF);
-          res[p++] = (c >> 18) | 240;
-          res[p++] = ((c >> 12) & 63) | 128;
-          res[p++] = ((c >> 6) & 63) | 128;
-          res[p++] = (c & 63) | 128;
-        } else {
-          res[p++] = (c >> 12) | 224;
-          res[p++] = ((c >> 6) & 63) | 128;
-          res[p++] = (c & 63) | 128;
-        }
-      }
-    } else if (enc === 'hex') {
-      msg = msg.replace(/[^a-z0-9]+/ig, '');
-      if (msg.length % 2 !== 0)
-        msg = '0' + msg;
-      for (i = 0; i < msg.length; i += 2)
-        res.push(parseInt(msg[i] + msg[i + 1], 16));
-    }
-  } else {
-    for (i = 0; i < msg.length; i++)
-      res[i] = msg[i] | 0;
-  }
-  return res;
-}
-utils$9.toArray = toArray;
-
-function toHex(msg) {
-  var res = '';
-  for (var i = 0; i < msg.length; i++)
-    res += zero2(msg[i].toString(16));
-  return res;
-}
-utils$9.toHex = toHex;
-
-function htonl(w) {
-  var res = (w >>> 24) |
-            ((w >>> 8) & 0xff00) |
-            ((w << 8) & 0xff0000) |
-            ((w & 0xff) << 24);
-  return res >>> 0;
-}
-utils$9.htonl = htonl;
-
-function toHex32(msg, endian) {
-  var res = '';
-  for (var i = 0; i < msg.length; i++) {
-    var w = msg[i];
-    if (endian === 'little')
-      w = htonl(w);
-    res += zero8(w.toString(16));
-  }
-  return res;
-}
-utils$9.toHex32 = toHex32;
-
-function zero2(word) {
-  if (word.length === 1)
-    return '0' + word;
-  else
-    return word;
-}
-utils$9.zero2 = zero2;
-
-function zero8(word) {
-  if (word.length === 7)
-    return '0' + word;
-  else if (word.length === 6)
-    return '00' + word;
-  else if (word.length === 5)
-    return '000' + word;
-  else if (word.length === 4)
-    return '0000' + word;
-  else if (word.length === 3)
-    return '00000' + word;
-  else if (word.length === 2)
-    return '000000' + word;
-  else if (word.length === 1)
-    return '0000000' + word;
-  else
-    return word;
-}
-utils$9.zero8 = zero8;
-
-function join32(msg, start, end, endian) {
-  var len = end - start;
-  assert$5(len % 4 === 0);
-  var res = new Array(len / 4);
-  for (var i = 0, k = start; i < res.length; i++, k += 4) {
-    var w;
-    if (endian === 'big')
-      w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];
-    else
-      w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];
-    res[i] = w >>> 0;
-  }
-  return res;
-}
-utils$9.join32 = join32;
-
-function split32(msg, endian) {
-  var res = new Array(msg.length * 4);
-  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
-    var m = msg[i];
-    if (endian === 'big') {
-      res[k] = m >>> 24;
-      res[k + 1] = (m >>> 16) & 0xff;
-      res[k + 2] = (m >>> 8) & 0xff;
-      res[k + 3] = m & 0xff;
-    } else {
-      res[k + 3] = m >>> 24;
-      res[k + 2] = (m >>> 16) & 0xff;
-      res[k + 1] = (m >>> 8) & 0xff;
-      res[k] = m & 0xff;
-    }
-  }
-  return res;
-}
-utils$9.split32 = split32;
-
-function rotr32$1(w, b) {
-  return (w >>> b) | (w << (32 - b));
-}
-utils$9.rotr32 = rotr32$1;
-
-function rotl32$2(w, b) {
-  return (w << b) | (w >>> (32 - b));
-}
-utils$9.rotl32 = rotl32$2;
-
-function sum32$3(a, b) {
-  return (a + b) >>> 0;
-}
-utils$9.sum32 = sum32$3;
-
-function sum32_3$1(a, b, c) {
-  return (a + b + c) >>> 0;
-}
-utils$9.sum32_3 = sum32_3$1;
-
-function sum32_4$2(a, b, c, d) {
-  return (a + b + c + d) >>> 0;
-}
-utils$9.sum32_4 = sum32_4$2;
-
-function sum32_5$2(a, b, c, d, e) {
-  return (a + b + c + d + e) >>> 0;
-}
-utils$9.sum32_5 = sum32_5$2;
-
-function sum64$1(buf, pos, ah, al) {
-  var bh = buf[pos];
-  var bl = buf[pos + 1];
-
-  var lo = (al + bl) >>> 0;
-  var hi = (lo < al ? 1 : 0) + ah + bh;
-  buf[pos] = hi >>> 0;
-  buf[pos + 1] = lo;
-}
-utils$9.sum64 = sum64$1;
-
-function sum64_hi$1(ah, al, bh, bl) {
-  var lo = (al + bl) >>> 0;
-  var hi = (lo < al ? 1 : 0) + ah + bh;
-  return hi >>> 0;
-}
-utils$9.sum64_hi = sum64_hi$1;
-
-function sum64_lo$1(ah, al, bh, bl) {
-  var lo = al + bl;
-  return lo >>> 0;
-}
-utils$9.sum64_lo = sum64_lo$1;
-
-function sum64_4_hi$1(ah, al, bh, bl, ch, cl, dh, dl) {
-  var carry = 0;
-  var lo = al;
-  lo = (lo + bl) >>> 0;
-  carry += lo < al ? 1 : 0;
-  lo = (lo + cl) >>> 0;
-  carry += lo < cl ? 1 : 0;
-  lo = (lo + dl) >>> 0;
-  carry += lo < dl ? 1 : 0;
-
-  var hi = ah + bh + ch + dh + carry;
-  return hi >>> 0;
-}
-utils$9.sum64_4_hi = sum64_4_hi$1;
-
-function sum64_4_lo$1(ah, al, bh, bl, ch, cl, dh, dl) {
-  var lo = al + bl + cl + dl;
-  return lo >>> 0;
-}
-utils$9.sum64_4_lo = sum64_4_lo$1;
-
-function sum64_5_hi$1(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
-  var carry = 0;
-  var lo = al;
-  lo = (lo + bl) >>> 0;
-  carry += lo < al ? 1 : 0;
-  lo = (lo + cl) >>> 0;
-  carry += lo < cl ? 1 : 0;
-  lo = (lo + dl) >>> 0;
-  carry += lo < dl ? 1 : 0;
-  lo = (lo + el) >>> 0;
-  carry += lo < el ? 1 : 0;
-
-  var hi = ah + bh + ch + dh + eh + carry;
-  return hi >>> 0;
-}
-utils$9.sum64_5_hi = sum64_5_hi$1;
-
-function sum64_5_lo$1(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
-  var lo = al + bl + cl + dl + el;
-
-  return lo >>> 0;
-}
-utils$9.sum64_5_lo = sum64_5_lo$1;
-
-function rotr64_hi$1(ah, al, num) {
-  var r = (al << (32 - num)) | (ah >>> num);
-  return r >>> 0;
-}
-utils$9.rotr64_hi = rotr64_hi$1;
-
-function rotr64_lo$1(ah, al, num) {
-  var r = (ah << (32 - num)) | (al >>> num);
-  return r >>> 0;
-}
-utils$9.rotr64_lo = rotr64_lo$1;
-
-function shr64_hi$1(ah, al, num) {
-  return ah >>> num;
-}
-utils$9.shr64_hi = shr64_hi$1;
-
-function shr64_lo$1(ah, al, num) {
-  var r = (ah << (32 - num)) | (al >>> num);
-  return r >>> 0;
-}
-utils$9.shr64_lo = shr64_lo$1;
+utils$9.shr64_lo = shr64_lo$1;
 
 var common$5 = {};
 
@@ -1684,16 +1273,425 @@ hash.sha = sha;
 hash.ripemd = ripemd;
 hash.hmac = hmac;
 
-// Proxy hash functions to the main object
-hash.sha1 = hash.sha.sha1;
-hash.sha256 = hash.sha.sha256;
-hash.sha224 = hash.sha.sha224;
-hash.sha384 = hash.sha.sha384;
-hash.sha512 = hash.sha.sha512;
-hash.ripemd160 = hash.ripemd.ripemd160;
-}(hash$1));
+// Proxy hash functions to the main object
+hash.sha1 = hash.sha.sha1;
+hash.sha256 = hash.sha.sha256;
+hash.sha224 = hash.sha.sha224;
+hash.sha384 = hash.sha.sha384;
+hash.sha512 = hash.sha.sha512;
+hash.ripemd160 = hash.ripemd.ripemd160;
+}(hash$1));
+
+var hash = hash$1;
+
+const version$2 = "logger/5.5.0";
+
+let _permanentCensorErrors = false;
+let _censorErrors = false;
+const LogLevels = { debug: 1, "default": 2, info: 2, warning: 3, error: 4, off: 5 };
+let _logLevel = LogLevels["default"];
+let _globalLogger = null;
+function _checkNormalize() {
+    try {
+        const missing = [];
+        // Make sure all forms of normalization are supported
+        ["NFD", "NFC", "NFKD", "NFKC"].forEach((form) => {
+            try {
+                if ("test".normalize(form) !== "test") {
+                    throw new Error("bad normalize");
+                }
+                ;
+            }
+            catch (error) {
+                missing.push(form);
+            }
+        });
+        if (missing.length) {
+            throw new Error("missing " + missing.join(", "));
+        }
+        if (String.fromCharCode(0xe9).normalize("NFD") !== String.fromCharCode(0x65, 0x0301)) {
+            throw new Error("broken implementation");
+        }
+    }
+    catch (error) {
+        return error.message;
+    }
+    return null;
+}
+const _normalizeError = _checkNormalize();
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "DEBUG";
+    LogLevel["INFO"] = "INFO";
+    LogLevel["WARNING"] = "WARNING";
+    LogLevel["ERROR"] = "ERROR";
+    LogLevel["OFF"] = "OFF";
+})(LogLevel || (LogLevel = {}));
+var ErrorCode;
+(function (ErrorCode) {
+    ///////////////////
+    // Generic Errors
+    // Unknown Error
+    ErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+    // Not Implemented
+    ErrorCode["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
+    // Unsupported Operation
+    //   - operation
+    ErrorCode["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
+    // Network Error (i.e. Ethereum Network, such as an invalid chain ID)
+    //   - event ("noNetwork" is not re-thrown in provider.ready; otherwise thrown)
+    ErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
+    // Some sort of bad response from the server
+    ErrorCode["SERVER_ERROR"] = "SERVER_ERROR";
+    // Timeout
+    ErrorCode["TIMEOUT"] = "TIMEOUT";
+    ///////////////////
+    // Operational  Errors
+    // Buffer Overrun
+    ErrorCode["BUFFER_OVERRUN"] = "BUFFER_OVERRUN";
+    // Numeric Fault
+    //   - operation: the operation being executed
+    //   - fault: the reason this faulted
+    ErrorCode["NUMERIC_FAULT"] = "NUMERIC_FAULT";
+    ///////////////////
+    // Argument Errors
+    // Missing new operator to an object
+    //  - name: The name of the class
+    ErrorCode["MISSING_NEW"] = "MISSING_NEW";
+    // Invalid argument (e.g. value is incompatible with type) to a function:
+    //   - argument: The argument name that was invalid
+    //   - value: The value of the argument
+    ErrorCode["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
+    // Missing argument to a function:
+    //   - count: The number of arguments received
+    //   - expectedCount: The number of arguments expected
+    ErrorCode["MISSING_ARGUMENT"] = "MISSING_ARGUMENT";
+    // Too many arguments
+    //   - count: The number of arguments received
+    //   - expectedCount: The number of arguments expected
+    ErrorCode["UNEXPECTED_ARGUMENT"] = "UNEXPECTED_ARGUMENT";
+    ///////////////////
+    // Blockchain Errors
+    // Call exception
+    //  - transaction: the transaction
+    //  - address?: the contract address
+    //  - args?: The arguments passed into the function
+    //  - method?: The Solidity method signature
+    //  - errorSignature?: The EIP848 error signature
+    //  - errorArgs?: The EIP848 error parameters
+    //  - reason: The reason (only for EIP848 "Error(string)")
+    ErrorCode["CALL_EXCEPTION"] = "CALL_EXCEPTION";
+    // Insufficient funds (< value + gasLimit * gasPrice)
+    //   - transaction: the transaction attempted
+    ErrorCode["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
+    // Nonce has already been used
+    //   - transaction: the transaction attempted
+    ErrorCode["NONCE_EXPIRED"] = "NONCE_EXPIRED";
+    // The replacement fee for the transaction is too low
+    //   - transaction: the transaction attempted
+    ErrorCode["REPLACEMENT_UNDERPRICED"] = "REPLACEMENT_UNDERPRICED";
+    // The gas limit could not be estimated
+    //   - transaction: the transaction passed to estimateGas
+    ErrorCode["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
+    // The transaction was replaced by one with a higher gas price
+    //   - reason: "cancelled", "replaced" or "repriced"
+    //   - cancelled: true if reason == "cancelled" or reason == "replaced")
+    //   - hash: original transaction hash
+    //   - replacement: the full TransactionsResponse for the replacement
+    //   - receipt: the receipt of the replacement
+    ErrorCode["TRANSACTION_REPLACED"] = "TRANSACTION_REPLACED";
+})(ErrorCode || (ErrorCode = {}));
+const HEX = "0123456789abcdef";
+class Logger {
+    constructor(version) {
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            value: version,
+            writable: false
+        });
+    }
+    _log(logLevel, args) {
+        const level = logLevel.toLowerCase();
+        if (LogLevels[level] == null) {
+            this.throwArgumentError("invalid log level name", "logLevel", logLevel);
+        }
+        if (_logLevel > LogLevels[level]) {
+            return;
+        }
+        console.log.apply(console, args);
+    }
+    debug(...args) {
+        this._log(Logger.levels.DEBUG, args);
+    }
+    info(...args) {
+        this._log(Logger.levels.INFO, args);
+    }
+    warn(...args) {
+        this._log(Logger.levels.WARNING, args);
+    }
+    makeError(message, code, params) {
+        // Errors are being censored
+        if (_censorErrors) {
+            return this.makeError("censored error", code, {});
+        }
+        if (!code) {
+            code = Logger.errors.UNKNOWN_ERROR;
+        }
+        if (!params) {
+            params = {};
+        }
+        const messageDetails = [];
+        Object.keys(params).forEach((key) => {
+            const value = params[key];
+            try {
+                if (value instanceof Uint8Array) {
+                    let hex = "";
+                    for (let i = 0; i < value.length; i++) {
+                        hex += HEX[value[i] >> 4];
+                        hex += HEX[value[i] & 0x0f];
+                    }
+                    messageDetails.push(key + "=Uint8Array(0x" + hex + ")");
+                }
+                else {
+                    messageDetails.push(key + "=" + JSON.stringify(value));
+                }
+            }
+            catch (error) {
+                messageDetails.push(key + "=" + JSON.stringify(params[key].toString()));
+            }
+        });
+        messageDetails.push(`code=${code}`);
+        messageDetails.push(`version=${this.version}`);
+        const reason = message;
+        if (messageDetails.length) {
+            message += " (" + messageDetails.join(", ") + ")";
+        }
+        // @TODO: Any??
+        const error = new Error(message);
+        error.reason = reason;
+        error.code = code;
+        Object.keys(params).forEach(function (key) {
+            error[key] = params[key];
+        });
+        return error;
+    }
+    throwError(message, code, params) {
+        throw this.makeError(message, code, params);
+    }
+    throwArgumentError(message, name, value) {
+        return this.throwError(message, Logger.errors.INVALID_ARGUMENT, {
+            argument: name,
+            value: value
+        });
+    }
+    assert(condition, message, code, params) {
+        if (!!condition) {
+            return;
+        }
+        this.throwError(message, code, params);
+    }
+    assertArgument(condition, message, name, value) {
+        if (!!condition) {
+            return;
+        }
+        this.throwArgumentError(message, name, value);
+    }
+    checkNormalize(message) {
+        if (_normalizeError) {
+            this.throwError("platform missing String.prototype.normalize", Logger.errors.UNSUPPORTED_OPERATION, {
+                operation: "String.prototype.normalize", form: _normalizeError
+            });
+        }
+    }
+    checkSafeUint53(value, message) {
+        if (typeof (value) !== "number") {
+            return;
+        }
+        if (message == null) {
+            message = "value not safe";
+        }
+        if (value < 0 || value >= 0x1fffffffffffff) {
+            this.throwError(message, Logger.errors.NUMERIC_FAULT, {
+                operation: "checkSafeInteger",
+                fault: "out-of-safe-range",
+                value: value
+            });
+        }
+        if (value % 1) {
+            this.throwError(message, Logger.errors.NUMERIC_FAULT, {
+                operation: "checkSafeInteger",
+                fault: "non-integer",
+                value: value
+            });
+        }
+    }
+    checkArgumentCount(count, expectedCount, message) {
+        if (message) {
+            message = ": " + message;
+        }
+        else {
+            message = "";
+        }
+        if (count < expectedCount) {
+            this.throwError("missing argument" + message, Logger.errors.MISSING_ARGUMENT, {
+                count: count,
+                expectedCount: expectedCount
+            });
+        }
+        if (count > expectedCount) {
+            this.throwError("too many arguments" + message, Logger.errors.UNEXPECTED_ARGUMENT, {
+                count: count,
+                expectedCount: expectedCount
+            });
+        }
+    }
+    checkNew(target, kind) {
+        if (target === Object || target == null) {
+            this.throwError("missing new", Logger.errors.MISSING_NEW, { name: kind.name });
+        }
+    }
+    checkAbstract(target, kind) {
+        if (target === kind) {
+            this.throwError("cannot instantiate abstract class " + JSON.stringify(kind.name) + " directly; use a sub-class", Logger.errors.UNSUPPORTED_OPERATION, { name: target.name, operation: "new" });
+        }
+        else if (target === Object || target == null) {
+            this.throwError("missing new", Logger.errors.MISSING_NEW, { name: kind.name });
+        }
+    }
+    static globalLogger() {
+        if (!_globalLogger) {
+            _globalLogger = new Logger(version$2);
+        }
+        return _globalLogger;
+    }
+    static setCensorship(censorship, permanent) {
+        if (!censorship && permanent) {
+            this.globalLogger().throwError("cannot permanently disable censorship", Logger.errors.UNSUPPORTED_OPERATION, {
+                operation: "setCensorship"
+            });
+        }
+        if (_permanentCensorErrors) {
+            if (!censorship) {
+                return;
+            }
+            this.globalLogger().throwError("error censorship permanent", Logger.errors.UNSUPPORTED_OPERATION, {
+                operation: "setCensorship"
+            });
+        }
+        _censorErrors = !!censorship;
+        _permanentCensorErrors = !!permanent;
+    }
+    static setLogLevel(logLevel) {
+        const level = LogLevels[logLevel.toLowerCase()];
+        if (level == null) {
+            Logger.globalLogger().warn("invalid log level - " + logLevel);
+            return;
+        }
+        _logLevel = level;
+    }
+    static from(version) {
+        return new Logger(version);
+    }
+}
+Logger.errors = ErrorCode;
+Logger.levels = LogLevel;
+
+const version$1 = "bytes/5.5.0";
 
-var hash = hash$1;
+const logger = new Logger(version$1);
+///////////////////////////////
+function isHexable(value) {
+    return !!(value.toHexString);
+}
+function addSlice(array) {
+    if (array.slice) {
+        return array;
+    }
+    array.slice = function () {
+        const args = Array.prototype.slice.call(arguments);
+        return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args)));
+    };
+    return array;
+}
+function isInteger(value) {
+    return (typeof (value) === "number" && value == value && (value % 1) === 0);
+}
+function isBytes(value) {
+    if (value == null) {
+        return false;
+    }
+    if (value.constructor === Uint8Array) {
+        return true;
+    }
+    if (typeof (value) === "string") {
+        return false;
+    }
+    if (!isInteger(value.length) || value.length < 0) {
+        return false;
+    }
+    for (let i = 0; i < value.length; i++) {
+        const v = value[i];
+        if (!isInteger(v) || v < 0 || v >= 256) {
+            return false;
+        }
+    }
+    return true;
+}
+function arrayify(value, options) {
+    if (!options) {
+        options = {};
+    }
+    if (typeof (value) === "number") {
+        logger.checkSafeUint53(value, "invalid arrayify value");
+        const result = [];
+        while (value) {
+            result.unshift(value & 0xff);
+            value = parseInt(String(value / 256));
+        }
+        if (result.length === 0) {
+            result.push(0);
+        }
+        return addSlice(new Uint8Array(result));
+    }
+    if (options.allowMissingPrefix && typeof (value) === "string" && value.substring(0, 2) !== "0x") {
+        value = "0x" + value;
+    }
+    if (isHexable(value)) {
+        value = value.toHexString();
+    }
+    if (isHexString(value)) {
+        let hex = value.substring(2);
+        if (hex.length % 2) {
+            if (options.hexPad === "left") {
+                hex = "0x0" + hex.substring(2);
+            }
+            else if (options.hexPad === "right") {
+                hex += "0";
+            }
+            else {
+                logger.throwArgumentError("hex data is odd-length", "value", value);
+            }
+        }
+        const result = [];
+        for (let i = 0; i < hex.length; i += 2) {
+            result.push(parseInt(hex.substring(i, i + 2), 16));
+        }
+        return addSlice(new Uint8Array(result));
+    }
+    if (isBytes(value)) {
+        return addSlice(new Uint8Array(value));
+    }
+    return logger.throwArgumentError("invalid arrayify value", "value", value);
+}
+function isHexString(value, length) {
+    if (typeof (value) !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
+        return false;
+    }
+    if (length && value.length !== 2 + 2 * length) {
+        return false;
+    }
+    return true;
+}
 
 const version = "sha2/5.5.0";
 
@@ -1725,8 +1723,7 @@ class Struct {
 class Enum extends Struct {
   constructor(properties) {
     super(properties);
-
-    _defineProperty(this, "enum", '');
+    this.enum = '';
 
     if (Object.keys(properties).length !== 1) {
       throw new Error('Enum can only take single value');
@@ -1766,8 +1763,7 @@ class PublicKey extends Struct {
    */
   constructor(value) {
     super({});
-
-    _defineProperty(this, "_bn", void 0);
+    this._bn = void 0;
 
     if (isPublicKeyData(value)) {
       this._bn = value._bn;
@@ -1777,7 +1773,7 @@ class PublicKey extends Struct {
         const decoded = bs58.decode(value);
 
         if (decoded.length != 32) {
-          throw new Error("Invalid public key input");
+          throw new Error(`Invalid public key input`);
         }
 
         this._bn = new BN(decoded);
@@ -1786,7 +1782,7 @@ class PublicKey extends Struct {
       }
 
       if (this._bn.byteLength() > 32) {
-        throw new Error("Invalid public key input");
+        throw new Error(`Invalid public key input`);
       }
     }
   }
@@ -1809,6 +1805,10 @@ class PublicKey extends Struct {
   toBase58() {
     return bs58.encode(this.toBytes());
   }
+
+  toJSON() {
+    return this.toBase58();
+  }
   /**
    * Return the byte array representation of the public key
    */
@@ -1866,7 +1866,7 @@ class PublicKey extends Struct {
     let buffer = Buffer.alloc(0);
     seeds.forEach(function (seed) {
       if (seed.length > MAX_SEED_LENGTH) {
-        throw new TypeError("Max seed length exceeded");
+        throw new TypeError(`Max seed length exceeded`);
       }
 
       buffer = Buffer.concat([buffer, toBuffer(seed)]);
@@ -1876,7 +1876,7 @@ class PublicKey extends Struct {
     let publicKeyBytes = new BN(hash, 16).toArray(undefined, 32);
 
     if (is_on_curve(publicKeyBytes)) {
-      throw new Error("Invalid seeds, address must fall off the curve");
+      throw new Error(`Invalid seeds, address must fall off the curve`);
     }
 
     return new PublicKey(publicKeyBytes);
@@ -1910,7 +1910,7 @@ class PublicKey extends Struct {
       return [address, nonce];
     }
 
-    throw new Error("Unable to find a viable program address nonce");
+    throw new Error(`Unable to find a viable program address nonce`);
   }
   /**
    * Check that a pubkey is on the ed25519 curve.
@@ -1922,15 +1922,13 @@ class PublicKey extends Struct {
   }
 
 }
-
-_defineProperty(PublicKey, "default", new PublicKey('11111111111111111111111111111111'));
-
+PublicKey.default = new PublicKey('11111111111111111111111111111111');
 SOLANA_SCHEMA.set(PublicKey, {
   kind: 'struct',
   fields: [['_bn', 'u256']]
 }); // @ts-ignore
 
-let naclLowLevel = nacl__default.lowlevel; // Check that a pubkey is on the curve.
+let naclLowLevel = nacl.lowlevel; // Check that a pubkey is on the curve.
 // This function and its dependents were sourced from:
 // https://github.com/dchest/tweetnacl-js/blob/f1ec050ceae0861f34280e62498b1d3ed9c350c6/nacl.js#L792
 
@@ -1997,7 +1995,7 @@ class Account {
    * @param secretKey Secret key for the account
    */
   constructor(secretKey) {
-    _defineProperty(this, "_keypair", void 0);
+    this._keypair = void 0;
 
     if (secretKey) {
       this._keypair = nacl.sign.keyPair.fromSecretKey(toBuffer(secretKey));
@@ -2133,16 +2131,11 @@ const PUBKEY_LENGTH = 32;
 
 class Message {
   constructor(args) {
-    _defineProperty(this, "header", void 0);
-
-    _defineProperty(this, "accountKeys", void 0);
-
-    _defineProperty(this, "recentBlockhash", void 0);
-
-    _defineProperty(this, "instructions", void 0);
-
-    _defineProperty(this, "indexToProgramIds", new Map());
-
+    this.header = void 0;
+    this.accountKeys = void 0;
+    this.recentBlockhash = void 0;
+    this.instructions = void 0;
+    this.indexToProgramIds = new Map();
     this.header = args.header;
     this.accountKeys = args.accountKeys.map(account => new PublicKey(account));
     this.recentBlockhash = args.recentBlockhash;
@@ -2316,12 +2309,9 @@ class TransactionInstruction {
    * Program input
    */
   constructor(opts) {
-    _defineProperty(this, "keys", void 0);
-
-    _defineProperty(this, "programId", void 0);
-
-    _defineProperty(this, "data", Buffer.alloc(0));
-
+    this.keys = void 0;
+    this.programId = void 0;
+    this.data = Buffer.alloc(0);
     this.programId = opts.programId;
     this.keys = opts.keys;
 
@@ -2363,16 +2353,11 @@ class Transaction {
    * Construct an empty Transaction
    */
   constructor(opts) {
-    _defineProperty(this, "signatures", []);
-
-    _defineProperty(this, "feePayer", void 0);
-
-    _defineProperty(this, "instructions", []);
-
-    _defineProperty(this, "recentBlockhash", void 0);
-
-    _defineProperty(this, "nonceInfo", void 0);
-
+    this.signatures = [];
+    this.feePayer = void 0;
+    this.instructions = [];
+    this.recentBlockhash = void 0;
+    this.nonceInfo = void 0;
     opts && Object.assign(this, opts);
   }
   /**
@@ -2436,7 +2421,7 @@ class Transaction {
 
     for (let i = 0; i < this.instructions.length; i++) {
       if (this.instructions[i].programId === undefined) {
-        throw new Error("Transaction instruction index ".concat(i, " has undefined program id"));
+        throw new Error(`Transaction instruction index ${i} has undefined program id`);
       }
     }
 
@@ -2463,8 +2448,9 @@ class Transaction {
     }); // Sort. Prioritizing first by signer, then by writable
 
     accountMetas.sort(function (x, y) {
+      const pubkeySorting = x.pubkey.toBase58().localeCompare(y.pubkey.toBase58());
       const checkSigner = x.isSigner === y.isSigner ? 0 : x.isSigner ? -1 : 1;
-      const checkWritable = x.isWritable === y.isWritable ? 0 : x.isWritable ? -1 : 1;
+      const checkWritable = x.isWritable === y.isWritable ? pubkeySorting : x.isWritable ? -1 : 1;
       return checkSigner || checkWritable;
     }); // Cull duplicate account metas
 
@@ -2511,7 +2497,7 @@ class Transaction {
           console.warn('Transaction references a signature that is unnecessary, ' + 'only the fee payer and instruction signer accounts should sign a transaction. ' + 'This behavior is deprecated and will throw an error in the next major version release.');
         }
       } else {
-        throw new Error("unknown signer: ".concat(signature.publicKey.toString()));
+        throw new Error(`unknown signer: ${signature.publicKey.toString()}`);
       }
     }
 
@@ -2718,7 +2704,7 @@ class Transaction {
   _partialSign(message, ...signers) {
     const signData = message.serialize();
     signers.forEach(signer => {
-      const signature = nacl__default.sign.detached(signData, signer.secretKey);
+      const signature = nacl.sign.detached(signData, signer.secretKey);
 
       this._addSignature(signer.publicKey, toBuffer(signature));
     });
@@ -2746,7 +2732,7 @@ class Transaction {
     const index = this.signatures.findIndex(sigpair => pubkey.equals(sigpair.publicKey));
 
     if (index < 0) {
-      throw new Error("unknown signer: ".concat(pubkey.toString()));
+      throw new Error(`unknown signer: ${pubkey.toString()}`);
     }
 
     this.signatures[index].signature = Buffer.from(signature);
@@ -2774,7 +2760,7 @@ class Transaction {
           return false;
         }
       } else {
-        if (!nacl__default.sign.detached.verify(signData, signature, publicKey.toBuffer())) {
+        if (!nacl.sign.detached.verify(signData, signature, publicKey.toBuffer())) {
           return false;
         }
       }
@@ -2822,12 +2808,12 @@ class Transaction {
       signature
     }, index) => {
       if (signature !== null) {
-        assert(signature.length === 64, "signature has invalid length");
+        assert(signature.length === 64, `signature has invalid length`);
         Buffer.from(signature).copy(wireTransaction, signatureCount.length + index * 64);
       }
     });
     signData.copy(wireTransaction, signatureCount.length + signatures.length * 64);
-    assert(wireTransaction.length <= PACKET_DATA_SIZE, "Transaction too large: ".concat(wireTransaction.length, " > ").concat(PACKET_DATA_SIZE));
+    assert(wireTransaction.length <= PACKET_DATA_SIZE, `Transaction too large: ${wireTransaction.length} > ${PACKET_DATA_SIZE}`);
     return wireTransaction;
   }
   /**
@@ -2920,11 +2906,14 @@ class Transaction {
 }
 
 const SYSVAR_CLOCK_PUBKEY = new PublicKey('SysvarC1ock11111111111111111111111111111111');
+const SYSVAR_EPOCH_SCHEDULE_PUBKEY = new PublicKey('SysvarEpochSchedu1e111111111111111111111111');
+const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey('Sysvar1nstructions1111111111111111111111111');
 const SYSVAR_RECENT_BLOCKHASHES_PUBKEY = new PublicKey('SysvarRecentB1ockHashes11111111111111111111');
 const SYSVAR_RENT_PUBKEY = new PublicKey('SysvarRent111111111111111111111111111111111');
 const SYSVAR_REWARDS_PUBKEY = new PublicKey('SysvarRewards111111111111111111111111111111');
+const SYSVAR_SLOT_HASHES_PUBKEY = new PublicKey('SysvarS1otHashes111111111111111111111111111');
+const SYSVAR_SLOT_HISTORY_PUBKEY = new PublicKey('SysvarS1otHistory11111111111111111111111111');
 const SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey('SysvarStakeHistory1111111111111111111111111');
-const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey('Sysvar1nstructions1111111111111111111111111');
 
 /**
  * Sign, send and confirm a transaction.
@@ -2946,7 +2935,7 @@ async function sendAndConfirmTransaction(connection, transaction, signers, optio
   const status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
 
   if (status.err) {
-    throw new Error("Transaction ".concat(signature, " failed (").concat(JSON.stringify(status), ")"));
+    throw new Error(`Transaction ${signature} failed (${JSON.stringify(status)})`);
   }
 
   return signature;
@@ -2989,7 +2978,7 @@ function decodeData(type, buffer) {
   }
 
   if (data.instruction !== type.index) {
-    throw new Error("invalid instruction; instruction index mismatch ".concat(data.instruction, " != ").concat(type.index));
+    throw new Error(`invalid instruction; instruction index mismatch ${data.instruction} != ${type.index}`);
   }
 
   return data;
@@ -3023,12 +3012,9 @@ class NonceAccount {
    * @internal
    */
   constructor(args) {
-    _defineProperty(this, "authorizedPubkey", void 0);
-
-    _defineProperty(this, "nonce", void 0);
-
-    _defineProperty(this, "feeCalculator", void 0);
-
+    this.authorizedPubkey = void 0;
+    this.nonce = void 0;
+    this.feeCalculator = void 0;
     this.authorizedPubkey = args.authorizedPubkey;
     this.nonce = args.nonce;
     this.feeCalculator = args.feeCalculator;
@@ -3329,7 +3315,7 @@ class SystemInstruction {
 
   static checkKeyLength(keys, expectedLength) {
     if (keys.length < expectedLength) {
-      throw new Error("invalid instruction; found ".concat(keys.length, " keys, expected at least ").concat(expectedLength));
+      throw new Error(`invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`);
     }
   }
 
@@ -3761,8 +3747,7 @@ class SystemProgram {
   }
 
 }
-
-_defineProperty(SystemProgram, "programId", new PublicKey('11111111111111111111111111111111'));
+SystemProgram.programId = new PublicKey('11111111111111111111111111111111');
 
 // rest of the Transaction fields
 //
@@ -3931,8 +3916,7 @@ class Loader {
   }
 
 }
-
-_defineProperty(Loader, "chunkSize", CHUNK_SIZE);
+Loader.chunkSize = CHUNK_SIZE;
 
 const BPF_LOADER_PROGRAM_ID = new PublicKey('BPFLoader2111111111111111111111111111111111');
 /**
@@ -3983,14 +3967,10 @@ class AgentManager {
   }
 
   constructor(useHttps) {
-    _defineProperty(this, "_agent", void 0);
-
-    _defineProperty(this, "_activeRequests", 0);
-
-    _defineProperty(this, "_destroyTimeout", null);
-
-    _defineProperty(this, "_useHttps", void 0);
-
+    this._agent = void 0;
+    this._activeRequests = 0;
+    this._destroyTimeout = null;
+    this._useHttps = void 0;
     this._useHttps = useHttps === true;
     this._agent = AgentManager._newAgent(this._useHttps);
   }
@@ -4063,16 +4043,11 @@ class EpochSchedule {
 
   /** The first slot of `firstNormalEpoch` */
   constructor(slotsPerEpoch, leaderScheduleSlotOffset, warmup, firstNormalEpoch, firstNormalSlot) {
-    _defineProperty(this, "slotsPerEpoch", void 0);
-
-    _defineProperty(this, "leaderScheduleSlotOffset", void 0);
-
-    _defineProperty(this, "warmup", void 0);
-
-    _defineProperty(this, "firstNormalEpoch", void 0);
-
-    _defineProperty(this, "firstNormalSlot", void 0);
-
+    this.slotsPerEpoch = void 0;
+    this.leaderScheduleSlotOffset = void 0;
+    this.warmup = void 0;
+    this.firstNormalEpoch = void 0;
+    this.firstNormalSlot = void 0;
     this.slotsPerEpoch = slotsPerEpoch;
     this.leaderScheduleSlotOffset = leaderScheduleSlotOffset;
     this.warmup = warmup;
@@ -4124,9 +4099,7 @@ class EpochSchedule {
 class SendTransactionError extends Error {
   constructor(message, logs) {
     super(message);
-
-    _defineProperty(this, "logs", void 0);
-
+    this.logs = void 0;
     this.logs = logs;
   }
 
@@ -4358,16 +4331,15 @@ function createRpcClient(url, useHttps, httpHeaders, fetchMiddleware, disableRet
   let fetchWithMiddleware;
 
   if (fetchMiddleware) {
-    fetchWithMiddleware = (url, options) => {
-      return new Promise((resolve, reject) => {
-        fetchMiddleware(url, options, async (url, options) => {
-          try {
-            resolve(await fetch(url, options));
-          } catch (error) {
-            reject(error);
-          }
-        });
+    fetchWithMiddleware = async (url, options) => {
+      const modifiedFetchArgs = await new Promise((resolve, reject) => {
+        try {
+          fetchMiddleware(url, options, (modifiedUrl, modifiedOptions) => resolve([modifiedUrl, modifiedOptions]));
+        } catch (error) {
+          reject(error);
+        }
       });
+      return await fetch(...modifiedFetchArgs);
     };
   }
 
@@ -4410,7 +4382,7 @@ function createRpcClient(url, useHttps, httpHeaders, fetchMiddleware, disableRet
           break;
         }
 
-        console.log("Server responded with ".concat(res.status, " ").concat(res.statusText, ".  Retrying after ").concat(waitTime, "ms delay..."));
+        console.log(`Server responded with ${res.status} ${res.statusText}.  Retrying after ${waitTime}ms delay...`);
         await sleep(waitTime);
         waitTime *= 2;
       }
@@ -4420,7 +4392,7 @@ function createRpcClient(url, useHttps, httpHeaders, fetchMiddleware, disableRet
       if (res.ok) {
         callback(null, text);
       } else {
-        callback(new Error("".concat(res.status, " ").concat(res.statusText, ": ").concat(text)));
+        callback(new Error(`${res.status} ${res.statusText}: ${text}`));
       }
     } catch (err) {
       if (err instanceof Error) callback(err);
@@ -4861,6 +4833,7 @@ const ParsedConfirmedTransactionResult = type({
 const TokenBalanceResult = type({
   accountIndex: number(),
   mint: string(),
+  owner: optional(string()),
   uiTokenAmount: TokenAmountResult
 });
 /**
@@ -5086,67 +5059,39 @@ class Connection {
    * @param commitmentOrConfig optional default commitment level or optional ConnectionConfig configuration object
    */
   constructor(endpoint, commitmentOrConfig) {
-    _defineProperty(this, "_commitment", void 0);
-
-    _defineProperty(this, "_confirmTransactionInitialTimeout", void 0);
-
-    _defineProperty(this, "_rpcEndpoint", void 0);
-
-    _defineProperty(this, "_rpcWsEndpoint", void 0);
-
-    _defineProperty(this, "_rpcClient", void 0);
-
-    _defineProperty(this, "_rpcRequest", void 0);
-
-    _defineProperty(this, "_rpcBatchRequest", void 0);
-
-    _defineProperty(this, "_rpcWebSocket", void 0);
-
-    _defineProperty(this, "_rpcWebSocketConnected", false);
-
-    _defineProperty(this, "_rpcWebSocketHeartbeat", null);
-
-    _defineProperty(this, "_rpcWebSocketIdleTimeout", null);
-
-    _defineProperty(this, "_disableBlockhashCaching", false);
-
-    _defineProperty(this, "_pollingBlockhash", false);
-
-    _defineProperty(this, "_blockhashInfo", {
+    this._commitment = void 0;
+    this._confirmTransactionInitialTimeout = void 0;
+    this._rpcEndpoint = void 0;
+    this._rpcWsEndpoint = void 0;
+    this._rpcClient = void 0;
+    this._rpcRequest = void 0;
+    this._rpcBatchRequest = void 0;
+    this._rpcWebSocket = void 0;
+    this._rpcWebSocketConnected = false;
+    this._rpcWebSocketHeartbeat = null;
+    this._rpcWebSocketIdleTimeout = null;
+    this._disableBlockhashCaching = false;
+    this._pollingBlockhash = false;
+    this._blockhashInfo = {
       recentBlockhash: null,
       lastFetch: 0,
       transactionSignatures: [],
       simulatedSignatures: []
-    });
-
-    _defineProperty(this, "_accountChangeSubscriptionCounter", 0);
-
-    _defineProperty(this, "_accountChangeSubscriptions", {});
-
-    _defineProperty(this, "_programAccountChangeSubscriptionCounter", 0);
-
-    _defineProperty(this, "_programAccountChangeSubscriptions", {});
-
-    _defineProperty(this, "_rootSubscriptionCounter", 0);
-
-    _defineProperty(this, "_rootSubscriptions", {});
-
-    _defineProperty(this, "_signatureSubscriptionCounter", 0);
-
-    _defineProperty(this, "_signatureSubscriptions", {});
-
-    _defineProperty(this, "_slotSubscriptionCounter", 0);
-
-    _defineProperty(this, "_slotSubscriptions", {});
-
-    _defineProperty(this, "_logsSubscriptionCounter", 0);
-
-    _defineProperty(this, "_logsSubscriptions", {});
-
-    _defineProperty(this, "_slotUpdateSubscriptionCounter", 0);
-
-    _defineProperty(this, "_slotUpdateSubscriptions", {});
-
+    };
+    this._accountChangeSubscriptionCounter = 0;
+    this._accountChangeSubscriptions = {};
+    this._programAccountChangeSubscriptionCounter = 0;
+    this._programAccountChangeSubscriptions = {};
+    this._rootSubscriptionCounter = 0;
+    this._rootSubscriptions = {};
+    this._signatureSubscriptionCounter = 0;
+    this._signatureSubscriptions = {};
+    this._slotSubscriptionCounter = 0;
+    this._slotSubscriptions = {};
+    this._logsSubscriptionCounter = 0;
+    this._logsSubscriptions = {};
+    this._slotUpdateSubscriptionCounter = 0;
+    this._slotUpdateSubscriptions = {};
     let url = new URL(endpoint);
     const useHttps = url.protocol === 'https:';
     let wsEndpoint;
@@ -5492,13 +5437,25 @@ class Connection {
    */
 
 
-  async getMultipleAccountsInfo(publicKeys, commitment) {
+  async getMultipleAccountsInfo(publicKeys, configOrCommitment) {
     const keys = publicKeys.map(key => key.toBase58());
+    let commitment;
+    let encoding = 'base64';
+
+    if (configOrCommitment) {
+      if (typeof configOrCommitment === 'string') {
+        commitment = configOrCommitment;
+        encoding = 'base64';
+      } else {
+        commitment = configOrCommitment.commitment;
+        encoding = configOrCommitment.encoding || 'base64';
+      }
+    }
 
-    const args = this._buildArgs([keys], commitment, 'base64');
+    const args = this._buildArgs([keys], commitment, encoding);
 
     const unsafeRes = await this._rpcRequest('getMultipleAccounts', args);
-    const res = create(unsafeRes, jsonRpcResultAndContext(array(nullable(AccountInfoResult))));
+    const res = create(unsafeRes, jsonRpcResultAndContext(array(nullable(ParsedAccountInfoResult))));
 
     if ('error' in res) {
       throw new Error('failed to get info for accounts ' + keys + ': ' + res.error.message);
@@ -5520,7 +5477,7 @@ class Connection {
     const res = create(unsafeRes, jsonRpcResult(StakeActivationResult));
 
     if ('error' in res) {
-      throw new Error("failed to get Stake Activation ".concat(publicKey.toBase58(), ": ").concat(res.error.message));
+      throw new Error(`failed to get Stake Activation ${publicKey.toBase58()}: ${res.error.message}`);
     }
 
     return res.result;
@@ -5656,7 +5613,7 @@ class Connection {
 
     if (response === null) {
       const duration = (Date.now() - start) / 1000;
-      throw new Error("Transaction was not confirmed in ".concat(duration.toFixed(2), " seconds. It is unknown if it succeeded or failed. Check signature ").concat(signature, " using the Solana Explorer or CLI tools."));
+      throw new Error(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`);
     }
 
     return response;
@@ -5979,6 +5936,29 @@ class Connection {
       value: value !== null ? value.feeCalculator : null
     };
   }
+  /**
+   * Fetch the fee for a message from the cluster, return with context
+   */
+
+
+  async getFeeForMessage(message, commitment) {
+    const wireMessage = message.serialize().toString('base64');
+
+    const args = this._buildArgs([wireMessage], commitment);
+
+    const unsafeRes = await this._rpcRequest('getFeeForMessage', args);
+    const res = create(unsafeRes, jsonRpcResultAndContext(nullable(number())));
+
+    if ('error' in res) {
+      throw new Error('failed to get slot: ' + res.error.message);
+    }
+
+    if (res.result === null) {
+      throw new Error('invalid blockhash');
+    }
+
+    return res.result;
+  }
   /**
    * Fetch a recent blockhash from the cluster
    * @return {Promise<{blockhash: Blockhash, feeCalculator: FeeCalculator}>}
@@ -6430,7 +6410,7 @@ class Connection {
         await sleep(MS_PER_SLOT / 2);
       }
 
-      throw new Error("Unable to obtain a new blockhash after ".concat(Date.now() - startTime, "ms"));
+      throw new Error(`Unable to obtain a new blockhash after ${Date.now() - startTime}ms`);
     } finally {
       this._pollingBlockhash = false;
     }
@@ -6687,7 +6667,7 @@ class Connection {
         }
 
         if (err instanceof Error) {
-          console.error("".concat(rpcMethod, " error for argument"), rpcArgs, err.message);
+          console.error(`${rpcMethod} error for argument`, rpcArgs, err.message);
         }
       }
     }
@@ -6707,7 +6687,7 @@ class Connection {
         await this._rpcWebSocket.call(rpcMethod, [unsubscribeId]);
       } catch (err) {
         if (err instanceof Error) {
-          console.error("".concat(rpcMethod, " error:"), err.message);
+          console.error(`${rpcMethod} error:`, err.message);
         }
       }
     }
@@ -6872,7 +6852,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error("Unknown account change id: ".concat(id));
+      throw new Error(`Unknown account change id: ${id}`);
     }
   }
   /**
@@ -6938,7 +6918,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error("Unknown program account change id: ".concat(id));
+      throw new Error(`Unknown program account change id: ${id}`);
     }
   }
   /**
@@ -6968,7 +6948,7 @@ class Connection {
 
   async removeOnLogsListener(id) {
     if (!this._logsSubscriptions[id]) {
-      throw new Error("Unknown logs id: ".concat(id));
+      throw new Error(`Unknown logs id: ${id}`);
     }
 
     const subInfo = this._logsSubscriptions[id];
@@ -7044,7 +7024,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error("Unknown slot change id: ".concat(id));
+      throw new Error(`Unknown slot change id: ${id}`);
     }
   }
   /**
@@ -7097,7 +7077,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error("Unknown slot update id: ".concat(id));
+      throw new Error(`Unknown slot update id: ${id}`);
     }
   }
 
@@ -7238,7 +7218,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error("Unknown signature result id: ".concat(id));
+      throw new Error(`Unknown signature result id: ${id}`);
     }
   }
   /**
@@ -7290,7 +7270,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error("Unknown root change id: ".concat(id));
+      throw new Error(`Unknown root change id: ${id}`);
     }
   }
 
@@ -7311,7 +7291,7 @@ class Keypair {
    * @param keypair ed25519 keypair
    */
   constructor(keypair) {
-    _defineProperty(this, "_keypair", void 0);
+    this._keypair = void 0;
 
     if (keypair) {
       this._keypair = keypair;
@@ -7415,8 +7395,8 @@ class Ed25519Program {
       signature,
       instructionIndex
     } = params;
-    assert(publicKey.length === PUBLIC_KEY_BYTES$1, "Public Key must be ".concat(PUBLIC_KEY_BYTES$1, " bytes but received ").concat(publicKey.length, " bytes"));
-    assert(signature.length === SIGNATURE_BYTES, "Signature must be ".concat(SIGNATURE_BYTES, " bytes but received ").concat(signature.length, " bytes"));
+    assert(publicKey.length === PUBLIC_KEY_BYTES$1, `Public Key must be ${PUBLIC_KEY_BYTES$1} bytes but received ${publicKey.length} bytes`);
+    assert(signature.length === SIGNATURE_BYTES, `Signature must be ${SIGNATURE_BYTES} bytes but received ${signature.length} bytes`);
     const publicKeyOffset = ED25519_INSTRUCTION_LAYOUT.span;
     const signatureOffset = publicKeyOffset + publicKey.length;
     const messageDataOffset = signatureOffset + signature.length;
@@ -7454,12 +7434,12 @@ class Ed25519Program {
       message,
       instructionIndex
     } = params;
-    assert(privateKey.length === PRIVATE_KEY_BYTES$1, "Private key must be ".concat(PRIVATE_KEY_BYTES$1, " bytes but received ").concat(privateKey.length, " bytes"));
+    assert(privateKey.length === PRIVATE_KEY_BYTES$1, `Private key must be ${PRIVATE_KEY_BYTES$1} bytes but received ${privateKey.length} bytes`);
 
     try {
       const keypair = Keypair.fromSecretKey(privateKey);
       const publicKey = keypair.publicKey.toBytes();
-      const signature = nacl__default.sign.detached(message, keypair.secretKey);
+      const signature = nacl.sign.detached(message, keypair.secretKey);
       return this.createInstructionWithPublicKey({
         publicKey,
         message,
@@ -7467,13 +7447,12 @@ class Ed25519Program {
         instructionIndex
       });
     } catch (error) {
-      throw new Error("Error creating instruction; ".concat(error));
+      throw new Error(`Error creating instruction; ${error}`);
     }
   }
 
 }
-
-_defineProperty(Ed25519Program, "programId", new PublicKey('Ed25519SigVerify111111111111111111111111111'));
+Ed25519Program.programId = new PublicKey('Ed25519SigVerify111111111111111111111111111');
 
 /**
  * Address of the stake config account which configures the rate
@@ -7496,10 +7475,8 @@ class Authorized {
    * @param withdrawer the withdraw authority
    */
   constructor(staker, withdrawer) {
-    _defineProperty(this, "staker", void 0);
-
-    _defineProperty(this, "withdrawer", void 0);
-
+    this.staker = void 0;
+    this.withdrawer = void 0;
     this.staker = staker;
     this.withdrawer = withdrawer;
   }
@@ -7520,12 +7497,9 @@ class Lockup {
    * Create a new Lockup object
    */
   constructor(unixTimestamp, epoch, custodian) {
-    _defineProperty(this, "unixTimestamp", void 0);
-
-    _defineProperty(this, "epoch", void 0);
-
-    _defineProperty(this, "custodian", void 0);
-
+    this.unixTimestamp = void 0;
+    this.epoch = void 0;
+    this.custodian = void 0;
     this.unixTimestamp = unixTimestamp;
     this.epoch = epoch;
     this.custodian = custodian;
@@ -7540,7 +7514,7 @@ class Lockup {
  * Create stake account transaction params
  */
 
-_defineProperty(Lockup, "default", new Lockup(0, 0, PublicKey.default));
+Lockup.default = new Lockup(0, 0, PublicKey.default);
 
 /**
  * Stake Instruction class
@@ -7753,7 +7727,7 @@ class StakeInstruction {
 
   static checkKeyLength(keys, expectedLength) {
     if (keys.length < expectedLength) {
-      throw new Error("invalid instruction; found ".concat(keys.length, " keys, expected at least ").concat(expectedLength));
+      throw new Error(`invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`);
     }
   }
 
@@ -8228,10 +8202,8 @@ class StakeProgram {
   }
 
 }
-
-_defineProperty(StakeProgram, "programId", new PublicKey('Stake11111111111111111111111111111111111111'));
-
-_defineProperty(StakeProgram, "space", 200);
+StakeProgram.programId = new PublicKey('Stake11111111111111111111111111111111111111');
+StakeProgram.space = 200;
 
 const {
   publicKeyCreate,
@@ -8261,12 +8233,12 @@ class Secp256k1Program {
    * @param {Buffer} publicKey a 64 byte secp256k1 public key buffer
    */
   static publicKeyToEthAddress(publicKey) {
-    assert(publicKey.length === PUBLIC_KEY_BYTES, "Public key must be ".concat(PUBLIC_KEY_BYTES, " bytes but received ").concat(publicKey.length, " bytes"));
+    assert(publicKey.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`);
 
     try {
-      return Buffer.from(keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
+      return Buffer.from(sha3.keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
     } catch (error) {
-      throw new Error("Error constructing Ethereum address: ".concat(error));
+      throw new Error(`Error constructing Ethereum address: ${error}`);
     }
   }
   /**
@@ -8317,7 +8289,7 @@ class Secp256k1Program {
       ethAddress = rawAddress;
     }
 
-    assert(ethAddress.length === ETHEREUM_ADDRESS_BYTES, "Address must be ".concat(ETHEREUM_ADDRESS_BYTES, " bytes but received ").concat(ethAddress.length, " bytes"));
+    assert(ethAddress.length === ETHEREUM_ADDRESS_BYTES, `Address must be ${ETHEREUM_ADDRESS_BYTES} bytes but received ${ethAddress.length} bytes`);
     const dataStart = 1 + SIGNATURE_OFFSETS_SERIALIZED_SIZE;
     const ethAddressOffset = dataStart;
     const signatureOffset = dataStart + ethAddress.length;
@@ -8356,13 +8328,13 @@ class Secp256k1Program {
       message,
       instructionIndex
     } = params;
-    assert(pkey.length === PRIVATE_KEY_BYTES, "Private key must be ".concat(PRIVATE_KEY_BYTES, " bytes but received ").concat(pkey.length, " bytes"));
+    assert(pkey.length === PRIVATE_KEY_BYTES, `Private key must be ${PRIVATE_KEY_BYTES} bytes but received ${pkey.length} bytes`);
 
     try {
       const privateKey = toBuffer(pkey);
       const publicKey = publicKeyCreate(privateKey, false).slice(1); // throw away leading byte
 
-      const messageHash = Buffer.from(keccak_256.update(toBuffer(message)).digest());
+      const messageHash = Buffer.from(sha3.keccak_256.update(toBuffer(message)).digest());
       const {
         signature,
         recid: recoveryId
@@ -8375,13 +8347,12 @@ class Secp256k1Program {
         instructionIndex
       });
     } catch (error) {
-      throw new Error("Error creating instruction; ".concat(error));
+      throw new Error(`Error creating instruction; ${error}`);
     }
   }
 
 }
-
-_defineProperty(Secp256k1Program, "programId", new PublicKey('KeccakSecp256k11111111111111111111111111111'));
+Secp256k1Program.programId = new PublicKey('KeccakSecp256k11111111111111111111111111111');
 
 const VALIDATOR_INFO_KEY = new PublicKey('Va1idator1nfo111111111111111111111111111111');
 /**
@@ -8414,10 +8385,8 @@ class ValidatorInfo {
    * @param info validator information
    */
   constructor(key, info) {
-    _defineProperty(this, "key", void 0);
-
-    _defineProperty(this, "info", void 0);
-
+    this.key = void 0;
+    this.info = void 0;
     this.key = key;
     this.info = info;
   }
@@ -8469,9 +8438,10 @@ const VOTE_PROGRAM_ID = new PublicKey('Vote1111111111111111111111111111111111111
  *
  * @internal
  */
-const VoteAccountLayout = BufferLayout.struct([publicKey('nodePubkey'), publicKey('authorizedVoterPubkey'), publicKey('authorizedWithdrawerPubkey'), BufferLayout.u8('commission'), BufferLayout.nu64(), // votes.length
-BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64('slot'), BufferLayout.u32('confirmationCount')]), BufferLayout.offset(BufferLayout.u32(), -8), 'votes'), BufferLayout.u8('rootSlotValid'), BufferLayout.nu64('rootSlot'), BufferLayout.nu64('epoch'), BufferLayout.nu64('credits'), BufferLayout.nu64('lastEpochCredits'), BufferLayout.nu64(), // epochCredits.length
-BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64('epoch'), BufferLayout.nu64('credits'), BufferLayout.nu64('prevCredits')]), BufferLayout.offset(BufferLayout.u32(), -8), 'epochCredits')]);
+const VoteAccountLayout = BufferLayout.struct([publicKey('nodePubkey'), publicKey('authorizedWithdrawer'), BufferLayout.u8('commission'), BufferLayout.nu64(), // votes.length
+BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64('slot'), BufferLayout.u32('confirmationCount')]), BufferLayout.offset(BufferLayout.u32(), -8), 'votes'), BufferLayout.u8('rootSlotValid'), BufferLayout.nu64('rootSlot'), BufferLayout.nu64(), // authorizedVoters.length
+BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64('epoch'), publicKey('authorizedVoter')]), BufferLayout.offset(BufferLayout.u32(), -8), 'authorizedVoters'), BufferLayout.struct([BufferLayout.seq(BufferLayout.struct([publicKey('authorizedPubkey'), BufferLayout.nu64('epochOfLastAuthorizedSwitch'), BufferLayout.nu64('targetEpoch')]), 32, 'buf'), BufferLayout.nu64('idx'), BufferLayout.u8('isEmpty')], 'priorVoters'), BufferLayout.nu64(), // epochCredits.length
+BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64('epoch'), BufferLayout.nu64('credits'), BufferLayout.nu64('prevCredits')]), BufferLayout.offset(BufferLayout.u32(), -8), 'epochCredits'), BufferLayout.struct([BufferLayout.nu64('slot'), BufferLayout.nu64('timestamp')], 'lastTimestamp')]);
 
 /**
  * VoteAccount class
@@ -8481,36 +8451,24 @@ class VoteAccount {
    * @internal
    */
   constructor(args) {
-    _defineProperty(this, "nodePubkey", void 0);
-
-    _defineProperty(this, "authorizedVoterPubkey", void 0);
-
-    _defineProperty(this, "authorizedWithdrawerPubkey", void 0);
-
-    _defineProperty(this, "commission", void 0);
-
-    _defineProperty(this, "votes", void 0);
-
-    _defineProperty(this, "rootSlot", void 0);
-
-    _defineProperty(this, "epoch", void 0);
-
-    _defineProperty(this, "credits", void 0);
-
-    _defineProperty(this, "lastEpochCredits", void 0);
-
-    _defineProperty(this, "epochCredits", void 0);
-
+    this.nodePubkey = void 0;
+    this.authorizedWithdrawer = void 0;
+    this.commission = void 0;
+    this.rootSlot = void 0;
+    this.votes = void 0;
+    this.authorizedVoters = void 0;
+    this.priorVoters = void 0;
+    this.epochCredits = void 0;
+    this.lastTimestamp = void 0;
     this.nodePubkey = args.nodePubkey;
-    this.authorizedVoterPubkey = args.authorizedVoterPubkey;
-    this.authorizedWithdrawerPubkey = args.authorizedWithdrawerPubkey;
+    this.authorizedWithdrawer = args.authorizedWithdrawer;
     this.commission = args.commission;
-    this.votes = args.votes;
     this.rootSlot = args.rootSlot;
-    this.epoch = args.epoch;
-    this.credits = args.credits;
-    this.lastEpochCredits = args.lastEpochCredits;
+    this.votes = args.votes;
+    this.authorizedVoters = args.authorizedVoters;
+    this.priorVoters = args.priorVoters;
     this.epochCredits = args.epochCredits;
+    this.lastTimestamp = args.lastTimestamp;
   }
   /**
    * Deserialize VoteAccount from the account data.
@@ -8521,7 +8479,8 @@ class VoteAccount {
 
 
   static fromAccountData(buffer) {
-    const va = VoteAccountLayout.decode(toBuffer(buffer), 0);
+    const versionOffset = 4;
+    const va = VoteAccountLayout.decode(toBuffer(buffer), versionOffset);
     let rootSlot = va.rootSlot;
 
     if (!va.rootSlotValid) {
@@ -8530,20 +8489,53 @@ class VoteAccount {
 
     return new VoteAccount({
       nodePubkey: new PublicKey(va.nodePubkey),
-      authorizedVoterPubkey: new PublicKey(va.authorizedVoterPubkey),
-      authorizedWithdrawerPubkey: new PublicKey(va.authorizedWithdrawerPubkey),
+      authorizedWithdrawer: new PublicKey(va.authorizedWithdrawer),
       commission: va.commission,
       votes: va.votes,
       rootSlot,
-      epoch: va.epoch,
-      credits: va.credits,
-      lastEpochCredits: va.lastEpochCredits,
-      epochCredits: va.epochCredits
+      authorizedVoters: va.authorizedVoters.map(parseAuthorizedVoter),
+      priorVoters: getPriorVoters(va.priorVoters),
+      epochCredits: va.epochCredits,
+      lastTimestamp: va.lastTimestamp
     });
   }
 
 }
 
+function parseAuthorizedVoter({
+  epoch,
+  authorizedVoter
+}) {
+  return {
+    epoch,
+    authorizedVoter: new PublicKey(authorizedVoter)
+  };
+}
+
+function parsePriorVoters({
+  authorizedPubkey,
+  epochOfLastAuthorizedSwitch,
+  targetEpoch
+}) {
+  return {
+    authorizedPubkey: new PublicKey(authorizedPubkey),
+    epochOfLastAuthorizedSwitch,
+    targetEpoch
+  };
+}
+
+function getPriorVoters({
+  buf,
+  idx,
+  isEmpty
+}) {
+  if (isEmpty) {
+    return [];
+  }
+
+  return [...buf.slice(idx + 1).map(parsePriorVoters), ...buf.slice(0, idx)];
+}
+
 /**
  * Send and confirm a raw transaction
  *
@@ -8563,7 +8555,7 @@ async function sendAndConfirmRawTransaction(connection, rawTransaction, options)
   const status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
 
   if (status.err) {
-    throw new Error("Raw transaction ".concat(signature, " failed (").concat(JSON.stringify(status), ")"));
+    throw new Error(`Raw transaction ${signature} failed (${JSON.stringify(status)})`);
   }
 
   return signature;
@@ -8595,7 +8587,7 @@ function clusterApiUrl(cluster, tls) {
   const url = endpoint[key][cluster];
 
   if (!url) {
-    throw new Error("Unknown ".concat(key, " cluster: ").concat(cluster));
+    throw new Error(`Unknown ${key} cluster: ${cluster}`);
   }
 
   return url;
@@ -8607,5 +8599,5 @@ function clusterApiUrl(cluster, tls) {
 
 const LAMPORTS_PER_SOL = 1000000000;
 
-export { Account, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PublicKey, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionInstruction, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
+export { Account, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, Loader, Lockup, MAX_SEED_LENGTH, Message, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PublicKey, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionInstruction, VALIDATOR_INFO_KEY, VOTE_PROGRAM_ID, ValidatorInfo, VoteAccount, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
 //# sourceMappingURL=index.esm.js.map