@solana/web3.js 0.0.0-development → 0.0.0-pr-29130

package/lib/index.browser.cjs.js

@@ -2,17 +2,21 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var nacl = require('tweetnacl');
 var buffer = require('buffer');
+var sha512 = require('@noble/hashes/sha512');
+var ed25519 = require('@noble/ed25519');
 var BN = require('bn.js');
 var bs58 = require('bs58');
+var sha256 = require('@noble/hashes/sha256');
 var borsh = require('borsh');
 var BufferLayout = require('@solana/buffer-layout');
 var bigintBuffer = require('bigint-buffer');
 var superstruct = require('superstruct');
 var rpcWebsockets = require('rpc-websockets');
 var RpcClient = require('jayson/lib/client/browser');
-var sha3 = require('js-sha3');
+var sha3 = require('@noble/hashes/sha3');
+var hmac = require('@noble/hashes/hmac');
+var secp256k1 = require('@noble/secp256k1');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -34,12 +38,46 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var nacl__default = /*#__PURE__*/_interopDefaultLegacy(nacl);
+var ed25519__namespace = /*#__PURE__*/_interopNamespace(ed25519);
 var BN__default = /*#__PURE__*/_interopDefaultLegacy(BN);
 var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
 var BufferLayout__namespace = /*#__PURE__*/_interopNamespace(BufferLayout);
 var RpcClient__default = /*#__PURE__*/_interopDefaultLegacy(RpcClient);
-var sha3__default = /*#__PURE__*/_interopDefaultLegacy(sha3);
+var secp256k1__namespace = /*#__PURE__*/_interopNamespace(secp256k1);
+
+/**
+ * A 64 byte secret key, the first 32 bytes of which is the
+ * private scalar and the last 32 bytes is the public key.
+ * Read more: https://blog.mozilla.org/warner/2011/11/29/ed25519-keys/
+ */
+
+ed25519__namespace.utils.sha512Sync = (...m) => sha512.sha512(ed25519__namespace.utils.concatBytes(...m));
+
+const generatePrivateKey = ed25519__namespace.utils.randomPrivateKey;
+const generateKeypair = () => {
+  const privateScalar = ed25519__namespace.utils.randomPrivateKey();
+  const publicKey = getPublicKey(privateScalar);
+  const secretKey = new Uint8Array(64);
+  secretKey.set(privateScalar);
+  secretKey.set(publicKey, 32);
+  return {
+    publicKey,
+    secretKey
+  };
+};
+const getPublicKey = ed25519__namespace.sync.getPublicKey;
+function isOnCurve(publicKey) {
+  try {
+    ed25519__namespace.Point.fromHex(publicKey, true
+    /* strict */
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+const sign = (message, secretKey) => ed25519__namespace.sync.sign(message, secretKey.slice(0, 32));
+const verify = ed25519__namespace.sync.verify;
 
 const toBuffer = arr => {
   if (buffer.Buffer.isBuffer(arr)) {
@@ -51,298 +89,6 @@ const toBuffer = arr => {
   }
 };
 
-function number(n) {
-    if (!Number.isSafeInteger(n) || n < 0)
-        throw new Error(`Wrong positive integer: ${n}`);
-}
-function bool(b) {
-    if (typeof b !== 'boolean')
-        throw new Error(`Expected boolean, not ${b}`);
-}
-function bytes(b, ...lengths) {
-    if (!(b instanceof Uint8Array))
-        throw new TypeError('Expected Uint8Array');
-    if (lengths.length > 0 && !lengths.includes(b.length))
-        throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
-}
-function hash(hash) {
-    if (typeof hash !== 'function' || typeof hash.create !== 'function')
-        throw new Error('Hash should be wrapped by utils.wrapConstructor');
-    number(hash.outputLen);
-    number(hash.blockLen);
-}
-function exists(instance, checkFinished = true) {
-    if (instance.destroyed)
-        throw new Error('Hash instance has been destroyed');
-    if (checkFinished && instance.finished)
-        throw new Error('Hash#digest() has already been called');
-}
-function output(out, instance) {
-    bytes(out);
-    const min = instance.outputLen;
-    if (out.length < min) {
-        throw new Error(`digestInto() expects output buffer of length at least ${min}`);
-    }
-}
-const assert$1 = {
-    number,
-    bool,
-    bytes,
-    hash,
-    exists,
-    output,
-};
-var assert$2 = assert$1;
-
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-// Cast array to view
-const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-// The rotate right (circular right shift) operation for uint32
-const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
-const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
-// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.
-// So, just to be sure not to corrupt anything.
-if (!isLE)
-    throw new Error('Non little-endian hardware is not supported');
-Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
-function utf8ToBytes(str) {
-    if (typeof str !== 'string') {
-        throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);
-    }
-    return new TextEncoder().encode(str);
-}
-function toBytes(data) {
-    if (typeof data === 'string')
-        data = utf8ToBytes(data);
-    if (!(data instanceof Uint8Array))
-        throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);
-    return data;
-}
-// For runtime check if class implements interface
-class Hash {
-    // Safe version that clones internal state
-    clone() {
-        return this._cloneInto();
-    }
-}
-function wrapConstructor(hashConstructor) {
-    const hashC = (message) => hashConstructor().update(toBytes(message)).digest();
-    const tmp = hashConstructor();
-    hashC.outputLen = tmp.outputLen;
-    hashC.blockLen = tmp.blockLen;
-    hashC.create = () => hashConstructor();
-    return hashC;
-}
-
-// Polyfill for Safari 14
-function setBigUint64(view, byteOffset, value, isLE) {
-    if (typeof view.setBigUint64 === 'function')
-        return view.setBigUint64(byteOffset, value, isLE);
-    const _32n = BigInt(32);
-    const _u32_max = BigInt(0xffffffff);
-    const wh = Number((value >> _32n) & _u32_max);
-    const wl = Number(value & _u32_max);
-    const h = isLE ? 4 : 0;
-    const l = isLE ? 0 : 4;
-    view.setUint32(byteOffset + h, wh, isLE);
-    view.setUint32(byteOffset + l, wl, isLE);
-}
-// Base SHA2 class (RFC 6234)
-class SHA2 extends Hash {
-    constructor(blockLen, outputLen, padOffset, isLE) {
-        super();
-        this.blockLen = blockLen;
-        this.outputLen = outputLen;
-        this.padOffset = padOffset;
-        this.isLE = isLE;
-        this.finished = false;
-        this.length = 0;
-        this.pos = 0;
-        this.destroyed = false;
-        this.buffer = new Uint8Array(blockLen);
-        this.view = createView(this.buffer);
-    }
-    update(data) {
-        assert$2.exists(this);
-        const { view, buffer, blockLen } = this;
-        data = toBytes(data);
-        const len = data.length;
-        for (let pos = 0; pos < len;) {
-            const take = Math.min(blockLen - this.pos, len - pos);
-            // Fast path: we have at least one block in input, cast it to view and process
-            if (take === blockLen) {
-                const dataView = createView(data);
-                for (; blockLen <= len - pos; pos += blockLen)
-                    this.process(dataView, pos);
-                continue;
-            }
-            buffer.set(data.subarray(pos, pos + take), this.pos);
-            this.pos += take;
-            pos += take;
-            if (this.pos === blockLen) {
-                this.process(view, 0);
-                this.pos = 0;
-            }
-        }
-        this.length += data.length;
-        this.roundClean();
-        return this;
-    }
-    digestInto(out) {
-        assert$2.exists(this);
-        assert$2.output(out, this);
-        this.finished = true;
-        // Padding
-        // We can avoid allocation of buffer for padding completely if it
-        // was previously not allocated here. But it won't change performance.
-        const { buffer, view, blockLen, isLE } = this;
-        let { pos } = this;
-        // append the bit '1' to the message
-        buffer[pos++] = 0b10000000;
-        this.buffer.subarray(pos).fill(0);
-        // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again
-        if (this.padOffset > blockLen - pos) {
-            this.process(view, 0);
-            pos = 0;
-        }
-        // Pad until full block byte with zeros
-        for (let i = pos; i < blockLen; i++)
-            buffer[i] = 0;
-        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
-        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
-        // So we just write lowest 64 bits of that value.
-        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
-        this.process(view, 0);
-        const oview = createView(out);
-        this.get().forEach((v, i) => oview.setUint32(4 * i, v, isLE));
-    }
-    digest() {
-        const { buffer, outputLen } = this;
-        this.digestInto(buffer);
-        const res = buffer.slice(0, outputLen);
-        this.destroy();
-        return res;
-    }
-    _cloneInto(to) {
-        to || (to = new this.constructor());
-        to.set(...this.get());
-        const { blockLen, buffer, length, finished, destroyed, pos } = this;
-        to.length = length;
-        to.pos = pos;
-        to.finished = finished;
-        to.destroyed = destroyed;
-        if (length % blockLen)
-            to.buffer.set(buffer);
-        return to;
-    }
-}
-
-// Choice: a ? b : c
-const Chi = (a, b, c) => (a & b) ^ (~a & c);
-// Majority function, true if any two inpust is true
-const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
-// Round constants:
-// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
-// prettier-ignore
-const SHA256_K = new Uint32Array([
-    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-]);
-// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
-// prettier-ignore
-const IV = new Uint32Array([
-    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
-]);
-// Temporary buffer, not used to store anything between runs
-// Named this way because it matches specification.
-const SHA256_W = new Uint32Array(64);
-class SHA256 extends SHA2 {
-    constructor() {
-        super(64, 32, 8, false);
-        // We cannot use array here since array allows indexing by variable
-        // which means optimizer/compiler cannot use registers.
-        this.A = IV[0] | 0;
-        this.B = IV[1] | 0;
-        this.C = IV[2] | 0;
-        this.D = IV[3] | 0;
-        this.E = IV[4] | 0;
-        this.F = IV[5] | 0;
-        this.G = IV[6] | 0;
-        this.H = IV[7] | 0;
-    }
-    get() {
-        const { A, B, C, D, E, F, G, H } = this;
-        return [A, B, C, D, E, F, G, H];
-    }
-    // prettier-ignore
-    set(A, B, C, D, E, F, G, H) {
-        this.A = A | 0;
-        this.B = B | 0;
-        this.C = C | 0;
-        this.D = D | 0;
-        this.E = E | 0;
-        this.F = F | 0;
-        this.G = G | 0;
-        this.H = H | 0;
-    }
-    process(view, offset) {
-        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
-        for (let i = 0; i < 16; i++, offset += 4)
-            SHA256_W[i] = view.getUint32(offset, false);
-        for (let i = 16; i < 64; i++) {
-            const W15 = SHA256_W[i - 15];
-            const W2 = SHA256_W[i - 2];
-            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
-            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
-            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
-        }
-        // Compression function main loop, 64 rounds
-        let { A, B, C, D, E, F, G, H } = this;
-        for (let i = 0; i < 64; i++) {
-            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
-            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-            const T2 = (sigma0 + Maj(A, B, C)) | 0;
-            H = G;
-            G = F;
-            F = E;
-            E = (D + T1) | 0;
-            D = C;
-            C = B;
-            B = A;
-            A = (T1 + T2) | 0;
-        }
-        // Add the compressed chunk to the current hash value
-        A = (A + this.A) | 0;
-        B = (B + this.B) | 0;
-        C = (C + this.C) | 0;
-        D = (D + this.D) | 0;
-        E = (E + this.E) | 0;
-        F = (F + this.F) | 0;
-        G = (G + this.G) | 0;
-        H = (H + this.H) | 0;
-        this.set(A, B, C, D, E, F, G, H);
-    }
-    roundClean() {
-        SHA256_W.fill(0);
-    }
-    destroy() {
-        this.set(0, 0, 0, 0, 0, 0, 0, 0);
-        this.buffer.fill(0);
-    }
-}
-/**
- * SHA2-256 hash function
- * @param message - data that would be hashed
- */
-const sha256 = wrapConstructor(() => new SHA256());
-
 class Struct {
   constructor(properties) {
     Object.assign(this, properties);
@@ -396,12 +142,14 @@ const PUBLIC_KEY_LENGTH = 32;
 
 function isPublicKeyData(value) {
   return value._bn !== undefined;
-}
+} // local counter used by PublicKey.unique()
+
+
+let uniquePublicKeyCounter = 1;
 /**
  * A public key
  */
 
-
 class PublicKey extends Struct {
   /** @internal */
 
@@ -429,13 +177,24 @@ class PublicKey extends Struct {
         this._bn = new BN__default["default"](value);
       }
 
-      if (this._bn.byteLength() > 32) {
+      if (this._bn.byteLength() > PUBLIC_KEY_LENGTH) {
         throw new Error(`Invalid public key input`);
       }
     }
   }
   /**
-   * Default public key value. (All zeros)
+   * Returns a unique PublicKey for tests and benchmarks using a counter
+   */
+
+
+  static unique() {
+    const key = new PublicKey(uniquePublicKeyCounter);
+    uniquePublicKeyCounter += 1;
+    return new PublicKey(key.toBuffer());
+  }
+  /**
+   * Default public key value. The base58-encoded string representation is all ones (as seen below)
+   * The underlying BN number is 32 bytes that are all zeros
    */
 
 
@@ -500,8 +259,8 @@ class PublicKey extends Struct {
 
   static async createWithSeed(fromPublicKey, seed, programId) {
     const buffer$1 = buffer.Buffer.concat([fromPublicKey.toBuffer(), buffer.Buffer.from(seed), programId.toBuffer()]);
-    const hash = sha256(buffer$1);
-    return new PublicKey(hash);
+    const publicKeyBytes = sha256.sha256(buffer$1);
+    return new PublicKey(publicKeyBytes);
   }
   /**
    * Derive a program address from seeds and a program ID.
@@ -520,10 +279,9 @@ class PublicKey extends Struct {
       buffer$1 = buffer.Buffer.concat([buffer$1, toBuffer(seed)]);
     });
     buffer$1 = buffer.Buffer.concat([buffer$1, programId.toBuffer(), buffer.Buffer.from('ProgramDerivedAddress')]);
-    const hash = sha256(buffer$1);
-    let publicKeyBytes = new BN__default["default"](hash, 16).toArray(undefined, 32);
+    const publicKeyBytes = sha256.sha256(buffer$1);
 
-    if (is_on_curve(publicKeyBytes)) {
+    if (isOnCurve(publicKeyBytes)) {
       throw new Error(`Invalid seeds, address must fall off the curve`);
     }
 
@@ -532,6 +290,8 @@ class PublicKey extends Struct {
   /**
    * Async version of createProgramAddressSync
    * For backwards compatibility
+   *
+   * @deprecated Use {@link createProgramAddressSync} instead
    */
 
   /* eslint-disable require-await */
@@ -574,6 +334,8 @@ class PublicKey extends Struct {
   /**
    * Async version of findProgramAddressSync
    * For backwards compatibility
+   *
+   * @deprecated Use {@link findProgramAddressSync} instead
    */
 
 
@@ -587,7 +349,7 @@ class PublicKey extends Struct {
 
   static isOnCurve(pubkeyData) {
     const pubkey = new PublicKey(pubkeyData);
-    return is_on_curve(pubkey.toBytes()) == 1;
+    return isOnCurve(pubkey.toBytes());
   }
 
 }
@@ -595,56 +357,7 @@ PublicKey.default = new PublicKey('11111111111111111111111111111111');
 SOLANA_SCHEMA.set(PublicKey, {
   kind: 'struct',
   fields: [['_bn', 'u256']]
-}); // @ts-ignore
-
-let naclLowLevel = nacl__default["default"].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
-
-function is_on_curve(p) {
-  var r = [naclLowLevel.gf(), naclLowLevel.gf(), naclLowLevel.gf(), naclLowLevel.gf()];
-  var t = naclLowLevel.gf(),
-      chk = naclLowLevel.gf(),
-      num = naclLowLevel.gf(),
-      den = naclLowLevel.gf(),
-      den2 = naclLowLevel.gf(),
-      den4 = naclLowLevel.gf(),
-      den6 = naclLowLevel.gf();
-  naclLowLevel.set25519(r[2], gf1);
-  naclLowLevel.unpack25519(r[1], p);
-  naclLowLevel.S(num, r[1]);
-  naclLowLevel.M(den, num, naclLowLevel.D);
-  naclLowLevel.Z(num, num, r[2]);
-  naclLowLevel.A(den, r[2], den);
-  naclLowLevel.S(den2, den);
-  naclLowLevel.S(den4, den2);
-  naclLowLevel.M(den6, den4, den2);
-  naclLowLevel.M(t, den6, num);
-  naclLowLevel.M(t, t, den);
-  naclLowLevel.pow2523(t, t);
-  naclLowLevel.M(t, t, num);
-  naclLowLevel.M(t, t, den);
-  naclLowLevel.M(t, t, den);
-  naclLowLevel.M(r[0], t, den);
-  naclLowLevel.S(chk, r[0]);
-  naclLowLevel.M(chk, chk, den);
-  if (neq25519(chk, num)) naclLowLevel.M(r[0], r[0], I);
-  naclLowLevel.S(chk, r[0]);
-  naclLowLevel.M(chk, chk, den);
-  if (neq25519(chk, num)) return 0;
-  return 1;
-}
-
-let gf1 = naclLowLevel.gf([1]);
-let I = naclLowLevel.gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]);
-
-function neq25519(a, b) {
-  var c = new Uint8Array(32),
-      d = new Uint8Array(32);
-  naclLowLevel.pack25519(c, a);
-  naclLowLevel.pack25519(d, b);
-  return naclLowLevel.crypto_verify_32(c, 0, d, 0);
-}
+});
 
 /**
  * An account key pair (public and secret keys).
@@ -655,6 +368,8 @@ function neq25519(a, b) {
 class Account {
   /** @internal */
 
+  /** @internal */
+
   /**
    * Create a new Account object
    *
@@ -664,12 +379,21 @@ class Account {
    * @param secretKey Secret key for the account
    */
   constructor(secretKey) {
-    this._keypair = void 0;
+    this._publicKey = void 0;
+    this._secretKey = void 0;
 
     if (secretKey) {
-      this._keypair = nacl__default["default"].sign.keyPair.fromSecretKey(toBuffer(secretKey));
+      const secretKeyBuffer = toBuffer(secretKey);
+
+      if (secretKey.length !== 64) {
+        throw new Error('bad secret key size');
+      }
+
+      this._publicKey = secretKeyBuffer.slice(32, 64);
+      this._secretKey = secretKeyBuffer.slice(0, 32);
     } else {
-      this._keypair = nacl__default["default"].sign.keyPair();
+      this._secretKey = toBuffer(generatePrivateKey());
+      this._publicKey = toBuffer(getPublicKey(this._secretKey));
     }
   }
   /**
@@ -678,15 +402,17 @@ class Account {
 
 
   get publicKey() {
-    return new PublicKey(this._keypair.publicKey);
+    return new PublicKey(this._publicKey);
   }
   /**
-   * The **unencrypted** secret key for this account
+   * The **unencrypted** secret key for this account. The first 32 bytes
+   * is the private scalar and the last 32 bytes is the public key.
+   * Read more: https://blog.mozilla.org/warner/2011/11/29/ed25519-keys/
    */
 
 
   get secretKey() {
-    return toBuffer(this._keypair.secretKey);
+    return buffer.Buffer.concat([this._secretKey, this._publicKey], 64);
   }
 
 }
@@ -701,6 +427,7 @@ const BPF_LOADER_DEPRECATED_PROGRAM_ID = new PublicKey('BPFLoader111111111111111
  * 8 bytes is the size of the fragment header
  */
 const PACKET_DATA_SIZE = 1280 - 40 - 8;
+const VERSION_PREFIX_MASK = 0x7f;
 const SIGNATURE_LENGTH_IN_BYTES = 64;
 
 class TransactionExpiredBlockheightExceededError extends Error {
@@ -725,14 +452,96 @@ class TransactionExpiredTimeoutError extends Error {
 Object.defineProperty(TransactionExpiredTimeoutError.prototype, 'name', {
   value: 'TransactionExpiredTimeoutError'
 });
+class TransactionExpiredNonceInvalidError extends Error {
+  constructor(signature) {
+    super(`Signature ${signature} has expired: the nonce is no longer valid.`);
+    this.signature = void 0;
+    this.signature = signature;
+  }
+
+}
+Object.defineProperty(TransactionExpiredNonceInvalidError.prototype, 'name', {
+  value: 'TransactionExpiredNonceInvalidError'
+});
+
+class MessageAccountKeys {
+  constructor(staticAccountKeys, accountKeysFromLookups) {
+    this.staticAccountKeys = void 0;
+    this.accountKeysFromLookups = void 0;
+    this.staticAccountKeys = staticAccountKeys;
+    this.accountKeysFromLookups = accountKeysFromLookups;
+  }
+
+  keySegments() {
+    const keySegments = [this.staticAccountKeys];
+
+    if (this.accountKeysFromLookups) {
+      keySegments.push(this.accountKeysFromLookups.writable);
+      keySegments.push(this.accountKeysFromLookups.readonly);
+    }
+
+    return keySegments;
+  }
+
+  get(index) {
+    for (const keySegment of this.keySegments()) {
+      if (index < keySegment.length) {
+        return keySegment[index];
+      } else {
+        index -= keySegment.length;
+      }
+    }
+
+    return;
+  }
+
+  get length() {
+    return this.keySegments().flat().length;
+  }
+
+  compileInstructions(instructions) {
+    // Bail early if any account indexes would overflow a u8
+    const U8_MAX = 255;
+
+    if (this.length > U8_MAX + 1) {
+      throw new Error('Account index overflow encountered during compilation');
+    }
+
+    const keyIndexMap = new Map();
+    this.keySegments().flat().forEach((key, index) => {
+      keyIndexMap.set(key.toBase58(), index);
+    });
+
+    const findKeyIndex = key => {
+      const keyIndex = keyIndexMap.get(key.toBase58());
+      if (keyIndex === undefined) throw new Error('Encountered an unknown instruction account key during compilation');
+      return keyIndex;
+    };
+
+    return instructions.map(instruction => {
+      return {
+        programIdIndex: findKeyIndex(instruction.programId),
+        accountKeyIndexes: instruction.keys.map(meta => findKeyIndex(meta.pubkey)),
+        data: instruction.data
+      };
+    });
+  }
+
+}
 
 /**
  * Layout for a public key
  */
-
 const publicKey = (property = 'publicKey') => {
   return BufferLayout__namespace.blob(32, property);
 };
+/**
+ * Layout for a signature
+ */
+
+const signature = (property = 'signature') => {
+  return BufferLayout__namespace.blob(64, property);
+};
 
 /**
  * Layout for a Rust String type
@@ -786,6 +595,13 @@ const lockup = (property = 'lockup') => {
 const voteInit = (property = 'voteInit') => {
   return BufferLayout__namespace.struct([publicKey('nodePubkey'), publicKey('authorizedVoter'), publicKey('authorizedWithdrawer'), BufferLayout__namespace.u8('commission')], property);
 };
+/**
+ *  Layout for a VoteAuthorizeWithSeedArgs object
+ */
+
+const voteAuthorizeWithSeedArgs = (property = 'voteAuthorizeWithSeedArgs') => {
+  return BufferLayout__namespace.struct([BufferLayout__namespace.u32('voteAuthorizationType'), publicKey('currentAuthorityDerivedKeyOwnerPubkey'), rustString('currentAuthorityDerivedKeySeed'), publicKey('newAuthorized')], property);
+};
 function getAlloc(type, fields) {
   const getItemAlloc = item => {
     if (item.span >= 0) {
@@ -798,6 +614,11 @@ function getAlloc(type, fields) {
       if (Array.isArray(field)) {
         return field.length * getItemAlloc(item.elementLayout);
       }
+    } else if ('fields' in item) {
+      // This is a `Structure` whose size needs to be recursively measured.
+      return getAlloc({
+        layout: item
+      }, fields[item.property]);
     } // Couldn't determine allocated size of layout
 
 
@@ -844,6 +665,129 @@ function encodeLength(bytes, len) {
   }
 }
 
+function assert (condition, message) {
+  if (!condition) {
+    throw new Error(message || 'Assertion failed');
+  }
+}
+
+class CompiledKeys {
+  constructor(payer, keyMetaMap) {
+    this.payer = void 0;
+    this.keyMetaMap = void 0;
+    this.payer = payer;
+    this.keyMetaMap = keyMetaMap;
+  }
+
+  static compile(instructions, payer) {
+    const keyMetaMap = new Map();
+
+    const getOrInsertDefault = pubkey => {
+      const address = pubkey.toBase58();
+      let keyMeta = keyMetaMap.get(address);
+
+      if (keyMeta === undefined) {
+        keyMeta = {
+          isSigner: false,
+          isWritable: false,
+          isInvoked: false
+        };
+        keyMetaMap.set(address, keyMeta);
+      }
+
+      return keyMeta;
+    };
+
+    const payerKeyMeta = getOrInsertDefault(payer);
+    payerKeyMeta.isSigner = true;
+    payerKeyMeta.isWritable = true;
+
+    for (const ix of instructions) {
+      getOrInsertDefault(ix.programId).isInvoked = true;
+
+      for (const accountMeta of ix.keys) {
+        const keyMeta = getOrInsertDefault(accountMeta.pubkey);
+        keyMeta.isSigner || (keyMeta.isSigner = accountMeta.isSigner);
+        keyMeta.isWritable || (keyMeta.isWritable = accountMeta.isWritable);
+      }
+    }
+
+    return new CompiledKeys(payer, keyMetaMap);
+  }
+
+  getMessageComponents() {
+    const mapEntries = [...this.keyMetaMap.entries()];
+    assert(mapEntries.length <= 256, 'Max static account keys length exceeded');
+    const writableSigners = mapEntries.filter(([, meta]) => meta.isSigner && meta.isWritable);
+    const readonlySigners = mapEntries.filter(([, meta]) => meta.isSigner && !meta.isWritable);
+    const writableNonSigners = mapEntries.filter(([, meta]) => !meta.isSigner && meta.isWritable);
+    const readonlyNonSigners = mapEntries.filter(([, meta]) => !meta.isSigner && !meta.isWritable);
+    const header = {
+      numRequiredSignatures: writableSigners.length + readonlySigners.length,
+      numReadonlySignedAccounts: readonlySigners.length,
+      numReadonlyUnsignedAccounts: readonlyNonSigners.length
+    }; // sanity checks
+
+    {
+      assert(writableSigners.length > 0, 'Expected at least one writable signer key');
+      const [payerAddress] = writableSigners[0];
+      assert(payerAddress === this.payer.toBase58(), 'Expected first writable signer key to be the fee payer');
+    }
+    const staticAccountKeys = [...writableSigners.map(([address]) => new PublicKey(address)), ...readonlySigners.map(([address]) => new PublicKey(address)), ...writableNonSigners.map(([address]) => new PublicKey(address)), ...readonlyNonSigners.map(([address]) => new PublicKey(address))];
+    return [header, staticAccountKeys];
+  }
+
+  extractTableLookup(lookupTable) {
+    const [writableIndexes, drainedWritableKeys] = this.drainKeysFoundInLookupTable(lookupTable.state.addresses, keyMeta => !keyMeta.isSigner && !keyMeta.isInvoked && keyMeta.isWritable);
+    const [readonlyIndexes, drainedReadonlyKeys] = this.drainKeysFoundInLookupTable(lookupTable.state.addresses, keyMeta => !keyMeta.isSigner && !keyMeta.isInvoked && !keyMeta.isWritable); // Don't extract lookup if no keys were found
+
+    if (writableIndexes.length === 0 && readonlyIndexes.length === 0) {
+      return;
+    }
+
+    return [{
+      accountKey: lookupTable.key,
+      writableIndexes,
+      readonlyIndexes
+    }, {
+      writable: drainedWritableKeys,
+      readonly: drainedReadonlyKeys
+    }];
+  }
+  /** @internal */
+
+
+  drainKeysFoundInLookupTable(lookupTableEntries, keyMetaFilter) {
+    const lookupTableIndexes = new Array();
+    const drainedKeys = new Array();
+
+    for (const [address, keyMeta] of this.keyMetaMap.entries()) {
+      if (keyMetaFilter(keyMeta)) {
+        const key = new PublicKey(address);
+        const lookupTableIndex = lookupTableEntries.findIndex(entry => entry.equals(key));
+
+        if (lookupTableIndex >= 0) {
+          assert(lookupTableIndex < 256, 'Max lookup table index exceeded');
+          lookupTableIndexes.push(lookupTableIndex);
+          drainedKeys.push(key);
+          this.keyMetaMap.delete(address);
+        }
+      }
+    }
+
+    return [lookupTableIndexes, drainedKeys];
+  }
+
+}
+
+/**
+ * An instruction to execute by a program
+ *
+ * @property {number} programIdIndex
+ * @property {number[]} accounts
+ * @property {string} data
+ */
+
 /**
  * List of instructions to be processed atomically
  */
@@ -861,12 +805,63 @@ class Message {
     this.instructions.forEach(ix => this.indexToProgramIds.set(ix.programIdIndex, this.accountKeys[ix.programIdIndex]));
   }
 
+  get version() {
+    return 'legacy';
+  }
+
+  get staticAccountKeys() {
+    return this.accountKeys;
+  }
+
+  get compiledInstructions() {
+    return this.instructions.map(ix => ({
+      programIdIndex: ix.programIdIndex,
+      accountKeyIndexes: ix.accounts,
+      data: bs58__default["default"].decode(ix.data)
+    }));
+  }
+
+  get addressTableLookups() {
+    return [];
+  }
+
+  getAccountKeys() {
+    return new MessageAccountKeys(this.staticAccountKeys);
+  }
+
+  static compile(args) {
+    const compiledKeys = CompiledKeys.compile(args.instructions, args.payerKey);
+    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+    const accountKeys = new MessageAccountKeys(staticAccountKeys);
+    const instructions = accountKeys.compileInstructions(args.instructions).map(ix => ({
+      programIdIndex: ix.programIdIndex,
+      accounts: ix.accountKeyIndexes,
+      data: bs58__default["default"].encode(ix.data)
+    }));
+    return new Message({
+      header,
+      accountKeys: staticAccountKeys,
+      recentBlockhash: args.recentBlockhash,
+      instructions
+    });
+  }
+
   isAccountSigner(index) {
     return index < this.header.numRequiredSignatures;
   }
 
   isAccountWritable(index) {
-    return index < this.header.numRequiredSignatures - this.header.numReadonlySignedAccounts || index >= this.header.numRequiredSignatures && index < this.accountKeys.length - this.header.numReadonlyUnsignedAccounts;
+    const numSignedAccounts = this.header.numRequiredSignatures;
+
+    if (index >= this.header.numRequiredSignatures) {
+      const unsignedAccountIndex = index - numSignedAccounts;
+      const numUnsignedAccounts = this.accountKeys.length - numSignedAccounts;
+      const numWritableUnsignedAccounts = numUnsignedAccounts - this.header.numReadonlyUnsignedAccounts;
+      return unsignedAccountIndex < numWritableUnsignedAccounts;
+    } else {
+      const numWritableSignedAccounts = numSignedAccounts - this.header.numReadonlySignedAccounts;
+      return index < numWritableSignedAccounts;
+    }
   }
 
   isProgramId(index) {
@@ -937,6 +932,11 @@ class Message {
     // Slice up wire data
     let byteArray = [...buffer$1];
     const numRequiredSignatures = byteArray.shift();
+
+    if (numRequiredSignatures !== (numRequiredSignatures & VERSION_PREFIX_MASK)) {
+      throw new Error('Versioned messages must be deserialized with VersionedMessage.deserialize()');
+    }
+
     const numReadonlySignedAccounts = byteArray.shift();
     const numReadonlyUnsignedAccounts = byteArray.shift();
     const accountCount = decodeLength(byteArray);
@@ -945,7 +945,7 @@ class Message {
     for (let i = 0; i < accountCount; i++) {
       const account = byteArray.slice(0, PUBLIC_KEY_LENGTH);
       byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);
-      accountKeys.push(bs58__default["default"].encode(buffer.Buffer.from(account)));
+      accountKeys.push(new PublicKey(buffer.Buffer.from(account)));
     }
 
     const recentBlockhash = byteArray.slice(0, PUBLIC_KEY_LENGTH);
@@ -984,12 +984,313 @@ class Message {
 
 }
 
-function assert (condition, message) {
-  if (!condition) {
-    throw new Error(message || 'Assertion failed');
+/**
+ * Message constructor arguments
+ */
+
+class MessageV0 {
+  constructor(args) {
+    this.header = void 0;
+    this.staticAccountKeys = void 0;
+    this.recentBlockhash = void 0;
+    this.compiledInstructions = void 0;
+    this.addressTableLookups = void 0;
+    this.header = args.header;
+    this.staticAccountKeys = args.staticAccountKeys;
+    this.recentBlockhash = args.recentBlockhash;
+    this.compiledInstructions = args.compiledInstructions;
+    this.addressTableLookups = args.addressTableLookups;
   }
+
+  get version() {
+    return 0;
+  }
+
+  get numAccountKeysFromLookups() {
+    let count = 0;
+
+    for (const lookup of this.addressTableLookups) {
+      count += lookup.readonlyIndexes.length + lookup.writableIndexes.length;
+    }
+
+    return count;
+  }
+
+  getAccountKeys(args) {
+    let accountKeysFromLookups;
+
+    if (args && 'accountKeysFromLookups' in args && args.accountKeysFromLookups) {
+      if (this.numAccountKeysFromLookups != args.accountKeysFromLookups.writable.length + args.accountKeysFromLookups.readonly.length) {
+        throw new Error('Failed to get account keys because of a mismatch in the number of account keys from lookups');
+      }
+
+      accountKeysFromLookups = args.accountKeysFromLookups;
+    } else if (args && 'addressLookupTableAccounts' in args && args.addressLookupTableAccounts) {
+      accountKeysFromLookups = this.resolveAddressTableLookups(args.addressLookupTableAccounts);
+    } else if (this.addressTableLookups.length > 0) {
+      throw new Error('Failed to get account keys because address table lookups were not resolved');
+    }
+
+    return new MessageAccountKeys(this.staticAccountKeys, accountKeysFromLookups);
+  }
+
+  isAccountSigner(index) {
+    return index < this.header.numRequiredSignatures;
+  }
+
+  isAccountWritable(index) {
+    const numSignedAccounts = this.header.numRequiredSignatures;
+    const numStaticAccountKeys = this.staticAccountKeys.length;
+
+    if (index >= numStaticAccountKeys) {
+      const lookupAccountKeysIndex = index - numStaticAccountKeys;
+      const numWritableLookupAccountKeys = this.addressTableLookups.reduce((count, lookup) => count + lookup.writableIndexes.length, 0);
+      return lookupAccountKeysIndex < numWritableLookupAccountKeys;
+    } else if (index >= this.header.numRequiredSignatures) {
+      const unsignedAccountIndex = index - numSignedAccounts;
+      const numUnsignedAccounts = numStaticAccountKeys - numSignedAccounts;
+      const numWritableUnsignedAccounts = numUnsignedAccounts - this.header.numReadonlyUnsignedAccounts;
+      return unsignedAccountIndex < numWritableUnsignedAccounts;
+    } else {
+      const numWritableSignedAccounts = numSignedAccounts - this.header.numReadonlySignedAccounts;
+      return index < numWritableSignedAccounts;
+    }
+  }
+
+  resolveAddressTableLookups(addressLookupTableAccounts) {
+    const accountKeysFromLookups = {
+      writable: [],
+      readonly: []
+    };
+
+    for (const tableLookup of this.addressTableLookups) {
+      const tableAccount = addressLookupTableAccounts.find(account => account.key.equals(tableLookup.accountKey));
+
+      if (!tableAccount) {
+        throw new Error(`Failed to find address lookup table account for table key ${tableLookup.accountKey.toBase58()}`);
+      }
+
+      for (const index of tableLookup.writableIndexes) {
+        if (index < tableAccount.state.addresses.length) {
+          accountKeysFromLookups.writable.push(tableAccount.state.addresses[index]);
+        } else {
+          throw new Error(`Failed to find address for index ${index} in address lookup table ${tableLookup.accountKey.toBase58()}`);
+        }
+      }
+
+      for (const index of tableLookup.readonlyIndexes) {
+        if (index < tableAccount.state.addresses.length) {
+          accountKeysFromLookups.readonly.push(tableAccount.state.addresses[index]);
+        } else {
+          throw new Error(`Failed to find address for index ${index} in address lookup table ${tableLookup.accountKey.toBase58()}`);
+        }
+      }
+    }
+
+    return accountKeysFromLookups;
+  }
+
+  static compile(args) {
+    const compiledKeys = CompiledKeys.compile(args.instructions, args.payerKey);
+    const addressTableLookups = new Array();
+    const accountKeysFromLookups = {
+      writable: new Array(),
+      readonly: new Array()
+    };
+    const lookupTableAccounts = args.addressLookupTableAccounts || [];
+
+    for (const lookupTable of lookupTableAccounts) {
+      const extractResult = compiledKeys.extractTableLookup(lookupTable);
+
+      if (extractResult !== undefined) {
+        const [addressTableLookup, {
+          writable,
+          readonly
+        }] = extractResult;
+        addressTableLookups.push(addressTableLookup);
+        accountKeysFromLookups.writable.push(...writable);
+        accountKeysFromLookups.readonly.push(...readonly);
+      }
+    }
+
+    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+    const accountKeys = new MessageAccountKeys(staticAccountKeys, accountKeysFromLookups);
+    const compiledInstructions = accountKeys.compileInstructions(args.instructions);
+    return new MessageV0({
+      header,
+      staticAccountKeys,
+      recentBlockhash: args.recentBlockhash,
+      compiledInstructions,
+      addressTableLookups
+    });
+  }
+
+  serialize() {
+    const encodedStaticAccountKeysLength = Array();
+    encodeLength(encodedStaticAccountKeysLength, this.staticAccountKeys.length);
+    const serializedInstructions = this.serializeInstructions();
+    const encodedInstructionsLength = Array();
+    encodeLength(encodedInstructionsLength, this.compiledInstructions.length);
+    const serializedAddressTableLookups = this.serializeAddressTableLookups();
+    const encodedAddressTableLookupsLength = Array();
+    encodeLength(encodedAddressTableLookupsLength, this.addressTableLookups.length);
+    const messageLayout = BufferLayout__namespace.struct([BufferLayout__namespace.u8('prefix'), BufferLayout__namespace.struct([BufferLayout__namespace.u8('numRequiredSignatures'), BufferLayout__namespace.u8('numReadonlySignedAccounts'), BufferLayout__namespace.u8('numReadonlyUnsignedAccounts')], 'header'), BufferLayout__namespace.blob(encodedStaticAccountKeysLength.length, 'staticAccountKeysLength'), BufferLayout__namespace.seq(publicKey(), this.staticAccountKeys.length, 'staticAccountKeys'), publicKey('recentBlockhash'), BufferLayout__namespace.blob(encodedInstructionsLength.length, 'instructionsLength'), BufferLayout__namespace.blob(serializedInstructions.length, 'serializedInstructions'), BufferLayout__namespace.blob(encodedAddressTableLookupsLength.length, 'addressTableLookupsLength'), BufferLayout__namespace.blob(serializedAddressTableLookups.length, 'serializedAddressTableLookups')]);
+    const serializedMessage = new Uint8Array(PACKET_DATA_SIZE);
+    const MESSAGE_VERSION_0_PREFIX = 1 << 7;
+    const serializedMessageLength = messageLayout.encode({
+      prefix: MESSAGE_VERSION_0_PREFIX,
+      header: this.header,
+      staticAccountKeysLength: new Uint8Array(encodedStaticAccountKeysLength),
+      staticAccountKeys: this.staticAccountKeys.map(key => key.toBytes()),
+      recentBlockhash: bs58__default["default"].decode(this.recentBlockhash),
+      instructionsLength: new Uint8Array(encodedInstructionsLength),
+      serializedInstructions,
+      addressTableLookupsLength: new Uint8Array(encodedAddressTableLookupsLength),
+      serializedAddressTableLookups
+    }, serializedMessage);
+    return serializedMessage.slice(0, serializedMessageLength);
+  }
+
+  serializeInstructions() {
+    let serializedLength = 0;
+    const serializedInstructions = new Uint8Array(PACKET_DATA_SIZE);
+
+    for (const instruction of this.compiledInstructions) {
+      const encodedAccountKeyIndexesLength = Array();
+      encodeLength(encodedAccountKeyIndexesLength, instruction.accountKeyIndexes.length);
+      const encodedDataLength = Array();
+      encodeLength(encodedDataLength, instruction.data.length);
+      const instructionLayout = BufferLayout__namespace.struct([BufferLayout__namespace.u8('programIdIndex'), BufferLayout__namespace.blob(encodedAccountKeyIndexesLength.length, 'encodedAccountKeyIndexesLength'), BufferLayout__namespace.seq(BufferLayout__namespace.u8(), instruction.accountKeyIndexes.length, 'accountKeyIndexes'), BufferLayout__namespace.blob(encodedDataLength.length, 'encodedDataLength'), BufferLayout__namespace.blob(instruction.data.length, 'data')]);
+      serializedLength += instructionLayout.encode({
+        programIdIndex: instruction.programIdIndex,
+        encodedAccountKeyIndexesLength: new Uint8Array(encodedAccountKeyIndexesLength),
+        accountKeyIndexes: instruction.accountKeyIndexes,
+        encodedDataLength: new Uint8Array(encodedDataLength),
+        data: instruction.data
+      }, serializedInstructions, serializedLength);
+    }
+
+    return serializedInstructions.slice(0, serializedLength);
+  }
+
+  serializeAddressTableLookups() {
+    let serializedLength = 0;
+    const serializedAddressTableLookups = new Uint8Array(PACKET_DATA_SIZE);
+
+    for (const lookup of this.addressTableLookups) {
+      const encodedWritableIndexesLength = Array();
+      encodeLength(encodedWritableIndexesLength, lookup.writableIndexes.length);
+      const encodedReadonlyIndexesLength = Array();
+      encodeLength(encodedReadonlyIndexesLength, lookup.readonlyIndexes.length);
+      const addressTableLookupLayout = BufferLayout__namespace.struct([publicKey('accountKey'), BufferLayout__namespace.blob(encodedWritableIndexesLength.length, 'encodedWritableIndexesLength'), BufferLayout__namespace.seq(BufferLayout__namespace.u8(), lookup.writableIndexes.length, 'writableIndexes'), BufferLayout__namespace.blob(encodedReadonlyIndexesLength.length, 'encodedReadonlyIndexesLength'), BufferLayout__namespace.seq(BufferLayout__namespace.u8(), lookup.readonlyIndexes.length, 'readonlyIndexes')]);
+      serializedLength += addressTableLookupLayout.encode({
+        accountKey: lookup.accountKey.toBytes(),
+        encodedWritableIndexesLength: new Uint8Array(encodedWritableIndexesLength),
+        writableIndexes: lookup.writableIndexes,
+        encodedReadonlyIndexesLength: new Uint8Array(encodedReadonlyIndexesLength),
+        readonlyIndexes: lookup.readonlyIndexes
+      }, serializedAddressTableLookups, serializedLength);
+    }
+
+    return serializedAddressTableLookups.slice(0, serializedLength);
+  }
+
+  static deserialize(serializedMessage) {
+    let byteArray = [...serializedMessage];
+    const prefix = byteArray.shift();
+    const maskedPrefix = prefix & VERSION_PREFIX_MASK;
+    assert(prefix !== maskedPrefix, `Expected versioned message but received legacy message`);
+    const version = maskedPrefix;
+    assert(version === 0, `Expected versioned message with version 0 but found version ${version}`);
+    const header = {
+      numRequiredSignatures: byteArray.shift(),
+      numReadonlySignedAccounts: byteArray.shift(),
+      numReadonlyUnsignedAccounts: byteArray.shift()
+    };
+    const staticAccountKeys = [];
+    const staticAccountKeysLength = decodeLength(byteArray);
+
+    for (let i = 0; i < staticAccountKeysLength; i++) {
+      staticAccountKeys.push(new PublicKey(byteArray.splice(0, PUBLIC_KEY_LENGTH)));
+    }
+
+    const recentBlockhash = bs58__default["default"].encode(byteArray.splice(0, PUBLIC_KEY_LENGTH));
+    const instructionCount = decodeLength(byteArray);
+    const compiledInstructions = [];
+
+    for (let i = 0; i < instructionCount; i++) {
+      const programIdIndex = byteArray.shift();
+      const accountKeyIndexesLength = decodeLength(byteArray);
+      const accountKeyIndexes = byteArray.splice(0, accountKeyIndexesLength);
+      const dataLength = decodeLength(byteArray);
+      const data = new Uint8Array(byteArray.splice(0, dataLength));
+      compiledInstructions.push({
+        programIdIndex,
+        accountKeyIndexes,
+        data
+      });
+    }
+
+    const addressTableLookupsCount = decodeLength(byteArray);
+    const addressTableLookups = [];
+
+    for (let i = 0; i < addressTableLookupsCount; i++) {
+      const accountKey = new PublicKey(byteArray.splice(0, PUBLIC_KEY_LENGTH));
+      const writableIndexesLength = decodeLength(byteArray);
+      const writableIndexes = byteArray.splice(0, writableIndexesLength);
+      const readonlyIndexesLength = decodeLength(byteArray);
+      const readonlyIndexes = byteArray.splice(0, readonlyIndexesLength);
+      addressTableLookups.push({
+        accountKey,
+        writableIndexes,
+        readonlyIndexes
+      });
+    }
+
+    return new MessageV0({
+      header,
+      staticAccountKeys,
+      recentBlockhash,
+      compiledInstructions,
+      addressTableLookups
+    });
+  }
+
 }
 
+// eslint-disable-next-line no-redeclare
+const VersionedMessage = {
+  deserializeMessageVersion(serializedMessage) {
+    const prefix = serializedMessage[0];
+    const maskedPrefix = prefix & VERSION_PREFIX_MASK; // if the highest bit of the prefix is not set, the message is not versioned
+
+    if (maskedPrefix === prefix) {
+      return 'legacy';
+    } // the lower 7 bits of the prefix indicate the message version
+
+
+    return maskedPrefix;
+  },
+
+  deserialize: serializedMessage => {
+    const version = VersionedMessage.deserializeMessageVersion(serializedMessage);
+
+    if (version === 'legacy') {
+      return Message.from(serializedMessage);
+    }
+
+    if (version === 0) {
+      return MessageV0.deserialize(serializedMessage);
+    } else {
+      throw new Error(`Transaction message version ${version} deserialization is not supported`);
+    }
+  }
+};
+
+/**
+ * Transaction signature as base-58 encoded string
+ */
+
 exports.TransactionStatus = void 0;
 /**
  * Default (empty) signature
@@ -999,6 +1300,7 @@ exports.TransactionStatus = void 0;
   TransactionStatus[TransactionStatus["BLOCKHEIGHT_EXCEEDED"] = 0] = "BLOCKHEIGHT_EXCEEDED";
   TransactionStatus[TransactionStatus["PROCESSED"] = 1] = "PROCESSED";
   TransactionStatus[TransactionStatus["TIMED_OUT"] = 2] = "TIMED_OUT";
+  TransactionStatus[TransactionStatus["NONCE_INVALID"] = 3] = "NONCE_INVALID";
 })(exports.TransactionStatus || (exports.TransactionStatus = {}));
 
 const DEFAULT_SIGNATURE = buffer.Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
@@ -1093,6 +1395,7 @@ class Transaction {
     this.recentBlockhash = void 0;
     this.lastValidBlockHeight = void 0;
     this.nonceInfo = void 0;
+    this.minNonceContextSlot = void 0;
     this._message = void 0;
     this._json = void 0;
 
@@ -1108,7 +1411,14 @@ class Transaction {
       this.signatures = opts.signatures;
     }
 
-    if (Object.prototype.hasOwnProperty.call(opts, 'lastValidBlockHeight')) {
+    if (Object.prototype.hasOwnProperty.call(opts, 'nonceInfo')) {
+      const {
+        minContextSlot,
+        nonceInfo
+      } = opts;
+      this.minNonceContextSlot = minContextSlot;
+      this.nonceInfo = nonceInfo;
+    } else if (Object.prototype.hasOwnProperty.call(opts, 'lastValidBlockHeight')) {
       const {
         blockhash,
         lastValidBlockHeight
@@ -1515,7 +1825,7 @@ class Transaction {
   _partialSign(message, ...signers) {
     const signData = message.serialize();
     signers.forEach(signer => {
-      const signature = nacl__default["default"].sign.detached(signData, signer.secretKey);
+      const signature = sign(signData, signer.secretKey);
 
       this._addSignature(signer.publicKey, toBuffer(signature));
     });
@@ -1571,7 +1881,7 @@ class Transaction {
           return false;
         }
       } else {
-        if (!nacl__default["default"].sign.detached.verify(signData, signature, publicKey.toBuffer())) {
+        if (!verify(signature, signData, publicKey.toBytes())) {
           return false;
         }
       }
@@ -1718,6 +2028,184 @@ class Transaction {
 
 }
 
+class TransactionMessage {
+  constructor(args) {
+    this.payerKey = void 0;
+    this.instructions = void 0;
+    this.recentBlockhash = void 0;
+    this.payerKey = args.payerKey;
+    this.instructions = args.instructions;
+    this.recentBlockhash = args.recentBlockhash;
+  }
+
+  static decompile(message, args) {
+    const {
+      header,
+      compiledInstructions,
+      recentBlockhash
+    } = message;
+    const {
+      numRequiredSignatures,
+      numReadonlySignedAccounts,
+      numReadonlyUnsignedAccounts
+    } = header;
+    const numWritableSignedAccounts = numRequiredSignatures - numReadonlySignedAccounts;
+    assert(numWritableSignedAccounts > 0, 'Message header is invalid');
+    const numWritableUnsignedAccounts = message.staticAccountKeys.length - numRequiredSignatures - numReadonlyUnsignedAccounts;
+    assert(numWritableUnsignedAccounts >= 0, 'Message header is invalid');
+    const accountKeys = message.getAccountKeys(args);
+    const payerKey = accountKeys.get(0);
+
+    if (payerKey === undefined) {
+      throw new Error('Failed to decompile message because no account keys were found');
+    }
+
+    const instructions = [];
+
+    for (const compiledIx of compiledInstructions) {
+      const keys = [];
+
+      for (const keyIndex of compiledIx.accountKeyIndexes) {
+        const pubkey = accountKeys.get(keyIndex);
+
+        if (pubkey === undefined) {
+          throw new Error(`Failed to find key for account key index ${keyIndex}`);
+        }
+
+        const isSigner = keyIndex < numRequiredSignatures;
+        let isWritable;
+
+        if (isSigner) {
+          isWritable = keyIndex < numWritableSignedAccounts;
+        } else if (keyIndex < accountKeys.staticAccountKeys.length) {
+          isWritable = keyIndex - numRequiredSignatures < numWritableUnsignedAccounts;
+        } else {
+          isWritable = keyIndex - accountKeys.staticAccountKeys.length < // accountKeysFromLookups cannot be undefined because we already found a pubkey for this index above
+          accountKeys.accountKeysFromLookups.writable.length;
+        }
+
+        keys.push({
+          pubkey,
+          isSigner: keyIndex < header.numRequiredSignatures,
+          isWritable
+        });
+      }
+
+      const programId = accountKeys.get(compiledIx.programIdIndex);
+
+      if (programId === undefined) {
+        throw new Error(`Failed to find program id for program id index ${compiledIx.programIdIndex}`);
+      }
+
+      instructions.push(new TransactionInstruction({
+        programId,
+        data: toBuffer(compiledIx.data),
+        keys
+      }));
+    }
+
+    return new TransactionMessage({
+      payerKey,
+      instructions,
+      recentBlockhash
+    });
+  }
+
+  compileToLegacyMessage() {
+    return Message.compile({
+      payerKey: this.payerKey,
+      recentBlockhash: this.recentBlockhash,
+      instructions: this.instructions
+    });
+  }
+
+  compileToV0Message(addressLookupTableAccounts) {
+    return MessageV0.compile({
+      payerKey: this.payerKey,
+      recentBlockhash: this.recentBlockhash,
+      instructions: this.instructions,
+      addressLookupTableAccounts
+    });
+  }
+
+}
+
+/**
+ * Versioned transaction class
+ */
+class VersionedTransaction {
+  get version() {
+    return this.message.version;
+  }
+
+  constructor(message, signatures) {
+    this.signatures = void 0;
+    this.message = void 0;
+
+    if (signatures !== undefined) {
+      assert(signatures.length === message.header.numRequiredSignatures, 'Expected signatures length to be equal to the number of required signatures');
+      this.signatures = signatures;
+    } else {
+      const defaultSignatures = [];
+
+      for (let i = 0; i < message.header.numRequiredSignatures; i++) {
+        defaultSignatures.push(new Uint8Array(SIGNATURE_LENGTH_IN_BYTES));
+      }
+
+      this.signatures = defaultSignatures;
+    }
+
+    this.message = message;
+  }
+
+  serialize() {
+    const serializedMessage = this.message.serialize();
+    const encodedSignaturesLength = Array();
+    encodeLength(encodedSignaturesLength, this.signatures.length);
+    const transactionLayout = BufferLayout__namespace.struct([BufferLayout__namespace.blob(encodedSignaturesLength.length, 'encodedSignaturesLength'), BufferLayout__namespace.seq(signature(), this.signatures.length, 'signatures'), BufferLayout__namespace.blob(serializedMessage.length, 'serializedMessage')]);
+    const serializedTransaction = new Uint8Array(2048);
+    const serializedTransactionLength = transactionLayout.encode({
+      encodedSignaturesLength: new Uint8Array(encodedSignaturesLength),
+      signatures: this.signatures,
+      serializedMessage
+    }, serializedTransaction);
+    return serializedTransaction.slice(0, serializedTransactionLength);
+  }
+
+  static deserialize(serializedTransaction) {
+    let byteArray = [...serializedTransaction];
+    const signatures = [];
+    const signaturesLength = decodeLength(byteArray);
+
+    for (let i = 0; i < signaturesLength; i++) {
+      signatures.push(new Uint8Array(byteArray.splice(0, SIGNATURE_LENGTH_IN_BYTES)));
+    }
+
+    const message = VersionedMessage.deserialize(new Uint8Array(byteArray));
+    return new VersionedTransaction(message, signatures);
+  }
+
+  sign(signers) {
+    const messageData = this.message.serialize();
+    const signerPubkeys = this.message.staticAccountKeys.slice(0, this.message.header.numRequiredSignatures);
+
+    for (const signer of signers) {
+      const signerIndex = signerPubkeys.findIndex(pubkey => pubkey.equals(signer.publicKey));
+      assert(signerIndex >= 0, `Cannot sign with non signer key ${signer.publicKey.toBase58()}`);
+      this.signatures[signerIndex] = sign(messageData, signer.secretKey);
+    }
+  }
+
+  addSignature(publicKey, signature) {
+    assert(signature.byteLength === 64, 'Signature must be 64 bytes long');
+    const signerPubkeys = this.message.staticAccountKeys.slice(0, this.message.header.numRequiredSignatures);
+    const signerIndex = signerPubkeys.findIndex(pubkey => pubkey.equals(publicKey));
+    assert(signerIndex >= 0, `Can not add signature; \`${publicKey.toBase58()}\` is not required to sign this transaction`);
+    this.signatures[signerIndex] = signature;
+  }
+
+}
+
 const SYSVAR_CLOCK_PUBKEY = new PublicKey('SysvarC1ock11111111111111111111111111111111');
 const SYSVAR_EPOCH_SCHEDULE_PUBKEY = new PublicKey('SysvarEpochSchedu1e111111111111111111111111');
 const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey('Sysvar1nstructions1111111111111111111111111');
@@ -1747,11 +2235,34 @@ async function sendAndConfirmTransaction(connection, transaction, signers, optio
     minContextSlot: options.minContextSlot
   };
   const signature = await connection.sendTransaction(transaction, signers, sendOptions);
-  const status = transaction.recentBlockhash != null && transaction.lastValidBlockHeight != null ? (await connection.confirmTransaction({
-    signature: signature,
-    blockhash: transaction.recentBlockhash,
-    lastValidBlockHeight: transaction.lastValidBlockHeight
-  }, options && options.commitment)).value : (await connection.confirmTransaction(signature, options && options.commitment)).value;
+  let status;
+
+  if (transaction.recentBlockhash != null && transaction.lastValidBlockHeight != null) {
+    status = (await connection.confirmTransaction({
+      abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal,
+      signature: signature,
+      blockhash: transaction.recentBlockhash,
+      lastValidBlockHeight: transaction.lastValidBlockHeight
+    }, options && options.commitment)).value;
+  } else if (transaction.minNonceContextSlot != null && transaction.nonceInfo != null) {
+    const {
+      nonceInstruction
+    } = transaction.nonceInfo;
+    const nonceAccountPubkey = nonceInstruction.keys[0].pubkey;
+    status = (await connection.confirmTransaction({
+      abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal,
+      minContextSlot: transaction.minNonceContextSlot,
+      nonceAccountPubkey,
+      nonceValue: transaction.nonceInfo.nonce,
+      signature
+    }, options && options.commitment)).value;
+  } else {
+    if ((options === null || options === void 0 ? void 0 : options.abortSignal) != null) {
+      console.warn('sendAndConfirmTransaction(): A transaction with a deprecated confirmation strategy was ' + 'supplied along with an `abortSignal`. Only transactions having `lastValidBlockHeight` ' + 'or a combination of `nonceInfo` and `minNonceContextSlot` are abortable.');
+    }
+
+    status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
+  }
 
   if (status.err) {
     throw new Error(`Transaction ${signature} failed (${JSON.stringify(status)})`);
@@ -1820,6 +2331,9 @@ const FeeCalculatorLayout = BufferLayout__namespace.nu64('lamportsPerSignature')
 
 const NonceAccountLayout = BufferLayout__namespace.struct([BufferLayout__namespace.u32('version'), BufferLayout__namespace.u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), BufferLayout__namespace.struct([FeeCalculatorLayout], 'feeCalculator')]);
 const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;
+/**
+ * A durable nonce is a 32 byte value encoded as a base58 string.
+ */
 
 /**
  * NonceAccount class
@@ -2789,12 +3303,12 @@ class BpfLoader {
     return Loader.getMinNumSignatures(dataLength);
   }
   /**
-   * Load a BPF program
+   * Load a SBF program
    *
    * @param connection The connection to use
    * @param payer Account that will pay program loading fees
    * @param program Account to load the program into
-   * @param elf The entire ELF containing the BPF program
+   * @param elf The entire ELF containing the SBF program
    * @param loaderProgramId The program id of the BPF loader to use
    * @return true if program was loaded successfully, false if program was already loaded
    */
@@ -2910,7 +3424,7 @@ function nextPowerOfTwo(n) {
 /**
  * Epoch schedule
  * (see https://docs.solana.com/terminology#epoch)
- * Can be retrieved with the {@link connection.getEpochSchedule} method
+ * Can be retrieved with the {@link Connection.getEpochSchedule} method
  */
 
 
@@ -3082,7 +3596,7 @@ class AddressLookupTableAccount {
   }
 
   isActive() {
-    const U64_MAX = 2n ** 64n - 1n;
+    const U64_MAX = BigInt('0xffffffffffffffff');
     return this.state.deactivationSlot === U64_MAX;
   }
 
@@ -3244,6 +3758,28 @@ function notificationResultAndContext(value) {
     value
   });
 }
+/**
+ * @internal
+ */
+
+
+function versionedMessageFromResponse(version, response) {
+  if (version === 0) {
+    return new MessageV0({
+      header: response.header,
+      staticAccountKeys: response.accountKeys.map(accountKey => new PublicKey(accountKey)),
+      recentBlockhash: response.recentBlockhash,
+      compiledInstructions: response.instructions.map(ix => ({
+        programIdIndex: ix.programIdIndex,
+        accountKeyIndexes: ix.accounts,
+        data: bs58__default["default"].decode(ix.data)
+      })),
+      addressTableLookups: response.addressTableLookups
+    });
+  } else {
+    return new Message(response);
+  }
+}
 /**
  * The level of commitment desired when querying state
  * <pre>
@@ -3355,8 +3891,15 @@ const BlockProductionResponseStruct = jsonRpcResultAndContext(superstruct.type({
  * A performance sample
  */
 
-function createRpcClient(url, httpHeaders, customFetch, fetchMiddleware, disableRetryOnRateLimit) {
+function createRpcClient(url, httpHeaders, customFetch, fetchMiddleware, disableRetryOnRateLimit, httpAgent) {
   const fetch = customFetch ? customFetch : fetchImpl;
+  let agent;
+
+  {
+    if (httpAgent != null) {
+      console.warn('You have supplied an `httpAgent` when creating a `Connection` in a browser environment.' + 'It has been ignored; `httpAgent` is only used in Node environments.');
+    }
+  }
 
   let fetchWithMiddleware;
 
@@ -3374,7 +3917,6 @@ function createRpcClient(url, httpHeaders, customFetch, fetchMiddleware, disable
   }
 
   const clientBrowser = new RpcClient__default["default"](async (request, callback) => {
-    const agent = undefined;
     const options = {
       method: 'POST',
       body: request,
@@ -3426,7 +3968,6 @@ function createRpcClient(url, httpHeaders, customFetch, fetchMiddleware, disable
       }
     } catch (err) {
       if (err instanceof Error) callback(err);
-    } finally {
     }
   }, {});
   return clientBrowser;
@@ -3799,6 +4340,11 @@ const GetSignatureStatusesRpcResult = jsonRpcResultAndContext(superstruct.array(
  */
 
 const GetMinimumBalanceForRentExemptionRpcResult = jsonRpcResult(superstruct.number());
+const AddressTableLookupStruct = superstruct.type({
+  accountKey: PublicKeyFromString,
+  writableIndexes: superstruct.array(superstruct.number()),
+  readonlyIndexes: superstruct.array(superstruct.number())
+});
 const ConfirmedTransactionResult = superstruct.type({
   signatures: superstruct.array(superstruct.string()),
   message: superstruct.type({
@@ -3813,9 +4359,20 @@ const ConfirmedTransactionResult = superstruct.type({
       data: superstruct.string(),
       programIdIndex: superstruct.number()
     })),
-    recentBlockhash: superstruct.string()
+    recentBlockhash: superstruct.string(),
+    addressTableLookups: superstruct.optional(superstruct.array(AddressTableLookupStruct))
   })
 });
+const AnnotatedAccountKey = superstruct.type({
+  pubkey: PublicKeyFromString,
+  signer: superstruct.boolean(),
+  writable: superstruct.boolean(),
+  source: superstruct.optional(superstruct.union([superstruct.literal('transaction'), superstruct.literal('lookupTable')]))
+});
+const ConfirmedTransactionAccountsModeResult = superstruct.type({
+  accountKeys: superstruct.array(AnnotatedAccountKey),
+  signatures: superstruct.array(superstruct.string())
+});
 const ParsedInstructionResult = superstruct.type({
   parsed: superstruct.unknown(),
   program: superstruct.string(),
@@ -3850,13 +4407,10 @@ const ParsedOrRawInstruction = superstruct.coerce(InstructionResult, UnknownInst
 const ParsedConfirmedTransactionResult = superstruct.type({
   signatures: superstruct.array(superstruct.string()),
   message: superstruct.type({
-    accountKeys: superstruct.array(superstruct.type({
-      pubkey: PublicKeyFromString,
-      signer: superstruct.boolean(),
-      writable: superstruct.boolean()
-    })),
+    accountKeys: superstruct.array(AnnotatedAccountKey),
     instructions: superstruct.array(ParsedOrRawInstruction),
-    recentBlockhash: superstruct.string()
+    recentBlockhash: superstruct.string(),
+    addressTableLookups: superstruct.optional(superstruct.nullable(superstruct.array(AddressTableLookupStruct)))
   })
 });
 const TokenBalanceResult = superstruct.type({
@@ -3889,44 +4443,126 @@ const ConfirmedTransactionMetaResult = superstruct.type({
   logMessages: superstruct.optional(superstruct.nullable(superstruct.array(superstruct.string()))),
   preTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
   postTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
-  loadedAddresses: superstruct.optional(LoadedAddressesResult)
+  loadedAddresses: superstruct.optional(LoadedAddressesResult),
+  computeUnitsConsumed: superstruct.optional(superstruct.number())
+});
+/**
+ * @internal
+ */
+
+const ParsedConfirmedTransactionMetaResult = superstruct.type({
+  err: TransactionErrorResult,
+  fee: superstruct.number(),
+  innerInstructions: superstruct.optional(superstruct.nullable(superstruct.array(superstruct.type({
+    index: superstruct.number(),
+    instructions: superstruct.array(ParsedOrRawInstruction)
+  })))),
+  preBalances: superstruct.array(superstruct.number()),
+  postBalances: superstruct.array(superstruct.number()),
+  logMessages: superstruct.optional(superstruct.nullable(superstruct.array(superstruct.string()))),
+  preTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
+  postTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
+  loadedAddresses: superstruct.optional(LoadedAddressesResult),
+  computeUnitsConsumed: superstruct.optional(superstruct.number())
+});
+const TransactionVersionStruct = superstruct.union([superstruct.literal(0), superstruct.literal('legacy')]);
+/** @internal */
+
+const RewardsResult = superstruct.type({
+  pubkey: superstruct.string(),
+  lamports: superstruct.number(),
+  postBalance: superstruct.nullable(superstruct.number()),
+  rewardType: superstruct.nullable(superstruct.string())
 });
 /**
- * @internal
+ * Expected JSON RPC response for the "getBlock" message
+ */
+
+const GetBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
+  blockhash: superstruct.string(),
+  previousBlockhash: superstruct.string(),
+  parentSlot: superstruct.number(),
+  transactions: superstruct.array(superstruct.type({
+    transaction: ConfirmedTransactionResult,
+    meta: superstruct.nullable(ConfirmedTransactionMetaResult),
+    version: superstruct.optional(TransactionVersionStruct)
+  })),
+  rewards: superstruct.optional(superstruct.array(RewardsResult)),
+  blockTime: superstruct.nullable(superstruct.number()),
+  blockHeight: superstruct.nullable(superstruct.number())
+})));
+/**
+ * Expected JSON RPC response for the "getBlock" message when `transactionDetails` is `none`
+ */
+
+const GetNoneModeBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
+  blockhash: superstruct.string(),
+  previousBlockhash: superstruct.string(),
+  parentSlot: superstruct.number(),
+  rewards: superstruct.optional(superstruct.array(RewardsResult)),
+  blockTime: superstruct.nullable(superstruct.number()),
+  blockHeight: superstruct.nullable(superstruct.number())
+})));
+/**
+ * Expected JSON RPC response for the "getBlock" message when `transactionDetails` is `accounts`
+ */
+
+const GetAccountsModeBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
+  blockhash: superstruct.string(),
+  previousBlockhash: superstruct.string(),
+  parentSlot: superstruct.number(),
+  transactions: superstruct.array(superstruct.type({
+    transaction: ConfirmedTransactionAccountsModeResult,
+    meta: superstruct.nullable(ConfirmedTransactionMetaResult),
+    version: superstruct.optional(TransactionVersionStruct)
+  })),
+  rewards: superstruct.optional(superstruct.array(RewardsResult)),
+  blockTime: superstruct.nullable(superstruct.number()),
+  blockHeight: superstruct.nullable(superstruct.number())
+})));
+/**
+ * Expected parsed JSON RPC response for the "getBlock" message
  */
 
-const ParsedConfirmedTransactionMetaResult = superstruct.type({
-  err: TransactionErrorResult,
-  fee: superstruct.number(),
-  innerInstructions: superstruct.optional(superstruct.nullable(superstruct.array(superstruct.type({
-    index: superstruct.number(),
-    instructions: superstruct.array(ParsedOrRawInstruction)
-  })))),
-  preBalances: superstruct.array(superstruct.number()),
-  postBalances: superstruct.array(superstruct.number()),
-  logMessages: superstruct.optional(superstruct.nullable(superstruct.array(superstruct.string()))),
-  preTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
-  postTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
-  loadedAddresses: superstruct.optional(LoadedAddressesResult)
-});
+const GetParsedBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
+  blockhash: superstruct.string(),
+  previousBlockhash: superstruct.string(),
+  parentSlot: superstruct.number(),
+  transactions: superstruct.array(superstruct.type({
+    transaction: ParsedConfirmedTransactionResult,
+    meta: superstruct.nullable(ParsedConfirmedTransactionMetaResult),
+    version: superstruct.optional(TransactionVersionStruct)
+  })),
+  rewards: superstruct.optional(superstruct.array(RewardsResult)),
+  blockTime: superstruct.nullable(superstruct.number()),
+  blockHeight: superstruct.nullable(superstruct.number())
+})));
 /**
- * Expected JSON RPC response for the "getBlock" message
+ * Expected parsed JSON RPC response for the "getBlock" message  when `transactionDetails` is `accounts`
  */
 
-const GetBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
+const GetParsedAccountsModeBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
   blockhash: superstruct.string(),
   previousBlockhash: superstruct.string(),
   parentSlot: superstruct.number(),
   transactions: superstruct.array(superstruct.type({
-    transaction: ConfirmedTransactionResult,
-    meta: superstruct.nullable(ConfirmedTransactionMetaResult)
+    transaction: ConfirmedTransactionAccountsModeResult,
+    meta: superstruct.nullable(ParsedConfirmedTransactionMetaResult),
+    version: superstruct.optional(TransactionVersionStruct)
   })),
-  rewards: superstruct.optional(superstruct.array(superstruct.type({
-    pubkey: superstruct.string(),
-    lamports: superstruct.number(),
-    postBalance: superstruct.nullable(superstruct.number()),
-    rewardType: superstruct.nullable(superstruct.string())
-  }))),
+  rewards: superstruct.optional(superstruct.array(RewardsResult)),
+  blockTime: superstruct.nullable(superstruct.number()),
+  blockHeight: superstruct.nullable(superstruct.number())
+})));
+/**
+ * Expected parsed JSON RPC response for the "getBlock" message  when `transactionDetails` is `none`
+ */
+
+const GetParsedNoneModeBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruct.type({
+  blockhash: superstruct.string(),
+  previousBlockhash: superstruct.string(),
+  parentSlot: superstruct.number(),
+  rewards: superstruct.optional(superstruct.array(RewardsResult)),
   blockTime: superstruct.nullable(superstruct.number()),
   blockHeight: superstruct.nullable(superstruct.number())
 })));
@@ -3944,12 +4580,7 @@ const GetConfirmedBlockRpcResult = jsonRpcResult(superstruct.nullable(superstruc
     transaction: ConfirmedTransactionResult,
     meta: superstruct.nullable(ConfirmedTransactionMetaResult)
   })),
-  rewards: superstruct.optional(superstruct.array(superstruct.type({
-    pubkey: superstruct.string(),
-    lamports: superstruct.number(),
-    postBalance: superstruct.nullable(superstruct.number()),
-    rewardType: superstruct.nullable(superstruct.string())
-  }))),
+  rewards: superstruct.optional(superstruct.array(RewardsResult)),
   blockTime: superstruct.nullable(superstruct.number())
 })));
 /**
@@ -3971,7 +4602,8 @@ const GetTransactionRpcResult = jsonRpcResult(superstruct.nullable(superstruct.t
   slot: superstruct.number(),
   meta: ConfirmedTransactionMetaResult,
   blockTime: superstruct.optional(superstruct.nullable(superstruct.number())),
-  transaction: ConfirmedTransactionResult
+  transaction: ConfirmedTransactionResult,
+  version: superstruct.optional(TransactionVersionStruct)
 })));
 /**
  * Expected parsed JSON RPC response for the "getTransaction" message
@@ -3981,7 +4613,8 @@ const GetParsedTransactionRpcResult = jsonRpcResult(superstruct.nullable(superst
   slot: superstruct.number(),
   transaction: ParsedConfirmedTransactionResult,
   meta: superstruct.nullable(ParsedConfirmedTransactionMetaResult),
-  blockTime: superstruct.optional(superstruct.nullable(superstruct.number()))
+  blockTime: superstruct.optional(superstruct.nullable(superstruct.number())),
+  version: superstruct.optional(TransactionVersionStruct)
 })));
 /**
  * Expected JSON RPC response for the "getRecentBlockhash" message
@@ -4113,6 +4746,10 @@ class Connection {
 
   /** @internal */
 
+  /** @internal */
+
+  /** @internal */
+
   /**
    * Special case.
    * After a signature is processed, RPCs automatically dispose of the
@@ -4158,6 +4795,8 @@ class Connection {
     };
     this._nextClientSubscriptionId = 0;
     this._subscriptionDisposeFunctionsByClientSubscriptionId = {};
+    this._subscriptionHashByClientSubscriptionId = {};
+    this._subscriptionStateChangeCallbacksByHash = {};
     this._subscriptionCallbacksByServerSubscriptionId = {};
     this._subscriptionsByHash = {};
     this._subscriptionsAutoDisposedByRpc = new Set();
@@ -4166,6 +4805,7 @@ class Connection {
     let fetch;
     let fetchMiddleware;
     let disableRetryOnRateLimit;
+    let httpAgent;
 
     if (commitmentOrConfig && typeof commitmentOrConfig === 'string') {
       this._commitment = commitmentOrConfig;
@@ -4177,11 +4817,12 @@ class Connection {
       fetch = commitmentOrConfig.fetch;
       fetchMiddleware = commitmentOrConfig.fetchMiddleware;
       disableRetryOnRateLimit = commitmentOrConfig.disableRetryOnRateLimit;
+      httpAgent = commitmentOrConfig.httpAgent;
     }
 
     this._rpcEndpoint = assertEndpointUrl(endpoint);
     this._rpcWsEndpoint = wsEndpoint || makeWebsocketUrl(endpoint);
-    this._rpcClient = createRpcClient(endpoint, httpHeaders, fetch, fetchMiddleware, disableRetryOnRateLimit);
+    this._rpcClient = createRpcClient(endpoint, httpHeaders, fetch, fetchMiddleware, disableRetryOnRateLimit, httpAgent);
     this._rpcRequest = createRpcRequest(this._rpcClient);
     this._rpcBatchRequest = createRpcBatchRequest(this._rpcClient);
     this._rpcWebSocket = new rpcWebsockets.Client(this._rpcWsEndpoint, {
@@ -4536,6 +5177,29 @@ class Connection {
    */
 
 
+  async getMultipleParsedAccounts(publicKeys, rawConfig) {
+    const {
+      commitment,
+      config
+    } = extractCommitmentFromConfig(rawConfig);
+    const keys = publicKeys.map(key => key.toBase58());
+
+    const args = this._buildArgs([keys], commitment, 'jsonParsed', config);
+
+    const unsafeRes = await this._rpcRequest('getMultipleAccounts', args);
+    const res = superstruct.create(unsafeRes, jsonRpcResultAndContext(superstruct.array(superstruct.nullable(ParsedAccountInfoResult))));
+
+    if ('error' in res) {
+      throw new SolanaJSONRPCError(res.error, `failed to get info for accounts ${keys}`);
+    }
+
+    return res.result;
+  }
+  /**
+   * Fetch all the account info for multiple accounts specified by an array of public keys, return with context
+   */
+
+
   async getMultipleAccountsInfoAndContext(publicKeys, commitmentOrConfig) {
     const {
       commitment,
@@ -4568,193 +5232,515 @@ class Connection {
    */
 
 
-  async getStakeActivation(publicKey, commitmentOrConfig, epoch) {
+  async getStakeActivation(publicKey, commitmentOrConfig, epoch) {
+    const {
+      commitment,
+      config
+    } = extractCommitmentFromConfig(commitmentOrConfig);
+
+    const args = this._buildArgs([publicKey.toBase58()], commitment, undefined
+    /* encoding */
+    , { ...config,
+      epoch: epoch != null ? epoch : config === null || config === void 0 ? void 0 : config.epoch
+    });
+
+    const unsafeRes = await this._rpcRequest('getStakeActivation', args);
+    const res = superstruct.create(unsafeRes, jsonRpcResult(StakeActivationResult));
+
+    if ('error' in res) {
+      throw new SolanaJSONRPCError(res.error, `failed to get Stake Activation ${publicKey.toBase58()}`);
+    }
+
+    return res.result;
+  }
+  /**
+   * Fetch all the accounts owned by the specified program id
+   *
+   * @return {Promise<Array<{pubkey: PublicKey, account: AccountInfo<Buffer>}>>}
+   */
+
+
+  async getProgramAccounts(programId, configOrCommitment) {
+    const {
+      commitment,
+      config
+    } = extractCommitmentFromConfig(configOrCommitment);
+    const {
+      encoding,
+      ...configWithoutEncoding
+    } = config || {};
+
+    const args = this._buildArgs([programId.toBase58()], commitment, encoding || 'base64', configWithoutEncoding);
+
+    const unsafeRes = await this._rpcRequest('getProgramAccounts', args);
+    const res = superstruct.create(unsafeRes, jsonRpcResult(superstruct.array(KeyedAccountInfoResult)));
+
+    if ('error' in res) {
+      throw new SolanaJSONRPCError(res.error, `failed to get accounts owned by program ${programId.toBase58()}`);
+    }
+
+    return res.result;
+  }
+  /**
+   * Fetch and parse all the accounts owned by the specified program id
+   *
+   * @return {Promise<Array<{pubkey: PublicKey, account: AccountInfo<Buffer | ParsedAccountData>}>>}
+   */
+
+
+  async getParsedProgramAccounts(programId, configOrCommitment) {
+    const {
+      commitment,
+      config
+    } = extractCommitmentFromConfig(configOrCommitment);
+
+    const args = this._buildArgs([programId.toBase58()], commitment, 'jsonParsed', config);
+
+    const unsafeRes = await this._rpcRequest('getProgramAccounts', args);
+    const res = superstruct.create(unsafeRes, jsonRpcResult(superstruct.array(KeyedParsedAccountInfoResult)));
+
+    if ('error' in res) {
+      throw new SolanaJSONRPCError(res.error, `failed to get accounts owned by program ${programId.toBase58()}`);
+    }
+
+    return res.result;
+  }
+
+  // eslint-disable-next-line no-dupe-class-members
+  async confirmTransaction(strategy, commitment) {
+    let rawSignature;
+
+    if (typeof strategy == 'string') {
+      rawSignature = strategy;
+    } else {
+      var _config$abortSignal;
+
+      const config = strategy;
+
+      if ((_config$abortSignal = config.abortSignal) !== null && _config$abortSignal !== void 0 && _config$abortSignal.aborted) {
+        return Promise.reject(config.abortSignal.reason);
+      }
+
+      rawSignature = config.signature;
+    }
+
+    let decodedSignature;
+
+    try {
+      decodedSignature = bs58__default["default"].decode(rawSignature);
+    } catch (err) {
+      throw new Error('signature must be base58 encoded: ' + rawSignature);
+    }
+
+    assert(decodedSignature.length === 64, 'signature has invalid length');
+
+    if (typeof strategy === 'string') {
+      return await this.confirmTransactionUsingLegacyTimeoutStrategy({
+        commitment: commitment || this.commitment,
+        signature: rawSignature
+      });
+    } else if ('lastValidBlockHeight' in strategy) {
+      return await this.confirmTransactionUsingBlockHeightExceedanceStrategy({
+        commitment: commitment || this.commitment,
+        strategy
+      });
+    } else {
+      return await this.confirmTransactionUsingDurableNonceStrategy({
+        commitment: commitment || this.commitment,
+        strategy
+      });
+    }
+  }
+
+  getCancellationPromise(signal) {
+    return new Promise((_, reject) => {
+      if (signal == null) {
+        return;
+      }
+
+      if (signal.aborted) {
+        reject(signal.reason);
+      } else {
+        signal.addEventListener('abort', () => {
+          reject(signal.reason);
+        });
+      }
+    });
+  }
+
+  getTransactionConfirmationPromise({
+    commitment,
+    signature
+  }) {
+    let signatureSubscriptionId;
+    let disposeSignatureSubscriptionStateChangeObserver;
+    let done = false;
+    const confirmationPromise = new Promise((resolve, reject) => {
+      try {
+        signatureSubscriptionId = this.onSignature(signature, (result, context) => {
+          signatureSubscriptionId = undefined;
+          const response = {
+            context,
+            value: result
+          };
+          resolve({
+            __type: exports.TransactionStatus.PROCESSED,
+            response
+          });
+        }, commitment);
+        const subscriptionSetupPromise = new Promise(resolveSubscriptionSetup => {
+          if (signatureSubscriptionId == null) {
+            resolveSubscriptionSetup();
+          } else {
+            disposeSignatureSubscriptionStateChangeObserver = this._onSubscriptionStateChange(signatureSubscriptionId, nextState => {
+              if (nextState === 'subscribed') {
+                resolveSubscriptionSetup();
+              }
+            });
+          }
+        });
+
+        (async () => {
+          await subscriptionSetupPromise;
+          if (done) return;
+          const response = await this.getSignatureStatus(signature);
+          if (done) return;
+
+          if (response == null) {
+            return;
+          }
+
+          const {
+            context,
+            value
+          } = response;
+
+          if (value == null) {
+            return;
+          }
+
+          if (value !== null && value !== void 0 && value.err) {
+            reject(value.err);
+          } else {
+            switch (commitment) {
+              case 'confirmed':
+              case 'single':
+              case 'singleGossip':
+                {
+                  if (value.confirmationStatus === 'processed') {
+                    return;
+                  }
+
+                  break;
+                }
+
+              case 'finalized':
+              case 'max':
+              case 'root':
+                {
+                  if (value.confirmationStatus === 'processed' || value.confirmationStatus === 'confirmed') {
+                    return;
+                  }
+
+                  break;
+                }
+              // exhaust enums to ensure full coverage
+
+              case 'processed':
+              case 'recent':
+            }
+
+            done = true;
+            resolve({
+              __type: exports.TransactionStatus.PROCESSED,
+              response: {
+                context,
+                value
+              }
+            });
+          }
+        })();
+      } catch (err) {
+        reject(err);
+      }
+    });
+
+    const abortConfirmation = () => {
+      if (disposeSignatureSubscriptionStateChangeObserver) {
+        disposeSignatureSubscriptionStateChangeObserver();
+        disposeSignatureSubscriptionStateChangeObserver = undefined;
+      }
+
+      if (signatureSubscriptionId != null) {
+        this.removeSignatureListener(signatureSubscriptionId);
+        signatureSubscriptionId = undefined;
+      }
+    };
+
+    return {
+      abortConfirmation,
+      confirmationPromise
+    };
+  }
+
+  async confirmTransactionUsingBlockHeightExceedanceStrategy({
+    commitment,
+    strategy: {
+      abortSignal,
+      lastValidBlockHeight,
+      signature
+    }
+  }) {
+    let done = false;
+    const expiryPromise = new Promise(resolve => {
+      const checkBlockHeight = async () => {
+        try {
+          const blockHeight = await this.getBlockHeight(commitment);
+          return blockHeight;
+        } catch (_e) {
+          return -1;
+        }
+      };
+
+      (async () => {
+        let currentBlockHeight = await checkBlockHeight();
+        if (done) return;
+
+        while (currentBlockHeight <= lastValidBlockHeight) {
+          await sleep(1000);
+          if (done) return;
+          currentBlockHeight = await checkBlockHeight();
+          if (done) return;
+        }
+
+        resolve({
+          __type: exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED
+        });
+      })();
+    });
     const {
+      abortConfirmation,
+      confirmationPromise
+    } = this.getTransactionConfirmationPromise({
       commitment,
-      config
-    } = extractCommitmentFromConfig(commitmentOrConfig);
-
-    const args = this._buildArgs([publicKey.toBase58()], commitment, undefined
-    /* encoding */
-    , { ...config,
-      epoch: epoch != null ? epoch : config === null || config === void 0 ? void 0 : config.epoch
+      signature
     });
+    const cancellationPromise = this.getCancellationPromise(abortSignal);
+    let result;
 
-    const unsafeRes = await this._rpcRequest('getStakeActivation', args);
-    const res = superstruct.create(unsafeRes, jsonRpcResult(StakeActivationResult));
+    try {
+      const outcome = await Promise.race([cancellationPromise, confirmationPromise, expiryPromise]);
 
-    if ('error' in res) {
-      throw new SolanaJSONRPCError(res.error, `failed to get Stake Activation ${publicKey.toBase58()}`);
+      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+        result = outcome.response;
+      } else {
+        throw new TransactionExpiredBlockheightExceededError(signature);
+      }
+    } finally {
+      done = true;
+      abortConfirmation();
     }
 
-    return res.result;
+    return result;
   }
-  /**
-   * Fetch all the accounts owned by the specified program id
-   *
-   * @return {Promise<Array<{pubkey: PublicKey, account: AccountInfo<Buffer>}>>}
-   */
 
+  async confirmTransactionUsingDurableNonceStrategy({
+    commitment,
+    strategy: {
+      abortSignal,
+      minContextSlot,
+      nonceAccountPubkey,
+      nonceValue,
+      signature
+    }
+  }) {
+    let done = false;
+    const expiryPromise = new Promise(resolve => {
+      let currentNonceValue = nonceValue;
+      let lastCheckedSlot = null;
+
+      const getCurrentNonceValue = async () => {
+        try {
+          const {
+            context,
+            value: nonceAccount
+          } = await this.getNonceAndContext(nonceAccountPubkey, {
+            commitment,
+            minContextSlot
+          });
+          lastCheckedSlot = context.slot;
+          return nonceAccount === null || nonceAccount === void 0 ? void 0 : nonceAccount.nonce;
+        } catch (e) {
+          // If for whatever reason we can't reach/read the nonce
+          // account, just keep using the last-known value.
+          return currentNonceValue;
+        }
+      };
+
+      (async () => {
+        currentNonceValue = await getCurrentNonceValue();
+        if (done) return;
 
-  async getProgramAccounts(programId, configOrCommitment) {
+        while (true // eslint-disable-line no-constant-condition
+        ) {
+          if (nonceValue !== currentNonceValue) {
+            resolve({
+              __type: exports.TransactionStatus.NONCE_INVALID,
+              slotInWhichNonceDidAdvance: lastCheckedSlot
+            });
+            return;
+          }
+
+          await sleep(2000);
+          if (done) return;
+          currentNonceValue = await getCurrentNonceValue();
+          if (done) return;
+        }
+      })();
+    });
     const {
+      abortConfirmation,
+      confirmationPromise
+    } = this.getTransactionConfirmationPromise({
       commitment,
-      config
-    } = extractCommitmentFromConfig(configOrCommitment);
-    const {
-      encoding,
-      ...configWithoutEncoding
-    } = config || {};
-
-    const args = this._buildArgs([programId.toBase58()], commitment, encoding || 'base64', configWithoutEncoding);
+      signature
+    });
+    const cancellationPromise = this.getCancellationPromise(abortSignal);
+    let result;
 
-    const unsafeRes = await this._rpcRequest('getProgramAccounts', args);
-    const res = superstruct.create(unsafeRes, jsonRpcResult(superstruct.array(KeyedAccountInfoResult)));
+    try {
+      const outcome = await Promise.race([cancellationPromise, confirmationPromise, expiryPromise]);
 
-    if ('error' in res) {
-      throw new SolanaJSONRPCError(res.error, `failed to get accounts owned by program ${programId.toBase58()}`);
-    }
+      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+        result = outcome.response;
+      } else {
+        var _signatureStatus;
 
-    return res.result;
-  }
-  /**
-   * Fetch and parse all the accounts owned by the specified program id
-   *
-   * @return {Promise<Array<{pubkey: PublicKey, account: AccountInfo<Buffer | ParsedAccountData>}>>}
-   */
+        // Double check that the transaction is indeed unconfirmed.
+        let signatureStatus;
 
+        while (true // eslint-disable-line no-constant-condition
+        ) {
+          var _outcome$slotInWhichN;
 
-  async getParsedProgramAccounts(programId, configOrCommitment) {
-    const {
-      commitment,
-      config
-    } = extractCommitmentFromConfig(configOrCommitment);
+          const status = await this.getSignatureStatus(signature);
 
-    const args = this._buildArgs([programId.toBase58()], commitment, 'jsonParsed', config);
+          if (status == null) {
+            break;
+          }
 
-    const unsafeRes = await this._rpcRequest('getProgramAccounts', args);
-    const res = superstruct.create(unsafeRes, jsonRpcResult(superstruct.array(KeyedParsedAccountInfoResult)));
+          if (status.context.slot < ((_outcome$slotInWhichN = outcome.slotInWhichNonceDidAdvance) !== null && _outcome$slotInWhichN !== void 0 ? _outcome$slotInWhichN : minContextSlot)) {
+            await sleep(400);
+            continue;
+          }
 
-    if ('error' in res) {
-      throw new SolanaJSONRPCError(res.error, `failed to get accounts owned by program ${programId.toBase58()}`);
-    }
+          signatureStatus = status;
+          break;
+        }
 
-    return res.result;
-  }
+        if ((_signatureStatus = signatureStatus) !== null && _signatureStatus !== void 0 && _signatureStatus.value) {
+          const commitmentForStatus = commitment || 'finalized';
+          const {
+            confirmationStatus
+          } = signatureStatus.value;
+
+          switch (commitmentForStatus) {
+            case 'processed':
+            case 'recent':
+              if (confirmationStatus !== 'processed' && confirmationStatus !== 'confirmed' && confirmationStatus !== 'finalized') {
+                throw new TransactionExpiredNonceInvalidError(signature);
+              }
 
-  // eslint-disable-next-line no-dupe-class-members
-  async confirmTransaction(strategy, commitment) {
-    let rawSignature;
+              break;
 
-    if (typeof strategy == 'string') {
-      rawSignature = strategy;
-    } else {
-      const config = strategy;
-      rawSignature = config.signature;
-    }
+            case 'confirmed':
+            case 'single':
+            case 'singleGossip':
+              if (confirmationStatus !== 'confirmed' && confirmationStatus !== 'finalized') {
+                throw new TransactionExpiredNonceInvalidError(signature);
+              }
 
-    let decodedSignature;
+              break;
 
-    try {
-      decodedSignature = bs58__default["default"].decode(rawSignature);
-    } catch (err) {
-      throw new Error('signature must be base58 encoded: ' + rawSignature);
-    }
+            case 'finalized':
+            case 'max':
+            case 'root':
+              if (confirmationStatus !== 'finalized') {
+                throw new TransactionExpiredNonceInvalidError(signature);
+              }
 
-    assert(decodedSignature.length === 64, 'signature has invalid length');
-    const subscriptionCommitment = commitment || this.commitment;
-    let timeoutId;
-    let subscriptionId;
-    let done = false;
-    const confirmationPromise = new Promise((resolve, reject) => {
-      try {
-        subscriptionId = this.onSignature(rawSignature, (result, context) => {
-          subscriptionId = undefined;
-          const response = {
-            context,
-            value: result
-          };
-          done = true;
-          resolve({
-            __type: exports.TransactionStatus.PROCESSED,
-            response
-          });
-        }, subscriptionCommitment);
-      } catch (err) {
-        reject(err);
-      }
-    });
-    const expiryPromise = new Promise(resolve => {
-      if (typeof strategy === 'string') {
-        let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
-
-        switch (subscriptionCommitment) {
-          case 'processed':
-          case 'recent':
-          case 'single':
-          case 'confirmed':
-          case 'singleGossip':
-            {
-              timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
               break;
-            }
-        }
 
-        timeoutId = setTimeout(() => resolve({
-          __type: exports.TransactionStatus.TIMED_OUT,
-          timeoutMs
-        }), timeoutMs);
-      } else {
-        let config = strategy;
+            default:
+              // Exhaustive switch.
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              (_ => {})(commitmentForStatus);
 
-        const checkBlockHeight = async () => {
-          try {
-            const blockHeight = await this.getBlockHeight(commitment);
-            return blockHeight;
-          } catch (_e) {
-            return -1;
           }
-        };
 
-        (async () => {
-          let currentBlockHeight = await checkBlockHeight();
-          if (done) return;
+          result = {
+            context: signatureStatus.context,
+            value: {
+              err: signatureStatus.value.err
+            }
+          };
+        } else {
+          throw new TransactionExpiredNonceInvalidError(signature);
+        }
+      }
+    } finally {
+      done = true;
+      abortConfirmation();
+    }
 
-          while (currentBlockHeight <= config.lastValidBlockHeight) {
-            await sleep(1000);
-            if (done) return;
-            currentBlockHeight = await checkBlockHeight();
-            if (done) return;
-          }
+    return result;
+  }
 
-          resolve({
-            __type: exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED
-          });
-        })();
+  async confirmTransactionUsingLegacyTimeoutStrategy({
+    commitment,
+    signature
+  }) {
+    let timeoutId;
+    const expiryPromise = new Promise(resolve => {
+      let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
+
+      switch (commitment) {
+        case 'processed':
+        case 'recent':
+        case 'single':
+        case 'confirmed':
+        case 'singleGossip':
+          {
+            timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
+            break;
+          }
       }
+
+      timeoutId = setTimeout(() => resolve({
+        __type: exports.TransactionStatus.TIMED_OUT,
+        timeoutMs
+      }), timeoutMs);
+    });
+    const {
+      abortConfirmation,
+      confirmationPromise
+    } = this.getTransactionConfirmationPromise({
+      commitment,
+      signature
     });
     let result;
 
     try {
       const outcome = await Promise.race([confirmationPromise, expiryPromise]);
 
-      switch (outcome.__type) {
-        case exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED:
-          throw new TransactionExpiredBlockheightExceededError(rawSignature);
-
-        case exports.TransactionStatus.PROCESSED:
-          result = outcome.response;
-          break;
-
-        case exports.TransactionStatus.TIMED_OUT:
-          throw new TransactionExpiredTimeoutError(rawSignature, outcome.timeoutMs / 1000);
+      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+        result = outcome.response;
+      } else {
+        throw new TransactionExpiredTimeoutError(signature, outcome.timeoutMs / 1000);
       }
     } finally {
       clearTimeout(timeoutId);
-
-      if (subscriptionId) {
-        this.removeSignatureListener(subscriptionId);
-      }
+      abortConfirmation();
     }
 
     return result;
@@ -5120,7 +6106,7 @@ class Connection {
 
 
   async getFeeForMessage(message, commitment) {
-    const wireMessage = message.serialize().toString('base64');
+    const wireMessage = toBuffer(message.serialize()).toString('base64');
 
     const args = this._buildArgs([wireMessage], commitment);
 
@@ -5128,7 +6114,7 @@ class Connection {
     const res = superstruct.create(unsafeRes, jsonRpcResultAndContext(superstruct.nullable(superstruct.number())));
 
     if ('error' in res) {
-      throw new SolanaJSONRPCError(res.error, 'failed to get slot');
+      throw new SolanaJSONRPCError(res.error, 'failed to get fee for message');
     }
 
     if (res.result === null) {
@@ -5224,9 +6210,16 @@ class Connection {
   }
   /**
    * Fetch a processed block from the cluster.
+   *
+   * @deprecated Instead, call `getBlock` using a `GetVersionedBlockConfig` by
+   * setting the `maxSupportedTransactionVersion` property.
    */
 
 
+  /**
+   * Fetch a processed block from the cluster.
+   */
+  // eslint-disable-next-line no-dupe-class-members
   async getBlock(slot, rawConfig) {
     const {
       commitment,
@@ -5238,28 +6231,115 @@ class Connection {
     , config);
 
     const unsafeRes = await this._rpcRequest('getBlock', args);
-    const res = superstruct.create(unsafeRes, GetBlockRpcResult);
 
-    if ('error' in res) {
-      throw new SolanaJSONRPCError(res.error, 'failed to get confirmed block');
+    try {
+      switch (config === null || config === void 0 ? void 0 : config.transactionDetails) {
+        case 'accounts':
+          {
+            const res = superstruct.create(unsafeRes, GetAccountsModeBlockRpcResult);
+
+            if ('error' in res) {
+              throw res.error;
+            }
+
+            return res.result;
+          }
+
+        case 'none':
+          {
+            const res = superstruct.create(unsafeRes, GetNoneModeBlockRpcResult);
+
+            if ('error' in res) {
+              throw res.error;
+            }
+
+            return res.result;
+          }
+
+        default:
+          {
+            const res = superstruct.create(unsafeRes, GetBlockRpcResult);
+
+            if ('error' in res) {
+              throw res.error;
+            }
+
+            const {
+              result
+            } = res;
+            return result ? { ...result,
+              transactions: result.transactions.map(({
+                transaction,
+                meta,
+                version
+              }) => ({
+                meta,
+                transaction: { ...transaction,
+                  message: versionedMessageFromResponse(version, transaction.message)
+                },
+                version
+              }))
+            } : null;
+          }
+      }
+    } catch (e) {
+      throw new SolanaJSONRPCError(e, 'failed to get confirmed block');
     }
+  }
+  /**
+   * Fetch parsed transaction details for a confirmed or finalized block
+   */
 
-    const result = res.result;
-    if (!result) return result;
-    return { ...result,
-      transactions: result.transactions.map(({
-        transaction,
-        meta
-      }) => {
-        const message = new Message(transaction.message);
-        return {
-          meta,
-          transaction: { ...transaction,
-            message
+
+  // eslint-disable-next-line no-dupe-class-members
+  async getParsedBlock(slot, rawConfig) {
+    const {
+      commitment,
+      config
+    } = extractCommitmentFromConfig(rawConfig);
+
+    const args = this._buildArgsAtLeastConfirmed([slot], commitment, 'jsonParsed', config);
+
+    const unsafeRes = await this._rpcRequest('getBlock', args);
+
+    try {
+      switch (config === null || config === void 0 ? void 0 : config.transactionDetails) {
+        case 'accounts':
+          {
+            const res = superstruct.create(unsafeRes, GetParsedAccountsModeBlockRpcResult);
+
+            if ('error' in res) {
+              throw res.error;
+            }
+
+            return res.result;
           }
-        };
-      })
-    };
+
+        case 'none':
+          {
+            const res = superstruct.create(unsafeRes, GetParsedNoneModeBlockRpcResult);
+
+            if ('error' in res) {
+              throw res.error;
+            }
+
+            return res.result;
+          }
+
+        default:
+          {
+            const res = superstruct.create(unsafeRes, GetParsedBlockRpcResult);
+
+            if ('error' in res) {
+              throw res.error;
+            }
+
+            return res.result;
+          }
+      }
+    } catch (e) {
+      throw new SolanaJSONRPCError(e, 'failed to get block');
+    }
   }
   /*
    * Returns the current block height of the node
@@ -5318,9 +6398,17 @@ class Connection {
   }
   /**
    * Fetch a confirmed or finalized transaction from the cluster.
+   *
+   * @deprecated Instead, call `getTransaction` using a
+   * `GetVersionedTransactionConfig` by setting the
+   * `maxSupportedTransactionVersion` property.
    */
 
 
+  /**
+   * Fetch a confirmed or finalized transaction from the cluster.
+   */
+  // eslint-disable-next-line no-dupe-class-members
   async getTransaction(signature, rawConfig) {
     const {
       commitment,
@@ -5342,7 +6430,7 @@ class Connection {
     if (!result) return result;
     return { ...result,
       transaction: { ...result.transaction,
-        message: new Message(result.transaction.message)
+        message: versionedMessageFromResponse(result.version, result.transaction.message)
       }
     };
   }
@@ -5401,9 +6489,19 @@ class Connection {
   /**
    * Fetch transaction details for a batch of confirmed transactions.
    * Similar to {@link getParsedTransactions} but returns a {@link TransactionResponse}.
+   *
+   * @deprecated Instead, call `getTransactions` using a
+   * `GetVersionedTransactionConfig` by setting the
+   * `maxSupportedTransactionVersion` property.
    */
 
 
+  /**
+   * Fetch transaction details for a batch of confirmed transactions.
+   * Similar to {@link getParsedTransactions} but returns a {@link
+   * VersionedTransactionResponse}.
+   */
+  // eslint-disable-next-line no-dupe-class-members
   async getTransactions(signatures, commitmentOrConfig) {
     const {
       commitment,
@@ -5431,7 +6529,7 @@ class Connection {
       if (!result) return result;
       return { ...result,
         transaction: { ...result.transaction,
-          message: new Message(result.transaction.message)
+          message: versionedMessageFromResponse(result.version, result.transaction.message)
         }
       };
     });
@@ -5764,11 +6862,11 @@ class Connection {
    */
 
 
-  async getNonceAndContext(nonceAccount, commitment) {
+  async getNonceAndContext(nonceAccount, commitmentOrConfig) {
     const {
       context,
       value: accountInfo
-    } = await this.getAccountInfoAndContext(nonceAccount, commitment);
+    } = await this.getAccountInfoAndContext(nonceAccount, commitmentOrConfig);
     let value = null;
 
     if (accountInfo !== null) {
@@ -5785,8 +6883,8 @@ class Connection {
    */
 
 
-  async getNonce(nonceAccount, commitment) {
-    return await this.getNonceAndContext(nonceAccount, commitment).then(x => x.value).catch(e => {
+  async getNonce(nonceAccount, commitmentOrConfig) {
+    return await this.getNonceAndContext(nonceAccount, commitmentOrConfig).then(x => x.value).catch(e => {
       throw new Error('failed to get nonce for account ' + nonceAccount.toBase58() + ': ' + e);
     });
   }
@@ -5894,14 +6992,48 @@ class Connection {
       throw new SolanaJSONRPCError(res.error, `failed to get stake minimum delegation`);
     }
 
-    return res.result;
-  }
+    return res.result;
+  }
+  /**
+   * Simulate a transaction
+   *
+   * @deprecated Instead, call {@link simulateTransaction} with {@link
+   * VersionedTransaction} and {@link SimulateTransactionConfig} parameters
+   */
+
+
   /**
    * Simulate a transaction
    */
+  // eslint-disable-next-line no-dupe-class-members
+  async simulateTransaction(transactionOrMessage, configOrSigners, includeAccounts) {
+    if ('message' in transactionOrMessage) {
+      const versionedTx = transactionOrMessage;
+      const wireTransaction = versionedTx.serialize();
+      const encodedTransaction = buffer.Buffer.from(wireTransaction).toString('base64');
+
+      if (Array.isArray(configOrSigners) || includeAccounts !== undefined) {
+        throw new Error('Invalid arguments');
+      }
+
+      const config = configOrSigners || {};
+      config.encoding = 'base64';
+
+      if (!('commitment' in config)) {
+        config.commitment = this.commitment;
+      }
+
+      const args = [encodedTransaction, config];
+      const unsafeRes = await this._rpcRequest('simulateTransaction', args);
+      const res = superstruct.create(unsafeRes, SimulatedTransactionResponseStruct);
 
+      if ('error' in res) {
+        throw new Error('failed to simulate transaction: ' + res.error.message);
+      }
+
+      return res.result;
+    }
 
-  async simulateTransaction(transactionOrMessage, signers, includeAccounts) {
     let transaction;
 
     if (transactionOrMessage instanceof Transaction) {
@@ -5917,6 +7049,12 @@ class Connection {
       transaction._message = transaction._json = undefined;
     }
 
+    if (configOrSigners !== undefined && !Array.isArray(configOrSigners)) {
+      throw new Error('Invalid arguments');
+    }
+
+    const signers = configOrSigners;
+
     if (transaction.nonceInfo && signers) {
       transaction.sign(...signers);
     } else {
@@ -5997,12 +7135,34 @@ class Connection {
 
     return res.result;
   }
+  /**
+   * Sign and send a transaction
+   *
+   * @deprecated Instead, call {@link sendTransaction} with a {@link
+   * VersionedTransaction}
+   */
+
+
   /**
    * Sign and send a transaction
    */
+  // eslint-disable-next-line no-dupe-class-members
+  async sendTransaction(transaction, signersOrOptions, options) {
+    if ('version' in transaction) {
+      if (signersOrOptions && Array.isArray(signersOrOptions)) {
+        throw new Error('Invalid arguments');
+      }
 
+      const wireTransaction = transaction.serialize();
+      return await this.sendRawTransaction(wireTransaction, options);
+    }
+
+    if (signersOrOptions === undefined || !Array.isArray(signersOrOptions)) {
+      throw new Error('Invalid arguments');
+    }
+
+    const signers = signersOrOptions;
 
-  async sendTransaction(transaction, signers, options) {
     if (transaction.nonceInfo) {
       transaction.sign(...signers);
     } else {
@@ -6125,7 +7285,7 @@ class Connection {
 
   _wsOnClose(code) {
     this._rpcWebSocketConnected = false;
-    this._rpcWebSocketGeneration++;
+    this._rpcWebSocketGeneration = (this._rpcWebSocketGeneration + 1) % Number.MAX_SAFE_INTEGER;
 
     if (this._rpcWebSocketIdleTimeout) {
       clearTimeout(this._rpcWebSocketIdleTimeout);
@@ -6147,9 +7307,9 @@ class Connection {
 
     this._subscriptionCallbacksByServerSubscriptionId = {};
     Object.entries(this._subscriptionsByHash).forEach(([hash, subscription]) => {
-      this._subscriptionsByHash[hash] = { ...subscription,
+      this._setSubscription(hash, { ...subscription,
         state: 'pending'
-      };
+      });
     });
   }
   /**
@@ -6157,6 +7317,53 @@ class Connection {
    */
 
 
+  _setSubscription(hash, nextSubscription) {
+    var _this$_subscriptionsB;
+
+    const prevState = (_this$_subscriptionsB = this._subscriptionsByHash[hash]) === null || _this$_subscriptionsB === void 0 ? void 0 : _this$_subscriptionsB.state;
+    this._subscriptionsByHash[hash] = nextSubscription;
+
+    if (prevState !== nextSubscription.state) {
+      const stateChangeCallbacks = this._subscriptionStateChangeCallbacksByHash[hash];
+
+      if (stateChangeCallbacks) {
+        stateChangeCallbacks.forEach(cb => {
+          try {
+            cb(nextSubscription.state); // eslint-disable-next-line no-empty
+          } catch {}
+        });
+      }
+    }
+  }
+  /**
+   * @internal
+   */
+
+
+  _onSubscriptionStateChange(clientSubscriptionId, callback) {
+    var _this$_subscriptionSt;
+
+    const hash = this._subscriptionHashByClientSubscriptionId[clientSubscriptionId];
+
+    if (hash == null) {
+      return () => {};
+    }
+
+    const stateChangeCallbacks = (_this$_subscriptionSt = this._subscriptionStateChangeCallbacksByHash)[hash] || (_this$_subscriptionSt[hash] = new Set());
+    stateChangeCallbacks.add(callback);
+    return () => {
+      stateChangeCallbacks.delete(callback);
+
+      if (stateChangeCallbacks.size === 0) {
+        delete this._subscriptionStateChangeCallbacksByHash[hash];
+      }
+    };
+  }
+  /**
+   * @internal
+   */
+
+
   async _updateSubscriptions() {
     if (Object.keys(this._subscriptionsByHash).length === 0) {
       if (this._rpcWebSocketConnected) {
@@ -6242,14 +7449,17 @@ class Connection {
             } = subscription;
 
             try {
-              this._subscriptionsByHash[hash] = { ...subscription,
+              this._setSubscription(hash, { ...subscription,
                 state: 'subscribing'
-              };
+              });
+
               const serverSubscriptionId = await this._rpcWebSocket.call(method, args);
-              this._subscriptionsByHash[hash] = { ...subscription,
+
+              this._setSubscription(hash, { ...subscription,
                 serverSubscriptionId,
                 state: 'subscribed'
-              };
+              });
+
               this._subscriptionCallbacksByServerSubscriptionId[serverSubscriptionId] = subscription.callbacks;
               await this._updateSubscriptions();
             } catch (e) {
@@ -6262,9 +7472,10 @@ class Connection {
               } // TODO: Maybe add an 'errored' state or a retry limit?
 
 
-              this._subscriptionsByHash[hash] = { ...subscription,
+              this._setSubscription(hash, { ...subscription,
                 state: 'pending'
-              };
+              });
+
               await this._updateSubscriptions();
             }
           })();
@@ -6293,9 +7504,13 @@ class Connection {
                  */
                 this._subscriptionsAutoDisposedByRpc.delete(serverSubscriptionId);
               } else {
-                this._subscriptionsByHash[hash] = { ...subscription,
+                this._setSubscription(hash, { ...subscription,
                   state: 'unsubscribing'
-                };
+                });
+
+                this._setSubscription(hash, { ...subscription,
+                  state: 'unsubscribing'
+                });
 
                 try {
                   await this._rpcWebSocket.call(unsubscribeMethod, [serverSubscriptionId]);
@@ -6309,17 +7524,19 @@ class Connection {
                   } // TODO: Maybe add an 'errored' state or a retry limit?
 
 
-                  this._subscriptionsByHash[hash] = { ...subscription,
+                  this._setSubscription(hash, { ...subscription,
                     state: 'subscribed'
-                  };
+                  });
+
                   await this._updateSubscriptions();
                   return;
                 }
               }
 
-              this._subscriptionsByHash[hash] = { ...subscription,
+              this._setSubscription(hash, { ...subscription,
                 state: 'unsubscribed'
-              };
+              });
+
               await this._updateSubscriptions();
             })();
           }
@@ -6412,8 +7629,11 @@ class Connection {
       existingSubscription.callbacks.add(subscriptionConfig.callback);
     }
 
+    this._subscriptionHashByClientSubscriptionId[clientSubscriptionId] = hash;
+
     this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId] = async () => {
       delete this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId];
+      delete this._subscriptionHashByClientSubscriptionId[clientSubscriptionId];
       const subscription = this._subscriptionsByHash[hash];
       assert(subscription !== undefined, `Could not find a \`Subscription\` when tearing down client subscription #${clientSubscriptionId}`);
       subscription.callbacks.delete(subscriptionConfig.callback);
@@ -6858,12 +8078,7 @@ class Keypair {
    */
   constructor(keypair) {
     this._keypair = void 0;
-
-    if (keypair) {
-      this._keypair = keypair;
-    } else {
-      this._keypair = nacl__default["default"].sign.keyPair();
-    }
+    this._keypair = keypair !== null && keypair !== void 0 ? keypair : generateKeypair();
   }
   /**
    * Generate a new random keypair
@@ -6871,7 +8086,7 @@ class Keypair {
 
 
   static generate() {
-    return new Keypair(nacl__default["default"].sign.keyPair());
+    return new Keypair(generateKeypair());
   }
   /**
    * Create a keypair from a raw secret key byte array.
@@ -6888,19 +8103,27 @@ class Keypair {
 
 
   static fromSecretKey(secretKey, options) {
-    const keypair = nacl__default["default"].sign.keyPair.fromSecretKey(secretKey);
+    if (secretKey.byteLength !== 64) {
+      throw new Error('bad secret key size');
+    }
+
+    const publicKey = secretKey.slice(32, 64);
 
     if (!options || !options.skipValidation) {
-      const encoder = new TextEncoder();
-      const signData = encoder.encode('@solana/web3.js-validation-v1');
-      const signature = nacl__default["default"].sign.detached(signData, keypair.secretKey);
+      const privateScalar = secretKey.slice(0, 32);
+      const computedPublicKey = getPublicKey(privateScalar);
 
-      if (!nacl__default["default"].sign.detached.verify(signData, signature, keypair.publicKey)) {
-        throw new Error('provided secretKey is invalid');
+      for (let ii = 0; ii < 32; ii++) {
+        if (publicKey[ii] !== computedPublicKey[ii]) {
+          throw new Error('provided secretKey is invalid');
+        }
       }
     }
 
-    return new Keypair(keypair);
+    return new Keypair({
+      publicKey,
+      secretKey
+    });
   }
   /**
    * Generate a keypair from a 32 byte seed.
@@ -6910,7 +8133,14 @@ class Keypair {
 
 
   static fromSeed(seed) {
-    return new Keypair(nacl__default["default"].sign.keyPair.fromSeed(seed));
+    const publicKey = getPublicKey(seed);
+    const secretKey = new Uint8Array(64);
+    secretKey.set(seed);
+    secretKey.set(publicKey, 32);
+    return new Keypair({
+      publicKey,
+      secretKey
+    });
   }
   /**
    * The public key for this keypair
@@ -6926,7 +8156,7 @@ class Keypair {
 
 
   get secretKey() {
-    return this._keypair.secretKey;
+    return new Uint8Array(this._keypair.secretKey);
   }
 
 }
@@ -7341,6 +8571,9 @@ class ComputeBudgetProgram {
    */
 
 
+  /**
+   * @deprecated Instead, call {@link setComputeUnitLimit} and/or {@link setComputeUnitPrice}
+   */
   static requestUnits(params) {
     const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits;
     const data = encodeData(type, params);
@@ -7462,7 +8695,7 @@ class Ed25519Program {
     try {
       const keypair = Keypair.fromSecretKey(privateKey);
       const publicKey = keypair.publicKey.toBytes();
-      const signature = nacl__default["default"].sign.detached(message, keypair.secretKey);
+      const signature = sign(message, keypair.secretKey);
       return this.createInstructionWithPublicKey({
         publicKey,
         message,
@@ -7477,1042 +8710,20 @@ class Ed25519Program {
 }
 Ed25519Program.programId = new PublicKey('Ed25519SigVerify111111111111111111111111111');
 
-// HMAC (RFC 2104)
-class HMAC extends Hash {
-    constructor(hash, _key) {
-        super();
-        this.finished = false;
-        this.destroyed = false;
-        assert$2.hash(hash);
-        const key = toBytes(_key);
-        this.iHash = hash.create();
-        if (!(this.iHash instanceof Hash))
-            throw new TypeError('Expected instance of class which extends utils.Hash');
-        const blockLen = (this.blockLen = this.iHash.blockLen);
-        this.outputLen = this.iHash.outputLen;
-        const pad = new Uint8Array(blockLen);
-        // blockLen can be bigger than outputLen
-        pad.set(key.length > this.iHash.blockLen ? hash.create().update(key).digest() : key);
-        for (let i = 0; i < pad.length; i++)
-            pad[i] ^= 0x36;
-        this.iHash.update(pad);
-        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone
-        this.oHash = hash.create();
-        // Undo internal XOR && apply outer XOR
-        for (let i = 0; i < pad.length; i++)
-            pad[i] ^= 0x36 ^ 0x5c;
-        this.oHash.update(pad);
-        pad.fill(0);
-    }
-    update(buf) {
-        assert$2.exists(this);
-        this.iHash.update(buf);
-        return this;
-    }
-    digestInto(out) {
-        assert$2.exists(this);
-        assert$2.bytes(out, this.outputLen);
-        this.finished = true;
-        this.iHash.digestInto(out);
-        this.oHash.update(out);
-        this.oHash.digestInto(out);
-        this.destroy();
-    }
-    digest() {
-        const out = new Uint8Array(this.oHash.outputLen);
-        this.digestInto(out);
-        return out;
-    }
-    _cloneInto(to) {
-        // Create new instance without calling constructor since key already in state and we don't know it.
-        to || (to = Object.create(Object.getPrototypeOf(this), {}));
-        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-        to = to;
-        to.finished = finished;
-        to.destroyed = destroyed;
-        to.blockLen = blockLen;
-        to.outputLen = outputLen;
-        to.oHash = oHash._cloneInto(to.oHash);
-        to.iHash = iHash._cloneInto(to.iHash);
-        return to;
-    }
-    destroy() {
-        this.destroyed = true;
-        this.oHash.destroy();
-        this.iHash.destroy();
-    }
-}
-/**
- * HMAC: RFC2104 message authentication code.
- * @param hash - function that would be used e.g. sha256
- * @param key - message key
- * @param message - message data
- */
-const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
-hmac.create = (hash, key) => new HMAC(hash, key);
-
-var _nodeResolve_empty = {};
-
-var nodeCrypto = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': _nodeResolve_empty
-});
-
-/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-const _2n = BigInt(2);
-const _3n = BigInt(3);
-const _8n = BigInt(8);
-const POW_2_256 = _2n ** BigInt(256);
-const CURVE = {
-    a: _0n,
-    b: BigInt(7),
-    P: POW_2_256 - _2n ** BigInt(32) - BigInt(977),
-    n: POW_2_256 - BigInt('432420386565659656852420866394968145599'),
-    h: _1n,
-    Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),
-    Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),
-    beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),
-};
-function weistrass(x) {
-    const { a, b } = CURVE;
-    const x2 = mod(x * x);
-    const x3 = mod(x2 * x);
-    return mod(x3 + a * x + b);
-}
-const USE_ENDOMORPHISM = CURVE.a === _0n;
-class JacobianPoint {
-    constructor(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-    static fromAffine(p) {
-        if (!(p instanceof Point)) {
-            throw new TypeError('JacobianPoint#fromAffine: expected Point');
-        }
-        return new JacobianPoint(p.x, p.y, _1n);
-    }
-    static toAffineBatch(points) {
-        const toInv = invertBatch(points.map((p) => p.z));
-        return points.map((p, i) => p.toAffine(toInv[i]));
-    }
-    static normalizeZ(points) {
-        return JacobianPoint.toAffineBatch(points).map(JacobianPoint.fromAffine);
-    }
-    equals(other) {
-        if (!(other instanceof JacobianPoint))
-            throw new TypeError('JacobianPoint expected');
-        const { x: X1, y: Y1, z: Z1 } = this;
-        const { x: X2, y: Y2, z: Z2 } = other;
-        const Z1Z1 = mod(Z1 ** _2n);
-        const Z2Z2 = mod(Z2 ** _2n);
-        const U1 = mod(X1 * Z2Z2);
-        const U2 = mod(X2 * Z1Z1);
-        const S1 = mod(mod(Y1 * Z2) * Z2Z2);
-        const S2 = mod(mod(Y2 * Z1) * Z1Z1);
-        return U1 === U2 && S1 === S2;
-    }
-    negate() {
-        return new JacobianPoint(this.x, mod(-this.y), this.z);
-    }
-    double() {
-        const { x: X1, y: Y1, z: Z1 } = this;
-        const A = mod(X1 ** _2n);
-        const B = mod(Y1 ** _2n);
-        const C = mod(B ** _2n);
-        const D = mod(_2n * (mod((X1 + B) ** _2n) - A - C));
-        const E = mod(_3n * A);
-        const F = mod(E ** _2n);
-        const X3 = mod(F - _2n * D);
-        const Y3 = mod(E * (D - X3) - _8n * C);
-        const Z3 = mod(_2n * Y1 * Z1);
-        return new JacobianPoint(X3, Y3, Z3);
-    }
-    add(other) {
-        if (!(other instanceof JacobianPoint))
-            throw new TypeError('JacobianPoint expected');
-        const { x: X1, y: Y1, z: Z1 } = this;
-        const { x: X2, y: Y2, z: Z2 } = other;
-        if (X2 === _0n || Y2 === _0n)
-            return this;
-        if (X1 === _0n || Y1 === _0n)
-            return other;
-        const Z1Z1 = mod(Z1 ** _2n);
-        const Z2Z2 = mod(Z2 ** _2n);
-        const U1 = mod(X1 * Z2Z2);
-        const U2 = mod(X2 * Z1Z1);
-        const S1 = mod(mod(Y1 * Z2) * Z2Z2);
-        const S2 = mod(mod(Y2 * Z1) * Z1Z1);
-        const H = mod(U2 - U1);
-        const r = mod(S2 - S1);
-        if (H === _0n) {
-            if (r === _0n) {
-                return this.double();
-            }
-            else {
-                return JacobianPoint.ZERO;
-            }
-        }
-        const HH = mod(H ** _2n);
-        const HHH = mod(H * HH);
-        const V = mod(U1 * HH);
-        const X3 = mod(r ** _2n - HHH - _2n * V);
-        const Y3 = mod(r * (V - X3) - S1 * HHH);
-        const Z3 = mod(Z1 * Z2 * H);
-        return new JacobianPoint(X3, Y3, Z3);
-    }
-    subtract(other) {
-        return this.add(other.negate());
-    }
-    multiplyUnsafe(scalar) {
-        const P0 = JacobianPoint.ZERO;
-        if (typeof scalar === 'bigint' && scalar === _0n)
-            return P0;
-        let n = normalizeScalar(scalar);
-        if (n === _1n)
-            return this;
-        if (!USE_ENDOMORPHISM) {
-            let p = P0;
-            let d = this;
-            while (n > _0n) {
-                if (n & _1n)
-                    p = p.add(d);
-                d = d.double();
-                n >>= _1n;
-            }
-            return p;
-        }
-        let { k1neg, k1, k2neg, k2 } = splitScalarEndo(n);
-        let k1p = P0;
-        let k2p = P0;
-        let d = this;
-        while (k1 > _0n || k2 > _0n) {
-            if (k1 & _1n)
-                k1p = k1p.add(d);
-            if (k2 & _1n)
-                k2p = k2p.add(d);
-            d = d.double();
-            k1 >>= _1n;
-            k2 >>= _1n;
-        }
-        if (k1neg)
-            k1p = k1p.negate();
-        if (k2neg)
-            k2p = k2p.negate();
-        k2p = new JacobianPoint(mod(k2p.x * CURVE.beta), k2p.y, k2p.z);
-        return k1p.add(k2p);
-    }
-    precomputeWindow(W) {
-        const windows = USE_ENDOMORPHISM ? 128 / W + 1 : 256 / W + 1;
-        const points = [];
-        let p = this;
-        let base = p;
-        for (let window = 0; window < windows; window++) {
-            base = p;
-            points.push(base);
-            for (let i = 1; i < 2 ** (W - 1); i++) {
-                base = base.add(p);
-                points.push(base);
-            }
-            p = base.double();
-        }
-        return points;
-    }
-    wNAF(n, affinePoint) {
-        if (!affinePoint && this.equals(JacobianPoint.BASE))
-            affinePoint = Point.BASE;
-        const W = (affinePoint && affinePoint._WINDOW_SIZE) || 1;
-        if (256 % W) {
-            throw new Error('Point#wNAF: Invalid precomputation window, must be power of 2');
-        }
-        let precomputes = affinePoint && pointPrecomputes.get(affinePoint);
-        if (!precomputes) {
-            precomputes = this.precomputeWindow(W);
-            if (affinePoint && W !== 1) {
-                precomputes = JacobianPoint.normalizeZ(precomputes);
-                pointPrecomputes.set(affinePoint, precomputes);
-            }
-        }
-        let p = JacobianPoint.ZERO;
-        let f = JacobianPoint.ZERO;
-        const windows = 1 + (USE_ENDOMORPHISM ? 128 / W : 256 / W);
-        const windowSize = 2 ** (W - 1);
-        const mask = BigInt(2 ** W - 1);
-        const maxNumber = 2 ** W;
-        const shiftBy = BigInt(W);
-        for (let window = 0; window < windows; window++) {
-            const offset = window * windowSize;
-            let wbits = Number(n & mask);
-            n >>= shiftBy;
-            if (wbits > windowSize) {
-                wbits -= maxNumber;
-                n += _1n;
-            }
-            if (wbits === 0) {
-                let pr = precomputes[offset];
-                if (window % 2)
-                    pr = pr.negate();
-                f = f.add(pr);
-            }
-            else {
-                let cached = precomputes[offset + Math.abs(wbits) - 1];
-                if (wbits < 0)
-                    cached = cached.negate();
-                p = p.add(cached);
-            }
-        }
-        return { p, f };
-    }
-    multiply(scalar, affinePoint) {
-        let n = normalizeScalar(scalar);
-        let point;
-        let fake;
-        if (USE_ENDOMORPHISM) {
-            const { k1neg, k1, k2neg, k2 } = splitScalarEndo(n);
-            let { p: k1p, f: f1p } = this.wNAF(k1, affinePoint);
-            let { p: k2p, f: f2p } = this.wNAF(k2, affinePoint);
-            if (k1neg)
-                k1p = k1p.negate();
-            if (k2neg)
-                k2p = k2p.negate();
-            k2p = new JacobianPoint(mod(k2p.x * CURVE.beta), k2p.y, k2p.z);
-            point = k1p.add(k2p);
-            fake = f1p.add(f2p);
-        }
-        else {
-            const { p, f } = this.wNAF(n, affinePoint);
-            point = p;
-            fake = f;
-        }
-        return JacobianPoint.normalizeZ([point, fake])[0];
-    }
-    toAffine(invZ = invert(this.z)) {
-        const { x, y, z } = this;
-        const iz1 = invZ;
-        const iz2 = mod(iz1 * iz1);
-        const iz3 = mod(iz2 * iz1);
-        const ax = mod(x * iz2);
-        const ay = mod(y * iz3);
-        const zz = mod(z * iz1);
-        if (zz !== _1n)
-            throw new Error('invZ was invalid');
-        return new Point(ax, ay);
-    }
-}
-JacobianPoint.BASE = new JacobianPoint(CURVE.Gx, CURVE.Gy, _1n);
-JacobianPoint.ZERO = new JacobianPoint(_0n, _1n, _0n);
-const pointPrecomputes = new WeakMap();
-class Point {
-    constructor(x, y) {
-        this.x = x;
-        this.y = y;
-    }
-    _setWindowSize(windowSize) {
-        this._WINDOW_SIZE = windowSize;
-        pointPrecomputes.delete(this);
-    }
-    static fromCompressedHex(bytes) {
-        const isShort = bytes.length === 32;
-        const x = bytesToNumber(isShort ? bytes : bytes.subarray(1));
-        if (!isValidFieldElement(x))
-            throw new Error('Point is not on curve');
-        const y2 = weistrass(x);
-        let y = sqrtMod(y2);
-        const isYOdd = (y & _1n) === _1n;
-        if (isShort) {
-            if (isYOdd)
-                y = mod(-y);
-        }
-        else {
-            const isFirstByteOdd = (bytes[0] & 1) === 1;
-            if (isFirstByteOdd !== isYOdd)
-                y = mod(-y);
-        }
-        const point = new Point(x, y);
-        point.assertValidity();
-        return point;
-    }
-    static fromUncompressedHex(bytes) {
-        const x = bytesToNumber(bytes.subarray(1, 33));
-        const y = bytesToNumber(bytes.subarray(33, 65));
-        const point = new Point(x, y);
-        point.assertValidity();
-        return point;
-    }
-    static fromHex(hex) {
-        const bytes = ensureBytes(hex);
-        const len = bytes.length;
-        const header = bytes[0];
-        if (len === 32 || (len === 33 && (header === 0x02 || header === 0x03))) {
-            return this.fromCompressedHex(bytes);
-        }
-        if (len === 65 && header === 0x04)
-            return this.fromUncompressedHex(bytes);
-        throw new Error(`Point.fromHex: received invalid point. Expected 32-33 compressed bytes or 65 uncompressed bytes, not ${len}`);
-    }
-    static fromPrivateKey(privateKey) {
-        return Point.BASE.multiply(normalizePrivateKey(privateKey));
-    }
-    static fromSignature(msgHash, signature, recovery) {
-        msgHash = ensureBytes(msgHash);
-        const h = truncateHash(msgHash);
-        const { r, s } = normalizeSignature(signature);
-        if (recovery !== 0 && recovery !== 1) {
-            throw new Error('Cannot recover signature: invalid recovery bit');
-        }
-        const prefix = recovery & 1 ? '03' : '02';
-        const R = Point.fromHex(prefix + numTo32bStr(r));
-        const { n } = CURVE;
-        const rinv = invert(r, n);
-        const u1 = mod(-h * rinv, n);
-        const u2 = mod(s * rinv, n);
-        const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);
-        if (!Q)
-            throw new Error('Cannot recover signature: point at infinify');
-        Q.assertValidity();
-        return Q;
-    }
-    toRawBytes(isCompressed = false) {
-        return hexToBytes(this.toHex(isCompressed));
-    }
-    toHex(isCompressed = false) {
-        const x = numTo32bStr(this.x);
-        if (isCompressed) {
-            const prefix = this.y & _1n ? '03' : '02';
-            return `${prefix}${x}`;
-        }
-        else {
-            return `04${x}${numTo32bStr(this.y)}`;
-        }
-    }
-    toHexX() {
-        return this.toHex(true).slice(2);
-    }
-    toRawX() {
-        return this.toRawBytes(true).slice(1);
-    }
-    assertValidity() {
-        const msg = 'Point is not on elliptic curve';
-        const { x, y } = this;
-        if (!isValidFieldElement(x) || !isValidFieldElement(y))
-            throw new Error(msg);
-        const left = mod(y * y);
-        const right = weistrass(x);
-        if (mod(left - right) !== _0n)
-            throw new Error(msg);
-    }
-    equals(other) {
-        return this.x === other.x && this.y === other.y;
-    }
-    negate() {
-        return new Point(this.x, mod(-this.y));
-    }
-    double() {
-        return JacobianPoint.fromAffine(this).double().toAffine();
-    }
-    add(other) {
-        return JacobianPoint.fromAffine(this).add(JacobianPoint.fromAffine(other)).toAffine();
-    }
-    subtract(other) {
-        return this.add(other.negate());
-    }
-    multiply(scalar) {
-        return JacobianPoint.fromAffine(this).multiply(scalar, this).toAffine();
-    }
-    multiplyAndAddUnsafe(Q, a, b) {
-        const P = JacobianPoint.fromAffine(this);
-        const aP = a === _0n || a === _1n || this !== Point.BASE ? P.multiplyUnsafe(a) : P.multiply(a);
-        const bQ = JacobianPoint.fromAffine(Q).multiplyUnsafe(b);
-        const sum = aP.add(bQ);
-        return sum.equals(JacobianPoint.ZERO) ? undefined : sum.toAffine();
-    }
-}
-Point.BASE = new Point(CURVE.Gx, CURVE.Gy);
-Point.ZERO = new Point(_0n, _0n);
-function sliceDER(s) {
-    return Number.parseInt(s[0], 16) >= 8 ? '00' + s : s;
-}
-function parseDERInt(data) {
-    if (data.length < 2 || data[0] !== 0x02) {
-        throw new Error(`Invalid signature integer tag: ${bytesToHex(data)}`);
-    }
-    const len = data[1];
-    const res = data.subarray(2, len + 2);
-    if (!len || res.length !== len) {
-        throw new Error(`Invalid signature integer: wrong length`);
-    }
-    if (res[0] === 0x00 && res[1] <= 0x7f) {
-        throw new Error('Invalid signature integer: trailing length');
-    }
-    return { data: bytesToNumber(res), left: data.subarray(len + 2) };
-}
-function parseDERSignature(data) {
-    if (data.length < 2 || data[0] != 0x30) {
-        throw new Error(`Invalid signature tag: ${bytesToHex(data)}`);
-    }
-    if (data[1] !== data.length - 2) {
-        throw new Error('Invalid signature: incorrect length');
-    }
-    const { data: r, left: sBytes } = parseDERInt(data.subarray(2));
-    const { data: s, left: rBytesLeft } = parseDERInt(sBytes);
-    if (rBytesLeft.length) {
-        throw new Error(`Invalid signature: left bytes after parsing: ${bytesToHex(rBytesLeft)}`);
-    }
-    return { r, s };
-}
-class Signature {
-    constructor(r, s) {
-        this.r = r;
-        this.s = s;
-        this.assertValidity();
-    }
-    static fromCompact(hex) {
-        const arr = isUint8a(hex);
-        const name = 'Signature.fromCompact';
-        if (typeof hex !== 'string' && !arr)
-            throw new TypeError(`${name}: Expected string or Uint8Array`);
-        const str = arr ? bytesToHex(hex) : hex;
-        if (str.length !== 128)
-            throw new Error(`${name}: Expected 64-byte hex`);
-        return new Signature(hexToNumber(str.slice(0, 64)), hexToNumber(str.slice(64, 128)));
-    }
-    static fromDER(hex) {
-        const arr = isUint8a(hex);
-        if (typeof hex !== 'string' && !arr)
-            throw new TypeError(`Signature.fromDER: Expected string or Uint8Array`);
-        const { r, s } = parseDERSignature(arr ? hex : hexToBytes(hex));
-        return new Signature(r, s);
-    }
-    static fromHex(hex) {
-        return this.fromDER(hex);
-    }
-    assertValidity() {
-        const { r, s } = this;
-        if (!isWithinCurveOrder(r))
-            throw new Error('Invalid Signature: r must be 0 < r < n');
-        if (!isWithinCurveOrder(s))
-            throw new Error('Invalid Signature: s must be 0 < s < n');
-    }
-    hasHighS() {
-        const HALF = CURVE.n >> _1n;
-        return this.s > HALF;
-    }
-    normalizeS() {
-        return this.hasHighS() ? new Signature(this.r, CURVE.n - this.s) : this;
-    }
-    toDERRawBytes(isCompressed = false) {
-        return hexToBytes(this.toDERHex(isCompressed));
-    }
-    toDERHex(isCompressed = false) {
-        const sHex = sliceDER(numberToHexUnpadded(this.s));
-        if (isCompressed)
-            return sHex;
-        const rHex = sliceDER(numberToHexUnpadded(this.r));
-        const rLen = numberToHexUnpadded(rHex.length / 2);
-        const sLen = numberToHexUnpadded(sHex.length / 2);
-        const length = numberToHexUnpadded(rHex.length / 2 + sHex.length / 2 + 4);
-        return `30${length}02${rLen}${rHex}02${sLen}${sHex}`;
-    }
-    toRawBytes() {
-        return this.toDERRawBytes();
-    }
-    toHex() {
-        return this.toDERHex();
-    }
-    toCompactRawBytes() {
-        return hexToBytes(this.toCompactHex());
-    }
-    toCompactHex() {
-        return numTo32bStr(this.r) + numTo32bStr(this.s);
-    }
-}
-function concatBytes(...arrays) {
-    if (!arrays.every(isUint8a))
-        throw new Error('Uint8Array list expected');
-    if (arrays.length === 1)
-        return arrays[0];
-    const length = arrays.reduce((a, arr) => a + arr.length, 0);
-    const result = new Uint8Array(length);
-    for (let i = 0, pad = 0; i < arrays.length; i++) {
-        const arr = arrays[i];
-        result.set(arr, pad);
-        pad += arr.length;
-    }
-    return result;
-}
-function isUint8a(bytes) {
-    return bytes instanceof Uint8Array;
-}
-const hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
-function bytesToHex(uint8a) {
-    if (!(uint8a instanceof Uint8Array))
-        throw new Error('Expected Uint8Array');
-    let hex = '';
-    for (let i = 0; i < uint8a.length; i++) {
-        hex += hexes[uint8a[i]];
-    }
-    return hex;
-}
-function numTo32bStr(num) {
-    if (num > POW_2_256)
-        throw new Error('Expected number < 2^256');
-    return num.toString(16).padStart(64, '0');
-}
-function numTo32b(num) {
-    return hexToBytes(numTo32bStr(num));
-}
-function numberToHexUnpadded(num) {
-    const hex = num.toString(16);
-    return hex.length & 1 ? `0${hex}` : hex;
-}
-function hexToNumber(hex) {
-    if (typeof hex !== 'string') {
-        throw new TypeError('hexToNumber: expected string, got ' + typeof hex);
-    }
-    return BigInt(`0x${hex}`);
-}
-function hexToBytes(hex) {
-    if (typeof hex !== 'string') {
-        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);
-    }
-    if (hex.length % 2)
-        throw new Error('hexToBytes: received invalid unpadded hex' + hex.length);
-    const array = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < array.length; i++) {
-        const j = i * 2;
-        const hexByte = hex.slice(j, j + 2);
-        const byte = Number.parseInt(hexByte, 16);
-        if (Number.isNaN(byte) || byte < 0)
-            throw new Error('Invalid byte sequence');
-        array[i] = byte;
-    }
-    return array;
-}
-function bytesToNumber(bytes) {
-    return hexToNumber(bytesToHex(bytes));
-}
-function ensureBytes(hex) {
-    return hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes(hex);
-}
-function normalizeScalar(num) {
-    if (typeof num === 'number' && Number.isSafeInteger(num) && num > 0)
-        return BigInt(num);
-    if (typeof num === 'bigint' && isWithinCurveOrder(num))
-        return num;
-    throw new TypeError('Expected valid private scalar: 0 < scalar < curve.n');
-}
-function mod(a, b = CURVE.P) {
-    const result = a % b;
-    return result >= _0n ? result : b + result;
-}
-function pow2(x, power) {
-    const { P } = CURVE;
-    let res = x;
-    while (power-- > _0n) {
-        res *= res;
-        res %= P;
-    }
-    return res;
-}
-function sqrtMod(x) {
-    const { P } = CURVE;
-    const _6n = BigInt(6);
-    const _11n = BigInt(11);
-    const _22n = BigInt(22);
-    const _23n = BigInt(23);
-    const _44n = BigInt(44);
-    const _88n = BigInt(88);
-    const b2 = (x * x * x) % P;
-    const b3 = (b2 * b2 * x) % P;
-    const b6 = (pow2(b3, _3n) * b3) % P;
-    const b9 = (pow2(b6, _3n) * b3) % P;
-    const b11 = (pow2(b9, _2n) * b2) % P;
-    const b22 = (pow2(b11, _11n) * b11) % P;
-    const b44 = (pow2(b22, _22n) * b22) % P;
-    const b88 = (pow2(b44, _44n) * b44) % P;
-    const b176 = (pow2(b88, _88n) * b88) % P;
-    const b220 = (pow2(b176, _44n) * b44) % P;
-    const b223 = (pow2(b220, _3n) * b3) % P;
-    const t1 = (pow2(b223, _23n) * b22) % P;
-    const t2 = (pow2(t1, _6n) * b2) % P;
-    return pow2(t2, _2n);
-}
-function invert(number, modulo = CURVE.P) {
-    if (number === _0n || modulo <= _0n) {
-        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
-    }
-    let a = mod(number, modulo);
-    let b = modulo;
-    let x = _0n, u = _1n;
-    while (a !== _0n) {
-        const q = b / a;
-        const r = b % a;
-        const m = x - u * q;
-        b = a, a = r, x = u, u = m;
-    }
-    const gcd = b;
-    if (gcd !== _1n)
-        throw new Error('invert: does not exist');
-    return mod(x, modulo);
-}
-function invertBatch(nums, p = CURVE.P) {
-    const scratch = new Array(nums.length);
-    const lastMultiplied = nums.reduce((acc, num, i) => {
-        if (num === _0n)
-            return acc;
-        scratch[i] = acc;
-        return mod(acc * num, p);
-    }, _1n);
-    const inverted = invert(lastMultiplied, p);
-    nums.reduceRight((acc, num, i) => {
-        if (num === _0n)
-            return acc;
-        scratch[i] = mod(acc * scratch[i], p);
-        return mod(acc * num, p);
-    }, inverted);
-    return scratch;
-}
-const divNearest = (a, b) => (a + b / _2n) / b;
-const POW_2_128 = _2n ** BigInt(128);
-function splitScalarEndo(k) {
-    const { n } = CURVE;
-    const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');
-    const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');
-    const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');
-    const b2 = a1;
-    const c1 = divNearest(b2 * k, n);
-    const c2 = divNearest(-b1 * k, n);
-    let k1 = mod(k - c1 * a1 - c2 * a2, n);
-    let k2 = mod(-c1 * b1 - c2 * b2, n);
-    const k1neg = k1 > POW_2_128;
-    const k2neg = k2 > POW_2_128;
-    if (k1neg)
-        k1 = n - k1;
-    if (k2neg)
-        k2 = n - k2;
-    if (k1 > POW_2_128 || k2 > POW_2_128) {
-        throw new Error('splitScalarEndo: Endomorphism failed, k=' + k);
-    }
-    return { k1neg, k1, k2neg, k2 };
-}
-function truncateHash(hash) {
-    const { n } = CURVE;
-    const byteLength = hash.length;
-    const delta = byteLength * 8 - 256;
-    let h = bytesToNumber(hash);
-    if (delta > 0)
-        h = h >> BigInt(delta);
-    if (h >= n)
-        h -= n;
-    return h;
-}
-class HmacDrbg {
-    constructor() {
-        this.v = new Uint8Array(32).fill(1);
-        this.k = new Uint8Array(32).fill(0);
-        this.counter = 0;
-    }
-    hmac(...values) {
-        return utils.hmacSha256(this.k, ...values);
-    }
-    hmacSync(...values) {
-        if (typeof utils.hmacSha256Sync !== 'function')
-            throw new Error('utils.hmacSha256Sync is undefined, you need to set it');
-        const res = utils.hmacSha256Sync(this.k, ...values);
-        if (res instanceof Promise)
-            throw new Error('To use sync sign(), ensure utils.hmacSha256 is sync');
-        return res;
-    }
-    incr() {
-        if (this.counter >= 1000) {
-            throw new Error('Tried 1,000 k values for sign(), all were invalid');
-        }
-        this.counter += 1;
-    }
-    async reseed(seed = new Uint8Array()) {
-        this.k = await this.hmac(this.v, Uint8Array.from([0x00]), seed);
-        this.v = await this.hmac(this.v);
-        if (seed.length === 0)
-            return;
-        this.k = await this.hmac(this.v, Uint8Array.from([0x01]), seed);
-        this.v = await this.hmac(this.v);
-    }
-    reseedSync(seed = new Uint8Array()) {
-        this.k = this.hmacSync(this.v, Uint8Array.from([0x00]), seed);
-        this.v = this.hmacSync(this.v);
-        if (seed.length === 0)
-            return;
-        this.k = this.hmacSync(this.v, Uint8Array.from([0x01]), seed);
-        this.v = this.hmacSync(this.v);
-    }
-    async generate() {
-        this.incr();
-        this.v = await this.hmac(this.v);
-        return this.v;
-    }
-    generateSync() {
-        this.incr();
-        this.v = this.hmacSync(this.v);
-        return this.v;
-    }
-}
-function isWithinCurveOrder(num) {
-    return _0n < num && num < CURVE.n;
-}
-function isValidFieldElement(num) {
-    return _0n < num && num < CURVE.P;
-}
-function kmdToSig(kBytes, m, d) {
-    const k = bytesToNumber(kBytes);
-    if (!isWithinCurveOrder(k))
-        return;
-    const { n } = CURVE;
-    const q = Point.BASE.multiply(k);
-    const r = mod(q.x, n);
-    if (r === _0n)
-        return;
-    const s = mod(invert(k, n) * mod(m + d * r, n), n);
-    if (s === _0n)
-        return;
-    const sig = new Signature(r, s);
-    const recovery = (q.x === sig.r ? 0 : 2) | Number(q.y & _1n);
-    return { sig, recovery };
-}
-function normalizePrivateKey(key) {
-    let num;
-    if (typeof key === 'bigint') {
-        num = key;
-    }
-    else if (typeof key === 'number' && Number.isSafeInteger(key) && key > 0) {
-        num = BigInt(key);
-    }
-    else if (typeof key === 'string') {
-        if (key.length !== 64)
-            throw new Error('Expected 32 bytes of private key');
-        num = hexToNumber(key);
-    }
-    else if (isUint8a(key)) {
-        if (key.length !== 32)
-            throw new Error('Expected 32 bytes of private key');
-        num = bytesToNumber(key);
-    }
-    else {
-        throw new TypeError('Expected valid private key');
-    }
-    if (!isWithinCurveOrder(num))
-        throw new Error('Expected private key: 0 < key < n');
-    return num;
-}
-function normalizeSignature(signature) {
-    if (signature instanceof Signature) {
-        signature.assertValidity();
-        return signature;
-    }
-    try {
-        return Signature.fromDER(signature);
-    }
-    catch (error) {
-        return Signature.fromCompact(signature);
-    }
-}
-function getPublicKey(privateKey, isCompressed = false) {
-    return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
-}
-function bits2int(bytes) {
-    const slice = bytes.length > 32 ? bytes.slice(0, 32) : bytes;
-    return bytesToNumber(slice);
-}
-function bits2octets(bytes) {
-    const z1 = bits2int(bytes);
-    const z2 = mod(z1, CURVE.n);
-    return int2octets(z2 < _0n ? z1 : z2);
-}
-function int2octets(num) {
-    if (typeof num !== 'bigint')
-        throw new Error('Expected bigint');
-    const hex = numTo32bStr(num);
-    return hexToBytes(hex);
-}
-function initSigArgs(msgHash, privateKey, extraEntropy) {
-    if (msgHash == null)
-        throw new Error(`sign: expected valid message hash, not "${msgHash}"`);
-    const h1 = ensureBytes(msgHash);
-    const d = normalizePrivateKey(privateKey);
-    const seedArgs = [int2octets(d), bits2octets(h1)];
-    if (extraEntropy != null) {
-        if (extraEntropy === true)
-            extraEntropy = utils.randomBytes(32);
-        const e = ensureBytes(extraEntropy);
-        if (e.length !== 32)
-            throw new Error('sign: Expected 32 bytes of extra data');
-        seedArgs.push(e);
-    }
-    const seed = concatBytes(...seedArgs);
-    const m = bits2int(h1);
-    return { seed, m, d };
-}
-function finalizeSig(recSig, opts) {
-    let { sig, recovery } = recSig;
-    const { canonical, der, recovered } = Object.assign({ canonical: true, der: true }, opts);
-    if (canonical && sig.hasHighS()) {
-        sig = sig.normalizeS();
-        recovery ^= 1;
-    }
-    const hashed = der ? sig.toDERRawBytes() : sig.toCompactRawBytes();
-    return recovered ? [hashed, recovery] : hashed;
-}
-function signSync(msgHash, privKey, opts = {}) {
-    const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);
-    let sig;
-    const drbg = new HmacDrbg();
-    drbg.reseedSync(seed);
-    while (!(sig = kmdToSig(drbg.generateSync(), m, d)))
-        drbg.reseedSync();
-    return finalizeSig(sig, opts);
-}
-Point.BASE._setWindowSize(8);
-const crypto = {
-    node: nodeCrypto,
-    web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,
-};
-const TAGGED_HASH_PREFIXES = {};
-const utils = {
-    isValidPrivateKey(privateKey) {
-        try {
-            normalizePrivateKey(privateKey);
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    },
-    privateAdd: (privateKey, tweak) => {
-        const p = normalizePrivateKey(privateKey);
-        const t = normalizePrivateKey(tweak);
-        return numTo32b(mod(p + t, CURVE.n));
-    },
-    privateNegate: (privateKey) => {
-        const p = normalizePrivateKey(privateKey);
-        return numTo32b(CURVE.n - p);
-    },
-    pointAddScalar: (p, tweak, isCompressed) => {
-        const P = Point.fromHex(p);
-        const t = normalizePrivateKey(tweak);
-        const Q = Point.BASE.multiplyAndAddUnsafe(P, t, _1n);
-        if (!Q)
-            throw new Error('Tweaked point at infinity');
-        return Q.toRawBytes(isCompressed);
-    },
-    pointMultiply: (p, tweak, isCompressed) => {
-        const P = Point.fromHex(p);
-        const t = bytesToNumber(ensureBytes(tweak));
-        return P.multiply(t).toRawBytes(isCompressed);
-    },
-    hashToPrivateKey: (hash) => {
-        hash = ensureBytes(hash);
-        if (hash.length < 40 || hash.length > 1024)
-            throw new Error('Expected 40-1024 bytes of private key as per FIPS 186');
-        const num = mod(bytesToNumber(hash), CURVE.n - _1n) + _1n;
-        return numTo32b(num);
-    },
-    randomBytes: (bytesLength = 32) => {
-        if (crypto.web) {
-            return crypto.web.getRandomValues(new Uint8Array(bytesLength));
-        }
-        else if (crypto.node) {
-            const { randomBytes } = crypto.node;
-            return Uint8Array.from(randomBytes(bytesLength));
-        }
-        else {
-            throw new Error("The environment doesn't have randomBytes function");
-        }
-    },
-    randomPrivateKey: () => {
-        return utils.hashToPrivateKey(utils.randomBytes(40));
-    },
-    bytesToHex,
-    hexToBytes,
-    concatBytes,
-    mod,
-    invert,
-    sha256: async (...messages) => {
-        if (crypto.web) {
-            const buffer = await crypto.web.subtle.digest('SHA-256', concatBytes(...messages));
-            return new Uint8Array(buffer);
-        }
-        else if (crypto.node) {
-            const { createHash } = crypto.node;
-            const hash = createHash('sha256');
-            messages.forEach((m) => hash.update(m));
-            return Uint8Array.from(hash.digest());
-        }
-        else {
-            throw new Error("The environment doesn't have sha256 function");
-        }
-    },
-    hmacSha256: async (key, ...messages) => {
-        if (crypto.web) {
-            const ckey = await crypto.web.subtle.importKey('raw', key, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign']);
-            const message = concatBytes(...messages);
-            const buffer = await crypto.web.subtle.sign('HMAC', ckey, message);
-            return new Uint8Array(buffer);
-        }
-        else if (crypto.node) {
-            const { createHmac } = crypto.node;
-            const hash = createHmac('sha256', key);
-            messages.forEach((m) => hash.update(m));
-            return Uint8Array.from(hash.digest());
-        }
-        else {
-            throw new Error("The environment doesn't have hmac-sha256 function");
-        }
-    },
-    sha256Sync: undefined,
-    hmacSha256Sync: undefined,
-    taggedHash: async (tag, ...messages) => {
-        let tagP = TAGGED_HASH_PREFIXES[tag];
-        if (tagP === undefined) {
-            const tagH = await utils.sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
-            tagP = concatBytes(tagH, tagH);
-            TAGGED_HASH_PREFIXES[tag] = tagP;
-        }
-        return utils.sha256(tagP, ...messages);
-    },
-    taggedHashSync: (tag, ...messages) => {
-        if (typeof utils.sha256Sync !== 'function')
-            throw new Error('utils.sha256Sync is undefined, you need to set it');
-        let tagP = TAGGED_HASH_PREFIXES[tag];
-        if (tagP === undefined) {
-            const tagH = utils.sha256Sync(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
-            tagP = concatBytes(tagH, tagH);
-            TAGGED_HASH_PREFIXES[tag] = tagP;
-        }
-        return utils.sha256Sync(tagP, ...messages);
-    },
-    precompute(windowSize = 8, point = Point.BASE) {
-        const cached = point === Point.BASE ? point : new Point(point.x, point.y);
-        cached._setWindowSize(windowSize);
-        cached.multiply(_3n);
-        return cached;
-    },
-};
-
 // library interoperable with the synchronous APIs in web3.js.
 
-utils.hmacSha256Sync = (key, ...msgs) => {
-  const h = hmac.create(sha256, key);
+secp256k1__namespace.utils.hmacSha256Sync = (key, ...msgs) => {
+  const h = hmac.hmac.create(sha256.sha256, key);
   msgs.forEach(msg => h.update(msg));
   return h.digest();
 };
 
-const ecdsaSign = (msgHash, privKey) => signSync(msgHash, privKey, {
+const ecdsaSign = (msgHash, privKey) => secp256k1__namespace.signSync(msgHash, privKey, {
   der: false,
   recovered: true
 });
-utils.isValidPrivateKey;
-const publicKeyCreate = getPublicKey;
+secp256k1__namespace.utils.isValidPrivateKey;
+const publicKeyCreate = secp256k1__namespace.getPublicKey;
 
 const PRIVATE_KEY_BYTES = 32;
 const ETHEREUM_ADDRESS_BYTES = 20;
@@ -8541,7 +8752,7 @@ class Secp256k1Program {
     assert(publicKey.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`);
 
     try {
-      return buffer.Buffer.from(sha3__default["default"].keccak_256.update(toBuffer(publicKey)).digest()).slice(-ETHEREUM_ADDRESS_BYTES);
+      return buffer.Buffer.from(sha3.keccak_256(toBuffer(publicKey))).slice(-ETHEREUM_ADDRESS_BYTES);
     } catch (error) {
       throw new Error(`Error constructing Ethereum address: ${error}`);
     }
@@ -8641,7 +8852,7 @@ class Secp256k1Program {
       /* isCompressed */
       ).slice(1); // throw away leading byte
 
-      const messageHash = buffer.Buffer.from(sha3__default["default"].keccak_256.update(toBuffer(message)).digest());
+      const messageHash = buffer.Buffer.from(sha3.keccak_256(toBuffer(message)));
       const [signature, recoveryId] = ecdsaSign(messageHash, privateKey);
       return this.createInstructionWithPublicKey({
         publicKey,
@@ -9535,6 +9746,33 @@ class VoteInstruction {
       }
     };
   }
+  /**
+   * Decode an authorize instruction and retrieve the instruction params.
+   */
+
+
+  static decodeAuthorizeWithSeed(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 3);
+    const {
+      voteAuthorizeWithSeedArgs: {
+        currentAuthorityDerivedKeyOwnerPubkey,
+        currentAuthorityDerivedKeySeed,
+        newAuthorized,
+        voteAuthorizationType
+      }
+    } = decodeData$1(VOTE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed, instruction.data);
+    return {
+      currentAuthorityDerivedKeyBasePubkey: instruction.keys[2].pubkey,
+      currentAuthorityDerivedKeyOwnerPubkey: new PublicKey(currentAuthorityDerivedKeyOwnerPubkey),
+      currentAuthorityDerivedKeySeed: currentAuthorityDerivedKeySeed,
+      newAuthorizedPubkey: new PublicKey(newAuthorized),
+      voteAuthorizationType: {
+        index: voteAuthorizationType
+      },
+      votePubkey: instruction.keys[0].pubkey
+    };
+  }
   /**
    * Decode a withdraw instruction and retrieve the instruction params.
    */
@@ -9591,6 +9829,10 @@ const VOTE_INSTRUCTION_LAYOUTS = Object.freeze({
   Withdraw: {
     index: 3,
     layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), BufferLayout__namespace.ns64('lamports')])
+  },
+  AuthorizeWithSeed: {
+    index: 10,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u32('instruction'), voteAuthorizeWithSeedArgs()])
   }
 });
 /**
@@ -9719,6 +9961,49 @@ class VoteProgram {
       data
     });
   }
+  /**
+   * Generate a transaction that authorizes a new Voter or Withdrawer on the Vote account
+   * where the current Voter or Withdrawer authority is a derived key.
+   */
+
+
+  static authorizeWithSeed(params) {
+    const {
+      currentAuthorityDerivedKeyBasePubkey,
+      currentAuthorityDerivedKeyOwnerPubkey,
+      currentAuthorityDerivedKeySeed,
+      newAuthorizedPubkey,
+      voteAuthorizationType,
+      votePubkey
+    } = params;
+    const type = VOTE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed;
+    const data = encodeData(type, {
+      voteAuthorizeWithSeedArgs: {
+        currentAuthorityDerivedKeyOwnerPubkey: toBuffer(currentAuthorityDerivedKeyOwnerPubkey.toBuffer()),
+        currentAuthorityDerivedKeySeed: currentAuthorityDerivedKeySeed,
+        newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
+        voteAuthorizationType: voteAuthorizationType.index
+      }
+    });
+    const keys = [{
+      pubkey: votePubkey,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: SYSVAR_CLOCK_PUBKEY,
+      isSigner: false,
+      isWritable: false
+    }, {
+      pubkey: currentAuthorityDerivedKeyBasePubkey,
+      isSigner: true,
+      isWritable: false
+    }];
+    return new Transaction().add({
+      keys,
+      programId: this.programId,
+      data
+    });
+  }
   /**
    * Generate a transaction to withdraw from a Vote account.
    */
@@ -10014,6 +10299,9 @@ async function sendAndConfirmRawTransaction(connection, rawTransaction, confirma
   if (confirmationStrategyOrConfirmOptions && Object.prototype.hasOwnProperty.call(confirmationStrategyOrConfirmOptions, 'lastValidBlockHeight')) {
     confirmationStrategy = confirmationStrategyOrConfirmOptions;
     options = maybeConfirmOptions;
+  } else if (confirmationStrategyOrConfirmOptions && Object.prototype.hasOwnProperty.call(confirmationStrategyOrConfirmOptions, 'nonceValue')) {
+    confirmationStrategy = confirmationStrategyOrConfirmOptions;
+    options = maybeConfirmOptions;
   } else {
     options = confirmationStrategyOrConfirmOptions;
   }
@@ -10065,6 +10353,8 @@ exports.Loader = Loader;
 exports.Lockup = Lockup;
 exports.MAX_SEED_LENGTH = MAX_SEED_LENGTH;
 exports.Message = Message;
+exports.MessageAccountKeys = MessageAccountKeys;
+exports.MessageV0 = MessageV0;
 exports.NONCE_ACCOUNT_LENGTH = NONCE_ACCOUNT_LENGTH;
 exports.NonceAccount = NonceAccount;
 exports.PACKET_DATA_SIZE = PACKET_DATA_SIZE;
@@ -10096,11 +10386,16 @@ exports.SystemInstruction = SystemInstruction;
 exports.SystemProgram = SystemProgram;
 exports.Transaction = Transaction;
 exports.TransactionExpiredBlockheightExceededError = TransactionExpiredBlockheightExceededError;
+exports.TransactionExpiredNonceInvalidError = TransactionExpiredNonceInvalidError;
 exports.TransactionExpiredTimeoutError = TransactionExpiredTimeoutError;
 exports.TransactionInstruction = TransactionInstruction;
+exports.TransactionMessage = TransactionMessage;
 exports.VALIDATOR_INFO_KEY = VALIDATOR_INFO_KEY;
+exports.VERSION_PREFIX_MASK = VERSION_PREFIX_MASK;
 exports.VOTE_PROGRAM_ID = VOTE_PROGRAM_ID;
 exports.ValidatorInfo = ValidatorInfo;
+exports.VersionedMessage = VersionedMessage;
+exports.VersionedTransaction = VersionedTransaction;
 exports.VoteAccount = VoteAccount;
 exports.VoteAuthorizationLayout = VoteAuthorizationLayout;
 exports.VoteInit = VoteInit;